devrites 5.14.0 → 5.14.1

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to DevRites are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and DevRites adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). Releases are generated automatically by [semantic-release](https://semantic-release.gitbook.io/) from Conventional Commits on `main`.
 
+## [5.14.1](https://github.com/ViktorsBaikers/DevRites/compare/v5.14.0...v5.14.1) (2026-09-29)
+
+### Added
+
+* **no-release:** add /rite-fast lane for mid-size work ([#89](https://github.com/ViktorsBaikers/DevRites/issues/89)) ([7b71593](https://github.com/ViktorsBaikers/DevRites/commit/7b7159377a88002d33b19277f3b365cd9be89520))
+* **no-release:** close /overhaul audit and repair coverage gaps ([f7c4e6a](https://github.com/ViktorsBaikers/DevRites/commit/f7c4e6a0e27b83e7fa65befdee44df2efebbccca))
+
+### Fixed
+
+* **repo:** close engine, script, and doc quality gaps ([#90](https://github.com/ViktorsBaikers/DevRites/issues/90)) ([61572e2](https://github.com/ViktorsBaikers/DevRites/commit/61572e2bccae418aa47c7852807d2551f7f0bda1))
+
 ## [5.14.0](https://github.com/ViktorsBaikers/DevRites/compare/v5.13.1...v5.14.0) (2026-09-25)
 
 ### Added

package/README.md

@@ -31,7 +31,7 @@ history can't lose it. After you clear the conversation, switch hosts, or hand
 the feature to another engineer, the next session reads the same plan,
 decisions, and evidence before it continues.
 
-**Status:** [`v5.14.0`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v5.14.0): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
+**Status:** [`v5.14.1`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v5.14.1): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
 
 This is the latest published release; `main` may contain unreleased work.
 
@@ -147,6 +147,7 @@ equivalent.
 | --- | --- |
 | [`/rite`](pack/.claude/skills/rite/SKILL.md) | Show the command menu, or route a verb. |
 | [`/rite-quick`](pack/.claude/skills/rite-quick/SKILL.md) | Ship a small, reversible change with a compact contract, focused proof, and scope review. Escalates to `/rite-spec` when the work stops being small. |
+| [`/rite-fast`](pack/.claude/skills/rite-fast/SKILL.md) | Take mid-size work through one spec-and-plan step with your answers, up to ten slices, one completeness check, review, polish, and proof. No gate after each slice; explicit invocation only. |
 | [`/rite-autocomplete`](pack/.claude/skills/rite-autocomplete/SKILL.md) | Run the reversible lifecycle unattended and stop at Seal `GO`. With `--ship`, continue through Ship preflight and wait for your literal `GO`. |
 | [`/rite-adopt`](pack/.claude/skills/rite-adopt/SKILL.md) | Reverse-engineer current behavior of an existing codebase into a baseline workspace. |
 | [`/rite-upgrade [slug]`](pack/.claude/skills/rite-upgrade/SKILL.md) | Reconcile an older active workspace with current contracts. Routes only evidence-backed defects to their phase owners. |
@@ -423,8 +424,8 @@ through Claude Code or Codex plugin stores.
 
 ## Skills and agents
 
-The pack ships 45 skills: 34 public and 11 internal. The public surface
-contains the `rite` menu, 32 `rite-*` workflows and utilities, and the
+The pack ships 46 skills: 35 public and 11 internal. The public surface
+contains the `rite` menu, 33 `rite-*` workflows and utilities, and the
 standalone, explicit-only `/overhaul`. Ten `devrites-*` specialists load when a
 matching task needs them; `devrites-lib` carries the shared contracts and
 engineering standards.
@@ -434,6 +435,8 @@ roles plus `devrites-slice-wright`, the sole source and test writer. Codex,
 omp, pi, and Devin generate the same one-writer, sixteen-reader split.
 `/overhaul` adds eight `overhaul-*` agents that only it dispatches; they keep
 every tool ([ADR-0031](docs/adr/0031-overhaul-agents-keep-every-tool.md)).
+`/rite-fast` adds four `fast-*` agents that only it dispatches: three read-only
+roles and `fast-builder`, its own writer ([ADR-0033](docs/adr/0033-rite-fast-own-agents.md)).
 
 The [skills catalogue](docs/skills.md) lists every skill and agent. The
 [flow diagrams](docs/flow.md) show routing, reviewer fan-out, and namespace

package/docs/adr/0033-rite-fast-own-agents.md

@@ -0,0 +1,45 @@
+# ADR-0033: `/rite-fast` ships its own agents and its own writer
+
+- **Status:** Accepted
+- **Date:** 2026-09-26
+
+## Context
+
+Mid-size work had two routes. `/rite-quick` covers one small reversible change. The
+full lifecycle adds strategy review, a vetted plan, and review plus proof after every
+slice. Users asked for a lane in between: one spec-and-plan step with clarifying
+questions, up to ten slices built with no gate between them, one completeness check
+with gap fixes, then review, polish, and proof.
+
+The lifecycle agents are shaped for per-slice gates and engine workspace artifacts
+(`state.md`, `tasks.md`, `touched-files.md`, readiness bindings). `devrites-slice-wright`
+runs writer-safe proof on every slice, which is the step the fast lane removes.
+ADR-0010, ADR-0015, ADR-0017, ADR-0018 and ADR-0019 keep one writer among `devrites-*`
+specialists; ADR-0031 already scoped that rule for `/overhaul`.
+
+## Decision
+
+- `/rite-fast` is an explicit-only skill (`disable-model-invocation: true`). It stands
+  outside the engine lifecycle: its record is `spec.md`, `plan.md`, and `evidence.md`
+  under `.devrites/work/<slug>/`, with no `state.md`, no `.devrites/ACTIVE`, and no
+  seal. No engine change is needed.
+- The pack ships four agents that only `/rite-fast` dispatches: `fast-planner`,
+  `fast-checker`, and `fast-critic` (read-only, `permissionMode: plan`), and
+  `fast-builder` (write-capable in the exact paths of its contract,
+  `permissionMode: acceptEdits`). `fast-builder` runs no test suite; the skill runs one
+  check after all slices and proof last.
+- `validate-agent-composition.py` accepts `fast-builder` as write-capable when it states
+  that mode. Codex gives it `default_permissions = ":workspace"`; omp, pi, and Devin give
+  it the write tool set. The other `fast-*` agents stay read-only on every host.
+
+## Consequences
+
+- The one-writer clauses of the lifecycle ADRs govern `devrites-*` specialists only;
+  `/overhaul` (ADR-0031) and `/rite-fast` each own one more writer.
+- A `/rite-fast` run is not visible to `/rite-status`, `orient`, `next`, or `handoff`.
+  It resumes from its own `plan.md` ledger.
+- Four more agents are installed, updated, and removed with the pack. `/rite-fast`
+  stops when they are missing and no fresh context is available.
+
+Verified by `scripts/validate-agent-composition.py`, `tests/rite-fast-contract-test.sh`,
+and the host generators' `fast-builder` branches.

package/docs/adr/README.md

@@ -47,7 +47,7 @@ architecture; per-feature `decisions.md` files stay scoped to that feature.
 | ADR | Title | Status | Guard test |
 |-----|-------|--------|-----------|
 | [0001](0001-go-engine-as-control-plane.md) | Go engine as deterministic control plane | Accepted in part; all-state-transition/derivation scope superseded by 0024 | none |
-| [0002](0002-dual-host-harness.md) | Dual-host harness (Claude + Codex) | Accepted | `tests/parity_*_test.go` |
+| [0002](0002-dual-host-harness.md) | Dual-host harness (Claude + Codex) | Accepted | `engine/tests/parity_*_test.go` |
 | [0003](0003-gate-model-hitl-pause.md) | Gates block as HITL pause, never crash | Accepted | `engine/tests/adr_0003_gate_exit_code_test.go` |
 | [0004](0004-state-schema-phases-sections.md) | Phase-relative section completeness | Accepted | `engine/tests/adr_0004_required_by_phase_test.go`, `engine/internal/state/state_test.go` |
 | [0005](0005-hooks-as-engine-subcommands.md) | Hooks are engine subcommands, not shell scripts | Accepted; active hook clause superseded by 0018 | historical |
@@ -77,3 +77,4 @@ architecture; per-feature `decisions.md` files stay scoped to that feature.
 | [0029](0029-v5-workspace-schema-and-native-migration.md) | v5 workspace schema and native migration | Accepted | `engine/internal/state/workspaceschema_test.go`, `engine/tests/parity_resolve_test.go`, `engine/tests/parity_closeout_test.go` |
 | [0031](0031-overhaul-agents-keep-every-tool.md) | `/overhaul` ships its own agents that keep every tool | Accepted; scopes the one-writer clauses of 0010/0015/0017/0018/0019 to `devrites-*` specialists | `scripts/validate-agent-composition.py`, `tests/codex-agent-generation-test.sh` |
 | [0032](0032-single-lint-gate-and-cached-pr-tests.md) | One engine lint gate, and PR tests that reuse main's results | Accepted | `tests/validation-governance-test.sh` |
+| [0033](0033-rite-fast-own-agents.md) | `/rite-fast` ships its own agents and its own writer | Accepted; adds `fast-builder` as a writer outside the `devrites-*` one-writer rule | `scripts/validate-agent-composition.py`, `tests/rite-fast-contract-test.sh` |

package/docs/architecture.md

@@ -30,7 +30,7 @@ cursor readers, traceability rules, and phase-relative completeness model, see
    irreversible git ladder and **closes** the task by archiving the workspace
    and clearing `ACTIVE`. Separate steps let users audit the release decision
    before any irreversible action.
-2. **Public utility and on-ramp skills**: `rite-adopt`, `rite-quick`,
+2. **Public utility and on-ramp skills**: `rite-adopt`, `rite-quick`, `rite-fast`,
    `rite-frame`, `rite-status`, `rite-doctor`, `rite-upgrade`, `rite-learn`, `rite-explain`,
    `rite-customize`, `rite-zoom-out`, `rite-prototype`, `rite-handoff`,
    `rite-pressure-test`, `rite-pov`, `rite-dogfood`, `rite-pr-feedback`,
@@ -389,8 +389,8 @@ contract.
 
 ## Design choices at a glance
 
-- **Surface**: 32 public `rite-*` skills (45 total), plus the thin `/rite`
-  menu and the standalone `overhaul` skill: 34 public and 11 internal. The lifecycle
+- **Surface**: 33 public `rite-*` skills (46 total), plus the thin `/rite`
+  menu and the standalone `overhaul` skill: 35 public and 11 internal. The lifecycle
   includes mandatory adaptive Clarify, optional Temper, mandatory Vet, and
   Converge recovery; Seal **decides** and Ship **executes + closes**. Ten
   `devrites-*` specialist skills are model-invoked; `devrites-lib` is the
@@ -413,7 +413,9 @@ contract.
 - **Agents**: 17 fresh-context roles at flat depth one: 16 read-only leaves and
   one wright. Dispatch uses the exact named project role; if it cannot spawn,
   the workflow stops for HITL. `/overhaul` adds eight `overhaul-*` agents
-  that only it dispatches and that keep every tool (ADR-0031).
+  that only it dispatches and that keep every tool (ADR-0031). `/rite-fast`
+  adds four `fast-*` agents: three read-only roles and `fast-builder`, its own
+  writer (ADR-0033).
 - **Review**: **feature-scoped** multi-axis review with severity labels and
   fresh-context agents at the seal.
 - **Scope**: clarify → seal (decide) → ship (read-only preflight → type-GO →

package/docs/command-map.md

@@ -16,7 +16,7 @@ installer; DevRites is not distributed as a Claude or Codex plugin.
 The `devrites-` prefix avoids collisions with bundled Claude Code skill names
 such as `prototype`, `handoff`, `triage`, and `diagnose`. The prefix does not
 mean that a skill is internal; each `SKILL.md` uses `user-invocable:` to set
-visibility. Public utilities use the `rite-*` prefix: `rite-quick`,
+visibility. Public utilities use the `rite-*` prefix: `rite-quick`, `rite-fast`,
 `rite-frame`, `rite-adopt`, `rite-learn`, `rite-doctor`, `rite-customize`,
 `rite-zoom-out`, `rite-prototype`, `rite-handoff`, `rite-pressure-test`,
 `rite-autocomplete`, `rite-explain`, `rite-pov`, `rite-dogfood`,
@@ -106,6 +106,7 @@ See [`cli.md`](cli.md).
 | [`/rite-ship`](../pack/.claude/skills/rite-ship/SKILL.md) | ship | `[slug]` | Starts with a read-only Seal/candidate check and exact plan disclosure, then requires fresh literal `GO`. Only then may it collapse checkpoints, stage exact candidate paths, validate staged scope/bytes/bindings/secrets, commit and reverify, perform optional separately approved push/tag/PR actions, and archive/close. | `seal.md` + candidate + Git index | `ship.md`, `state.md`, archive |
 | [`/rite-autocomplete`](../pack/.claude/skills/rite-autocomplete/SKILL.md) | (orchestrator) | `[idea] [--ship\|--yolo] [--max-slices N] [--full] [--cross-model]` | Full lifecycle (spec → clarify → … → seal → ship). Spec + clarify form the one interactive window; AFK/checkpoint mode arms only after decision coverage is CLEAR. Pauses for irreversible risk, escalating, unanswered blocking with no recommended option, human-only access, or remaining NO-GO — not recommended-option blocking questions, temper expand, validating gates, `--max-slices`, or default resource caps. Objective red checks use bounded technical recovery. Default stops at Seal GO; `--ship` (`--yolo`) reaches Ship preflight but still requires fresh literal `GO` and native approval; `--full` selects the Full profile and `--cross-model` arms Vet's second opinion. | idea + workspace | whole workspace (drives every phase) |
 | [`/rite-quick`](../pack/.claude/skills/rite-quick/SKILL.md) | (express) | `<change>` | Express lane for a **small, reversible, unambiguous** change: one-line contract → TDD build → scoped prove → review-lite → ship, no full artifact tree. **Significance gate first**: auth / migration / public-API / destructive / multi-slice / ambiguous → escalates to `/rite-spec`. Triggers: "quick fix", "small change", "tiny tweak", "just do X". | the change + codebase | code + commit (optional `brief.md` / `evidence.md`) |
+| [`/rite-fast`](../pack/.claude/skills/rite-fast/SKILL.md) | (fast lane) | `<task \| slug>` | **Explicit-only** shortened lane for mid-size work: one SHAPE step (`fast-planner` drafts spec + ≤10 slices, root asks ≤5 ranked questions, 10 when risk is flagged, user approves) → BUILD with `fast-builder` and **no per-slice gate** → one CHECK (`fast-checker` completeness pass, ≤2 gap-fix rounds) → REFINE (`fast-critic` review + polish) → PROVE on the final tree. Outside the engine lifecycle: no `state.md`, no `ACTIVE`, no seal; commits only on confirmation. | the task + codebase | `spec.md`, `plan.md`, `evidence.md` under `.devrites/work/<slug>/` + code |
 | [`/rite-frame`](../pack/.claude/skills/rite-frame/SKILL.md) | lens | `[ask \| diff]` | Pre-flight + self-audit lens for ad-hoc work the lifecycle gates never see: **FRAME** turns an imperative ask into a falsifiable success criterion + verify command before code; **AUDIT** checks a raw diff against the four LLM coding failure modes (silent assumption / overcomplication / out-of-scope edit / unverifiable goal). Top of `/rite-quick` or before a plain "just do X". | the ask / a raw diff | success criterion + verify command (inline) |
 | [`/rite-adopt`](../pack/.claude/skills/rite-adopt/SKILL.md) | onboard | `[path or area to adopt] [+ what you want to build next]` | Reverse-derive the existing baseline and next objective; propose any durable project guidance in the nearest native instruction file. | codebase + project instructions | workspace spec/state artifacts + optional guidance proposal |
 | [`/rite-status`](../pack/.claude/skills/rite-status/SKILL.md) | status | `[slug]` | Active feature: phase, run mode, status, persisted next action, evidence, questions, drift, risks, and handoff readiness. | direct workspace ledger/artifacts | none |

package/docs/flow.md

@@ -381,7 +381,7 @@ separately by `disable-model-invocation`.
 
 ```mermaid
 flowchart TB
-    subgraph Public["Public (user-invocable: true): 34 skills"]
+    subgraph Public["Public (user-invocable: true): 35 skills"]
         direction TB
         R1[/rite/]
         R2[/rite-spec/]
@@ -401,6 +401,7 @@ flowchart TB
         R10[/rite-status/]
         R11[/rite-resolve/]
         RQ[/rite-quick/]
+        RFA[/rite-fast/]
         RF[/rite-frame/]
         RA[/rite-adopt/]
         RL[/rite-learn/]
@@ -435,7 +436,7 @@ flowchart TB
 
     classDef pub fill:#064e3b,stroke:#34d399,color:#ecfdf5
     classDef int fill:#1f2937,stroke:#9ca3af,color:#f9fafb
-    class R1,R2,RCL,RT,R3,RV,R4,R5,RC,R6,R7,R8,R9,R12,R13,R10,R11,RQ,RF,RA,RL,RD,RU,RE,RCU,RDO,RPOV,RPF,IPT,D1,D2,D3 pub
+    class R1,R2,RCL,RT,R3,RV,R4,R5,RC,R6,R7,R8,R9,R12,R13,R10,R11,RQ,RFA,RF,RA,RL,RD,RU,RE,RCU,RDO,RPOV,RPF,IPT,D1,D2,D3 pub
     class I1,I2,I3,I4,I5,I6,I7,I8,I9,I10,I11 int
 ```
 

package/docs/orchestration.md

@@ -52,6 +52,9 @@ slice-wright uses `default_permissions = ":workspace"` and the other 16
 specialists use `default_permissions = ":read-only"`. The eight `overhaul-*` agents of the
 explicit `/overhaul` skill sit outside this split: Claude gives them every tool and
 Codex gives them `:workspace` ([ADR-0031](adr/0031-overhaul-agents-keep-every-tool.md)).
+The four `fast-*` agents of `/rite-fast` also sit outside it: `fast-builder` uses
+`acceptEdits` on Claude and `:workspace` on Codex, and the other three are
+read-only ([ADR-0033](adr/0033-rite-fast-own-agents.md)).
 
 If the exact role is unavailable, the root stops instead of substituting a
 generic agent or doing specialist/writer work inline.

package/docs/quick-reference.md

@@ -3,7 +3,8 @@
 Executive fast path: **Spec → Build → Prove**. `/rite-spec` writes the
 contract, `/rite-build` implements one slice, `/rite-prove` binds evidence.
 Adaptive Clarify/Vet still run; they ask nothing when the contract is already
-complete. Use `/rite-quick` for a small reversible change.
+complete. Use `/rite-quick` for a small reversible change and `/rite-fast` for
+mid-size work that does not need a gate after every slice.
 
 Install DevRites with `npx devrites ...`. Normal installs from package and
 release candidates consume pre-generated project-local Claude Code and Codex

package/docs/skills.md

@@ -1,6 +1,6 @@
-# All 45 skills
+# All 46 skills
 
-The pack contains 45 skills: the `rite` menu, 32 user-invocable `rite-*`
+The pack contains 46 skills: the `rite` menu, 33 user-invocable `rite-*`
 workflow and utility skills, the standalone `overhaul` skill,
 10 model-invoked `devrites-*` specialists, and the internal `devrites-lib` library. `devrites-lib` is not a command. It holds shared
 references and the few explicit script exceptions.
@@ -19,8 +19,9 @@ guidance block in `AGENTS.md`.
 The root and reviewers never write source. Claude enforces the root boundary in
 plan mode. Codex uses a workspace-capable root so its sole write-capable
 slice-wright can execute, while all other specialists remain read-only. On
-Devin, `allowed-tools` gives only `devrites-slice-wright` `edit`, `write`, and
-`exec`; a missing required profile stops for HITL instead of substituting a
+Devin, `allowed-tools` gives `edit`, `write`, and `exec` only to
+`devrites-slice-wright` among lifecycle roles (plus `fast-builder` for
+`/rite-fast`); a missing required profile stops for HITL instead of substituting a
 generic profile. The
 installed `devrites-engine` owns strict candidate identity, deterministic checks,
 exact proof/review/seal bindings,
@@ -42,7 +43,7 @@ contract when a rite names parallel reviewers.
 ## Naming convention
 
 `rite-*` is the namespace for lifecycle and utility commands. Its utilities are
-`rite-quick`, `rite-frame`, `rite-adopt`, `rite-learn`, `rite-customize`,
+`rite-quick`, `rite-fast`, `rite-frame`, `rite-adopt`, `rite-learn`, `rite-customize`,
 `rite-explain`, `rite-pov`, `rite-dogfood`, `rite-pr-feedback`, `rite-watch-pr`, `rite-doctor`,
 `rite-upgrade`, `rite-prototype`, `rite-handoff`, `rite-zoom-out`, and
 `rite-pressure-test`.
@@ -145,6 +146,7 @@ and `Shipped`. Utility commands keep the same compact labels and one-next-action
 | Skill | What It Does | Use When |
 |---|---|---|
 | [`rite-quick`](../pack/.claude/skills/rite-quick/SKILL.md) | Express lane for a **small, reversible, unambiguous** change: one-line contract → TDD build → scoped prove → review-lite → ship, collapsing the full lifecycle into one pass. Significance gate first: auth / migration / public-API / destructive / multi-slice / ambiguous **escalates to `/rite-spec`**. | "quick fix", "small change", "tiny tweak", "just do X" on a low-risk change. |
+| [`rite-fast`](../pack/.claude/skills/rite-fast/SKILL.md) | Shortened lane: one spec-and-plan step with ranked clarifying questions (more when risk is flagged), up to ten vertical slices built by `fast-builder` without per-slice gates, one `fast-checker` completeness pass with gap fixes, one `fast-critic` review and polish pass, then proof on the final tree. Own `fast-*` agents; outside the engine lifecycle. | Explicit-only: `/rite-fast <task>` for mid-size work that does not need a gate after every slice. |
 | [`rite-frame`](../pack/.claude/skills/rite-frame/SKILL.md) | Pre-flight + self-audit lens for ad-hoc work the lifecycle gates never see: FRAME converts an imperative ask into a falsifiable success criterion + verify command before code; AUDIT checks a raw diff against the four LLM coding failure modes (silent assumption / overcomplication / out-of-scope edit / unverifiable goal). | Top of `/rite-quick`, before a plain "just do X" edit, or to self-review a raw diff. |
 | [`rite-adopt`](../pack/.claude/skills/rite-adopt/SKILL.md) | Bring an EXISTING codebase under DevRites: reverse-derive a baseline `spec.md` of current behavior, placement, and architecture; optionally propose one reviewed scoped-instruction update; then hand off to the lifecycle. | "adopt this project", "onboard this codebase", "we already have code", "reverse-engineer a spec from the existing app". |
 
@@ -261,8 +263,10 @@ and `Shipped`. Utility commands keep the same compact labels and one-next-action
 DevRites ships 17 role profiles at depth one. Both hosts have 16 read-only
 leaves and one source/test writer role. The explicit `/overhaul` skill ships eight
 more agents, `overhaul-*`, that only it dispatches and that keep every tool
-([ADR-0031](adr/0031-overhaul-agents-keep-every-tool.md)); the counts here cover the
-lifecycle roles. Four read-only work roles handle
+([ADR-0031](adr/0031-overhaul-agents-keep-every-tool.md)). `/rite-fast` adds four
+`fast-*` agents that only it dispatches: three read-only roles and `fast-builder`,
+its own writer ([ADR-0033](adr/0033-rite-fast-own-agents.md)). The counts here cover
+the lifecycle roles. Four read-only work roles handle
 bounded evidence, planning, proof, and compatibility while the root keeps
 authority:
 
@@ -302,7 +306,8 @@ Seal fan-out diagram: [`flow.md` § /rite-seal fan-out](flow.md#4-rite-seal-fan-
 
 ## Executor agent: fresh-context writer
 
-The catalog has one writer role. Claude and Codex run it with one exact
+The lifecycle catalog has one writer role (`/rite-fast` keeps its own
+`fast-builder`, ADR-0033). Claude and Codex run it with one exact
 path-bounded slice or accepted correction; every other agent remains read-only.
 
 | Agent | Purpose |

package/docs/usage.md

@@ -2,8 +2,8 @@
 
 These examples cover the common DevRites workflows. Start a new feature with
 `/rite-spec` and bring an existing codebase in with `/rite-adopt`.
-`/rite-quick` and `/rite-frame` handle bounded work outside the full feature
-lifecycle. Workspace phases first read the active workspace from
+`/rite-quick`, `/rite-fast`, and `/rite-frame` handle bounded work outside the full
+feature lifecycle. Workspace phases first read the active workspace from
 `.devrites/ACTIVE` and `.devrites/work/<slug>/`. If none exists, they report the
 command that can create or select one. `/rite-upgrade [slug]` is the
 compatibility audit for an older active workspace that cannot resume.

package/engine/internal/install/apply.go

@@ -274,9 +274,11 @@ func (r *runner) pruneDropped() error {
 						return fmt.Errorf("strip hooks from %s: %w", merge.TargetRel, err)
 					}
 				} else if merge.TargetRel == hostpack.ClaudeSettingsMerge.TargetRel {
-					_ = r.stripClaudeSettings(filepath.Join(r.target, filepath.FromSlash(merge.TargetRel)), true)
-				} else {
-					_ = stripMarkerPath(filepath.Join(r.target, filepath.FromSlash(merge.TargetRel)), merge.Begin, merge.End)
+					if err := r.stripClaudeSettings(filepath.Join(r.target, filepath.FromSlash(merge.TargetRel)), true); err != nil {
+						return fmt.Errorf("strip DevRites settings from %s: %w", merge.TargetRel, err)
+					}
+				} else if err := stripMarkerPath(filepath.Join(r.target, filepath.FromSlash(merge.TargetRel)), merge.Begin, merge.End); err != nil {
+					return fmt.Errorf("strip marker block from %s: %w", merge.TargetRel, err)
 				}
 			}
 			if err := os.Remove(dead); err != nil && !os.IsNotExist(err) {

package/engine/internal/install/binary.go

@@ -13,6 +13,7 @@ import (
 	"time"
 
 	"github.com/devrites/devrites/internal/fsutil"
+	"github.com/devrites/devrites/internal/version"
 )
 
 func (r *runner) installBinary() error {
@@ -28,7 +29,8 @@ func (r *runner) installBinary() error {
 	incoming := strings.TrimPrefix(tag, "v")
 	dest := binaryDest()
 	if exists(dest) {
-		if ev := engineVersion(dest); semverLike(ev) && semverLike(incoming) && verGT(ev, incoming) {
+		ev := engineVersion(dest)
+		if c, ok := version.Compare(ev, incoming); ok && c > 0 {
 			fmt.Fprintf(r.opts.Stderr, "warning: engine binary: installed %s is newer than %s - refusing to downgrade (kept).\n", ev, tag)
 			return nil
 		}

package/engine/internal/install/install.go

@@ -405,28 +405,3 @@ func semverLike(v string) bool {
 	v = strings.TrimPrefix(v, "v")
 	return len(v) > 0 && v[0] >= '0' && v[0] <= '9'
 }
-
-func verGT(a, b string) bool {
-	a = strings.TrimPrefix(a, "v")
-	b = strings.TrimPrefix(b, "v")
-	as := strings.Split(strings.Split(a, "-")[0], ".")
-	bs := strings.Split(strings.Split(b, "-")[0], ".")
-	for len(as) < 3 {
-		as = append(as, "0")
-	}
-	for len(bs) < 3 {
-		bs = append(bs, "0")
-	}
-	for i := 0; i < 3; i++ {
-		var ai, bi int
-		_, _ = fmt.Sscanf(as[i], "%d", &ai)
-		_, _ = fmt.Sscanf(bs[i], "%d", &bi)
-		if ai > bi {
-			return true
-		}
-		if ai < bi {
-			return false
-		}
-	}
-	return false
-}

package/engine/internal/lib/claims.go

@@ -15,6 +15,7 @@ import (
 	"time"
 
 	"github.com/devrites/devrites/internal/parallel"
+	"github.com/devrites/devrites/internal/state"
 )
 
 // ClaimsFile is the repo-level append-only claim ledger under .devrites.
@@ -249,6 +250,20 @@ func claimAdd(root string, args []string, stdout, stderr io.Writer) int {
 		return 2
 	}
 	path := claimsPath(root)
+	// Hold the ledger lock across read, conflict check, and append so two
+	// sessions cannot both pass the check and claim the same path.
+	code := 0
+	if err := state.WithLock(path+".lock", func() error {
+		code = claimAddLocked(path, session, reason, ttl, paths, stdout, stderr)
+		return nil
+	}); err != nil {
+		fmt.Fprintf(stderr, "claim: %v\n", err)
+		return 2
+	}
+	return code
+}
+
+func claimAddLocked(path, session, reason string, ttl int, paths []string, stdout, stderr io.Writer) int {
 	latest, order, _, err := readClaims(path)
 	if err != nil {
 		fmt.Fprintf(stderr, "claim: %v\n", err)

package/engine/internal/lib/claims_test.go

@@ -3,9 +3,11 @@ package lib
 import (
 	"bytes"
 	"encoding/json"
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 	"testing"
 	"time"
 )
@@ -180,3 +182,29 @@ func TestClaimLedgerToleratesMalformedLines(t *testing.T) {
 		t.Fatalf("malformed ledger: %d %q", code, out)
 	}
 }
+
+func TestClaimAddConcurrentOverlapOneWins(t *testing.T) {
+	root := claimTestRoot(t)
+	const n = 8
+	codes := make(chan int, n)
+	var wg sync.WaitGroup
+	for i := range n {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			var out, errOut bytes.Buffer
+			codes <- RunClaim(root, []string{"add", "--session", fmt.Sprintf("s%d", i), "pkg/a.go"}, &out, &errOut)
+		}()
+	}
+	wg.Wait()
+	close(codes)
+	wins := 0
+	for c := range codes {
+		if c == 0 {
+			wins++
+		}
+	}
+	if wins != 1 {
+		t.Fatalf("overlapping concurrent claims: %d succeeded, want exactly 1", wins)
+	}
+}

package/engine/internal/lib/context_next_test.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 	"testing"
 )
 
@@ -519,3 +520,55 @@ func TestDiffScopeAllowlist(t *testing.T) {
 		t.Fatalf("code=%d\n%s", code, stdout.String())
 	}
 }
+
+func TestDispatchConcurrentReturnsCompleteWave(t *testing.T) {
+	root, featureDir := newWorkspace(t, "build")
+	run := func(args ...string) int {
+		out, err := &bytes.Buffer{}, &bytes.Buffer{}
+		return RunDispatch(root, args, out, err)
+	}
+	roles := []string{"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7"}
+	open := []string{"feat", "open", "--phase", "review", "--wave", "w"}
+	for _, r := range roles {
+		open = append(open, "--role", r)
+	}
+	if c := run(open...); c != 0 {
+		t.Fatal("open failed")
+	}
+	for _, r := range roles {
+		if c := run("feat", "start", "--wave", "w", "--role", r, "--handle", "h-"+r); c != 0 {
+			t.Fatalf("start %s failed", r)
+		}
+	}
+	if c := run("feat", "seal", "--wave", "w"); c != 0 {
+		t.Fatal("seal failed")
+	}
+	var wg sync.WaitGroup
+	for _, r := range roles {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			if c := run("feat", "return", "--wave", "w", "--role", r); c != 0 {
+				t.Errorf("return %s failed: %d", r, c)
+			}
+		}()
+	}
+	wg.Wait()
+	if c := run("feat", "status", "--wave", "w"); c != 0 {
+		data, _ := os.ReadFile(filepath.Join(featureDir, "dispatch.json"))
+		t.Fatalf("concurrent returns lost an update; wave not complete:\n%s", data)
+	}
+}
+
+func TestDispatchAbandonRecordsReason(t *testing.T) {
+	root, featureDir := newWorkspace(t, "build")
+	out, errOut := &bytes.Buffer{}, &bytes.Buffer{}
+	if c := RunDispatch(root, []string{"feat", "open", "--phase", "build", "--wave", "w", "--role", "x"}, out, errOut); c != 0 {
+		t.Fatal("open failed")
+	}
+	RunDispatch(root, []string{"feat", "abandon", "--wave", "w", "--reason", "host limit"}, out, errOut)
+	data, err := os.ReadFile(filepath.Join(featureDir, "dispatch.json"))
+	if err != nil || !strings.Contains(string(data), `"reason": "host limit"`) {
+		t.Fatalf("abandon reason not persisted: %v\n%s", err, data)
+	}
+}

package/engine/internal/lib/dispatch.go

@@ -6,10 +6,12 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"sort"
 	"strings"
 	"time"
 
 	"github.com/devrites/devrites/internal/devritespaths"
+	"github.com/devrites/devrites/internal/state"
 )
 
 // dispatch.go: launch-wave barrier for host-native agent dispatch. Hosts own
@@ -31,9 +33,10 @@ type dispatchFile struct {
 }
 
 type dispatchWave struct {
-	Phase string                   `json:"phase"`
-	State string                   `json:"state"` // open, sealed, abandoned, complete
-	Roles map[string]*dispatchRole `json:"roles"`
+	Phase  string                   `json:"phase"`
+	State  string                   `json:"state"` // open, sealed, abandoned, complete
+	Reason string                   `json:"reason,omitempty"`
+	Roles  map[string]*dispatchRole `json:"roles"`
 }
 
 type dispatchRole struct {
@@ -79,7 +82,7 @@ func saveDispatch(path string, f *dispatchFile) error {
 	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
 		return err
 	}
-	return os.WriteFile(path, data, 0o600)
+	return state.AtomicWrite(path, data, 0o600)
 }
 
 func nowStamp() string { return time.Now().UTC().Format(time.RFC3339) }
@@ -122,6 +125,20 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 		fmt.Fprintf(stderr, "dispatch: %v\n", err)
 		return 2
 	}
+	// Serialize load-modify-save so concurrent start/return calls never lose
+	// an update and strand the wave short of complete.
+	code := 0
+	if err := state.WithFeatureLock(root, slug, func() error {
+		code = dispatchLocked(root, slug, sub, phase, wave, role, handle, reason, roles, stdout, stderr)
+		return nil
+	}); err != nil {
+		fmt.Fprintf(stderr, "dispatch: %v\n", err)
+		return 3
+	}
+	return code
+}
+
+func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, roles []string, stdout, stderr io.Writer) int {
 	f, path, err := loadDispatch(root, slug)
 	if err != nil {
 		fmt.Fprintf(stderr, "dispatch: %v\n", err)
@@ -204,6 +221,7 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 			}
 		}
 		if len(missing) > 0 {
+			sort.Strings(missing)
 			return fail("wave %q cannot seal: no start handle for %s", wave, strings.Join(missing, ","))
 		}
 		w.State = "sealed"
@@ -244,7 +262,8 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 
 	case "status":
 		if wave == "" {
-			for name, w := range f.Waves {
+			for _, name := range sortedKeys(f.Waves) {
+				w := f.Waves[name]
 				fmt.Fprintf(stdout, "dispatch: wave %s state=%s roles=%d\n", name, w.State, len(w.Roles))
 			}
 			if len(f.Waves) == 0 {
@@ -257,7 +276,8 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 			return fail("no wave %q", wave)
 		}
 		var pending []string
-		for name, r := range w.Roles {
+		for _, name := range sortedKeys(w.Roles) {
+			r := w.Roles[name]
 			mark := "declared"
 			if r.Handle != "" {
 				mark = "started"
@@ -281,9 +301,10 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 			return fail("no wave %q", wave)
 		}
 		if strings.TrimSpace(reason) == "" {
-			return fail("--reason is required (non-empty, surfaced in handoff)")
+			return fail("--reason is required (non-empty, recorded in dispatch.json)")
 		}
 		w.State = "abandoned"
+		w.Reason = reason
 		if err := saveDispatch(path, f); err != nil {
 			return fail("%v", err)
 		}

package/engine/internal/lib/manifest_union.go

@@ -48,6 +48,20 @@ func RunMergeManifest(root string, args []string, stdout, stderr io.Writer) int
 		fmt.Fprintf(stderr, "merge-manifest: BLOCKED: %v\n", err)
 		return 3
 	}
+	code := 0
+	if err := state.WithFeatureLock(root, slug, func() error {
+		code = mergeManifestLocked(root, slug, workspace, args, stdout, stderr)
+		return nil
+	}); err != nil {
+		fmt.Fprintf(stderr, "merge-manifest: %v\n", err)
+		return 1
+	}
+	return code
+}
+
+// mergeManifestLocked reads, unions, and rewrites touched-files.md under the
+// feature lock so a concurrent writer cannot interleave with the rewrite.
+func mergeManifestLocked(root, slug, workspace string, args []string, stdout, stderr io.Writer) int {
 	manifestPath := filepath.Join(workspace, "touched-files.md")
 	releaseRaw, err := readBoundedRegularFile(manifestPath, maxCandidateManifestBytes)
 	if err != nil {

package/engine/internal/overhaul/admit/admit_test.go

@@ -80,8 +80,16 @@ func TestReceipt(t *testing.T) {
 			r["task_id"], r["role"], r["lane"], r["outcome"] = "R-1", "reviewer", "security", "no-findings"
 			delete(r, "changed_paths")
 		}, "-", 1, "no-findings without inspected ranges is malformed"},
+		{"reviewer no-findings without domains", func(r J) {
+			r["task_id"], r["role"], r["lane"], r["outcome"], r["inspected"] = "R-1", "reviewer", "security", "no-findings", L{"src/a.py:1-9"}
+		}, "-", 1, "no-findings must name its domains_checked"},
+		{"reviewer unknown domain", func(r J) {
+			r["task_id"], r["role"], r["lane"], r["outcome"], r["inspected"] = "R-1", "reviewer", "security", "no-findings", L{"src/a.py:1-9"}
+			r["domains_checked"] = L{"style"}
+		}, "-", 1, "domains_checked has unknown domain 'style'"},
 		{"reviewer admissible", func(r J) {
 			r["task_id"], r["role"], r["lane"], r["outcome"], r["inspected"] = "R-1", "reviewer", "security", "no-findings", L{"src/a.py:1-9"}
+			r["domains_checked"] = L{"security"}
 		}, "-", 0, "ADMISSIBLE"},
 	}
 	for _, c := range cases {
@@ -114,6 +122,7 @@ func TestReceiptAgainstOpenStage(t *testing.T) {
 	}})
 	rc := writerReceipt()
 	rc["task_id"], rc["role"], rc["lane"], rc["outcome"], rc["inspected"] = "R-2", "reviewer", "security", "no-findings", L{"src/a.py:1-9"}
+	rc["domains_checked"] = L{"security"}
 	delete(rc, "changed_paths")
 	p := write(t, filepath.Join(dir, "receipts/r2.json"), rc)
 	if code, out, errs := run("receipt", dir, p); code != 0 || !strings.Contains(out, "ADMISSIBLE") {