devrites 7.3.6 → 7.3.8

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.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
+
+* **devrites:** count only the owning slice of a build item ([#210](https://github.com/ViktorsBaikers/DevRites/issues/210)) ([b1e4f92](https://github.com/ViktorsBaikers/DevRites/commit/b1e4f92cb5d49d2865b4c0994523e52993b5d133))
+
 ## [7.3.6](https://github.com/ViktorsBaikers/DevRites/compare/v7.3.5...v7.3.6) (2026-11-06)
 
 ### Fixed
@@ -59,6 +71,10 @@ All notable changes to DevRites are documented here. The format follows [Keep a
 
 ### Fixed
 
+- 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
+  once with `check regression <slug> --update`.
 - Guard Autocomplete's early phase context and dispatch, not only Build writers,
   against unstarted successor preparation. Keep normalization research reachable
   and bound successor preparation before its first wave without recursively

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.6`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v7.3.6): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
+**Status:** [`v7.3.8`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v7.3.8): 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

@@ -61,6 +61,10 @@ func RunCheckContinuation(root string, args []string, stdout, stderr io.Writer)
 			verdict = continuationVerdict{Required: true, Invoke: "/rite-autocomplete", Source: slug, Reason: "global frontier requires native preparation, authority review, or selection; no Ship approval"}
 		} 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)

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, cmd)
+			}
+		}
 		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,51 @@ 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)
+}
+
+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 +661,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 {
@@ -682,7 +742,7 @@ func frontierLocal(root, controller string, n *frontierWorkspace, candidates *[]
 	}
 	if _, internal, err := internalPhaseEdge(n.next, n.slug); err != nil {
 		return "", "", err
-	} else if internal && n.status == "running" {
+	} else if internal && (n.status == "running" || n.agentOwnedPlanning) {
 		return "prepare", "native internal phase cursor: " + n.next, nil
 	}
 	if command := workflow.ForAction(n.next); command.Verb == "ship" {

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/regression.go

@@ -59,6 +59,18 @@ var (
 	regressH2Re      = regexp.MustCompile(`(?m)^## `)
 )
 
+// ledgerOwner returns the slice digits a checked state.md item owns: only its
+// first slice token (documented `SLICE-003` or `Slice 3`). Later tokens on the
+// same line are context — a blocked dependent, an INV reference, a NOT_RUN
+// note — and do not make those slices built.
+func ledgerOwner(item string) (string, bool) {
+	m := regressSliceIDRe.FindStringSubmatch(item)
+	if m == nil {
+		return "", false
+	}
+	return m[1], true
+}
+
 // progressFingerprint is the structural state one baseline records. Sets are
 // sorted for deterministic output and diffing.
 type progressFingerprint struct {
@@ -180,13 +192,15 @@ func fingerprintWorkspace(root, slug, workspace string) (progressFingerprint, er
 	note("state.md", err)
 	if err == nil {
 		for _, item := range regressBuiltRe.FindAllString(masked, -1) {
-			for _, m := range regressSliceIDRe.FindAllStringSubmatch(item, -1) {
-				// `SLICE-001` and `Slice 1` name the same slice.
-				n, _ := strconv.Atoi(m[1])
-				id := fmt.Sprintf("SLICE-%03d", n)
-				if !slices.Contains(fp.DoneSlices, id) {
-					fp.DoneSlices = append(fp.DoneSlices, id)
-				}
+			digits, ok := ledgerOwner(item)
+			if !ok {
+				continue
+			}
+			// `SLICE-001` and `Slice 1` name the same slice.
+			n, _ := strconv.Atoi(digits)
+			id := fmt.Sprintf("SLICE-%03d", n)
+			if !slices.Contains(fp.DoneSlices, id) {
+				fp.DoneSlices = append(fp.DoneSlices, id)
 			}
 		}
 	}

package/engine/internal/lib/taskgraph.go

@@ -235,8 +235,8 @@ func builtSlicesFrom(read func(string) ([]byte, error)) (map[string]bool, error)
 		if !builtWordRe.MatchString(item) {
 			continue
 		}
-		for _, m := range regressSliceIDRe.FindAllStringSubmatch(item, -1) {
-			built[strings.TrimLeft(m[1], "0")] = true
+		if digits, ok := ledgerOwner(item); ok {
+			built[strings.TrimLeft(digits, "0")] = true
 		}
 	}
 	extra, err := evidenceBuiltFrom(read)

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

@@ -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. 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.
 
 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

@@ -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. 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.
 
 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

@@ -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. 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.
 
 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

@@ -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. 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.
 
 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

@@ -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. 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.
 
 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

@@ -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. 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.
 
 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

@@ -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. 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.
 
 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.6",
+  "version": "7.3.8",
   "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",