devrites 7.3.8 → 7.3.10

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 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.3.10](https://github.com/ViktorsBaikers/DevRites/compare/v7.3.9...v7.3.10) (2026-11-12)
+
+### Fixed
+
+* **devrites:** recover autocomplete owner when ACTIVE is empty ([#213](https://github.com/ViktorsBaikers/DevRites/issues/213)) ([7014453](https://github.com/ViktorsBaikers/DevRites/commit/70144532ef53e9d6df9021b53523828b44ffc4f3))
+
+## [7.3.9](https://github.com/ViktorsBaikers/DevRites/compare/v7.3.8...v7.3.9) (2026-11-10)
+
+### Fixed
+
+* **devrites:** keep parallel autocomplete running past a source GO ([#212](https://github.com/ViktorsBaikers/DevRites/issues/212)) ([8dd7ab3](https://github.com/ViktorsBaikers/DevRites/commit/8dd7ab34a3d5ced36a7adb9ea4f2036db4116dcb))
+
 ## [7.3.8](https://github.com/ViktorsBaikers/DevRites/compare/v7.3.7...v7.3.8) (2026-11-09)
 
 ### Fixed
@@ -71,6 +83,8 @@ All notable changes to DevRites are documented here. The format follows [Keep a
 
 ### Fixed
 
+- Pin the engine and workflow-artifact fixture to Go 1.27.4 to address
+  GO-2026-6859 in `net/http`.
 - Mark only the slice a checked state.md item names first as built; a later
   `SLICE-###` reference in the same line no longer inflates regression, next, or
   parallel admission. Baselines written under the old all-token parsing re-ratchet
@@ -97,6 +111,9 @@ All notable changes to DevRites are documented here. The format follows [Keep a
   complete writer allowlist against live foreign claims, including symlink
   aliases, even when optional claim flags are absent or name unrelated paths.
 
+- Recover Autocomplete's recorded live sequence owner when ACTIVE is missing or
+  empty before requesting a workspace handoff; retain ambiguity, metadata repair,
+  human gates, and read-only recovery without changing ACTIVE.
 - Use `GH_TOKEN`, then `GITHUB_TOKEN`, then optional bounded noninteractive GitHub
   CLI credential lookup for release API requests. Keep credentials off release
   assets and off-origin redirects, fail explicit invalid credentials, and document

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

package/docs/engine/commands.md

@@ -35,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. |
-| `frontier [slug]` | Read-only report across exact recorded sequence relations, including archived intermediaries and live descendants. Emits `frontier: actionable\|waiting\|blocked\|clear` (`none` for a non-sequence source), `frontier-source:`, and `frontier-workspace:` rows with location, `inspect\|prepare\|repair\|wait\|complete` action, and reason. Emits `frontier-select-command:`, `frontier-picks:`, `frontier-selection: blocked`, `frontier-prepare:`, or `frontier-review-sequence:` where applicable. Explicit slug may be archived; absent ACTIVE recovery requires a unique archived terminal tip with a recorded native Spec edge, otherwise refuses ambiguity. One explicit `roadmap.md` owner anywhere in the related live/archive chain may supersede historical maps for scheduling: both `Sequence root:` and `Decision:` headers, a unique owner-local decision heading, and one contiguous position/workspace table must match recorded identities and successors. Either header claims this format; invalid authority fails closed without legacy fallback. Headerless maps retain legacy parsing. Native normalization preserves historical bytes; structural identity is not semantic approval. Never changes ACTIVE, restores archives, creates workspaces, or launches writers. Native preparation and semantic admission remain required; see [sequence frontier](../cli.md#sequence-frontier). |
+| `frontier [slug]` | Read-only report across exact recorded sequence relations, including archived intermediaries and live descendants. Emits `frontier: actionable\|waiting\|blocked\|clear` (`none` for a non-sequence source or no recorded sequence evidence), `frontier-source:`, and `frontier-workspace:` rows with location, `inspect\|prepare\|repair\|wait\|complete` action, and reason. Emits `frontier-select-command:`, `frontier-picks:`, `frontier-selection: blocked`, `frontier-prepare:`, or `frontier-review-sequence:` where applicable. Explicit slug may be archived. Without a slug and with missing/empty ACTIVE, recovers the earliest live owner of a unique validated recorded sequence (parent links or a numbered root with a sequence counter), or a unique archived terminal tip with an exact native next Spec edge and no children. Related live members share one sequence; equally earliest live siblings or unrelated eligible sequences refuse ambiguity, and invalid competing metadata requires repair. Without sequence evidence, `none` permits a fresh idea rather than forcing workspace selection. Standalone or loose directories, names, mtimes, and chat never identify a source. Explicit workspace overrides and retained controller constraints remain authoritative. Carry the returned `frontier-source:` explicitly to `handoff`, `context`, and `check continuation`. One explicit `roadmap.md` owner anywhere in the related live/archive chain may supersede historical maps for scheduling: both `Sequence root:` and `Decision:` headers, a unique owner-local decision heading, and one contiguous position/workspace table must match recorded identities and successors. Either header claims this format; invalid authority fails closed without legacy fallback. Headerless maps retain legacy parsing. Native normalization preserves historical bytes; structural identity is not semantic approval. Never changes ACTIVE, restores archives, creates workspaces, or launches writers. Native preparation and semantic admission remain required; see [sequence frontier](../cli.md#sequence-frontier). |
 | `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) ...`), unless `.devrites/AFK` `max_parallel` is 2 or more or a parallel lease is `running` (the bundle stays whole); `--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. |

package/engine/go.mod

@@ -2,4 +2,4 @@ module github.com/devrites/devrites
 
 go 1.26
 
-toolchain go1.27.3
+toolchain go1.27.4

package/engine/internal/lib/continuation.go

@@ -58,7 +58,11 @@ func RunCheckContinuation(root string, args []string, stdout, stderr io.Writer)
 			return 2
 		}
 		if mode && frontierGlobalPriority(slug, frontier) || !mode && !verdict.Required && len(frontier) > 0 && frontier[0] == "frontier: actionable" {
-			verdict = continuationVerdict{Required: true, Invoke: "/rite-autocomplete", Source: slug, Reason: "global frontier requires native preparation, authority review, or selection; no Ship approval"}
+			reason := "global frontier requires native preparation, authority review, or selection; Git stays unauthorized"
+			if mode && frontierHasBatch(frontier) {
+				reason = "a source GO does not end autocomplete; run every launch command and every picks writer this turn; do not ask; Git stays unauthorized"
+			}
+			verdict = continuationVerdict{Required: true, Invoke: "/rite-autocomplete", Source: slug, Reason: reason}
 		} else if mode && frontierSourcePreparationWait(slug, frontier) {
 			verdict = continuationVerdict{Reason: frontierInheritedPreparationWait}
 		} else if mode && !verdict.Required {
@@ -67,13 +71,37 @@ func RunCheckContinuation(root string, args []string, stdout, stderr io.Writer)
 			}
 		}
 	}
-	writeContinuation(stdout, verdict)
+	writeContinuation(stdout, verdict, frontier)
 	for _, line := range frontier {
 		fmt.Fprintln(stdout, line)
 	}
 	return 0
 }
 
+// frontierHasBatch reports a capped same-turn batch: planning commands and/or
+// admitted slice writers. The controller invoke stays /rite-autocomplete.
+func frontierHasBatch(lines []string) bool {
+	for _, line := range lines {
+		if strings.HasPrefix(line, "frontier-concurrent: ") || strings.HasPrefix(line, "frontier-picks: ") {
+			return true
+		}
+	}
+	return false
+}
+
+func writeFrontierBatch(stdout io.Writer, lines []string) {
+	for _, line := range lines {
+		if cmd, ok := strings.CutPrefix(line, "frontier-concurrent: "); ok && cmd != "" {
+			fmt.Fprintf(stdout, "launch: %s\n", cmd)
+		}
+	}
+	for _, line := range lines {
+		if picks, ok := strings.CutPrefix(line, "frontier-picks: "); ok && picks != "" {
+			fmt.Fprintf(stdout, "picks: %s\n", picks)
+		}
+	}
+}
+
 func classifyContinuation(root, slug string) (continuationVerdict, error) {
 	featureDir, err := devritespaths.ExistingFeatureDirChecked(root, slug)
 	if err != nil {
@@ -246,11 +274,12 @@ func continuationArguments(command workflow.Command, args []string, slug string)
 	return badArgs()
 }
 
-func writeContinuation(stdout io.Writer, verdict continuationVerdict) {
+func writeContinuation(stdout io.Writer, verdict continuationVerdict, frontier []string) {
 	if verdict.Required {
 		fmt.Fprintln(stdout, "continuation: required")
 		fmt.Fprintf(stdout, "invoke: %s\n", verdict.Invoke)
 		fmt.Fprintf(stdout, "source: %s\n", verdict.Source)
+		writeFrontierBatch(stdout, frontier)
 	} else {
 		fmt.Fprintln(stdout, "continuation: clear")
 	}

package/engine/internal/lib/frontier.go

@@ -5,6 +5,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"sort"
 	"strconv"
 	"strings"
 
@@ -22,6 +23,7 @@ type frontierWorkspace struct {
 	slug, dir, location, parent, phase, status, next, question string
 	position, remaining                                        int
 	hasPosition, hasRemaining                                  bool
+	hasParent                                                  bool
 	selectionHeld, agentOwnedPlanning                          bool
 	problem                                                    error
 }
@@ -92,7 +94,10 @@ func frontierRead(root, slug, location string) *frontierWorkspace {
 	}{
 		{state.CursorSequenceParent, &n.parent}, {state.CursorPhase, &n.phase}, {state.CursorStatus, &n.status}, {state.CursorNextAction, &n.next}, {state.CursorQuestionID, &n.question},
 	} {
-		value, _, err := frontierField(lines, field.key)
+		value, present, err := frontierField(lines, field.key)
+		if field.key == state.CursorSequenceParent {
+			n.hasParent = present
+		}
 		*field.dst = value
 		if err != nil {
 			n.problem = err
@@ -238,6 +243,75 @@ func frontierTerminal(n *frontierWorkspace) bool {
 
 func frontierQuote(s string) string { return "'" + strings.ReplaceAll(s, "'", "'\"'\"'") + "'" }
 
+func frontierRecoverSource(nodes map[string]*frontierWorkspace) (string, error) {
+	names := make([]string, 0, len(nodes))
+	hasChild := make(map[string]bool, len(nodes))
+	for name, n := range nodes {
+		names = append(names, name)
+		hasChild[n.parent] = true
+	}
+	sort.Strings(names)
+	owners := map[string]string{}
+	depths := map[string]int{}
+	ambiguous := map[string]bool{}
+	recorded := false
+	var tips []struct{ slug, anchor string }
+	for _, name := range names {
+		n := nodes[name]
+		tip := n.location == "archive" && frontierTerminal(n) && frontierSpecTarget(n) != "" && !hasChild[name]
+		recorded = recorded || n.parent != "" || n.hasPosition || n.hasRemaining || hasChild[name] || tip
+		if !n.hasParent && !n.hasPosition && !n.hasRemaining && !hasChild[name] && !tip {
+			continue
+		}
+		chain, err := frontierChain(nodes, name)
+		if err != nil {
+			return "", fmt.Errorf("empty ACTIVE: invalid recorded sequence at %s: %w; repair native sequence metadata before recovery", name, err)
+		}
+		anchor := chain[len(chain)-1]
+		if len(chain) > 1 || hasChild[name] || n.hasPosition && n.hasRemaining {
+			for i := len(chain) - 1; i >= 0; i-- {
+				member := chain[i]
+				if nodes[member].location != "live" {
+					continue
+				}
+				depth := len(chain) - i
+				old := owners[anchor]
+				if old == "" || depth < depths[anchor] {
+					owners[anchor], depths[anchor] = member, depth
+					ambiguous[anchor] = false
+				} else if depth == depths[anchor] && member != old {
+					ambiguous[anchor] = true
+				}
+				break
+			}
+		}
+		if tip {
+			tips = append(tips, struct{ slug, anchor string }{name, anchor})
+		}
+	}
+	if !recorded {
+		return "", nil
+	}
+	for _, name := range names {
+		if ambiguous[name] {
+			return "", fmt.Errorf("empty ACTIVE: sequence %s has multiple equally earliest live owners; repair native sequence ownership before recovery", name)
+		}
+	}
+	var sources []string
+	for _, owner := range owners {
+		sources = append(sources, owner)
+	}
+	for _, tip := range tips {
+		if owners[tip.anchor] == "" {
+			sources = append(sources, tip.slug)
+		}
+	}
+	if len(sources) != 1 {
+		return "", fmt.Errorf("empty ACTIVE: need a unique recorded live sequence owner or unique archived terminal sequence tip with exact next Spec edge; found %d", len(sources))
+	}
+	return sources[0], nil
+}
+
 // FrontierLines reports structural obligations, never semantic authorization or Ship approval.
 func FrontierLines(root, slug string) ([]string, error) {
 	mode, err := autocompleteMode(root)
@@ -266,26 +340,13 @@ func FrontierLines(root, slug string) ([]string, error) {
 		return nil, err
 	}
 	if slug == "" {
-		var tips []string
-		for name, n := range nodes {
-			if n.location != "archive" || !frontierTerminal(n) || frontierSpecTarget(n) == "" {
-				continue
-			}
-			if _, err := frontierChain(nodes, name); err != nil {
-				continue
-			}
-			hasChild := false
-			for _, child := range nodes {
-				hasChild = hasChild || child.parent == name
-			}
-			if !hasChild {
-				tips = append(tips, name)
-			}
+		slug, err = frontierRecoverSource(nodes)
+		if err != nil {
+			return nil, err
 		}
-		if len(tips) != 1 {
-			return nil, fmt.Errorf("empty ACTIVE: need a unique archived terminal sequence tip with exact next Spec edge; found %d", len(tips))
+		if slug == "" {
+			return []string{"frontier: none"}, nil
 		}
-		slug = tips[0]
 	}
 	source := nodes[slug]
 	if source == nil {
@@ -429,7 +490,7 @@ func FrontierLines(root, slug string) ([]string, error) {
 		}
 		if mode && action == "prepare" {
 			if cmd, ok := planningCursorCommand(reason); ok {
-				concurrent = append(concurrent, cmd)
+				concurrent = append(concurrent, commandWithWorkspace(cmd, name))
 			}
 		}
 		lines = append(lines, fmt.Sprintf("frontier-workspace: %s location=%s action=%s reason=%s", name, n.location, action, reason))
@@ -625,6 +686,20 @@ func agentOwnedPlanningCursor(n *frontierWorkspace) bool {
 	return preparationPhase(workflow.ForAction(n.next).Verb)
 }
 
+// commandWithWorkspace names the workspace on a phase command that omitted it.
+// `/rite-vet` cannot be launched; `/rite-vet <slug>` can.
+func commandWithWorkspace(cmd, slug string) string {
+	if slug == "" {
+		return cmd
+	}
+	for _, field := range strings.Fields(cmd) {
+		if field == slug {
+			return cmd
+		}
+	}
+	return cmd + " " + slug
+}
+
 func planningCursorCommand(reason string) (string, bool) {
 	const prefix = "native internal phase cursor: "
 	if !strings.HasPrefix(reason, prefix) {
@@ -740,10 +815,10 @@ func frontierLocal(root, controller string, n *frontierWorkspace, candidates *[]
 	if frontierSpecTarget(n) != "" {
 		return "complete", "native next Spec cursor recorded", nil
 	}
-	if _, internal, err := internalPhaseEdge(n.next, n.slug); err != nil {
+	if invoke, internal, err := internalPhaseEdge(n.next, n.slug); err != nil {
 		return "", "", err
 	} else if internal && (n.status == "running" || n.agentOwnedPlanning) {
-		return "prepare", "native internal phase cursor: " + n.next, nil
+		return "prepare", "native internal phase cursor: " + commandWithWorkspace(invoke, n.slug), nil
 	}
 	if command := workflow.ForAction(n.next); command.Verb == "ship" {
 		fields := strings.Fields(n.next)

package/engine/internal/lib/next.go

@@ -88,6 +88,7 @@ func RunNext(root string, args []string, stdout, stderr io.Writer) int {
 			return 2
 		}
 		if mode && frontierGlobalPriority(slug, lines) {
+			writeFrontierBatch(stdout, lines)
 			fmt.Fprintln(stdout, "next-command: /rite-autocomplete")
 			return exit
 		}

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

@@ -60,12 +60,9 @@ executable controller/harness/bundle bytes or a missing writer, read
 - Do not stop on `--max-slices`, sentinel `max_slices`, `max_agents`,
   `max_minutes`, or `max_review_queue`. Count failed, malformed, and
   unavailable leaf calls.
-- Never end the turn with a progress note while a wave runs or a next step
-  exists: on a headless host a text-only reply ends the session and kills
-  running children. Wait with the host's wait tool and keep working; end only
-  at a recorded stop. A host reminder or rule notice (style rule, advisory) is
-  not a stop either: follow it in your next tool call, never in a text-only
-  acknowledgement.
+- While waves run or next steps exist, use host tools/wait; text replies kill
+  headless sessions/children. End only at recorded stops; reminders/advisories
+  require tools, not acknowledgements.
 - Parse flags only from this invocation. `--ship`, `--yolo`, `--max-slices`,
   `--parallel`, `--full`, `--cross-model`, and `--lookahead` activate only as exact standalone
   tokens in `$ARGUMENTS`; examples or earlier messages can never arm them.
@@ -84,23 +81,30 @@ With `--lookahead` (trigger `lookahead`), follow
 [`lookahead.md`](reference/lookahead.md) instead of the steps below: plan the
 next sequence continuation through Vet in a second session, then stop.
 
-1. **Orient and parse.** Resolve source per [phase target binding](../devrites-lib/reference/parallel-workspaces.md#phase-target-binding).
-   Read its existing cursor; a fresh idea starts empty at step 2. Normalize this
-   invocation to idea, `ship_preflight: yes|no`, `max_slices: unlimited`,
+1. **Orient and parse.** Bind [source](../devrites-lib/reference/parallel-workspaces.md#phase-target-binding);
+   Keep validated overrides. With no source/override and missing/empty
+   `ACTIVE`, run `devrites-engine frontier` without slug first. Use unique
+   `frontier-source:` before asking. `frontier: none` without sequence
+   evidence permits fresh Spec at step 2; ambiguity/invalidity gates recovery.
+   Recovery never changes ACTIVE/flags or binds source from chat/recency.
+   Read existing `state.md` cursor.
+   Bind source in `devrites-engine`: `handoff <source> --resume`,
+   `context <source> --phase autocomplete`, `check continuation <source>`.
+   Arguments: idea, `ship_preflight: yes|no`, `max_slices: unlimited`,
    `parallel: N|default`, `profile: standard|full`, `cross_model: yes|no`.
-   Apply the loop's [AFK contract](reference/loop.md#arm-afk-once) to an existing
-   sentinel: upsert `mode: autocomplete`, plus capacity only for explicit
-   `--parallel N`. Mode identifies this controller, never grants authority.
-   Run `devrites-engine frontier <source>` before local recovery; execute the
+   Apply [AFK contract](reference/loop.md#arm-afk-once) to existing sentinel:
+   upsert `mode: autocomplete`; capacity only for explicit `--parallel N`.
+   Mode identifies controller, grants no authority. Run
+   `devrites-engine frontier <source>` before local recovery; execute
    [global pass](../devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).
-   Reconcile blocked/terminal cursors against retained action evidence and exact
-   fingerprint attempts; resume offline recovery below its cap. This explicit
-   invocation reopens parked fingerprints. Reconstruct missing return cursors
-   only from the current phase and approved `test-plan.md`/evidence action.
+   Reconcile blocked/terminal cursors with retained action evidence/exact fingerprint
+   attempts; resume below-cap offline recovery and reopen parked fingerprints.
+   Reconstruct missing return cursors only from current phase and approved
+   `test-plan.md`/evidence action, never chat.
 <!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"lifecycle cursor encounters admitted set or resumable journal","action":"invoke classifier; execute returned route internally","return":"saved phase/action; zero intermediate reply"} -->
-   After compaction/resume, run `devrites-engine handoff <source> --resume`
-   and open its `read_next` artifacts per [context hygiene](../devrites-lib/reference/standards/context-hygiene.md).
-   **Completion:** arguments/source are unambiguous; local cursor and handles survive.
+   On compaction/resume, first run `devrites-engine handoff <source> --resume`;
+   read only its `read_next` per [context hygiene](../devrites-lib/reference/standards/context-hygiene.md).
+   **Completion:** unambiguous arguments/source; cursor and handles intact.
 2. **Specify and clarify.** Run `devrites-interview`, `/rite-spec`, and
    `/rite-clarify` as one window. `open` material coverage never arms
    AFK. **Completion:** `Decision coverage: CLEAR` is durable.
@@ -147,15 +151,12 @@ next sequence continuation through Vet in a second session, then stop.
 
 ## Reply and resume
 
-HITL Build returns after one slice; Autocomplete ignores `--max-slices`, chaining
-pending slices. Each Autocomplete invocation owns internal backtracking. Context pressure, compaction, or a nested completion footer does
-not create a stop; persist and resume the cursor.
-
-Reply only at final state: text-only turns end the run. Keep
-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`:
+HITL Build returns after one slice; Autocomplete chains pending slices, ignoring
+`--max-slices`, and owns backtracking. Context pressure, compaction, and nested
+completion footers never stop it; persist/resume the cursor and keep calling tools.
+Before replying, `devrites-engine check continuation <source>` must print
+`continuation: clear` (`handoff` emits it too); `required` means execute `invoke:`
+now. `stopped` is no phase token. Only after `clear`, print:
 
 ```text
 Autocomplete: <slug>

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

@@ -44,9 +44,9 @@ admission and the global pass below; local readiness is insufficient. Count ever
 Explicit activation resets only activation-local counters, not durable recovery.
 Pass resolved `--parallel N` to [Build](../../rite-build/reference/output.md#caller-owned-continuation).
 Legacy or invented execution ceilings never stop this controller; human limits bind.
-Resolve ranked validating/blocking picks via `devrites-engine state resolve`, not
-a user handoff. Escalating, irreversible-risk, access, unrecommended blocking picks
-and Seal judgment (`slice: seal`) still pause.
+Resolve ranked picks via `devrites-engine state resolve`, not
+a user handoff. Escalating, irreversible-risk, access, and unrecommended blocking
+picks pause that source only. A Seal GO does not end the run.
 
 ## Early preparation admission
 

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

@@ -33,10 +33,10 @@ Autocomplete. Source human/Ship holds remain binding, while independent
 authorized planning can continue. `clear` is reply permission, not Ship approval.
 In autocomplete mode, `blocked` or `awaiting_human` is agent-owned recovery
 when no question cursor is set, no blocking or escalating question is open,
-and `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. Ship, Build,
-a question cursor, and an open blocking or escalating question still wait.
-`frontier-concurrent:` lists at most the cap of those cursors. Before any reply,
-start every listed command and every `frontier-picks` writer in the same turn.
+and `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. A GO, Ship,
+Build, question, or blocking hold binds that source only and does not end the run.
+Before any reply, start every `frontier-concurrent:` command and every
+`frontier-picks` writer, at most the cap. Ask only when both are empty.
 
 A preparation refusal routes native work or a narrow disclosed scheduling
 deferral under the [global pass](../../devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).

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

@@ -62,12 +62,9 @@ executable controller/harness/bundle bytes or a missing writer, read
 - Do not stop on `--max-slices`, sentinel `max_slices`, `max_agents`,
   `max_minutes`, or `max_review_queue`. Count failed, malformed, and
   unavailable leaf calls.
-- Never end the turn with a progress note while a wave runs or a next step
-  exists: on a headless host a text-only reply ends the session and kills
-  running children. Wait with the host's wait tool and keep working; end only
-  at a recorded stop. A host reminder or rule notice (style rule, advisory) is
-  not a stop either: follow it in your next tool call, never in a text-only
-  acknowledgement.
+- While waves run or next steps exist, use host tools/wait; text replies kill
+  headless sessions/children. End only at recorded stops; reminders/advisories
+  require tools, not acknowledgements.
 - Parse flags only from this invocation. `--ship`, `--yolo`, `--max-slices`,
   `--parallel`, `--full`, `--cross-model`, and `--lookahead` activate only as exact standalone
   tokens in `$ARGUMENTS`; examples or earlier messages can never arm them.
@@ -86,23 +83,30 @@ With `--lookahead` (trigger `lookahead`), follow
 [`lookahead.md`](reference/lookahead.md) instead of the steps below: plan the
 next sequence continuation through Vet in a second session, then stop.
 
-1. **Orient and parse.** Resolve source per [phase target binding](../devrites-lib/reference/parallel-workspaces.md#phase-target-binding).
-   Read its existing cursor; a fresh idea starts empty at step 2. Normalize this
-   invocation to idea, `ship_preflight: yes|no`, `max_slices: unlimited`,
+1. **Orient and parse.** Bind [source](../devrites-lib/reference/parallel-workspaces.md#phase-target-binding);
+   Keep validated overrides. With no source/override and missing/empty
+   `ACTIVE`, run `devrites-engine frontier` without slug first. Use unique
+   `frontier-source:` before asking. `frontier: none` without sequence
+   evidence permits fresh Spec at step 2; ambiguity/invalidity gates recovery.
+   Recovery never changes ACTIVE/flags or binds source from chat/recency.
+   Read existing `state.md` cursor.
+   Bind source in `devrites-engine`: `handoff <source> --resume`,
+   `context <source> --phase autocomplete`, `check continuation <source>`.
+   Arguments: idea, `ship_preflight: yes|no`, `max_slices: unlimited`,
    `parallel: N|default`, `profile: standard|full`, `cross_model: yes|no`.
-   Apply the loop's [AFK contract](reference/loop.md#arm-afk-once) to an existing
-   sentinel: upsert `mode: autocomplete`, plus capacity only for explicit
-   `--parallel N`. Mode identifies this controller, never grants authority.
-   Run `devrites-engine frontier <source>` before local recovery; execute the
+   Apply [AFK contract](reference/loop.md#arm-afk-once) to existing sentinel:
+   upsert `mode: autocomplete`; capacity only for explicit `--parallel N`.
+   Mode identifies controller, grants no authority. Run
+   `devrites-engine frontier <source>` before local recovery; execute
    [global pass](../devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).
-   Reconcile blocked/terminal cursors against retained action evidence and exact
-   fingerprint attempts; resume offline recovery below its cap. This explicit
-   invocation reopens parked fingerprints. Reconstruct missing return cursors
-   only from the current phase and approved `test-plan.md`/evidence action.
+   Reconcile blocked/terminal cursors with retained action evidence/exact fingerprint
+   attempts; resume below-cap offline recovery and reopen parked fingerprints.
+   Reconstruct missing return cursors only from current phase and approved
+   `test-plan.md`/evidence action, never chat.
 <!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"lifecycle cursor encounters admitted set or resumable journal","action":"invoke classifier; execute returned route internally","return":"saved phase/action; zero intermediate reply"} -->
-   After compaction/resume, run `devrites-engine handoff <source> --resume`
-   and open its `read_next` artifacts per [context hygiene](../devrites-lib/reference/standards/context-hygiene.md).
-   **Completion:** arguments/source are unambiguous; local cursor and handles survive.
+   On compaction/resume, first run `devrites-engine handoff <source> --resume`;
+   read only its `read_next` per [context hygiene](../devrites-lib/reference/standards/context-hygiene.md).
+   **Completion:** unambiguous arguments/source; cursor and handles intact.
 2. **Specify and clarify.** Run `devrites-interview`, `/rite-spec`, and
    `/rite-clarify` as one window. `open` material coverage never arms
    AFK. **Completion:** `Decision coverage: CLEAR` is durable.
@@ -149,15 +153,12 @@ next sequence continuation through Vet in a second session, then stop.
 
 ## Reply and resume
 
-HITL Build returns after one slice; Autocomplete ignores `--max-slices`, chaining
-pending slices. Each Autocomplete invocation owns internal backtracking. Context pressure, compaction, or a nested completion footer does
-not create a stop; persist and resume the cursor.
-
-Reply only at final state: text-only turns end the run. Keep
-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`:
+HITL Build returns after one slice; Autocomplete chains pending slices, ignoring
+`--max-slices`, and owns backtracking. Context pressure, compaction, and nested
+completion footers never stop it; persist/resume the cursor and keep calling tools.
+Before replying, `devrites-engine check continuation <source>` must print
+`continuation: clear` (`handoff` emits it too); `required` means execute `invoke:`
+now. `stopped` is no phase token. Only after `clear`, print:
 
 ```text
 Autocomplete: <slug>

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

@@ -46,9 +46,9 @@ admission and the global pass below; local readiness is insufficient. Count ever
 Explicit activation resets only activation-local counters, not durable recovery.
 Pass resolved `--parallel N` to [Build](../../rite-build/reference/output.md#caller-owned-continuation).
 Legacy or invented execution ceilings never stop this controller; human limits bind.
-Resolve ranked validating/blocking picks via `devrites-engine state resolve`, not
-a user handoff. Escalating, irreversible-risk, access, unrecommended blocking picks
-and Seal judgment (`slice: seal`) still pause.
+Resolve ranked picks via `devrites-engine state resolve`, not
+a user handoff. Escalating, irreversible-risk, access, and unrecommended blocking
+picks pause that source only. A Seal GO does not end the run.
 
 ## Early preparation admission
 

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

@@ -35,10 +35,10 @@ Autocomplete. Source human/Ship holds remain binding, while independent
 authorized planning can continue. `clear` is reply permission, not Ship approval.
 In autocomplete mode, `blocked` or `awaiting_human` is agent-owned recovery
 when no question cursor is set, no blocking or escalating question is open,
-and `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. Ship, Build,
-a question cursor, and an open blocking or escalating question still wait.
-`frontier-concurrent:` lists at most the cap of those cursors. Before any reply,
-start every listed command and every `frontier-picks` writer in the same turn.
+and `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. A GO, Ship,
+Build, question, or blocking hold binds that source only and does not end the run.
+Before any reply, start every `frontier-concurrent:` command and every
+`frontier-picks` writer, at most the cap. Ask only when both are empty.
 
 A preparation refusal routes native work or a narrow disclosed scheduling
 deferral under the [global pass](../../devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).

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

@@ -62,12 +62,9 @@ executable controller/harness/bundle bytes or a missing writer, read
 - Do not stop on `--max-slices`, sentinel `max_slices`, `max_agents`,
   `max_minutes`, or `max_review_queue`. Count failed, malformed, and
   unavailable leaf calls.
-- Never end the turn with a progress note while a wave runs or a next step
-  exists: on a headless host a text-only reply ends the session and kills
-  running children. Wait with the host's wait tool and keep working; end only
-  at a recorded stop. A host reminder or rule notice (style rule, advisory) is
-  not a stop either: follow it in your next tool call, never in a text-only
-  acknowledgement.
+- While waves run or next steps exist, use host tools/wait; text replies kill
+  headless sessions/children. End only at recorded stops; reminders/advisories
+  require tools, not acknowledgements.
 - Parse flags only from this invocation. `--ship`, `--yolo`, `--max-slices`,
   `--parallel`, `--full`, `--cross-model`, and `--lookahead` activate only as exact standalone
   tokens in `$ARGUMENTS`; examples or earlier messages can never arm them.
@@ -86,23 +83,30 @@ With `--lookahead` (trigger `lookahead`), follow
 [`lookahead.md`](reference/lookahead.md) instead of the steps below: plan the
 next sequence continuation through Vet in a second session, then stop.
 
-1. **Orient and parse.** Resolve source per [phase target binding](../devrites-lib/reference/parallel-workspaces.md#phase-target-binding).
-   Read its existing cursor; a fresh idea starts empty at step 2. Normalize this
-   invocation to idea, `ship_preflight: yes|no`, `max_slices: unlimited`,
+1. **Orient and parse.** Bind [source](../devrites-lib/reference/parallel-workspaces.md#phase-target-binding);
+   Keep validated overrides. With no source/override and missing/empty
+   `ACTIVE`, run `devrites-engine frontier` without slug first. Use unique
+   `frontier-source:` before asking. `frontier: none` without sequence
+   evidence permits fresh Spec at step 2; ambiguity/invalidity gates recovery.
+   Recovery never changes ACTIVE/flags or binds source from chat/recency.
+   Read existing `state.md` cursor.
+   Bind source in `devrites-engine`: `handoff <source> --resume`,
+   `context <source> --phase autocomplete`, `check continuation <source>`.
+   Arguments: idea, `ship_preflight: yes|no`, `max_slices: unlimited`,
    `parallel: N|default`, `profile: standard|full`, `cross_model: yes|no`.
-   Apply the loop's [AFK contract](reference/loop.md#arm-afk-once) to an existing
-   sentinel: upsert `mode: autocomplete`, plus capacity only for explicit
-   `--parallel N`. Mode identifies this controller, never grants authority.
-   Run `devrites-engine frontier <source>` before local recovery; execute the
+   Apply [AFK contract](reference/loop.md#arm-afk-once) to existing sentinel:
+   upsert `mode: autocomplete`; capacity only for explicit `--parallel N`.
+   Mode identifies controller, grants no authority. Run
+   `devrites-engine frontier <source>` before local recovery; execute
    [global pass](../devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).
-   Reconcile blocked/terminal cursors against retained action evidence and exact
-   fingerprint attempts; resume offline recovery below its cap. This explicit
-   invocation reopens parked fingerprints. Reconstruct missing return cursors
-   only from the current phase and approved `test-plan.md`/evidence action.
+   Reconcile blocked/terminal cursors with retained action evidence/exact fingerprint
+   attempts; resume below-cap offline recovery and reopen parked fingerprints.
+   Reconstruct missing return cursors only from current phase and approved
+   `test-plan.md`/evidence action, never chat.
 <!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"lifecycle cursor encounters admitted set or resumable journal","action":"invoke classifier; execute returned route internally","return":"saved phase/action; zero intermediate reply"} -->
-   After compaction/resume, run `devrites-engine handoff <source> --resume`
-   and open its `read_next` artifacts per [context hygiene](../devrites-lib/reference/standards/context-hygiene.md).
-   **Completion:** arguments/source are unambiguous; local cursor and handles survive.
+   On compaction/resume, first run `devrites-engine handoff <source> --resume`;
+   read only its `read_next` per [context hygiene](../devrites-lib/reference/standards/context-hygiene.md).
+   **Completion:** unambiguous arguments/source; cursor and handles intact.
 2. **Specify and clarify.** Run `devrites-interview`, `$rite-spec`, and
    `$rite-clarify` as one window. `open` material coverage never arms
    AFK. **Completion:** `Decision coverage: CLEAR` is durable.
@@ -149,15 +153,12 @@ next sequence continuation through Vet in a second session, then stop.
 
 ## Reply and resume
 
-HITL Build returns after one slice; Autocomplete ignores `--max-slices`, chaining
-pending slices. Each Autocomplete invocation owns internal backtracking. Context pressure, compaction, or a nested completion footer does
-not create a stop; persist and resume the cursor.
-
-Reply only at final state: text-only turns end the run. Keep
-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`:
+HITL Build returns after one slice; Autocomplete chains pending slices, ignoring
+`--max-slices`, and owns backtracking. Context pressure, compaction, and nested
+completion footers never stop it; persist/resume the cursor and keep calling tools.
+Before replying, `devrites-engine check continuation <source>` must print
+`continuation: clear` (`handoff` emits it too); `required` means execute `invoke:`
+now. `stopped` is no phase token. Only after `clear`, print:
 
 ```text
 Autocomplete: <slug>

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

@@ -46,9 +46,9 @@ admission and the global pass below; local readiness is insufficient. Count ever
 Explicit activation resets only activation-local counters, not durable recovery.
 Pass resolved `--parallel N` to [Build](../../rite-build/reference/output.md#caller-owned-continuation).
 Legacy or invented execution ceilings never stop this controller; human limits bind.
-Resolve ranked validating/blocking picks via `devrites-engine state resolve`, not
-a user handoff. Escalating, irreversible-risk, access, unrecommended blocking picks
-and Seal judgment (`slice: seal`) still pause.
+Resolve ranked picks via `devrites-engine state resolve`, not
+a user handoff. Escalating, irreversible-risk, access, and unrecommended blocking
+picks pause that source only. A Seal GO does not end the run.
 
 ## Early preparation admission
 

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

@@ -35,10 +35,10 @@ Autocomplete. Source human/Ship holds remain binding, while independent
 authorized planning can continue. `clear` is reply permission, not Ship approval.
 In autocomplete mode, `blocked` or `awaiting_human` is agent-owned recovery
 when no question cursor is set, no blocking or escalating question is open,
-and `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. Ship, Build,
-a question cursor, and an open blocking or escalating question still wait.
-`frontier-concurrent:` lists at most the cap of those cursors. Before any reply,
-start every listed command and every `frontier-picks` writer in the same turn.
+and `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. A GO, Ship,
+Build, question, or blocking hold binds that source only and does not end the run.
+Before any reply, start every `frontier-concurrent:` command and every
+`frontier-picks` writer, at most the cap. Ask only when both are empty.
 
 A preparation refusal routes native work or a narrow disclosed scheduling
 deferral under the [global pass](../../devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).

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

@@ -61,12 +61,9 @@ executable controller/harness/bundle bytes or a missing writer, read
 - Do not stop on `--max-slices`, sentinel `max_slices`, `max_agents`,
   `max_minutes`, or `max_review_queue`. Count failed, malformed, and
   unavailable leaf calls.
-- Never end the turn with a progress note while a wave runs or a next step
-  exists: on a headless host a text-only reply ends the session and kills
-  running children. Wait with the host's wait tool and keep working; end only
-  at a recorded stop. A host reminder or rule notice (style rule, advisory) is
-  not a stop either: follow it in your next tool call, never in a text-only
-  acknowledgement.
+- While waves run or next steps exist, use host tools/wait; text replies kill
+  headless sessions/children. End only at recorded stops; reminders/advisories
+  require tools, not acknowledgements.
 - Parse flags only from this invocation. `--ship`, `--yolo`, `--max-slices`,
   `--parallel`, `--full`, `--cross-model`, and `--lookahead` activate only as exact standalone
   tokens in `$ARGUMENTS`; examples or earlier messages can never arm them.
@@ -85,23 +82,30 @@ With `--lookahead` (trigger `lookahead`), follow
 [`lookahead.md`](reference/lookahead.md) instead of the steps below: plan the
 next sequence continuation through Vet in a second session, then stop.
 
-1. **Orient and parse.** Resolve source per [phase target binding](../devrites-lib/reference/parallel-workspaces.md#phase-target-binding).
-   Read its existing cursor; a fresh idea starts empty at step 2. Normalize this
-   invocation to idea, `ship_preflight: yes|no`, `max_slices: unlimited`,
+1. **Orient and parse.** Bind [source](../devrites-lib/reference/parallel-workspaces.md#phase-target-binding);
+   Keep validated overrides. With no source/override and missing/empty
+   `ACTIVE`, run `devrites-engine frontier` without slug first. Use unique
+   `frontier-source:` before asking. `frontier: none` without sequence
+   evidence permits fresh Spec at step 2; ambiguity/invalidity gates recovery.
+   Recovery never changes ACTIVE/flags or binds source from chat/recency.
+   Read existing `state.md` cursor.
+   Bind source in `devrites-engine`: `handoff <source> --resume`,
+   `context <source> --phase autocomplete`, `check continuation <source>`.
+   Arguments: idea, `ship_preflight: yes|no`, `max_slices: unlimited`,
    `parallel: N|default`, `profile: standard|full`, `cross_model: yes|no`.
-   Apply the loop's [AFK contract](reference/loop.md#arm-afk-once) to an existing
-   sentinel: upsert `mode: autocomplete`, plus capacity only for explicit
-   `--parallel N`. Mode identifies this controller, never grants authority.
-   Run `devrites-engine frontier <source>` before local recovery; execute the
+   Apply [AFK contract](reference/loop.md#arm-afk-once) to existing sentinel:
+   upsert `mode: autocomplete`; capacity only for explicit `--parallel N`.
+   Mode identifies controller, grants no authority. Run
+   `devrites-engine frontier <source>` before local recovery; execute
    [global pass](../devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).
-   Reconcile blocked/terminal cursors against retained action evidence and exact
-   fingerprint attempts; resume offline recovery below its cap. This explicit
-   invocation reopens parked fingerprints. Reconstruct missing return cursors
-   only from the current phase and approved `test-plan.md`/evidence action.
+   Reconcile blocked/terminal cursors with retained action evidence/exact fingerprint
+   attempts; resume below-cap offline recovery and reopen parked fingerprints.
+   Reconstruct missing return cursors only from current phase and approved
+   `test-plan.md`/evidence action, never chat.
 <!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"lifecycle cursor encounters admitted set or resumable journal","action":"invoke classifier; execute returned route internally","return":"saved phase/action; zero intermediate reply"} -->
-   After compaction/resume, run `devrites-engine handoff <source> --resume`
-   and open its `read_next` artifacts per [context hygiene](../devrites-lib/reference/standards/context-hygiene.md).
-   **Completion:** arguments/source are unambiguous; local cursor and handles survive.
+   On compaction/resume, first run `devrites-engine handoff <source> --resume`;
+   read only its `read_next` per [context hygiene](../devrites-lib/reference/standards/context-hygiene.md).
+   **Completion:** unambiguous arguments/source; cursor and handles intact.
 2. **Specify and clarify.** Run `devrites-interview`, `/rite-spec`, and
    `/rite-clarify` as one window. `open` material coverage never arms
    AFK. **Completion:** `Decision coverage: CLEAR` is durable.
@@ -148,15 +152,12 @@ next sequence continuation through Vet in a second session, then stop.
 
 ## Reply and resume
 
-HITL Build returns after one slice; Autocomplete ignores `--max-slices`, chaining
-pending slices. Each Autocomplete invocation owns internal backtracking. Context pressure, compaction, or a nested completion footer does
-not create a stop; persist and resume the cursor.
-
-Reply only at final state: text-only turns end the run. Keep
-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`:
+HITL Build returns after one slice; Autocomplete chains pending slices, ignoring
+`--max-slices`, and owns backtracking. Context pressure, compaction, and nested
+completion footers never stop it; persist/resume the cursor and keep calling tools.
+Before replying, `devrites-engine check continuation <source>` must print
+`continuation: clear` (`handoff` emits it too); `required` means execute `invoke:`
+now. `stopped` is no phase token. Only after `clear`, print:
 
 ```text
 Autocomplete: <slug>

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

@@ -46,9 +46,9 @@ admission and the global pass below; local readiness is insufficient. Count ever
 Explicit activation resets only activation-local counters, not durable recovery.
 Pass resolved `--parallel N` to [Build](../../rite-build/reference/output.md#caller-owned-continuation).
 Legacy or invented execution ceilings never stop this controller; human limits bind.
-Resolve ranked validating/blocking picks via `devrites-engine state resolve`, not
-a user handoff. Escalating, irreversible-risk, access, unrecommended blocking picks
-and Seal judgment (`slice: seal`) still pause.
+Resolve ranked picks via `devrites-engine state resolve`, not
+a user handoff. Escalating, irreversible-risk, access, and unrecommended blocking
+picks pause that source only. A Seal GO does not end the run.
 
 ## Early preparation admission
 

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

@@ -35,10 +35,10 @@ Autocomplete. Source human/Ship holds remain binding, while independent
 authorized planning can continue. `clear` is reply permission, not Ship approval.
 In autocomplete mode, `blocked` or `awaiting_human` is agent-owned recovery
 when no question cursor is set, no blocking or escalating question is open,
-and `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. Ship, Build,
-a question cursor, and an open blocking or escalating question still wait.
-`frontier-concurrent:` lists at most the cap of those cursors. Before any reply,
-start every listed command and every `frontier-picks` writer in the same turn.
+and `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. A GO, Ship,
+Build, question, or blocking hold binds that source only and does not end the run.
+Before any reply, start every `frontier-concurrent:` command and every
+`frontier-picks` writer, at most the cap. Ask only when both are empty.
 
 A preparation refusal routes native work or a narrow disclosed scheduling
 deferral under the [global pass](../../devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).

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

@@ -62,12 +62,9 @@ executable controller/harness/bundle bytes or a missing writer, read
 - Do not stop on `--max-slices`, sentinel `max_slices`, `max_agents`,
   `max_minutes`, or `max_review_queue`. Count failed, malformed, and
   unavailable leaf calls.
-- Never end the turn with a progress note while a wave runs or a next step
-  exists: on a headless host a text-only reply ends the session and kills
-  running children. Wait with the host's wait tool and keep working; end only
-  at a recorded stop. A host reminder or rule notice (style rule, advisory) is
-  not a stop either: follow it in your next tool call, never in a text-only
-  acknowledgement.
+- While waves run or next steps exist, use host tools/wait; text replies kill
+  headless sessions/children. End only at recorded stops; reminders/advisories
+  require tools, not acknowledgements.
 - Parse flags only from this invocation. `--ship`, `--yolo`, `--max-slices`,
   `--parallel`, `--full`, `--cross-model`, and `--lookahead` activate only as exact standalone
   tokens in `$ARGUMENTS`; examples or earlier messages can never arm them.
@@ -86,23 +83,30 @@ With `--lookahead` (trigger `lookahead`), follow
 [`lookahead.md`](reference/lookahead.md) instead of the steps below: plan the
 next sequence continuation through Vet in a second session, then stop.
 
-1. **Orient and parse.** Resolve source per [phase target binding](../devrites-lib/reference/parallel-workspaces.md#phase-target-binding).
-   Read its existing cursor; a fresh idea starts empty at step 2. Normalize this
-   invocation to idea, `ship_preflight: yes|no`, `max_slices: unlimited`,
+1. **Orient and parse.** Bind [source](../devrites-lib/reference/parallel-workspaces.md#phase-target-binding);
+   Keep validated overrides. With no source/override and missing/empty
+   `ACTIVE`, run `devrites-engine frontier` without slug first. Use unique
+   `frontier-source:` before asking. `frontier: none` without sequence
+   evidence permits fresh Spec at step 2; ambiguity/invalidity gates recovery.
+   Recovery never changes ACTIVE/flags or binds source from chat/recency.
+   Read existing `state.md` cursor.
+   Bind source in `devrites-engine`: `handoff <source> --resume`,
+   `context <source> --phase autocomplete`, `check continuation <source>`.
+   Arguments: idea, `ship_preflight: yes|no`, `max_slices: unlimited`,
    `parallel: N|default`, `profile: standard|full`, `cross_model: yes|no`.
-   Apply the loop's [AFK contract](reference/loop.md#arm-afk-once) to an existing
-   sentinel: upsert `mode: autocomplete`, plus capacity only for explicit
-   `--parallel N`. Mode identifies this controller, never grants authority.
-   Run `devrites-engine frontier <source>` before local recovery; execute the
+   Apply [AFK contract](reference/loop.md#arm-afk-once) to existing sentinel:
+   upsert `mode: autocomplete`; capacity only for explicit `--parallel N`.
+   Mode identifies controller, grants no authority. Run
+   `devrites-engine frontier <source>` before local recovery; execute
    [global pass](../devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).
-   Reconcile blocked/terminal cursors against retained action evidence and exact
-   fingerprint attempts; resume offline recovery below its cap. This explicit
-   invocation reopens parked fingerprints. Reconstruct missing return cursors
-   only from the current phase and approved `test-plan.md`/evidence action.
+   Reconcile blocked/terminal cursors with retained action evidence/exact fingerprint
+   attempts; resume below-cap offline recovery and reopen parked fingerprints.
+   Reconstruct missing return cursors only from current phase and approved
+   `test-plan.md`/evidence action, never chat.
 <!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"lifecycle cursor encounters admitted set or resumable journal","action":"invoke classifier; execute returned route internally","return":"saved phase/action; zero intermediate reply"} -->
-   After compaction/resume, run `devrites-engine handoff <source> --resume`
-   and open its `read_next` artifacts per [context hygiene](../devrites-lib/reference/standards/context-hygiene.md).
-   **Completion:** arguments/source are unambiguous; local cursor and handles survive.
+   On compaction/resume, first run `devrites-engine handoff <source> --resume`;
+   read only its `read_next` per [context hygiene](../devrites-lib/reference/standards/context-hygiene.md).
+   **Completion:** unambiguous arguments/source; cursor and handles intact.
 2. **Specify and clarify.** Run `devrites-interview`, `/rite-spec`, and
    `/rite-clarify` as one window. `open` material coverage never arms
    AFK. **Completion:** `Decision coverage: CLEAR` is durable.
@@ -149,15 +153,12 @@ next sequence continuation through Vet in a second session, then stop.
 
 ## Reply and resume
 
-HITL Build returns after one slice; Autocomplete ignores `--max-slices`, chaining
-pending slices. Each Autocomplete invocation owns internal backtracking. Context pressure, compaction, or a nested completion footer does
-not create a stop; persist and resume the cursor.
-
-Reply only at final state: text-only turns end the run. Keep
-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`:
+HITL Build returns after one slice; Autocomplete chains pending slices, ignoring
+`--max-slices`, and owns backtracking. Context pressure, compaction, and nested
+completion footers never stop it; persist/resume the cursor and keep calling tools.
+Before replying, `devrites-engine check continuation <source>` must print
+`continuation: clear` (`handoff` emits it too); `required` means execute `invoke:`
+now. `stopped` is no phase token. Only after `clear`, print:
 
 ```text
 Autocomplete: <slug>

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

@@ -46,9 +46,9 @@ admission and the global pass below; local readiness is insufficient. Count ever
 Explicit activation resets only activation-local counters, not durable recovery.
 Pass resolved `--parallel N` to [Build](../../rite-build/reference/output.md#caller-owned-continuation).
 Legacy or invented execution ceilings never stop this controller; human limits bind.
-Resolve ranked validating/blocking picks via `devrites-engine state resolve`, not
-a user handoff. Escalating, irreversible-risk, access, unrecommended blocking picks
-and Seal judgment (`slice: seal`) still pause.
+Resolve ranked picks via `devrites-engine state resolve`, not
+a user handoff. Escalating, irreversible-risk, access, and unrecommended blocking
+picks pause that source only. A Seal GO does not end the run.
 
 ## Early preparation admission
 

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

@@ -35,10 +35,10 @@ Autocomplete. Source human/Ship holds remain binding, while independent
 authorized planning can continue. `clear` is reply permission, not Ship approval.
 In autocomplete mode, `blocked` or `awaiting_human` is agent-owned recovery
 when no question cursor is set, no blocking or escalating question is open,
-and `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. Ship, Build,
-a question cursor, and an open blocking or escalating question still wait.
-`frontier-concurrent:` lists at most the cap of those cursors. Before any reply,
-start every listed command and every `frontier-picks` writer in the same turn.
+and `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. A GO, Ship,
+Build, question, or blocking hold binds that source only and does not end the run.
+Before any reply, start every `frontier-concurrent:` command and every
+`frontier-picks` writer, at most the cap. Ask only when both are empty.
 
 A preparation refusal routes native work or a narrow disclosed scheduling
 deferral under the [global pass](../../devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).

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

@@ -62,12 +62,9 @@ executable controller/harness/bundle bytes or a missing writer, read
 - Do not stop on `--max-slices`, sentinel `max_slices`, `max_agents`,
   `max_minutes`, or `max_review_queue`. Count failed, malformed, and
   unavailable leaf calls.
-- Never end the turn with a progress note while a wave runs or a next step
-  exists: on a headless host a text-only reply ends the session and kills
-  running children. Wait with the host's wait tool and keep working; end only
-  at a recorded stop. A host reminder or rule notice (style rule, advisory) is
-  not a stop either: follow it in your next tool call, never in a text-only
-  acknowledgement.
+- While waves run or next steps exist, use host tools/wait; text replies kill
+  headless sessions/children. End only at recorded stops; reminders/advisories
+  require tools, not acknowledgements.
 - Parse flags only from this invocation. `--ship`, `--yolo`, `--max-slices`,
   `--parallel`, `--full`, `--cross-model`, and `--lookahead` activate only as exact standalone
   tokens in `$ARGUMENTS`; examples or earlier messages can never arm them.
@@ -86,23 +83,30 @@ With `--lookahead` (trigger `lookahead`), follow
 [`lookahead.md`](reference/lookahead.md) instead of the steps below: plan the
 next sequence continuation through Vet in a second session, then stop.
 
-1. **Orient and parse.** Resolve source per [phase target binding](skill://devrites-lib/reference/parallel-workspaces.md#phase-target-binding).
-   Read its existing cursor; a fresh idea starts empty at step 2. Normalize this
-   invocation to idea, `ship_preflight: yes|no`, `max_slices: unlimited`,
+1. **Orient and parse.** Bind [source](skill://devrites-lib/reference/parallel-workspaces.md#phase-target-binding);
+   Keep validated overrides. With no source/override and missing/empty
+   `ACTIVE`, run `devrites-engine frontier` without slug first. Use unique
+   `frontier-source:` before asking. `frontier: none` without sequence
+   evidence permits fresh Spec at step 2; ambiguity/invalidity gates recovery.
+   Recovery never changes ACTIVE/flags or binds source from chat/recency.
+   Read existing `state.md` cursor.
+   Bind source in `devrites-engine`: `handoff <source> --resume`,
+   `context <source> --phase autocomplete`, `check continuation <source>`.
+   Arguments: idea, `ship_preflight: yes|no`, `max_slices: unlimited`,
    `parallel: N|default`, `profile: standard|full`, `cross_model: yes|no`.
-   Apply the loop's [AFK contract](reference/loop.md#arm-afk-once) to an existing
-   sentinel: upsert `mode: autocomplete`, plus capacity only for explicit
-   `--parallel N`. Mode identifies this controller, never grants authority.
-   Run `devrites-engine frontier <source>` before local recovery; execute the
+   Apply [AFK contract](reference/loop.md#arm-afk-once) to existing sentinel:
+   upsert `mode: autocomplete`; capacity only for explicit `--parallel N`.
+   Mode identifies controller, grants no authority. Run
+   `devrites-engine frontier <source>` before local recovery; execute
    [global pass](skill://devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).
-   Reconcile blocked/terminal cursors against retained action evidence and exact
-   fingerprint attempts; resume offline recovery below its cap. This explicit
-   invocation reopens parked fingerprints. Reconstruct missing return cursors
-   only from the current phase and approved `test-plan.md`/evidence action.
+   Reconcile blocked/terminal cursors with retained action evidence/exact fingerprint
+   attempts; resume below-cap offline recovery and reopen parked fingerprints.
+   Reconstruct missing return cursors only from current phase and approved
+   `test-plan.md`/evidence action, never chat.
 <!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"lifecycle cursor encounters admitted set or resumable journal","action":"invoke classifier; execute returned route internally","return":"saved phase/action; zero intermediate reply"} -->
-   After compaction/resume, run `devrites-engine handoff <source> --resume`
-   and open its `read_next` artifacts per [context hygiene](skill://devrites-lib/reference/standards/context-hygiene.md).
-   **Completion:** arguments/source are unambiguous; local cursor and handles survive.
+   On compaction/resume, first run `devrites-engine handoff <source> --resume`;
+   read only its `read_next` per [context hygiene](skill://devrites-lib/reference/standards/context-hygiene.md).
+   **Completion:** unambiguous arguments/source; cursor and handles intact.
 2. **Specify and clarify.** Run `devrites-interview`, `/rite-spec`, and
    `/rite-clarify` as one window. `open` material coverage never arms
    AFK. **Completion:** `Decision coverage: CLEAR` is durable.
@@ -149,15 +153,12 @@ next sequence continuation through Vet in a second session, then stop.
 
 ## Reply and resume
 
-HITL Build returns after one slice; Autocomplete ignores `--max-slices`, chaining
-pending slices. Each Autocomplete invocation owns internal backtracking. Context pressure, compaction, or a nested completion footer does
-not create a stop; persist and resume the cursor.
-
-Reply only at final state: text-only turns end the run. Keep
-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`:
+HITL Build returns after one slice; Autocomplete chains pending slices, ignoring
+`--max-slices`, and owns backtracking. Context pressure, compaction, and nested
+completion footers never stop it; persist/resume the cursor and keep calling tools.
+Before replying, `devrites-engine check continuation <source>` must print
+`continuation: clear` (`handoff` emits it too); `required` means execute `invoke:`
+now. `stopped` is no phase token. Only after `clear`, print:
 
 ```text
 Autocomplete: <slug>

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

@@ -46,9 +46,9 @@ admission and the global pass below; local readiness is insufficient. Count ever
 Explicit activation resets only activation-local counters, not durable recovery.
 Pass resolved `--parallel N` to [Build](skill://rite-build/reference/output.md#caller-owned-continuation).
 Legacy or invented execution ceilings never stop this controller; human limits bind.
-Resolve ranked validating/blocking picks via `devrites-engine state resolve`, not
-a user handoff. Escalating, irreversible-risk, access, unrecommended blocking picks
-and Seal judgment (`slice: seal`) still pause.
+Resolve ranked picks via `devrites-engine state resolve`, not
+a user handoff. Escalating, irreversible-risk, access, and unrecommended blocking
+picks pause that source only. A Seal GO does not end the run.
 
 ## Early preparation admission
 

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

@@ -35,10 +35,10 @@ Autocomplete. Source human/Ship holds remain binding, while independent
 authorized planning can continue. `clear` is reply permission, not Ship approval.
 In autocomplete mode, `blocked` or `awaiting_human` is agent-owned recovery
 when no question cursor is set, no blocking or escalating question is open,
-and `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. Ship, Build,
-a question cursor, and an open blocking or escalating question still wait.
-`frontier-concurrent:` lists at most the cap of those cursors. Before any reply,
-start every listed command and every `frontier-picks` writer in the same turn.
+and `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. A GO, Ship,
+Build, question, or blocking hold binds that source only and does not end the run.
+Before any reply, start every `frontier-concurrent:` command and every
+`frontier-picks` writer, at most the cap. Ask only when both are empty.
 
 A preparation refusal routes native work or a narrow disclosed scheduling
 deferral under the [global pass](skill://devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).

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

@@ -62,12 +62,9 @@ executable controller/harness/bundle bytes or a missing writer, read
 - Do not stop on `--max-slices`, sentinel `max_slices`, `max_agents`,
   `max_minutes`, or `max_review_queue`. Count failed, malformed, and
   unavailable leaf calls.
-- Never end the turn with a progress note while a wave runs or a next step
-  exists: on a headless host a text-only reply ends the session and kills
-  running children. Wait with the host's wait tool and keep working; end only
-  at a recorded stop. A host reminder or rule notice (style rule, advisory) is
-  not a stop either: follow it in your next tool call, never in a text-only
-  acknowledgement.
+- While waves run or next steps exist, use host tools/wait; text replies kill
+  headless sessions/children. End only at recorded stops; reminders/advisories
+  require tools, not acknowledgements.
 - Parse flags only from this invocation. `--ship`, `--yolo`, `--max-slices`,
   `--parallel`, `--full`, `--cross-model`, and `--lookahead` activate only as exact standalone
   tokens in `$ARGUMENTS`; examples or earlier messages can never arm them.
@@ -86,23 +83,30 @@ With `--lookahead` (trigger `lookahead`), follow
 [`lookahead.md`](reference/lookahead.md) instead of the steps below: plan the
 next sequence continuation through Vet in a second session, then stop.
 
-1. **Orient and parse.** Resolve source per [phase target binding](../devrites-lib/reference/parallel-workspaces.md#phase-target-binding).
-   Read its existing cursor; a fresh idea starts empty at step 2. Normalize this
-   invocation to idea, `ship_preflight: yes|no`, `max_slices: unlimited`,
+1. **Orient and parse.** Bind [source](../devrites-lib/reference/parallel-workspaces.md#phase-target-binding);
+   Keep validated overrides. With no source/override and missing/empty
+   `ACTIVE`, run `devrites-engine frontier` without slug first. Use unique
+   `frontier-source:` before asking. `frontier: none` without sequence
+   evidence permits fresh Spec at step 2; ambiguity/invalidity gates recovery.
+   Recovery never changes ACTIVE/flags or binds source from chat/recency.
+   Read existing `state.md` cursor.
+   Bind source in `devrites-engine`: `handoff <source> --resume`,
+   `context <source> --phase autocomplete`, `check continuation <source>`.
+   Arguments: idea, `ship_preflight: yes|no`, `max_slices: unlimited`,
    `parallel: N|default`, `profile: standard|full`, `cross_model: yes|no`.
-   Apply the loop's [AFK contract](reference/loop.md#arm-afk-once) to an existing
-   sentinel: upsert `mode: autocomplete`, plus capacity only for explicit
-   `--parallel N`. Mode identifies this controller, never grants authority.
-   Run `devrites-engine frontier <source>` before local recovery; execute the
+   Apply [AFK contract](reference/loop.md#arm-afk-once) to existing sentinel:
+   upsert `mode: autocomplete`; capacity only for explicit `--parallel N`.
+   Mode identifies controller, grants no authority. Run
+   `devrites-engine frontier <source>` before local recovery; execute
    [global pass](../devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).
-   Reconcile blocked/terminal cursors against retained action evidence and exact
-   fingerprint attempts; resume offline recovery below its cap. This explicit
-   invocation reopens parked fingerprints. Reconstruct missing return cursors
-   only from the current phase and approved `test-plan.md`/evidence action.
+   Reconcile blocked/terminal cursors with retained action evidence/exact fingerprint
+   attempts; resume below-cap offline recovery and reopen parked fingerprints.
+   Reconstruct missing return cursors only from current phase and approved
+   `test-plan.md`/evidence action, never chat.
 <!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"lifecycle cursor encounters admitted set or resumable journal","action":"invoke classifier; execute returned route internally","return":"saved phase/action; zero intermediate reply"} -->
-   After compaction/resume, run `devrites-engine handoff <source> --resume`
-   and open its `read_next` artifacts per [context hygiene](../devrites-lib/reference/standards/context-hygiene.md).
-   **Completion:** arguments/source are unambiguous; local cursor and handles survive.
+   On compaction/resume, first run `devrites-engine handoff <source> --resume`;
+   read only its `read_next` per [context hygiene](../devrites-lib/reference/standards/context-hygiene.md).
+   **Completion:** unambiguous arguments/source; cursor and handles intact.
 2. **Specify and clarify.** Run `devrites-interview`, `/rite-spec`, and
    `/rite-clarify` as one window. `open` material coverage never arms
    AFK. **Completion:** `Decision coverage: CLEAR` is durable.
@@ -149,15 +153,12 @@ next sequence continuation through Vet in a second session, then stop.
 
 ## Reply and resume
 
-HITL Build returns after one slice; Autocomplete ignores `--max-slices`, chaining
-pending slices. Each Autocomplete invocation owns internal backtracking. Context pressure, compaction, or a nested completion footer does
-not create a stop; persist and resume the cursor.
-
-Reply only at final state: text-only turns end the run. Keep
-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`:
+HITL Build returns after one slice; Autocomplete chains pending slices, ignoring
+`--max-slices`, and owns backtracking. Context pressure, compaction, and nested
+completion footers never stop it; persist/resume the cursor and keep calling tools.
+Before replying, `devrites-engine check continuation <source>` must print
+`continuation: clear` (`handoff` emits it too); `required` means execute `invoke:`
+now. `stopped` is no phase token. Only after `clear`, print:
 
 ```text
 Autocomplete: <slug>

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

@@ -46,9 +46,9 @@ admission and the global pass below; local readiness is insufficient. Count ever
 Explicit activation resets only activation-local counters, not durable recovery.
 Pass resolved `--parallel N` to [Build](../../rite-build/reference/output.md#caller-owned-continuation).
 Legacy or invented execution ceilings never stop this controller; human limits bind.
-Resolve ranked validating/blocking picks via `devrites-engine state resolve`, not
-a user handoff. Escalating, irreversible-risk, access, unrecommended blocking picks
-and Seal judgment (`slice: seal`) still pause.
+Resolve ranked picks via `devrites-engine state resolve`, not
+a user handoff. Escalating, irreversible-risk, access, and unrecommended blocking
+picks pause that source only. A Seal GO does not end the run.
 
 ## Early preparation admission
 

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

@@ -35,10 +35,10 @@ Autocomplete. Source human/Ship holds remain binding, while independent
 authorized planning can continue. `clear` is reply permission, not Ship approval.
 In autocomplete mode, `blocked` or `awaiting_human` is agent-owned recovery
 when no question cursor is set, no blocking or escalating question is open,
-and `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. Ship, Build,
-a question cursor, and an open blocking or escalating question still wait.
-`frontier-concurrent:` lists at most the cap of those cursors. Before any reply,
-start every listed command and every `frontier-picks` writer in the same turn.
+and `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. A GO, Ship,
+Build, question, or blocking hold binds that source only and does not end the run.
+Before any reply, start every `frontier-concurrent:` command and every
+`frontier-picks` writer, at most the cap. Ask only when both are empty.
 
 A preparation refusal routes native work or a narrow disclosed scheduling
 deferral under the [global pass](../../devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devrites",
-  "version": "7.3.8",
+  "version": "7.3.10",
   "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",