devrites 7.3.7 → 7.3.9

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.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
+
+* **devrites:** schedule agent-owned planning cursors together ([#211](https://github.com/ViktorsBaikers/DevRites/issues/211)) ([8553c00](https://github.com/ViktorsBaikers/DevRites/commit/8553c0038ddeb2608608cdc19f133f3f2a1de0e1))
+
 ## [7.3.7](https://github.com/ViktorsBaikers/DevRites/compare/v7.3.6...v7.3.7) (2026-11-09)
 
 ### 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.3.7`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v7.3.7): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
+**Status:** [`v7.3.9`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v7.3.9): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
 
 This is the latest published release; `main` may contain unreleased work.
 

package/engine/internal/lib/continuation.go

@@ -58,18 +58,50 @@ 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 {
+			if invoke, ok := frontierSourcePlanningCursor(slug, frontier); ok {
+				verdict = continuationVerdict{Required: true, Invoke: invoke, Source: slug, Reason: "agent-owned planning cursor; launch every frontier-concurrent command before replying"}
+			}
 		}
 	}
-	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 {
@@ -242,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

@@ -22,7 +22,7 @@ type frontierWorkspace struct {
 	slug, dir, location, parent, phase, status, next, question string
 	position, remaining                                        int
 	hasPosition, hasRemaining                                  bool
-	selectionHeld                                              bool
+	selectionHeld, agentOwnedPlanning                          bool
 	problem                                                    error
 }
 
@@ -374,6 +374,7 @@ func FrontierLines(root, slug string) ([]string, error) {
 	}
 	deferred := map[string]string{}
 	prepared := map[string]bool{}
+	var concurrent []string
 	var preparatory map[string]bool
 	var preparationAccounts map[string]*dispatchFile
 	if mode && capN > 1 {
@@ -393,7 +394,7 @@ func FrontierLines(root, slug string) ([]string, error) {
 		_, invalid := frontierChain(nodes, name)
 		if invalid != nil {
 			action, reason, blocked = "repair", invalid.Error(), true
-		} else if gateReason, gateErr := frontierQuestionHold(n); gateErr != nil {
+		} else if gateReason, gateErr := frontierSchedulingHold(n, mode); gateErr != nil {
 			action, reason, held, blocked = "repair", gateErr.Error(), true, true
 		} else if gateReason != "" {
 			action, reason, held, blocked = "wait", gateReason, true, true
@@ -426,6 +427,11 @@ func FrontierLines(root, slug string) ([]string, error) {
 				action = "wait"
 			}
 		}
+		if mode && action == "prepare" {
+			if cmd, ok := planningCursorCommand(reason); ok {
+				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))
 		if preparatory[name] {
 			continue
@@ -518,6 +524,15 @@ func FrontierLines(root, slug string) ([]string, error) {
 			}
 		}
 	}
+	if mode && capN > 0 && len(concurrent) > 0 {
+		limit := capN
+		if limit > len(concurrent) {
+			limit = len(concurrent)
+		}
+		for _, cmd := range concurrent[:limit] {
+			lines = append(lines, "frontier-concurrent: "+cmd)
+		}
+	}
 	verdict := "clear"
 	if blocked {
 		verdict = "blocked"
@@ -577,6 +592,65 @@ func frontierPolicy(root string) (bool, int, error) {
 	return allow, capN, nil
 }
 
+func frontierSchedulingHold(n *frontierWorkspace, mode bool) (string, error) {
+	if mode && agentOwnedPlanningCursor(n) {
+		if n.question != "" {
+			return "human/blocked cursor; retain native gate", nil
+		}
+		questions, err := readBoundedRegularFile(filepath.Join(n.dir, "questions.md"), workspaceArtifactLimit)
+		if err != nil && !os.IsNotExist(err) {
+			return "", err
+		}
+		if err == nil {
+			for _, kind := range gate.OpenBlockingQuestionGates(questions) {
+				if kind == "blocking" || kind == "escalating" {
+					return "open " + kind + " question; retain native gate", nil
+				}
+			}
+		}
+		n.agentOwnedPlanning = true
+		return "", nil
+	}
+	return frontierQuestionHold(n)
+}
+
+func agentOwnedPlanningCursor(n *frontierWorkspace) bool {
+	if n == nil || (n.status != "blocked" && n.status != "awaiting_human") {
+		return false
+	}
+	_, internal, err := internalPhaseEdge(n.next, n.slug)
+	if err != nil || !internal {
+		return false
+	}
+	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) {
+		return "", false
+	}
+	cmd := strings.TrimSpace(strings.TrimPrefix(reason, prefix))
+	if cmd == "" || strings.ContainsAny(cmd, "\n\r") {
+		return "", false
+	}
+	return cmd, true
+}
+
 func frontierQuestionHold(n *frontierWorkspace) (string, error) {
 	if n.status == "awaiting_human" || n.status == "blocked" || n.question != "" {
 		return "human/blocked cursor; retain native gate", nil
@@ -601,7 +675,7 @@ func frontierLocal(root, controller string, n *frontierWorkspace, candidates *[]
 	if _, err := devritespaths.WorkspaceOverrideChecked(root, n.slug); err != nil {
 		return "blocked", "DEVRITES_WORKSPACE scope retained; unset override before global admission", nil
 	}
-	if n.status != "running" && n.status != "ready" {
+	if n.status != "running" && n.status != "ready" && !n.agentOwnedPlanning {
 		return "blocked", "status lacks an actionable native cursor; normalize state without inventing authority", nil
 	}
 	if dispatch == nil {
@@ -680,10 +754,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" {
-		return "prepare", "native internal phase cursor: " + n.next, nil
+	} else if internal && (n.status == "running" || n.agentOwnedPlanning) {
+		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/frontier_controller.go

@@ -618,6 +618,19 @@ func autocompleteWriterAdmission(root, source string, wave *dispatchWave, curren
 
 const frontierInheritedPreparationWait = "preparatory descendant; continue immediate-parent preparation before this native cursor"
 
+func frontierSourcePlanningCursor(source string, lines []string) (string, bool) {
+	prefix := "frontier-workspace: " + source + " location=live action=prepare reason=native internal phase cursor: "
+	for _, line := range lines {
+		if strings.HasPrefix(line, prefix) {
+			cmd := strings.TrimSpace(strings.TrimPrefix(line, prefix))
+			if cmd != "" {
+				return cmd, true
+			}
+		}
+	}
+	return "", false
+}
+
 func frontierSourcePreparationWait(source string, lines []string) bool {
 	wait := "frontier-workspace: " + source + " location=live action=wait reason=" + frontierInheritedPreparationWait
 	for _, line := range lines {

package/engine/internal/lib/frontier_preparation.go

@@ -57,6 +57,15 @@ func (p preparationPurpose) validate(phase string, roles []string, context bool)
 	return nil
 }
 
+func ordinaryAdmittedPhase(phase string) bool {
+	switch phase {
+	case "temper", "define", "plan", "vet", "build", "prove", "polish", "review", "seal", "ship", "done":
+		return true
+	default:
+		return false
+	}
+}
+
 func earlyPreparationPhase(phase string) bool {
 	phase = strings.ToLower(phase)
 	return phase == "temper" || phase == "define" || phase == "plan" || phase == "vet"
@@ -199,6 +208,11 @@ func frontierPreparatoryOnly(root string, n *frontierWorkspace, nodes map[string
 		return false, account, nil
 	}
 	if account == nil {
+		// A recorded Temper-or-later phase is ordinary work. Missing dispatch
+		// waves do not keep every later sibling preparatory-only.
+		if ordinaryAdmittedPhase(n.phase) {
+			return false, nil, nil
+		}
 		return true, nil, nil
 	}
 	for _, wave := range account.Waves {

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/devrites-lib/reference/parallel-workspaces.md

@@ -113,6 +113,12 @@ return cursors and native handles: one controller, not another phase or queue.
    obligation. Placeholders, reports and unopened waves prove nothing.
    Opt-out, zero opening budget or source human/question holds prevent new
    openings, not existing child preparation or independent work.
+   In autocomplete mode, `blocked` or `awaiting_human` with no question cursor
+   and no open blocking or escalating question is existing work when
+   `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. A recorded
+   Temper-or-later phase is ordinary work, so later siblings stay visible.
+   Launch every `frontier-concurrent:` command and every `frontier-picks`
+   writer in the same turn, up to the cap, picks first.
    If preparation cannot start, retain `frontier-blocked: <successor> — <constraint>`
    in source `evidence.md`. `frontier-blocked: sequence — <constraint>` may defer
    unresolved historical normalization for valid independent local work. Each row

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
 
@@ -97,6 +97,10 @@ At phase entry, before recovery/waits, execute the
 [global pass](../../devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).
 Consume persisted return frontiers; rerun after landing/artifact/capacity changes.
 Execute authorized routes, retaining handles, cursors and protected proof windows.
+When frontier prints `frontier-concurrent:`, launch every listed command and every
+`frontier-picks` writer in that same turn, each on its own source. The cap bounds
+the turn: start picks first, then fill remaining slots from `frontier-concurrent`.
+Do not finish one listed source and reply.
 
 Check [stop-conditions.md](stop-conditions.md) before advancing. Discard stale
 pass evidence after source edits. Re-read the selected source before each phase per [phase target binding](../../devrites-lib/reference/parallel-workspaces.md#phase-target-binding). On a cold resume or

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

@@ -31,6 +31,12 @@ For AFK `status=running`, consume an internal phase edge. In
 work takes priority over local Build; local-only picks do not recurse through
 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. 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/devrites-lib/reference/parallel-workspaces.md

@@ -113,6 +113,12 @@ return cursors and native handles: one controller, not another phase or queue.
    obligation. Placeholders, reports and unopened waves prove nothing.
    Opt-out, zero opening budget or source human/question holds prevent new
    openings, not existing child preparation or independent work.
+   In autocomplete mode, `blocked` or `awaiting_human` with no question cursor
+   and no open blocking or escalating question is existing work when
+   `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. A recorded
+   Temper-or-later phase is ordinary work, so later siblings stay visible.
+   Launch every `frontier-concurrent:` command and every `frontier-picks`
+   writer in the same turn, up to the cap, picks first.
    If preparation cannot start, retain `frontier-blocked: <successor> — <constraint>`
    in source `evidence.md`. `frontier-blocked: sequence — <constraint>` may defer
    unresolved historical normalization for valid independent local work. Each row

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
 
@@ -99,6 +99,10 @@ At phase entry, before recovery/waits, execute the
 [global pass](../../devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).
 Consume persisted return frontiers; rerun after landing/artifact/capacity changes.
 Execute authorized routes, retaining handles, cursors and protected proof windows.
+When frontier prints `frontier-concurrent:`, launch every listed command and every
+`frontier-picks` writer in that same turn, each on its own source. The cap bounds
+the turn: start picks first, then fill remaining slots from `frontier-concurrent`.
+Do not finish one listed source and reply.
 
 Check [stop-conditions.md](stop-conditions.md) before advancing. Discard stale
 pass evidence after source edits. Re-read the selected source before each phase per [phase target binding](../../devrites-lib/reference/parallel-workspaces.md#phase-target-binding). On a cold resume or

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

@@ -33,6 +33,12 @@ For AFK `status=running`, consume an internal phase edge. In
 work takes priority over local Build; local-only picks do not recurse through
 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. 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/devrites-lib/reference/parallel-workspaces.md

@@ -113,6 +113,12 @@ return cursors and native handles: one controller, not another phase or queue.
    obligation. Placeholders, reports and unopened waves prove nothing.
    Opt-out, zero opening budget or source human/question holds prevent new
    openings, not existing child preparation or independent work.
+   In autocomplete mode, `blocked` or `awaiting_human` with no question cursor
+   and no open blocking or escalating question is existing work when
+   `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. A recorded
+   Temper-or-later phase is ordinary work, so later siblings stay visible.
+   Launch every `frontier-concurrent:` command and every `frontier-picks`
+   writer in the same turn, up to the cap, picks first.
    If preparation cannot start, retain `frontier-blocked: <successor> — <constraint>`
    in source `evidence.md`. `frontier-blocked: sequence — <constraint>` may defer
    unresolved historical normalization for valid independent local work. Each row

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
 
@@ -99,6 +99,10 @@ At phase entry, before recovery/waits, execute the
 [global pass](../../devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).
 Consume persisted return frontiers; rerun after landing/artifact/capacity changes.
 Execute authorized routes, retaining handles, cursors and protected proof windows.
+When frontier prints `frontier-concurrent:`, launch every listed command and every
+`frontier-picks` writer in that same turn, each on its own source. The cap bounds
+the turn: start picks first, then fill remaining slots from `frontier-concurrent`.
+Do not finish one listed source and reply.
 
 Check [stop-conditions.md](stop-conditions.md) before advancing. Discard stale
 pass evidence after source edits. Re-read the selected source before each phase per [phase target binding](../../devrites-lib/reference/parallel-workspaces.md#phase-target-binding). On a cold resume or

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

@@ -33,6 +33,12 @@ For AFK `status=running`, consume an internal phase edge. In
 work takes priority over local Build; local-only picks do not recurse through
 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. 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/devrites-lib/reference/parallel-workspaces.md

@@ -113,6 +113,12 @@ return cursors and native handles: one controller, not another phase or queue.
    obligation. Placeholders, reports and unopened waves prove nothing.
    Opt-out, zero opening budget or source human/question holds prevent new
    openings, not existing child preparation or independent work.
+   In autocomplete mode, `blocked` or `awaiting_human` with no question cursor
+   and no open blocking or escalating question is existing work when
+   `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. A recorded
+   Temper-or-later phase is ordinary work, so later siblings stay visible.
+   Launch every `frontier-concurrent:` command and every `frontier-picks`
+   writer in the same turn, up to the cap, picks first.
    If preparation cannot start, retain `frontier-blocked: <successor> — <constraint>`
    in source `evidence.md`. `frontier-blocked: sequence — <constraint>` may defer
    unresolved historical normalization for valid independent local work. Each row

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
 
@@ -99,6 +99,10 @@ At phase entry, before recovery/waits, execute the
 [global pass](../../devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).
 Consume persisted return frontiers; rerun after landing/artifact/capacity changes.
 Execute authorized routes, retaining handles, cursors and protected proof windows.
+When frontier prints `frontier-concurrent:`, launch every listed command and every
+`frontier-picks` writer in that same turn, each on its own source. The cap bounds
+the turn: start picks first, then fill remaining slots from `frontier-concurrent`.
+Do not finish one listed source and reply.
 
 Check [stop-conditions.md](stop-conditions.md) before advancing. Discard stale
 pass evidence after source edits. Re-read the selected source before each phase per [phase target binding](../../devrites-lib/reference/parallel-workspaces.md#phase-target-binding). On a cold resume or

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

@@ -33,6 +33,12 @@ For AFK `status=running`, consume an internal phase edge. In
 work takes priority over local Build; local-only picks do not recurse through
 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. 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/devrites-lib/reference/parallel-workspaces.md

@@ -113,6 +113,12 @@ return cursors and native handles: one controller, not another phase or queue.
    obligation. Placeholders, reports and unopened waves prove nothing.
    Opt-out, zero opening budget or source human/question holds prevent new
    openings, not existing child preparation or independent work.
+   In autocomplete mode, `blocked` or `awaiting_human` with no question cursor
+   and no open blocking or escalating question is existing work when
+   `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. A recorded
+   Temper-or-later phase is ordinary work, so later siblings stay visible.
+   Launch every `frontier-concurrent:` command and every `frontier-picks`
+   writer in the same turn, up to the cap, picks first.
    If preparation cannot start, retain `frontier-blocked: <successor> — <constraint>`
    in source `evidence.md`. `frontier-blocked: sequence — <constraint>` may defer
    unresolved historical normalization for valid independent local work. Each row

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
 
@@ -99,6 +99,10 @@ At phase entry, before recovery/waits, execute the
 [global pass](../../devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).
 Consume persisted return frontiers; rerun after landing/artifact/capacity changes.
 Execute authorized routes, retaining handles, cursors and protected proof windows.
+When frontier prints `frontier-concurrent:`, launch every listed command and every
+`frontier-picks` writer in that same turn, each on its own source. The cap bounds
+the turn: start picks first, then fill remaining slots from `frontier-concurrent`.
+Do not finish one listed source and reply.
 
 Check [stop-conditions.md](stop-conditions.md) before advancing. Discard stale
 pass evidence after source edits. Re-read the selected source before each phase per [phase target binding](../../devrites-lib/reference/parallel-workspaces.md#phase-target-binding). On a cold resume or

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

@@ -33,6 +33,12 @@ For AFK `status=running`, consume an internal phase edge. In
 work takes priority over local Build; local-only picks do not recurse through
 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. 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/devrites-lib/reference/parallel-workspaces.md

@@ -113,6 +113,12 @@ return cursors and native handles: one controller, not another phase or queue.
    obligation. Placeholders, reports and unopened waves prove nothing.
    Opt-out, zero opening budget or source human/question holds prevent new
    openings, not existing child preparation or independent work.
+   In autocomplete mode, `blocked` or `awaiting_human` with no question cursor
+   and no open blocking or escalating question is existing work when
+   `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. A recorded
+   Temper-or-later phase is ordinary work, so later siblings stay visible.
+   Launch every `frontier-concurrent:` command and every `frontier-picks`
+   writer in the same turn, up to the cap, picks first.
    If preparation cannot start, retain `frontier-blocked: <successor> — <constraint>`
    in source `evidence.md`. `frontier-blocked: sequence — <constraint>` may defer
    unresolved historical normalization for valid independent local work. Each row

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
 
@@ -99,6 +99,10 @@ At phase entry, before recovery/waits, execute the
 [global pass](skill://devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).
 Consume persisted return frontiers; rerun after landing/artifact/capacity changes.
 Execute authorized routes, retaining handles, cursors and protected proof windows.
+When frontier prints `frontier-concurrent:`, launch every listed command and every
+`frontier-picks` writer in that same turn, each on its own source. The cap bounds
+the turn: start picks first, then fill remaining slots from `frontier-concurrent`.
+Do not finish one listed source and reply.
 
 Check [stop-conditions.md](stop-conditions.md) before advancing. Discard stale
 pass evidence after source edits. Re-read the selected source before each phase per [phase target binding](skill://devrites-lib/reference/parallel-workspaces.md#phase-target-binding). On a cold resume or

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

@@ -33,6 +33,12 @@ For AFK `status=running`, consume an internal phase edge. In
 work takes priority over local Build; local-only picks do not recurse through
 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. 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/devrites-lib/reference/parallel-workspaces.md

@@ -113,6 +113,12 @@ return cursors and native handles: one controller, not another phase or queue.
    obligation. Placeholders, reports and unopened waves prove nothing.
    Opt-out, zero opening budget or source human/question holds prevent new
    openings, not existing child preparation or independent work.
+   In autocomplete mode, `blocked` or `awaiting_human` with no question cursor
+   and no open blocking or escalating question is existing work when
+   `next_action` is Spec, Clarify, Temper, Define, Plan, or Vet. A recorded
+   Temper-or-later phase is ordinary work, so later siblings stay visible.
+   Launch every `frontier-concurrent:` command and every `frontier-picks`
+   writer in the same turn, up to the cap, picks first.
    If preparation cannot start, retain `frontier-blocked: <successor> — <constraint>`
    in source `evidence.md`. `frontier-blocked: sequence — <constraint>` may defer
    unresolved historical normalization for valid independent local work. Each row

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
 
@@ -99,6 +99,10 @@ At phase entry, before recovery/waits, execute the
 [global pass](../../devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).
 Consume persisted return frontiers; rerun after landing/artifact/capacity changes.
 Execute authorized routes, retaining handles, cursors and protected proof windows.
+When frontier prints `frontier-concurrent:`, launch every listed command and every
+`frontier-picks` writer in that same turn, each on its own source. The cap bounds
+the turn: start picks first, then fill remaining slots from `frontier-concurrent`.
+Do not finish one listed source and reply.
 
 Check [stop-conditions.md](stop-conditions.md) before advancing. Discard stale
 pass evidence after source edits. Re-read the selected source before each phase per [phase target binding](../../devrites-lib/reference/parallel-workspaces.md#phase-target-binding). On a cold resume or

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

@@ -33,6 +33,12 @@ For AFK `status=running`, consume an internal phase edge. In
 work takes priority over local Build; local-only picks do not recurse through
 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. 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.7",
+  "version": "7.3.9",
   "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",