devrites 7.2.4 → 7.2.6

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 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`.
 
+## [7.2.6](https://github.com/ViktorsBaikers/DevRites/compare/v7.2.5...v7.2.6) (2026-10-31)
+
+### Fixed
+
+* **devrites:** count reserved manifests in task-graph schedule ([#191](https://github.com/ViktorsBaikers/DevRites/issues/191)) ([499014b](https://github.com/ViktorsBaikers/DevRites/commit/499014b00d3313fd6f8722715e9cdf8b155dabf5))
+* **no-release:** stop reserving go.mod for existing-only deps ([#190](https://github.com/ViktorsBaikers/DevRites/issues/190)) ([4a8844c](https://github.com/ViktorsBaikers/DevRites/commit/4a8844cb8eaa53c29e46b5122b40827e9522c56a))
+
+## [7.2.5](https://github.com/ViktorsBaikers/DevRites/compare/v7.2.4...v7.2.5) (2026-10-30)
+
+### Fixed
+
+* **devrites:** block autocomplete handoff of an internal phase edge ([#189](https://github.com/ViktorsBaikers/DevRites/issues/189)) ([5655fa7](https://github.com/ViktorsBaikers/DevRites/commit/5655fa7efdb8cbbbb0612fb603b170a4affa7fbf))
+
 ## [7.2.4](https://github.com/ViktorsBaikers/DevRites/compare/v7.2.3...v7.2.4) (2026-10-30)
 
 ### Fixed

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:** [`v7.2.4`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v7.2.4): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
+**Status:** [`v7.2.6`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v7.2.6): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
 
 This is the latest published release; `main` may contain unreleased work.
 

package/docs/cli.md

@@ -29,6 +29,7 @@ devrites-engine check diff-scope <slug> --allow <csv>|--allow-file <path> [--wor
 devrites-engine check perturb <slug> --patch <file> --expect <test-name> --gate <G-ID> [--timeout N] [--worktree <path> --slice <SLICE-ID>]
 devrites-engine check task-graph <slug>
 devrites-engine check regression <slug> [--update]
+devrites-engine check continuation [slug]
 devrites-engine check drift <slug> [--record]
 devrites-engine check windows <slug> [--worktree|--staged|--base <ref>|--since-dispatch <wave>]
 devrites-engine check dup [slug] [--all|--worktree|--staged|--base <ref>]
@@ -147,6 +148,13 @@ self-contained updater.
   scheduled wake before acting on durable state, ratchet after a landed slice
   checkpoint or phase advance, and treat `BLOCKED` at Seal as NO-GO; `--update`
   never excuses an unreconciled regression.
+- `check continuation [slug]` prints `continuation: required` and
+  `invoke: <next_action>` when `.devrites/AFK` is present, `status` is
+  `running`, no question cursor is set, no blocking or escalating question is
+  open, and `next_action` is an internal phase command (`/rite-vet`,
+  `/rite-build`, not `/rite-ship`). Otherwise it prints `continuation: clear`.
+  Exit `0` either way: `required` means invoke that command, not pause for a
+  human. `handoff` prints the same lines.
 - `check drift <slug>` attributes readiness-input drift to the exact artifact.
   `--record` snapshots per-input SHA-256 digests into `readiness-inputs.json`
   under the feature lock after Vet records the aggregate binding; a later

package/docs/command-map.md

@@ -41,8 +41,8 @@ The Go surface is intentionally closed and deterministic:
 
 | Lane | Commands | Owner |
 |---|---|---|
-| Candidate and deterministic checks | `check candidate`, `check readiness [--emit-binding]`, `check preconditions <slug> [--slice <SLICE-ID>]`, `check seal`, `check slice <slug> <SLICE-ID>`, `check task-graph`, `check regression <slug> [--update]`, `check drift <slug> [--record]`, `check windows <slug>`, `check dup`, `check path-disjoint`, `parallel select`, `check skill-trust`, `check indexes`, `detect commands [--root <dir>] [--json]` | Candidate validates/hashes the strict project manifest; readiness checks phase files, the required `tasks.md` slice graph, or emits the vetted Build-input binding; `check preconditions` runs the `test-plan.md` preflight rows whose `Run at` is `vet` (or `pre-dispatch <SLICE>`) with candidate-bound transcripts; seal checks final files/open gates, that graph and binding, then exact candidate bindings. `check slice` preflights one slice before wright dispatch — contract present, exact Writer allowlist paths, `Satisfies` AC ids resolvable, bounded scope — so a malformed slice fails before a writer context is spent. `check indexes` reports install manifest and optional code-index directory presence as JSON. `parallel select` returns the greedy path-disjoint subset ≤ cap from the supplied ready slices, or with `--from-plan` from tasks.md slices whose dependencies state.md checks built. `check regression` compares current workspace progress against the durable `regression-baseline.json` high-water mark and `--update` ratchets it at a checkpoint, so a lost slice, unchecked criterion, or reopened question fails closed instead of passing silently. `check windows` scans the feature diff for newly introduced deferral markers (TODO/FIXME/skipped test/stub idioms) and fails when any lacks a `windows.md` waiver row — silent deferrals block the seal. `check dup` reports advisory near-duplicate clusters that survive renaming (normalized token shingles, transitive clusters, distance-boosted rank, `*`-marked diff overlap, stable content hashes, `.devrites/dup-ignore` dismissal ledger) — leads for reviewer triage, never a gate. `check drift` attributes readiness-input drift to the exact artifact: `--record` snapshots per-input SHA-256 digests into `readiness-inputs.json` under the feature lock, and a later compare names each `changed`/`missing`/`added` input (falling back to the aggregate `eng-review.md` binding plus mtime candidates when no baseline exists) so a stale-binding repair starts at the right file — advisory, never a gate. `detect commands` resolves the repository's own test/lint/vet/build commands (Makefile targets, then `package.json` scripts, then language-manifest fallbacks, plus the lockfile-derived package manager) so `gates.md` `CHECK` lines and proof steps cite real wiring instead of invented commands — read-only, no installs, no execution. |
-| Workspace observation | `observe summary`, `orient`, `observe slice <slug> <SLICE-ID>`, `next`, `handoff` | JSON workspace snapshot for agents (cursor, task graph, `artifact_budgets`, `bulk_files`); `orient` is an alias for `observe summary`. `observe slice` prints one `SLICE-###` section of `tasks.md` so Build reads a slice, not the file. `next` prints the minimal remaining lifecycle path plus advisory skips (e.g. clarify at zero open questions). `handoff` emits the deterministic resume record (cursor, `awaiting_human`, blocking question gates, ledger reduction with unmet/stale ids, dead ends, read-next order) — the `/rite-handoff` spine and compaction-fallback entry. |
+| Candidate and deterministic checks | `check candidate`, `check readiness [--emit-binding]`, `check preconditions <slug> [--slice <SLICE-ID>]`, `check seal`, `check slice <slug> <SLICE-ID>`, `check task-graph`, `check regression <slug> [--update]`, `check continuation [slug]`, `check drift <slug> [--record]`, `check windows <slug>`, `check dup`, `check path-disjoint`, `parallel select`, `check skill-trust`, `check indexes`, `detect commands [--root <dir>] [--json]` | Candidate validates/hashes the strict project manifest; readiness checks phase files, the required `tasks.md` slice graph, or emits the vetted Build-input binding; `check preconditions` runs the `test-plan.md` preflight rows whose `Run at` is `vet` (or `pre-dispatch <SLICE>`) with candidate-bound transcripts; seal checks final files/open gates, that graph and binding, then exact candidate bindings. `check slice` preflights one slice before wright dispatch — contract present, exact Writer allowlist paths, `Satisfies` AC ids resolvable, bounded scope — so a malformed slice fails before a writer context is spent. `check indexes` reports install manifest and optional code-index directory presence as JSON. `parallel select` returns the greedy path-disjoint subset ≤ cap from the supplied ready slices, or with `--from-plan` from tasks.md slices whose dependencies state.md checks built. `check regression` compares current workspace progress against the durable `regression-baseline.json` high-water mark and `--update` ratchets it at a checkpoint, so a lost slice, unchecked criterion, or reopened question fails closed instead of passing silently. `check continuation` prints `required` and the phase command to invoke when AFK, `status=running`, and `next_action` is an internal phase edge; `clear` otherwise. Exit 0 either way. `handoff` prints the same lines. `check windows` scans the feature diff for newly introduced deferral markers (TODO/FIXME/skipped test/stub idioms) and fails when any lacks a `windows.md` waiver row — silent deferrals block the seal. `check dup` reports advisory near-duplicate clusters that survive renaming (normalized token shingles, transitive clusters, distance-boosted rank, `*`-marked diff overlap, stable content hashes, `.devrites/dup-ignore` dismissal ledger) — leads for reviewer triage, never a gate. `check drift` attributes readiness-input drift to the exact artifact: `--record` snapshots per-input SHA-256 digests into `readiness-inputs.json` under the feature lock, and a later compare names each `changed`/`missing`/`added` input (falling back to the aggregate `eng-review.md` binding plus mtime candidates when no baseline exists) so a stale-binding repair starts at the right file — advisory, never a gate. `detect commands` resolves the repository's own test/lint/vet/build commands (Makefile targets, then `package.json` scripts, then language-manifest fallbacks, plus the lockfile-derived package manager) so `gates.md` `CHECK` lines and proof steps cite real wiring instead of invented commands — read-only, no installs, no execution. |
+| Workspace observation | `observe summary`, `orient`, `observe slice <slug> <SLICE-ID>`, `next`, `handoff` | JSON workspace snapshot for agents (cursor, task graph, `artifact_budgets`, `bulk_files`); `orient` is an alias for `observe summary`. `observe slice` prints one `SLICE-###` section of `tasks.md` so Build reads a slice, not the file. `next` prints the minimal remaining lifecycle path plus advisory skips (e.g. clarify at zero open questions). `handoff` emits the deterministic resume record (cursor, `awaiting_human`, blocking question gates, ledger reduction with unmet/stale ids, dead ends, read-next order, continuation verdict) — the `/rite-handoff` spine and compaction-fallback entry. |
 | Context packets, dispatch waves, metrics, claims, notes | `context [slug] (--phase <p> \| --skill <name>) [--role <r>] [--trigger a,b]`, `dispatch <slug> <open\|start\|seal\|return\|status\|abandon>`, `candidate freeze`, `packet`, `metrics record`, `metrics summary`, `claim <add\|release\|list\|check>`, `note <add\|list\|check\|rm>` | `context` emits one deduplicated read-set bundle per phase/role/skill from each skill's `loads:` manifest — a dispatch target reads it instead of selecting files; `--skill` works without a workspace when `--out` is given. `dispatch` owns the launch-wave barrier (seal needs a handle per role; return needs seal; the last start seals; open --claim-session/--claim takes the wave's file claim, released by the completing return or abandon --release) and auto-records dispatch/return metrics. `candidate freeze` writes a wave's frozen `packets/<w>.diff` + `.sha256`; `packet` renders and lints one role's by-reference packet. `metrics` owns the append-only `metrics.jsonl` ledger. `claim` owns the append-only `.devrites/claims.jsonl` ledger — advisory, session-scoped file claims with TTL so concurrent same-tree sessions see each other's write intent before edits collide (conflict exits 3; never a substitute for one-writer-per-worktree). `note` owns the anchored `notes.md` ledger — notes bound to verbatim code quotes, regraded `exact`/`moved`/`stale`/`ambiguous`/`lost` as the code drifts; `check seal` refuses non-`exact` anchors. `check diff-scope` is the mechanical changed-paths ⊆ allowlist gate run before reviewer dispatch. |
 | Atomic workspace state | `state resolve`, `state merge-manifest`, `state apply-bundle <slug> <bundle.json>... [--dry-run]`, `state set <slug> key=value... [--unset key]`, `state append <slug> <ledger.md> --heading <text> --body-file <path\|->`, `state close`, `migrate [--dry-run] [--answer id=choice]` | Go owns answer/drop/batch resolution, the recorded predecessor-chain manifest union for a release milestone, the all-or-nothing apply of plan-drafter hunk bundles (base-hash pins, unique non-overlapping anchors, no lost IDs, no new task-graph or budget defect, no appended dated delta section), cursor writes (known phase, engine-owned schema, no return-cursor overwrite; an AFK pause names auto-pickable questions), append-only ledger sections that refuse a duplicate heading, transactional close, and fail-closed v5 schema normalization. |
 | Acceptance ledger | `gates scaffold`, `gates status`, `gates run [--timeout N]`, `gates reverify [--timeout N]`, `gates lint [--strict]`, `gates precheck <slug> --worktree <path> [--slice <SLICE-ID>]`, `gates attest <id> <note>`, `gates abandon <id> <why>` | Go owns the `gates.md` ledger: per-outcome gates whose runnable `CHECK`/`CWD` must exactly match a `test-plan.md` Build-entry preflight row, evidence bound to the gate definition digest (stale = unmet), `ABANDON:` handoffs, oracle lint, and the wright's never-evidence `precheck` of `RUN: writer` gates. Readiness/seal require a parse-clean, all-met ledger whenever `gates.md` is a required artifact. |

package/docs/engine/commands.md

@@ -17,10 +17,11 @@ workflow strategy.
 | `check preconditions <slug> [--slice SLICE-###] [--timeout N]` | Run the `test-plan.md` Build-entry preflight rows whose optional `Run at` cell is `vet` (with `--slice`, `pre-dispatch <SLICE>`); `action` rows and rows without the cell never run. Writes one candidate-bound transcript per row under `references/gates/preflight-*/`; a row passes on exit 0. A `pre-dispatch` row whose newest transcript passed is kept, not re-run: it is a pre-edit baseline, so a re-dispatch never runs it against the slice's own edits; changing its command or cwd retires the pass. Exit `3` on any failure or an invalid `Run at` value. |
 | `check seal <slug>` | Check files required by target Phase `seal`, open human gates, the `tasks.md` slice graph, canonical `AC-###` presence when `tasks.md`/`test-plan.md` are required, the stable Build-input binding, and exact candidate bindings. `check readiness` and `check seal` also block a `scripts/` test driver that a tasks.md Writer allowlist plans or touched-files.md lists when no gates.md `CHECK` runs it and no `Driver waiver: <path> — DEC-### <reason>` line cites a recorded decision; waived drivers print as `note: unexecuted driver (waived by DEC-###): <path>` lines, on pass or block. |
 | `check path-disjoint [--root <dir>] [<json-file> | -]` | Verify slice path sets are pairwise disjoint. |
-| `parallel select --cap <1-10> [--root <dir>] [--slug <slug>] [--from-plan \| <json-file> \| -]` | Choose the greedy path-disjoint subset ≤ cap from supplied ready slices, or with `--from-plan` (needs `--slug`) from the plan: tasks.md slices whose dependencies state.md checks `built`, with Writer allowlist (else Files likely touched) paths plus the nearest manifest/lockfile when `External dependencies:` is not none. With `--slug` and a running lease, the lease's not-yet-landed slices hold cap slots and paths, slices it names are never picked, and only new picks print. |
+| `parallel select --cap <1-10> [--root <dir>] [--slug <slug>] [--from-plan \| <json-file> \| -]` | Choose the greedy path-disjoint subset ≤ cap from supplied ready slices, or with `--from-plan` (needs `--slug`) from the plan: tasks.md slices whose dependencies state.md checks `built`, with Writer allowlist (else Files likely touched) paths plus the nearest manifest/lockfile when `External dependencies:` names a package (`none*`, existing, or no-new prose without a coordinate). With `--slug` and a running lease, the lease's not-yet-landed slices hold cap slots and paths, slices it names are never picked, and only new picks print. |
 | `parallel <create\|add\|integrate\|cleanup\|status\|abort\|lease-read\|lease-write\|lease-clear\|record-green>` | Deterministic parallel worktree leases, integration, and cleanup for parallel writer batches. A lease is a pipeline: `integrate --slice <id> --apply-to-control` lands one green sibling onto control (refusing if anything but this lease moved control), and `add` starts new path-disjoint siblings from the current control tip while others still run. |
-| `check task-graph <slug>` | Validate `tasks.md` slice dependency graph for cycles, unknown deps, malformed tokens, duplicate IDs, missing `Dependencies`, and `depends_on` mismatch. Prints a non-blocking `ADVISORY size:` line (and records a `size-advisory` metric) for each slice with 12+ Writer allowlist files and no `Size rationale:`. A `Dependencies` ID may carry a `(via <interface>)` suffix (empty or unclosed is a malformed token); prints a non-blocking `ADVISORY edge:` line (and records an `edge-advisory` metric) for each edge with no via, or whose via text is not a case-insensitive substring of the dependency's `Consumes / Produces:`. Prints `schedule: <n> slices in <r> build rounds at cap 10` (the `/rite-build` batch selection replayed over each slice's Writer allowlist, else Files likely touched; omitted when a slice has no path) and a non-blocking `ADVISORY hub:` line (top five; records a `hub-advisory` metric) for each path, compared case-folded, that three or more slices without `Serial rationale:` write. Advisories print only when the graph is valid. |
+| `check task-graph <slug>` | Validate `tasks.md` slice dependency graph for cycles, unknown deps, malformed tokens, duplicate IDs, missing `Dependencies`, and `depends_on` mismatch. Prints a non-blocking `ADVISORY size:` line (and records a `size-advisory` metric) for each slice with 12+ Writer allowlist files and no `Size rationale:`. A `Dependencies` ID may carry a `(via <interface>)` suffix (empty or unclosed is a malformed token); prints a non-blocking `ADVISORY edge:` line (and records an `edge-advisory` metric) for each edge with no via, or whose via text is not a case-insensitive substring of the dependency's `Consumes / Produces:`. Prints `schedule: <n> slices in <r> build rounds at cap 10` (the `/rite-build` batch selection replayed over each slice's Writer allowlist, else Files likely touched, plus the manifest parallel select reserves; omitted when a slice has no path) and a non-blocking `ADVISORY hub:` line (top five; records a `hub-advisory` metric) for each path, compared case-folded, that three or more slices without `Serial rationale:` write. Advisories print only when the graph is valid. |
 | `check regression <slug> [--update]` | Compare the workspace's structural progress facts (phase ordinal, checked ACs, met/abandoned gates, done slices, resolved questions, present artifacts) against the recorded `regression-baseline.json` high-water mark; `--update` ratchets the baseline forward under the feature lock and prints each blessed regression. |
+| `check continuation [slug]` | Print whether an armed AFK run must invoke its cursor instead of replying. `continuation: required` plus `invoke: <next_action>` when `.devrites/AFK` is a regular file, `status` is `running`, `question_id` is empty, no blocking or escalating question is open, and `next_action` is an internal phase command (`/rite-spec` through `/rite-seal`, including `/rite-plan`, not `/rite-ship` or `/rite-autocomplete`). Otherwise `continuation: clear` with a one-line `reason`. Exit `0` either way. `handoff` prints the same lines. |
 | `check drift <slug> [--record]` | Attribute readiness-input changes to the exact artifact. `--record` writes the per-input `readiness-inputs.json` digest baseline under the feature lock; without it the workspace diffs current inputs against that baseline (or falls back to the aggregate binding recorded in `eng-review.md`). Advisory: exit `0` on drift; a corrupt baseline exits `3`. A `test-plan.md` change limited to exact `Workflow Artifact reviewed identity: <64hex>` lines is reported as `reviewed-identity-only` (ADR-0034). `--record` also stores each slice's proof bytes (its `tasks.md` block plus the `test-plan.md` lines naming it); both modes print `ADVISORY proportion:` for a slice whose proof grew over 2x since that baseline or carries over 3x the median proof per AC. |
 | `check windows <slug> [--worktree\|--staged\|--base <ref>\|--since-dispatch <wave>]` | Fail on deferral and bar-lowering markers the change introduces without a waiver row in the workspace's `windows.md`: added TODO/FIXME/XXX/HACK, skipped/focused-test and stub idioms, checker suppressions, one-line empty catch; removed `deleted-test` files and net `removed-assertion` lines in remaining test files. `--since-dispatch <wave>` reports only `deleted-test`/`removed-assertion` against the work-tree snapshot (`tree` in `dispatch.json`) recorded when that build wright wave opened, untracked files included; it takes no `--cwd` and records the `windows-since` metric. |
 | `check dup [slug] [--all\|--worktree\|--staged\|--base <ref>] [--min-lines n] [--threshold f] [--ignore-file <path>] [--limit n] [--exclude <csv>]` | Report near-duplicate code clusters that survive comment stripping, literal collapsing, and identifier renaming — token-shingle matches chained into segments, clustered transitively, ranked with bounded path/line-distance boosts. Diff modes mark units overlapping changed hunks with `*`; stable content-derived cluster hashes let `.devrites/dup-ignore` dismissals survive line moves but resurface on structural edits. Staged mode reads index blobs and excludes untracked files. Bounded heuristic: successful scans/leads exit `0`; usage, unavailable input, and partial scans exit `2`. |
@@ -34,7 +35,7 @@ workflow strategy.
 | `orient <slug>` | Alias for `observe summary`. |
 | `observe slice <slug> <SLICE-ID>` | Print one `SLICE-###` section of `tasks.md` so Build reads a slice, not the file. |
 | `next [slug]` | Print the minimal remaining lifecycle path plus advisory skips; in Build also `eligible_now:`, `batch:` and the `select-command:` (`parallel select --root <project> --slug <slug> --cap N --from-plan`, N = AFK max_parallel else 10) that reproduces the batch. Prints `blocked: unattributed root edit: ...` after `open-questions:` and exits `3` while the ADR-0038 tripwire flags a product path; the rest of the output still prints. |
-| `handoff [slug] [--resume]` | Emit the deterministic resume record: cursor fields, `awaiting_human`, open `questions.md` gate kinds, the `gates.md` reduction with unmet/stale/abandoned ids, `decisions.md` dead ends, in-flight dispatch waves (`inflight_wave:` lines: phase, state, pending roles, slices), missing required files, and the canonical read-next order. Read-only unless `--resume`, which appends one `resume` event (role root) to `metrics.jsonl`; `metrics summary` then reports minutes from each resume to the next dispatch. The `/rite-handoff` spine and the compaction-fallback entry point. |
+| `handoff [slug] [--resume]` | Emit the deterministic resume record: cursor fields, `awaiting_human`, open `questions.md` gate kinds, the `gates.md` reduction with unmet/stale/abandoned ids, `decisions.md` dead ends, in-flight dispatch waves (`inflight_wave:` lines: phase, state, pending roles, slices), missing required files, the canonical read-next order, and the same `continuation:` lines as `check continuation`. Read-only unless `--resume`, which appends one `resume` event (role root) to `metrics.jsonl`; `metrics summary` then reports minutes from each resume to the next dispatch. The `/rite-handoff` spine and the compaction-fallback entry point. |
 | `recall --paths <p1,p2,...> [--limit n]` | Read-time query over `.devrites/archive/`: list archived features whose `touched-files.md` candidate manifest covers a queried project-relative path (exact or directory prefix, case-folded), ranked by overlap count, then newest archive-directory mtime, then slug (default 10 features). Each feature prints up to 8 `archive/<slug>/<file>:<line>` pointers, then `+N more`: `decisions.md` `DEC-###` entries and `## Carry-forward constraints` bullets whose `Files:` overlap (or a constraint naming no files), plus `review.md`/`seal.md`/`drift.md` lines that mention a queried path; fenced examples are ignored. Never writes, caches, or indexes (no metric either); symlinked archive entries are refused. An unreadable archive file prints `unreadable:` and the scan continues. Exit `0` (including `recall: no archive`), `1` invalid archive directory, `2` usage. |
 | `context [slug] (--phase <p>\|--skill <name>) [--role <r>] [--slice <SLICE-ID>] [--recheck <inventory>] [--trigger a,b] [--inline-contract] [--whole]` | Emit one deduplicated read-set bundle per phase/role/skill from each skill's `loads:` manifest; `--skill` works without a workspace when `--out` is given. A root `--phase build\|autocomplete` bundle (no `--role`, no `--slice`) defaults to `--slice <active_slice>` while the state.md cursor phase is `build` and active_slice names a slice present in tasks.md (prints `scope: slice SLICE-### (auto from state.md) ...`); `--whole` opts out. Every bundle opens, after its header comments, with a table of contents: one `L<start>-<end> <section label>` line per `===== label =====` section, giving its exact line range in the bundle file. A bundle without `--role` (the root's own read) gives over-budget artifacts as by-reference indexes; a `--role` bundle leads with the role's agent contract and names the manifest's `rootOnly` paths instead of inlining them. When the contract resolves under `.claude/agents`, `.omp/agents`, or `.codex/agents` (the host loads it as the agent's system prompt), the bundle writes one header line naming its path, size, and SHA-256 instead of the body; other layouts (pi, devin, unknown) and `--inline-contract` (only with `--role`) inline the body, and a missing contract still exits `3`. Inside inlined files, a `--role` bundle replaces each `<!-- root-only -->`…`<!-- /root-only -->` block with a one-line stub naming the omitted heading, and does the same for each `<!-- model-surface -->` block unless the role is `security-auditor`, the feature has an `ai-spec.md`, or `spec.md`/`plan.md`/`tasks.md`/`design-brief.md` are absent or (outside the spec template's `AI-SPEC annex`) name a model, agent, RAG, or tool surface; an unbalanced or headingless marker exits `2`. `--slice` inlines that slice's `tasks.md` block and turns each over-budget artifact, and each artifact over 16 KiB except `spec.md`, into a by-reference index (path, SHA-256, headings, line hits for every ID the block cites); repeat `--slice` for several slices; an unknown slice exits `3`. In phase `build`, a `--role` bundle other than `slice-wright` without `--slice` exits `3` (`unscoped build reviewer bundle`). `--recheck <inventory>` (phase `build`, with `--role` and `--slice`; path relative to the workspace) writes `<phase>-<role>.<slice>.recheck.bundle.md`: the inventory file and `core.md` inline whole, every other non-`rootOnly` pack file becomes a by-reference index (path, SHA-256, headings with line numbers) followed by each section the inventory cites as `<file>.md § <heading>`; workspace handling matches `--slice`. A missing or empty inventory exits `2`. First reviews, full-inventory rechecks, Vet, `/rite-review`, and Seal do not use it. |
 | `dispatch <slug> <open\|start\|seal\|return\|status\|abandon\|attribute>` | Launch-wave barrier for parallel dispatch: seal needs a handle per role, return needs seal; the start that gives the last role its handle seals the wave, and an explicit seal on a sealed wave is a no-op; `open --claim-session <id> --claim <path>... [--claim-ttl <minutes>]` records one file claim for the wave in claims.jsonl and exits `3`, creating no wave and no claim, while a live foreign session holds an overlapping path; the return that completes the wave releases that claim; `abandon --release` releases it on any other host-confirmed terminal path (a stop or a refused launch); re-opening an abandoned wave inherits its kept claim or, with new claim flags, replaces and releases it; claim flags apply to open only and `--release` to abandon only; start/return auto-record metrics, `return --outcome findings|no-findings|gap` records the role's Outcome line, and `abandon` records its reason, so `metrics summary` shows per-role yield and lost waves. Bare `status` prints every open, sealed, or abandoned wave and folds complete waves into one `N complete wave(s) (use --all)` line; `--all` lists every wave; it still exits nonzero while any wave is open or sealed. For a reviewer, auditor, or test-analyst role, `return --result <file>` stores the return verbatim as `packets/<wave>-<role>.return.md` (exit `3` if that file exists), derives the outcome from its `Outcome:`/`Counts:` head (a malformed or inconsistent head records `gap` with a warning, never `no-findings`), exits `3` when an explicit `--outcome` disagrees, and records each `Finding:` row's `role|slice|file|section|severity` key, so `metrics summary` adds per-role `resolution: resolved re-raised open late` counts. A `--result` file that already is that `packets/` path is kept as the stored return. A build wave with a wright role needs `--slice <SLICE-ID>` per slice, and a slice-bound vet wave takes it too; a reviewer-only wave (for example a Build slice review) may take it, uncapped, so its `Finding:` keys name that slice; a reviewer, auditor, or test-analyst wave needs `--packet <file>` and `open` exits `3` on a packet that seeds a conclusion (gate `*-PASS` token, `no-findings`, an `Outcome:`/`Counts:` line, an "already passed" claim, or zero Critical/Important counts) or tells the agent to read an installed `agents/devrites-*.md`/`.toml` role contract (on the line or under a "Read …" heading or label; canonical `pack/` paths excepted), and a wright wave's `--contract` gets the same role-contract check; a Review or Seal reviewer wave also exits `3` unless the packet names an existing non-empty `.diff`/`.patch` file and the manifest covers every checkpointed path; every 5 rounds of either kind on one slice, `open` exits `3` until `--reslice-review <DRIFT-ID>` names an unused `drift.md` `## <DRIFT-ID>` heading for that slice. `open` also warns when an earlier wave for the same slice never returned. Under `.devrites/AFK` max_parallel >= 2, a first-round build wright wave narrower than the `parallel select --from-plan` batch exits `3` (printing the batch, the command and the parallel-batch lifecycle) until evidence.md records `serial: <skipped ids> — <reason>`; repair rounds, lease siblings and HITL runs are never refused. A build wright `--contract` must name `gates precheck` under `Writer-safe checks:` when gates.md has a `RUN: writer` gate. `open` exits `3` when a `--role` names no pack agent in a project-level install (a `.<lane>` suffix is allowed), and lints a reviewer packet against the wave's roles, so a recheck may name its own role's fingerprint. Root-edit tripwire (ADR-0038): the first `open` records `<feature>/tree-baseline.json`, which maps dirty product paths outside `.devrites/` and `.scratch/` to their mode plus SHA-256, accepted as user work. The return that completes a wright wave (any phase) adds its slice write sets and claim paths. `open` exits `3` with `unattributed root edit: <paths>` while a dirty product path differs from that baseline and no live claim or in-flight wright wave covers it, unless the new wright wave covers the path through `--claim` or a slice write set. `attribute --reason <evidence> --path <path>...` records owner work, gate output, a standalone wright, or a sanctioned root write for flagged paths only. Each finding writes an `unattributed-edit` metrics row. The engine never reverts a file, and a workspace without the baseline is never blocked. |

package/docs/usage.md

@@ -389,7 +389,9 @@ Autocomplete discloses the exact Git plan, then still stops for a fresh literal
 `GO` and native host approval. It also pauses for irreversible risk, human-only access/actions, escalating
 gates, unanswered blocking with no recommended option, a remaining NO-GO, or low confidence — not for recommended-option blocking questions, temper expand, validating
 gates, `--max-slices`, or default slice/agent/time/review-queue caps.
-Objective red checks use bounded recovery instead. Args:
+Objective red checks use bounded recovery instead. A not-READY vet under AFK is
+not a pause: `devrites-engine check continuation` prints `continuation: required`
+and the phase command to invoke; `clear` is the only time autocomplete may reply. Args:
 `[idea] [--ship|--yolo] [--max-slices N] [--parallel N] [--full] [--cross-model] [--lookahead]`.
 Optional flags are inactive unless their exact token occurs in the invocation;
 `--max-slices` requires one positive base-10 integer and does not cap this run.

package/engine/commands.go

@@ -42,7 +42,7 @@ func rootModeFor(command string, args []string) rootMode {
 		return rootStrictUsage
 	case "check":
 		switch subcommand {
-		case "candidate", "readiness", "preconditions", "seal", "task-graph", "diff-scope", "slice", "regression", "windows", "drift", "anchors", "perturb":
+		case "candidate", "readiness", "preconditions", "seal", "task-graph", "diff-scope", "slice", "regression", "continuation", "windows", "drift", "anchors", "perturb":
 			return rootStrictUsage
 		case "indexes", "dup":
 			return rootLenient

package/engine/help.go

@@ -12,7 +12,7 @@ import (
 )
 
 const (
-	checkUsage = `usage: devrites-engine check <candidate|readiness|preconditions|seal|path-disjoint|task-graph|affected|slice|diff-scope|skill-trust|indexes|regression|drift|windows|dup|anchors|perturb> ...
+	checkUsage = `usage: devrites-engine check <candidate|readiness|preconditions|seal|path-disjoint|task-graph|affected|slice|diff-scope|skill-trust|indexes|regression|continuation|drift|windows|dup|anchors|perturb> ...
 
   check candidate <slug>
   check readiness <slug>
@@ -29,6 +29,7 @@ const (
   check skill-trust <path>
   check indexes [--root <dir>]
   check regression <slug> [--update]
+  check continuation [slug]
   check drift <slug> [--record]
   check windows <slug> [--worktree|--staged|--base <ref>|--since-dispatch <wave>] [--cwd <dir>]
   check dup [slug] [--all|--worktree|--staged|--base <ref>]
@@ -90,6 +91,7 @@ const (
 	skillTrustUsage     = "usage: devrites-engine check skill-trust <path>"
 	indexesUsage        = "usage: devrites-engine check indexes [--root <dir>]"
 	regressionUsageLine = "usage: devrites-engine check regression <slug> [--update]"
+	continuationUsage   = "usage: devrites-engine check continuation [slug]"
 	driftUsageLine      = "usage: devrites-engine check drift <slug> [--record]"
 	detectUsageLine     = "usage: devrites-engine detect commands [--root <dir>] [--json]"
 	windowsUsageLine    = "usage: devrites-engine check windows <slug> [--worktree|--staged|--base <ref>|--since-dispatch <wave>] [--cwd <dir>]"
@@ -292,6 +294,8 @@ func helpCheck(rest []string) string {
 		return indexesUsage
 	case "regression":
 		return regressionUsageLine
+	case "continuation":
+		return continuationUsage
 	case "drift":
 		return driftUsageLine
 	case "windows":

package/engine/internal/lib/cli_observe.go

@@ -49,7 +49,7 @@ func runTaskGraphCheck(root, slug string, strict bool, stdout, stderr io.Writer)
 		if over > 0 {
 			recordMetric(root, slug, "define", "size-advisory", "", int64(over))
 		}
-		paths, serial := sliceWritePaths(raw, graph)
+		paths, serial := schedulePaths(raw, graph, root)
 		if plan, idle, maxReady := schedulePlan(graph, paths, root); len(plan) > 0 {
 			fmt.Fprintf(stdout, "task-graph: schedule: %d slices in %d build rounds at cap %d, width %d, idle-eligible %d\n", len(graph.Slices), len(plan), parallel.MaxParallelSlices, scheduleWidth(plan), idle)
 			if chain := chainAdvisories(graph, serial, len(plan), maxReady); len(chain) > 0 {

package/engine/internal/lib/continuation.go

@@ -0,0 +1,131 @@
+package lib
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/devrites/devrites/internal/devritespaths"
+	"github.com/devrites/devrites/internal/gate"
+	"github.com/devrites/devrites/internal/state"
+)
+
+// ContinuationUsage is the help text for `check continuation`.
+const ContinuationUsage = "usage: devrites-engine check continuation [slug]"
+
+// internalPhaseVerbs are autocomplete phase edges. /rite-ship and
+// /rite-autocomplete stay user-facing (fresh GO, parked reopen).
+var internalPhaseVerbs = map[string]bool{
+	"/rite-spec":     true,
+	"/rite-clarify":  true,
+	"/rite-temper":   true,
+	"/rite-define":   true,
+	"/rite-plan":     true,
+	"/rite-vet":      true,
+	"/rite-build":    true,
+	"/rite-prove":    true,
+	"/rite-polish":   true,
+	"/rite-review":   true,
+	"/rite-converge": true,
+	"/rite-seal":     true,
+}
+
+// continuationVerdict is the cursor-shaped answer to "may autocomplete reply?".
+// Required is an internal phase edge, not a human pause (exit stays 0).
+// shortcut: a host that ends the turn without running this check still stops; no Stop hook (ADR-0015). Upgrade if a host can block stop without a DevRites hook payload.
+type continuationVerdict struct {
+	Required bool
+	Invoke   string
+	Reason   string
+}
+
+// RunCheckContinuation prints whether an armed AFK run must invoke its
+// next_action instead of replying. Exit 0 either way; exit 2 on usage or
+// an unreadable workspace.
+func RunCheckContinuation(root string, args []string, stdout, stderr io.Writer) int {
+	slug, code, err := ActiveSlug(root, args)
+	if err != nil {
+		fmt.Fprintf(stderr, "check continuation: %v\n", err)
+		if code == 0 {
+			code = 2
+		}
+		return code
+	}
+	verdict, err := classifyContinuation(root, slug)
+	if err != nil {
+		fmt.Fprintf(stderr, "check continuation: %v\n", err)
+		return 2
+	}
+	writeContinuation(stdout, verdict)
+	return 0
+}
+
+func classifyContinuation(root, slug string) (continuationVerdict, error) {
+	featureDir, err := devritespaths.ExistingFeatureDirChecked(root, slug)
+	if err != nil {
+		return continuationVerdict{}, err
+	}
+	report, err := state.Status(root, slug)
+	if err != nil {
+		return continuationVerdict{}, err
+	}
+	if !afkPresent(root) {
+		return continuationVerdict{Reason: "no AFK sentinel"}, nil
+	}
+	if report.Status != "running" {
+		if report.Status == "" {
+			return continuationVerdict{Reason: "status unset"}, nil
+		}
+		return continuationVerdict{Reason: "status=" + report.Status}, nil
+	}
+	// #nosec G304 -- state.md inside the checked feature workspace
+	data, err := os.ReadFile(filepath.Join(featureDir, "state.md"))
+	if err != nil {
+		return continuationVerdict{}, err
+	}
+	if qid, ok := state.CursorField(strings.Split(string(data), "\n"), state.CursorQuestionID); ok && strings.TrimSpace(qid) != "" {
+		return continuationVerdict{Reason: "question cursor set"}, nil
+	}
+	// #nosec G304 -- questions.md inside the checked feature workspace
+	qdata, err := os.ReadFile(filepath.Join(featureDir, "questions.md"))
+	if err != nil && !os.IsNotExist(err) {
+		return continuationVerdict{}, err
+	}
+	if err == nil {
+		for _, kind := range gate.OpenBlockingQuestionGates(qdata) {
+			if kind == "blocking" || kind == "escalating" {
+				return continuationVerdict{Reason: "open " + kind + " question"}, nil
+			}
+		}
+	}
+	invoke, ok := internalPhaseEdge(report.NextAction)
+	if !ok {
+		return continuationVerdict{Reason: "next_action is not an internal phase edge"}, nil
+	}
+	return continuationVerdict{Required: true, Invoke: invoke, Reason: "AFK status=running internal phase edge"}, nil
+}
+
+func afkPresent(root string) bool {
+	info, err := os.Stat(filepath.Join(root, "AFK")) // #nosec G304 -- .devrites/AFK sentinel
+	return err == nil && info.Mode().IsRegular()
+}
+
+func internalPhaseEdge(action string) (string, bool) {
+	fields := strings.Fields(action)
+	if len(fields) == 0 || !internalPhaseVerbs[strings.ToLower(fields[0])] {
+		return "", false
+	}
+	return strings.Join(fields, " "), true
+}
+
+func writeContinuation(stdout io.Writer, verdict continuationVerdict) {
+	if verdict.Required {
+		fmt.Fprintln(stdout, "continuation: required")
+		fmt.Fprintf(stdout, "invoke: %s\n", verdict.Invoke)
+	} else {
+		fmt.Fprintln(stdout, "continuation: clear")
+	}
+	fmt.Fprintf(stdout, "reason: %s\n", verdict.Reason)
+}

package/engine/internal/lib/handoff.go

@@ -89,6 +89,12 @@ func RunHandoff(root string, args []string, stdout, stderr io.Writer) int {
 		fmt.Fprintf(stdout, "missing_required: %s\n", strings.Join(report.MissingFiles, ", "))
 	}
 	fmt.Fprintf(stdout, "read_next: %s\n", strings.Join(readNext(featureDir), ", "))
+	verdict, err := classifyContinuation(root, slug)
+	if err != nil {
+		fmt.Fprintf(stderr, "handoff: continuation: %v\n", err)
+		return 2
+	}
+	writeContinuation(stdout, verdict)
 	if resume {
 		recordMetric(root, slug, string(report.Phase), "resume", "root", 0)
 	}

package/engine/internal/lib/taskgraph.go

@@ -66,6 +66,21 @@ func sliceWritePaths(tasksMarkdown []byte, graph TaskGraphResult) (map[string][]
 	return paths, serial
 }
 
+// schedulePaths is the write set the task-graph schedule and hub check use.
+// It adds the manifest withManifests reserves so printed rounds match
+// `parallel select --from-plan`, not the allowlist alone. devritesRoot is the
+// .devrites directory.
+func schedulePaths(tasksMarkdown []byte, graph TaskGraphResult, devritesRoot string) (map[string][]string, map[string]bool) {
+	paths, serial := sliceWritePaths(tasksMarkdown, graph)
+	project := filepath.Dir(devritesRoot)
+	for _, s := range graph.Slices {
+		block, _ := state.ExtractTaskSlice(tasksMarkdown, s.ID)
+		external, _ := fieldValue(sliceFields(block), "external dependencies")
+		paths[s.ID] = withManifests(project, paths[s.ID], external)
+	}
+	return paths, serial
+}
+
 // pathTokens keeps the list entries that can be paths; prose and Markdown links
 // (anything with whitespace) are not write paths.
 func pathTokens(raw string) []string {
@@ -241,14 +256,63 @@ func builtSlices(root, slug string) (map[string]bool, error) {
 	return built, nil
 }
 
-// withManifests adds, when external names dependencies (not empty or none),
-// the manifest and lockfiles of the nearest directory above each write path
-// that holds one, so two dependency-adding slices never share a round. A lone
-// lockfile is always claimed (adding a dependency writes it); of several, only
-// those present are.
-func withManifests(project string, paths []string, external string) []string {
+// manifestDenialRe is prose that says the slice adds no dependency.
+var manifestDenialRe = regexp.MustCompile(`(?i)\b(?:no new|no product|existing|already-admitted|already admitted|stdlib)\b`)
+
+// A backtick name, module path, npm scope, or x.y.z pin. go.mod/go.sum is not a module path.
+var (
+	backtickPkgRe  = regexp.MustCompile("`([^`]+)`")
+	modulePathRe   = regexp.MustCompile(`(?i)(?:[a-z0-9-]+\.)+[a-z]{2,}/[a-z0-9._@~+-]+`)
+	npmScopeRe     = regexp.MustCompile(`(?i)@[a-z0-9._-]+/[a-z0-9._-]+`)
+	versionPinRe   = regexp.MustCompile(`(?i)\bv?\d+\.\d+\.\d+\b`)
+	manifestHostRe = regexp.MustCompile(`(?i)\.(?:mod|sum|json|toml|yaml|yml|lock|lockb)$`)
+)
+
+// externalClaimsManifest reports whether External dependencies names a package
+// add, so parallel select reserves the nearest manifest. A none prefix does
+// not. shortcut: existing/no-new prose with no package coordinate does not
+// either; name the module, version, scope, or `package` when the slice edits one.
+func externalClaimsManifest(external string) bool {
 	ext := strings.ToLower(strings.Trim(strings.TrimSpace(external), "`"))
 	if ext == "" || ext == "-" || ext == "n/a" || strings.HasPrefix(ext, "none") {
+		return false
+	}
+	raw := strings.TrimSpace(external)
+	if manifestDenialRe.MatchString(raw) && !namesPackage(raw) {
+		return false
+	}
+	return true
+}
+
+// namesPackage reports a module path, version pin, npm scope, or `package`
+// name. Manifest filenames mentioned only to deny an edit do not count.
+func namesPackage(raw string) bool {
+	for _, m := range backtickPkgRe.FindAllStringSubmatch(raw, -1) {
+		base := path.Base(strings.TrimSpace(m[1]))
+		if base != "" && base != "." && !manifestHostRe.MatchString(base) {
+			return true
+		}
+	}
+	if npmScopeRe.MatchString(raw) || versionPinRe.MatchString(raw) {
+		return true
+	}
+	for _, loc := range modulePathRe.FindAllStringIndex(raw, -1) {
+		token := raw[loc[0]:loc[1]]
+		host := token[:strings.IndexByte(token, '/')]
+		if !manifestHostRe.MatchString(host) {
+			return true
+		}
+	}
+	return false
+}
+
+// withManifests adds, when external names a package add, the manifest and
+// lockfiles of the nearest directory above each write path that holds one,
+// so two dependency-adding slices never share a round. A lone lockfile is
+// always claimed (adding a dependency writes it); of several, only those
+// present are.
+func withManifests(project string, paths []string, external string) []string {
+	if !externalClaimsManifest(external) {
 		return paths
 	}
 	isFile := func(rel string) bool {

package/engine/main.go

@@ -41,6 +41,8 @@ Usage:
   devrites-engine check skill-trust <path> Scan one skill/agent Markdown for trust violations
   devrites-engine check regression <slug> [--update]
                                          Compare workspace progress against the recorded baseline; --update ratchets it
+  devrites-engine check continuation [slug]
+                                         AFK + running internal phase edge must be invoked, not replied to
   devrites-engine check drift <slug> [--record]
                                          Attribute readiness-input changes to the exact artifact since the Vet baseline
   devrites-engine check windows <slug> [--worktree|--staged|--base <ref>|--since-dispatch <wave>]
@@ -241,6 +243,8 @@ func cmdCheck(root string, args []string, stdin io.Reader, stdout, stderr io.Wri
 		return lib.RunEnvironmentCheck(root, rest, stdout, stderr)
 	case "regression":
 		return lib.RunCheckRegression(root, rest, stdout, stderr)
+	case "continuation":
+		return lib.RunCheckContinuation(root, rest, stdout, stderr)
 	case "windows":
 		return lib.RunCheckWindows(root, rest, stdout, stderr)
 	case "dup":

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

@@ -26,6 +26,9 @@ individually or in one named group, so reviewers can `git diff` those paths.
 
 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.
+Before that reply, `devrites-engine check continuation` must say `continuation: clear`.
+`required` means invoke `invoke:` now; exit 0 is not a pause. **Failing case:**
+`vet stopped` plus `Resume: /rite-vet` while the check says `required`.
 
 Standalone HITL mid-flight replies follow the same economy:
 

package/pack/.claude/skills/rite-autocomplete/SKILL.md

@@ -153,13 +153,17 @@ pending slices. Each Autocomplete invocation owns internal backtracking. Context
 not create a stop; persist and resume the cursor.
 
 Reply only at final state: text-only turns end the run. Keep
-calling tools after compaction or phase changes. Use one line:
+calling tools after compaction or phase changes. Before any user-visible reply,
+`devrites-engine check continuation` must print `continuation: clear`
+(`handoff` prints the same lines). `required` means invoke `invoke:` now.
+`stopped` is not a phase token. Print this card only after `clear`:
 
 ```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>
+spec done · clarify clear · temper done · define done · vet ready · build n/N · prove — · polish — · review — · seal —
 ```
 
-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.
+Final state, only after `clear`: `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.
+**Failing case:** `vet stopped` plus `Resume: /rite-vet` while the check says `required`.

package/pack/.claude/skills/rite-autocomplete/reference/loop.md

@@ -147,6 +147,7 @@ and park it after three escalations while independent work continues.
 
 Green slice/phase checkpoints consume their recorded `next_action` internally;
 only the caller replies finally at completion or a genuine stop.
+Before a reply, `devrites-engine check continuation` must print `continuation: clear`; `required` means invoke `invoke:` now.
 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

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

@@ -26,6 +26,8 @@ Fully escalated fingerprints park unless remaining owner is human.
 
 ## Not stops: internal technical routing
 
+AFK + `status=running` + an internal phase `next_action` is not a stop. `devrites-engine check continuation` prints `required` for that cursor and `clear` for `/rite-ship`, `awaiting_human`, a question cursor, or an open blocking or escalating question.
+
 `NEEDS_REPLAN` is not a stop condition under active Autocomplete. It blocks
 forward work, persists the return cursor, and invokes Plan repair plus Recovery
 Vet inline. The same applies to nested `STOP`/`Next step` when its decision is

package/pack/.claude/skills/rite-build/reference/parallel-batch.md

@@ -33,10 +33,10 @@ N_eff = min(
 ```
 
 Select **greedily in plan order** with
-`devrites-engine parallel select --slug <slug> --cap N --from-plan`: the engine
-reads the ready set (tasks.md dependencies checked `built` in `state.md`, minus
-running-lease slices) and each slice's Writer allowlist (else `Files likely
-touched`), plus its manifest/lockfile when `External dependencies:` is not none;
+`devrites-engine parallel select --slug <slug> --cap N --from-plan`: ready set
+(dependencies `built`, minus running-lease slices), Writer allowlist
+(else Files likely touched), plus manifest/lockfile when `External dependencies:`
+names a package (`none*`, existing, or no-new prose without a coordinate);
 `next` prints `eligible_now:`/`batch:`. `n_eff` counts new picks only.
 With a running lease, a single new pick still uses `parallel add`;
 `n_eff=0` with a running lease waits for siblings, not Prove. Without one:
@@ -73,7 +73,7 @@ Before `parallel select`, add each slice's hidden write surfaces (list owner:
 [repository-topology.md § Ownership rules](../../devrites-lib/reference/standards/repository-topology.md#ownership-rules))
 — lockfile/manifest, the generated target of an edited source, migration chain,
 snapshot directory, formatter sweep — and compare paths case-folded
-(`src/Api.ts` = `src/api.ts`); `--from-plan` adds the manifest/lockfile itself.
+(`src/Api.ts` = `src/api.ts`); `--from-plan` adds the manifest/lockfile for a package.
 Slices colliding on either run serially; the rest
 stay eligible. Record `serial: <ids> — <surface>` in `evidence.md`. Under AFK
 with `max_parallel ≥ 2`, `dispatch open` refuses a first-round build wright wave

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

@@ -26,6 +26,9 @@ individually or in one named group, so reviewers can `git diff` those paths.
 
 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.
+Before that reply, `devrites-engine check continuation` must say `continuation: clear`.
+`required` means invoke `invoke:` now; exit 0 is not a pause. **Failing case:**
+`vet stopped` plus `Resume: /rite-vet` while the check says `required`.
 
 Standalone HITL mid-flight replies follow the same economy:
 

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

@@ -155,13 +155,17 @@ pending slices. Each Autocomplete invocation owns internal backtracking. Context
 not create a stop; persist and resume the cursor.
 
 Reply only at final state: text-only turns end the run. Keep
-calling tools after compaction or phase changes. Use one line:
+calling tools after compaction or phase changes. Before any user-visible reply,
+`devrites-engine check continuation` must print `continuation: clear`
+(`handoff` prints the same lines). `required` means invoke `invoke:` now.
+`stopped` is not a phase token. Print this card only after `clear`:
 
 ```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>
+spec done · clarify clear · temper done · define done · vet ready · build n/N · prove — · polish — · review — · seal —
 ```
 
-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.
+Final state, only after `clear`: `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.
+**Failing case:** `vet stopped` plus `Resume: /rite-vet` while the check says `required`.

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

@@ -149,6 +149,7 @@ and park it after three escalations while independent work continues.
 
 Green slice/phase checkpoints consume their recorded `next_action` internally;
 only the caller replies finally at completion or a genuine stop.
+Before a reply, `devrites-engine check continuation` must print `continuation: clear`; `required` means invoke `invoke:` now.
 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

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

@@ -28,6 +28,8 @@ Fully escalated fingerprints park unless remaining owner is human.
 
 ## Not stops: internal technical routing
 
+AFK + `status=running` + an internal phase `next_action` is not a stop. `devrites-engine check continuation` prints `required` for that cursor and `clear` for `/rite-ship`, `awaiting_human`, a question cursor, or an open blocking or escalating question.
+
 `NEEDS_REPLAN` is not a stop condition under active Autocomplete. It blocks
 forward work, persists the return cursor, and invokes Plan repair plus Recovery
 Vet inline. The same applies to nested `STOP`/`Next step` when its decision is

package/pack/generated/claude/skills/rite-build/reference/parallel-batch.md

@@ -33,10 +33,10 @@ N_eff = min(
 ```
 
 Select **greedily in plan order** with
-`devrites-engine parallel select --slug <slug> --cap N --from-plan`: the engine
-reads the ready set (tasks.md dependencies checked `built` in `state.md`, minus
-running-lease slices) and each slice's Writer allowlist (else `Files likely
-touched`), plus its manifest/lockfile when `External dependencies:` is not none;
+`devrites-engine parallel select --slug <slug> --cap N --from-plan`: ready set
+(dependencies `built`, minus running-lease slices), Writer allowlist
+(else Files likely touched), plus manifest/lockfile when `External dependencies:`
+names a package (`none*`, existing, or no-new prose without a coordinate);
 `next` prints `eligible_now:`/`batch:`. `n_eff` counts new picks only.
 With a running lease, a single new pick still uses `parallel add`;
 `n_eff=0` with a running lease waits for siblings, not Prove. Without one:
@@ -73,7 +73,7 @@ Before `parallel select`, add each slice's hidden write surfaces (list owner:
 [repository-topology.md § Ownership rules](../../devrites-lib/reference/standards/repository-topology.md#ownership-rules))
 — lockfile/manifest, the generated target of an edited source, migration chain,
 snapshot directory, formatter sweep — and compare paths case-folded
-(`src/Api.ts` = `src/api.ts`); `--from-plan` adds the manifest/lockfile itself.
+(`src/Api.ts` = `src/api.ts`); `--from-plan` adds the manifest/lockfile for a package.
 Slices colliding on either run serially; the rest
 stay eligible. Record `serial: <ids> — <surface>` in `evidence.md`. Under AFK
 with `max_parallel ≥ 2`, `dispatch open` refuses a first-round build wright wave

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

@@ -26,6 +26,9 @@ individually or in one named group, so reviewers can `git diff` those paths.
 
 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.
+Before that reply, `devrites-engine check continuation` must say `continuation: clear`.
+`required` means invoke `invoke:` now; exit 0 is not a pause. **Failing case:**
+`vet stopped` plus `Resume: $rite-vet` while the check says `required`.
 
 Standalone HITL mid-flight replies follow the same economy:
 

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

@@ -155,13 +155,17 @@ pending slices. Each Autocomplete invocation owns internal backtracking. Context
 not create a stop; persist and resume the cursor.
 
 Reply only at final state: text-only turns end the run. Keep
-calling tools after compaction or phase changes. Use one line:
+calling tools after compaction or phase changes. Before any user-visible reply,
+`devrites-engine check continuation` must print `continuation: clear`
+(`handoff` prints the same lines). `required` means invoke `invoke:` now.
+`stopped` is not a phase token. Print this card only after `clear`:
 
 ```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>
+spec done · clarify clear · temper done · define done · vet ready · build n/N · prove — · polish — · review — · seal —
 ```
 
-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.
+Final state, only after `clear`: `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.
+**Failing case:** `vet stopped` plus `Resume: $rite-vet` while the check says `required`.

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

@@ -149,6 +149,7 @@ and park it after three escalations while independent work continues.
 
 Green slice/phase checkpoints consume their recorded `next_action` internally;
 only the caller replies finally at completion or a genuine stop.
+Before a reply, `devrites-engine check continuation` must print `continuation: clear`; `required` means invoke `invoke:` now.
 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

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

@@ -28,6 +28,8 @@ Fully escalated fingerprints park unless remaining owner is human.
 
 ## Not stops: internal technical routing
 
+AFK + `status=running` + an internal phase `next_action` is not a stop. `devrites-engine check continuation` prints `required` for that cursor and `clear` for `$rite-ship`, `awaiting_human`, a question cursor, or an open blocking or escalating question.
+
 `NEEDS_REPLAN` is not a stop condition under active Autocomplete. It blocks
 forward work, persists the return cursor, and invokes Plan repair plus Recovery
 Vet inline. The same applies to nested `STOP`/`Next step` when its decision is

package/pack/generated/codex/skills/rite-build/reference/parallel-batch.md

@@ -33,10 +33,10 @@ N_eff = min(
 ```
 
 Select **greedily in plan order** with
-`devrites-engine parallel select --slug <slug> --cap N --from-plan`: the engine
-reads the ready set (tasks.md dependencies checked `built` in `state.md`, minus
-running-lease slices) and each slice's Writer allowlist (else `Files likely
-touched`), plus its manifest/lockfile when `External dependencies:` is not none;
+`devrites-engine parallel select --slug <slug> --cap N --from-plan`: ready set
+(dependencies `built`, minus running-lease slices), Writer allowlist
+(else Files likely touched), plus manifest/lockfile when `External dependencies:`
+names a package (`none*`, existing, or no-new prose without a coordinate);
 `next` prints `eligible_now:`/`batch:`. `n_eff` counts new picks only.
 With a running lease, a single new pick still uses `parallel add`;
 `n_eff=0` with a running lease waits for siblings, not Prove. Without one:
@@ -73,7 +73,7 @@ Before `parallel select`, add each slice's hidden write surfaces (list owner:
 [repository-topology.md § Ownership rules](../../devrites-lib/reference/standards/repository-topology.md#ownership-rules))
 — lockfile/manifest, the generated target of an edited source, migration chain,
 snapshot directory, formatter sweep — and compare paths case-folded
-(`src/Api.ts` = `src/api.ts`); `--from-plan` adds the manifest/lockfile itself.
+(`src/Api.ts` = `src/api.ts`); `--from-plan` adds the manifest/lockfile for a package.
 Slices colliding on either run serially; the rest
 stay eligible. Record `serial: <ids> — <surface>` in `evidence.md`. Under AFK
 with `max_parallel ≥ 2`, `dispatch open` refuses a first-round build wright wave

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

@@ -26,6 +26,9 @@ individually or in one named group, so reviewers can `git diff` those paths.
 
 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.
+Before that reply, `devrites-engine check continuation` must say `continuation: clear`.
+`required` means invoke `invoke:` now; exit 0 is not a pause. **Failing case:**
+`vet stopped` plus `Resume: /rite-vet` while the check says `required`.
 
 Standalone HITL mid-flight replies follow the same economy:
 

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

@@ -154,13 +154,17 @@ pending slices. Each Autocomplete invocation owns internal backtracking. Context
 not create a stop; persist and resume the cursor.
 
 Reply only at final state: text-only turns end the run. Keep
-calling tools after compaction or phase changes. Use one line:
+calling tools after compaction or phase changes. Before any user-visible reply,
+`devrites-engine check continuation` must print `continuation: clear`
+(`handoff` prints the same lines). `required` means invoke `invoke:` now.
+`stopped` is not a phase token. Print this card only after `clear`:
 
 ```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>
+spec done · clarify clear · temper done · define done · vet ready · build n/N · prove — · polish — · review — · seal —
 ```
 
-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.
+Final state, only after `clear`: `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.
+**Failing case:** `vet stopped` plus `Resume: /rite-vet` while the check says `required`.

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

@@ -149,6 +149,7 @@ and park it after three escalations while independent work continues.
 
 Green slice/phase checkpoints consume their recorded `next_action` internally;
 only the caller replies finally at completion or a genuine stop.
+Before a reply, `devrites-engine check continuation` must print `continuation: clear`; `required` means invoke `invoke:` now.
 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

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

@@ -28,6 +28,8 @@ Fully escalated fingerprints park unless remaining owner is human.
 
 ## Not stops: internal technical routing
 
+AFK + `status=running` + an internal phase `next_action` is not a stop. `devrites-engine check continuation` prints `required` for that cursor and `clear` for `/rite-ship`, `awaiting_human`, a question cursor, or an open blocking or escalating question.
+
 `NEEDS_REPLAN` is not a stop condition under active Autocomplete. It blocks
 forward work, persists the return cursor, and invokes Plan repair plus Recovery
 Vet inline. The same applies to nested `STOP`/`Next step` when its decision is

package/pack/generated/devin/skills/rite-build/reference/parallel-batch.md

@@ -33,10 +33,10 @@ N_eff = min(
 ```
 
 Select **greedily in plan order** with
-`devrites-engine parallel select --slug <slug> --cap N --from-plan`: the engine
-reads the ready set (tasks.md dependencies checked `built` in `state.md`, minus
-running-lease slices) and each slice's Writer allowlist (else `Files likely
-touched`), plus its manifest/lockfile when `External dependencies:` is not none;
+`devrites-engine parallel select --slug <slug> --cap N --from-plan`: ready set
+(dependencies `built`, minus running-lease slices), Writer allowlist
+(else Files likely touched), plus manifest/lockfile when `External dependencies:`
+names a package (`none*`, existing, or no-new prose without a coordinate);
 `next` prints `eligible_now:`/`batch:`. `n_eff` counts new picks only.
 With a running lease, a single new pick still uses `parallel add`;
 `n_eff=0` with a running lease waits for siblings, not Prove. Without one:
@@ -73,7 +73,7 @@ Before `parallel select`, add each slice's hidden write surfaces (list owner:
 [repository-topology.md § Ownership rules](../../devrites-lib/reference/standards/repository-topology.md#ownership-rules))
 — lockfile/manifest, the generated target of an edited source, migration chain,
 snapshot directory, formatter sweep — and compare paths case-folded
-(`src/Api.ts` = `src/api.ts`); `--from-plan` adds the manifest/lockfile itself.
+(`src/Api.ts` = `src/api.ts`); `--from-plan` adds the manifest/lockfile for a package.
 Slices colliding on either run serially; the rest
 stay eligible. Record `serial: <ids> — <surface>` in `evidence.md`. Under AFK
 with `max_parallel ≥ 2`, `dispatch open` refuses a first-round build wright wave

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

@@ -26,6 +26,9 @@ individually or in one named group, so reviewers can `git diff` those paths.
 
 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.
+Before that reply, `devrites-engine check continuation` must say `continuation: clear`.
+`required` means invoke `invoke:` now; exit 0 is not a pause. **Failing case:**
+`vet stopped` plus `Resume: /rite-vet` while the check says `required`.
 
 Standalone HITL mid-flight replies follow the same economy:
 

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

@@ -155,13 +155,17 @@ pending slices. Each Autocomplete invocation owns internal backtracking. Context
 not create a stop; persist and resume the cursor.
 
 Reply only at final state: text-only turns end the run. Keep
-calling tools after compaction or phase changes. Use one line:
+calling tools after compaction or phase changes. Before any user-visible reply,
+`devrites-engine check continuation` must print `continuation: clear`
+(`handoff` prints the same lines). `required` means invoke `invoke:` now.
+`stopped` is not a phase token. Print this card only after `clear`:
 
 ```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>
+spec done · clarify clear · temper done · define done · vet ready · build n/N · prove — · polish — · review — · seal —
 ```
 
-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.
+Final state, only after `clear`: `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.
+**Failing case:** `vet stopped` plus `Resume: /rite-vet` while the check says `required`.

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

@@ -149,6 +149,7 @@ and park it after three escalations while independent work continues.
 
 Green slice/phase checkpoints consume their recorded `next_action` internally;
 only the caller replies finally at completion or a genuine stop.
+Before a reply, `devrites-engine check continuation` must print `continuation: clear`; `required` means invoke `invoke:` now.
 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

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

@@ -28,6 +28,8 @@ Fully escalated fingerprints park unless remaining owner is human.
 
 ## Not stops: internal technical routing
 
+AFK + `status=running` + an internal phase `next_action` is not a stop. `devrites-engine check continuation` prints `required` for that cursor and `clear` for `/rite-ship`, `awaiting_human`, a question cursor, or an open blocking or escalating question.
+
 `NEEDS_REPLAN` is not a stop condition under active Autocomplete. It blocks
 forward work, persists the return cursor, and invokes Plan repair plus Recovery
 Vet inline. The same applies to nested `STOP`/`Next step` when its decision is

package/pack/generated/dsh/skills/rite-build/reference/parallel-batch.md

@@ -33,10 +33,10 @@ N_eff = min(
 ```
 
 Select **greedily in plan order** with
-`devrites-engine parallel select --slug <slug> --cap N --from-plan`: the engine
-reads the ready set (tasks.md dependencies checked `built` in `state.md`, minus
-running-lease slices) and each slice's Writer allowlist (else `Files likely
-touched`), plus its manifest/lockfile when `External dependencies:` is not none;
+`devrites-engine parallel select --slug <slug> --cap N --from-plan`: ready set
+(dependencies `built`, minus running-lease slices), Writer allowlist
+(else Files likely touched), plus manifest/lockfile when `External dependencies:`
+names a package (`none*`, existing, or no-new prose without a coordinate);
 `next` prints `eligible_now:`/`batch:`. `n_eff` counts new picks only.
 With a running lease, a single new pick still uses `parallel add`;
 `n_eff=0` with a running lease waits for siblings, not Prove. Without one:
@@ -73,7 +73,7 @@ Before `parallel select`, add each slice's hidden write surfaces (list owner:
 [repository-topology.md § Ownership rules](../../devrites-lib/reference/standards/repository-topology.md#ownership-rules))
 — lockfile/manifest, the generated target of an edited source, migration chain,
 snapshot directory, formatter sweep — and compare paths case-folded
-(`src/Api.ts` = `src/api.ts`); `--from-plan` adds the manifest/lockfile itself.
+(`src/Api.ts` = `src/api.ts`); `--from-plan` adds the manifest/lockfile for a package.
 Slices colliding on either run serially; the rest
 stay eligible. Record `serial: <ids> — <surface>` in `evidence.md`. Under AFK
 with `max_parallel ≥ 2`, `dispatch open` refuses a first-round build wright wave

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

@@ -26,6 +26,9 @@ individually or in one named group, so reviewers can `git diff` those paths.
 
 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.
+Before that reply, `devrites-engine check continuation` must say `continuation: clear`.
+`required` means invoke `invoke:` now; exit 0 is not a pause. **Failing case:**
+`vet stopped` plus `Resume: /rite-vet` while the check says `required`.
 
 Standalone HITL mid-flight replies follow the same economy:
 

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

@@ -155,13 +155,17 @@ pending slices. Each Autocomplete invocation owns internal backtracking. Context
 not create a stop; persist and resume the cursor.
 
 Reply only at final state: text-only turns end the run. Keep
-calling tools after compaction or phase changes. Use one line:
+calling tools after compaction or phase changes. Before any user-visible reply,
+`devrites-engine check continuation` must print `continuation: clear`
+(`handoff` prints the same lines). `required` means invoke `invoke:` now.
+`stopped` is not a phase token. Print this card only after `clear`:
 
 ```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>
+spec done · clarify clear · temper done · define done · vet ready · build n/N · prove — · polish — · review — · seal —
 ```
 
-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.
+Final state, only after `clear`: `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.
+**Failing case:** `vet stopped` plus `Resume: /rite-vet` while the check says `required`.

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

@@ -149,6 +149,7 @@ and park it after three escalations while independent work continues.
 
 Green slice/phase checkpoints consume their recorded `next_action` internally;
 only the caller replies finally at completion or a genuine stop.
+Before a reply, `devrites-engine check continuation` must print `continuation: clear`; `required` means invoke `invoke:` now.
 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

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

@@ -28,6 +28,8 @@ Fully escalated fingerprints park unless remaining owner is human.
 
 ## Not stops: internal technical routing
 
+AFK + `status=running` + an internal phase `next_action` is not a stop. `devrites-engine check continuation` prints `required` for that cursor and `clear` for `/rite-ship`, `awaiting_human`, a question cursor, or an open blocking or escalating question.
+
 `NEEDS_REPLAN` is not a stop condition under active Autocomplete. It blocks
 forward work, persists the return cursor, and invokes Plan repair plus Recovery
 Vet inline. The same applies to nested `STOP`/`Next step` when its decision is

package/pack/generated/omp/skills/rite-build/reference/parallel-batch.md

@@ -33,10 +33,10 @@ N_eff = min(
 ```
 
 Select **greedily in plan order** with
-`devrites-engine parallel select --slug <slug> --cap N --from-plan`: the engine
-reads the ready set (tasks.md dependencies checked `built` in `state.md`, minus
-running-lease slices) and each slice's Writer allowlist (else `Files likely
-touched`), plus its manifest/lockfile when `External dependencies:` is not none;
+`devrites-engine parallel select --slug <slug> --cap N --from-plan`: ready set
+(dependencies `built`, minus running-lease slices), Writer allowlist
+(else Files likely touched), plus manifest/lockfile when `External dependencies:`
+names a package (`none*`, existing, or no-new prose without a coordinate);
 `next` prints `eligible_now:`/`batch:`. `n_eff` counts new picks only.
 With a running lease, a single new pick still uses `parallel add`;
 `n_eff=0` with a running lease waits for siblings, not Prove. Without one:
@@ -73,7 +73,7 @@ Before `parallel select`, add each slice's hidden write surfaces (list owner:
 [repository-topology.md § Ownership rules](skill://devrites-lib/reference/standards/repository-topology.md#ownership-rules))
 — lockfile/manifest, the generated target of an edited source, migration chain,
 snapshot directory, formatter sweep — and compare paths case-folded
-(`src/Api.ts` = `src/api.ts`); `--from-plan` adds the manifest/lockfile itself.
+(`src/Api.ts` = `src/api.ts`); `--from-plan` adds the manifest/lockfile for a package.
 Slices colliding on either run serially; the rest
 stay eligible. Record `serial: <ids> — <surface>` in `evidence.md`. Under AFK
 with `max_parallel ≥ 2`, `dispatch open` refuses a first-round build wright wave

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

@@ -26,6 +26,9 @@ individually or in one named group, so reviewers can `git diff` those paths.
 
 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.
+Before that reply, `devrites-engine check continuation` must say `continuation: clear`.
+`required` means invoke `invoke:` now; exit 0 is not a pause. **Failing case:**
+`vet stopped` plus `Resume: /rite-vet` while the check says `required`.
 
 Standalone HITL mid-flight replies follow the same economy:
 

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

@@ -155,13 +155,17 @@ pending slices. Each Autocomplete invocation owns internal backtracking. Context
 not create a stop; persist and resume the cursor.
 
 Reply only at final state: text-only turns end the run. Keep
-calling tools after compaction or phase changes. Use one line:
+calling tools after compaction or phase changes. Before any user-visible reply,
+`devrites-engine check continuation` must print `continuation: clear`
+(`handoff` prints the same lines). `required` means invoke `invoke:` now.
+`stopped` is not a phase token. Print this card only after `clear`:
 
 ```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>
+spec done · clarify clear · temper done · define done · vet ready · build n/N · prove — · polish — · review — · seal —
 ```
 
-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.
+Final state, only after `clear`: `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.
+**Failing case:** `vet stopped` plus `Resume: /rite-vet` while the check says `required`.

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

@@ -149,6 +149,7 @@ and park it after three escalations while independent work continues.
 
 Green slice/phase checkpoints consume their recorded `next_action` internally;
 only the caller replies finally at completion or a genuine stop.
+Before a reply, `devrites-engine check continuation` must print `continuation: clear`; `required` means invoke `invoke:` now.
 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

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

@@ -28,6 +28,8 @@ Fully escalated fingerprints park unless remaining owner is human.
 
 ## Not stops: internal technical routing
 
+AFK + `status=running` + an internal phase `next_action` is not a stop. `devrites-engine check continuation` prints `required` for that cursor and `clear` for `/rite-ship`, `awaiting_human`, a question cursor, or an open blocking or escalating question.
+
 `NEEDS_REPLAN` is not a stop condition under active Autocomplete. It blocks
 forward work, persists the return cursor, and invokes Plan repair plus Recovery
 Vet inline. The same applies to nested `STOP`/`Next step` when its decision is

package/pack/generated/pi/skills/rite-build/reference/parallel-batch.md

@@ -33,10 +33,10 @@ N_eff = min(
 ```
 
 Select **greedily in plan order** with
-`devrites-engine parallel select --slug <slug> --cap N --from-plan`: the engine
-reads the ready set (tasks.md dependencies checked `built` in `state.md`, minus
-running-lease slices) and each slice's Writer allowlist (else `Files likely
-touched`), plus its manifest/lockfile when `External dependencies:` is not none;
+`devrites-engine parallel select --slug <slug> --cap N --from-plan`: ready set
+(dependencies `built`, minus running-lease slices), Writer allowlist
+(else Files likely touched), plus manifest/lockfile when `External dependencies:`
+names a package (`none*`, existing, or no-new prose without a coordinate);
 `next` prints `eligible_now:`/`batch:`. `n_eff` counts new picks only.
 With a running lease, a single new pick still uses `parallel add`;
 `n_eff=0` with a running lease waits for siblings, not Prove. Without one:
@@ -73,7 +73,7 @@ Before `parallel select`, add each slice's hidden write surfaces (list owner:
 [repository-topology.md § Ownership rules](../../devrites-lib/reference/standards/repository-topology.md#ownership-rules))
 — lockfile/manifest, the generated target of an edited source, migration chain,
 snapshot directory, formatter sweep — and compare paths case-folded
-(`src/Api.ts` = `src/api.ts`); `--from-plan` adds the manifest/lockfile itself.
+(`src/Api.ts` = `src/api.ts`); `--from-plan` adds the manifest/lockfile for a package.
 Slices colliding on either run serially; the rest
 stay eligible. Record `serial: <ids> — <surface>` in `evidence.md`. Under AFK
 with `max_parallel ≥ 2`, `dispatch open` refuses a first-round build wright wave

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devrites",
-  "version": "7.2.4",
+  "version": "7.2.6",
   "description": "DevRites: a disciplined senior-engineer workflow pack for Claude Code, Codex, omp, pi, and Devin CLI",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://github.com/ViktorsBaikers/DevRites#readme",