devrites 6.1.0 → 6.1.2

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`.
 
+## [6.1.2](https://github.com/ViktorsBaikers/DevRites/compare/v6.1.1...v6.1.2) (2026-10-16)
+
+### Fixed
+
+* **devrites:** close autocomplete dead ends and orphaned writer claims ([#108](https://github.com/ViktorsBaikers/DevRites/issues/108)) ([a680203](https://github.com/ViktorsBaikers/DevRites/commit/a680203d226160f9dae3bf5a386914567bd25da5))
+
+## [6.1.1](https://github.com/ViktorsBaikers/DevRites/compare/v6.1.0...v6.1.1) (2026-10-16)
+
+### Fixed
+
+* **devrites:** escalate spent recovery strategies instead of dead-ending ([#107](https://github.com/ViktorsBaikers/DevRites/issues/107)) ([bf1c986](https://github.com/ViktorsBaikers/DevRites/commit/bf1c986e28e6ea8fb63aa47a342b036536cb0e38))
+
 ## [6.1.0](https://github.com/ViktorsBaikers/DevRites/compare/v6.0.4...v6.1.0) (2026-10-15)
 
 ### Added

package/README.md

@@ -31,7 +31,7 @@ history can't lose it. After you clear the conversation, switch hosts, or hand
 the feature to another engineer, the next session reads the same plan,
 decisions, and evidence before it continues.
 
-**Status:** [`v6.1.0`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v6.1.0): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
+**Status:** [`v6.1.2`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v6.1.2): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
 
 This is the latest published release; `main` may contain unreleased work.
 

package/docs/architecture.md

@@ -383,7 +383,9 @@ when the answer is required.
 AFK always pauses for genuine product/scope/policy choices, irreversible risk,
 and human-only access or actions, regardless of the sentinel. Objective test,
 type, lint, runtime, and coverage failures stay inside bounded technical
-recovery; exhaustion records a blocker without inventing a question. See
+recovery; a spent strategy escalates to a new correction class, and a fully
+escalated fingerprint parks while independent work continues, without inventing a
+question. See
 [`pack/.claude/skills/devrites-lib/reference/standards/afk-hitl.md`](../pack/.claude/skills/devrites-lib/reference/standards/afk-hitl.md) for the full
 contract.
 

package/docs/cli.md

@@ -165,7 +165,10 @@ self-contained updater.
   and exits `3` naming the holder when a live claim by another session covers a
   path; `release --session <id> --id <claim>` frees it; `list [--all]` shows
   live (or all) claims; `check [--session <id>] <path>...` is the read-only
-  preflight. Claims coordinate concurrent same-tree sessions; they never
+  preflight. Each claim records its host and the claiming session's long-lived
+  processes; when all of them have exited on this host, `list` shows the claim
+  `dead` and it no longer conflicts. Other hosts or an unavailable `ps` never
+  prove exit. Claims coordinate concurrent same-tree sessions; they never
   replace the one-writer-per-worktree rule in `standards/agents.md`.
 - `note <add|list|check|rm>` manages `notes.md` anchored notes: `add <slug>
   <subject> <quote> <title> [body]` binds a note to a verbatim quote in one

package/docs/engine/commands.md

@@ -16,9 +16,9 @@ workflow strategy.
 | `check readiness --emit-binding <slug>` | Render the exact stable Build-input binding for Vet to record after review. |
 | `check seal <slug>` | Check files required by target Phase `seal`, open human gates, the `tasks.md` slice graph, canonical `AC-###` presence when `tasks.md`/`test-plan.md` are required, the stable Build-input binding, and exact candidate bindings. |
 | `check path-disjoint [--root <dir>] [<json-file> | -]` | Verify slice path sets are pairwise disjoint. |
-| `parallel select --cap <1-10> [--root <dir>] [<json-file> | -]` | Choose the greedy path-disjoint subset ≤ cap from supplied ready slices. |
-| `parallel <create\|integrate\|cleanup\|status\|abort\|lease-read\|lease-write\|lease-clear\|record-green>` | Deterministic parallel worktree leases, integration, and cleanup for parallel writer batches. |
-| `check task-graph <slug>` | Validate `tasks.md` slice dependency graph for cycles, unknown deps, malformed tokens, duplicate IDs, missing `Dependencies`, and `depends_on` mismatch. Prints a non-blocking `ADVISORY size:` line (and records a `size-advisory` metric) for each slice with 12+ Writer allowlist files and no `Size rationale:`. A `Dependencies` ID may carry a `(via <interface>)` suffix (empty or unclosed is a malformed token); prints a non-blocking `ADVISORY edge:` line (and records an `edge-advisory` metric) for each edge with no via, or whose via text is not a case-insensitive substring of the dependency's `Consumes / Produces:`. Advisories print only when the graph is valid. |
+| `parallel select --cap <1-10> [--root <dir>] [--slug <slug>] [<json-file> | -]` | Choose the greedy path-disjoint subset ≤ cap from supplied ready slices. With `--slug` and a running lease, the lease's not-yet-landed slices hold cap slots and paths, and only new picks print. |
+| `parallel <create\|add\|integrate\|cleanup\|status\|abort\|lease-read\|lease-write\|lease-clear\|record-green>` | Deterministic parallel worktree leases, integration, and cleanup for parallel writer batches. A lease is a pipeline: `integrate --slice <id> --apply-to-control` lands one green sibling onto control (refusing if anything but this lease moved control), and `add` starts new path-disjoint siblings from the current control tip while others still run. |
+| `check task-graph <slug>` | Validate `tasks.md` slice dependency graph for cycles, unknown deps, malformed tokens, duplicate IDs, missing `Dependencies`, and `depends_on` mismatch. Prints a non-blocking `ADVISORY size:` line (and records a `size-advisory` metric) for each slice with 12+ Writer allowlist files and no `Size rationale:`. A `Dependencies` ID may carry a `(via <interface>)` suffix (empty or unclosed is a malformed token); prints a non-blocking `ADVISORY edge:` line (and records an `edge-advisory` metric) for each edge with no via, or whose via text is not a case-insensitive substring of the dependency's `Consumes / Produces:`. Prints `schedule: <n> slices in <r> build rounds at cap 10` (the `/rite-build` batch selection replayed over each slice's Writer allowlist, else Files likely touched; omitted when a slice has no path) and a non-blocking `ADVISORY hub:` line (top five; records a `hub-advisory` metric) for each path, compared case-folded, that three or more slices without `Serial rationale:` write. Advisories print only when the graph is valid. |
 | `check regression <slug> [--update]` | Compare the workspace's structural progress facts (phase ordinal, checked ACs, met/abandoned gates, done slices, resolved questions, present artifacts) against the recorded `regression-baseline.json` high-water mark; `--update` ratchets the baseline forward under the feature lock and prints each blessed regression. |
 | `check drift <slug> [--record]` | Attribute readiness-input changes to the exact artifact. `--record` writes the per-input `readiness-inputs.json` digest baseline under the feature lock; without it the workspace diffs current inputs against that baseline (or falls back to the aggregate binding recorded in `eng-review.md`). Advisory: exit `0` on drift; a corrupt baseline exits `3`. A `test-plan.md` change limited to exact `Workflow Artifact reviewed identity: <64hex>` lines is reported as `reviewed-identity-only` (ADR-0034). |
 | `check windows <slug> [--worktree\|--staged\|--base <ref>]` | Fail on deferral and bar-lowering markers the change introduces without a waiver row in the workspace's `windows.md`: added TODO/FIXME/XXX/HACK, skipped/focused-test and stub idioms, checker suppressions, one-line empty catch; removed `deleted-test` files and net `removed-assertion` lines in remaining test files. |
@@ -37,7 +37,7 @@ workflow strategy.
 | `dispatch <slug> <open\|start\|seal\|return\|status\|abandon>` | Launch-wave barrier for parallel dispatch: seal needs a handle per role, return needs seal; start/return auto-record metrics. A build wave with a wright role needs `--slice <SLICE-ID>` per slice, and a slice-bound vet wave takes it too; every 5 rounds of either kind on one slice, `open` exits `3` until `--reslice-review <DRIFT-ID>` names an unused `drift.md` `## <DRIFT-ID>` heading for that slice. `open` also warns when an earlier wave for the same slice never returned. |
 | `metrics record <slug> --phase <p> --event <e> [--role r] [--bytes n] [--note s]` | Append an event to the workspace's `metrics.jsonl` ledger. |
 | `metrics summary [slug] [--by-slice]` | Reduce `metrics.jsonl` into a per-phase roll-up. `--by-slice` reads `dispatch.json` instead: per slice, build wright rounds, slice-bound Vet rechecks, and agent-minutes (role start to `returned_at`; abandoned waves excluded). |
-| `claim <add\|release\|list\|check>` | Advisory session-scoped file claims in `.devrites/claims.jsonl` (append-only). `add` records intent to write a path set with a TTL (1–240 min, default 30); a live claim by another session exits `3` and names the holder. `release` appends a release event owned by the claiming session. `list` shows live claims (`--all` includes expired/released). `check` is the read-only preflight for a path set. Coordination aid only — never a substitute for one-writer-per-worktree. |
+| `claim <add\|release\|list\|check>` | Advisory session-scoped file claims in `.devrites/claims.jsonl` (append-only). `add` records intent to write a path set with a TTL (1–240 min, default 30); a live claim by another session exits `3` and names the holder. `release` appends a release event owned by the claiming session. `list` shows live claims (`--all` includes expired/released); a claim whose holding session has provably exited on this host shows `dead` and no longer conflicts. `check` is the read-only preflight for a path set. Coordination aid only — never a substitute for one-writer-per-worktree. |
 | `note <add\|list\|check\|rm> <slug> ...` | Anchored workspace notes in `notes.md`: `add <slug> <subject> <quote> <title> [body]` binds a note to a verbatim quote in one repository file and assigns `NOTE-###`; `list` and `check` regrade each anchor `exact`/`moved`/`stale`/`ambiguous`/`lost` by searching the repo for the quote (dependency and workspace trees excluded); `check --repair` rewrites a `moved` subject to its new file; `rm` deletes by ID. `check seal` refuses a malformed `notes.md` and any non-`exact` anchor. |
 | `gates <scaffold\|status\|run\|reverify\|lint\|attest\|abandon> <slug>` | Operate the `gates.md` acceptance ledger: seed per-AC gates, execute runnable gates bound to `test-plan.md` preflight rows, attest manual gates, and reduce to `all-met`/`not-met`/`handoff`/`malformed`. |
 | `state resolve <qid> "<answer>"` | Resolve an open question and update `questions.md` plus `state.md` atomically. |

package/docs/orchestration.md

@@ -138,9 +138,10 @@ and a control `parallel-lease.md` apply. `--parallel N` on `/rite-autocomplete`
 or `/rite-build` is the batch cap for that run and wins over leftover sentinel
 `max_parallel`; `/rite-autocomplete --parallel N` also writes or replaces only
 that field. Absent the flag, the sentinel (default cap 10 under
-`/rite-autocomplete`) is a **cap**: each round runs
-the largest eligible set, recomputes after every completed round, and repeats until no
-pending slice remains; a one-slice round is serial for that round only (see
+`/rite-autocomplete`) is a **cap**: the run fills it
+with the largest eligible set, lands each sibling as soon as its review and proof are
+green, refills the freed slot (`parallel add`), and repeats until no pending slice
+remains; a one-slice round is serial for that round only (see
 [`parallel-batch.md`](../pack/.claude/skills/rite-build/reference/parallel-batch.md)).
 Same-worktree multi-writer and root-emulated worktrees remain forbidden; default
 `/rite-build` stays one writer across linked worktrees.

package/docs/usage.md

@@ -71,7 +71,7 @@ Project-root sentinel (outside the workspace):
 | `.devrites/AFK` | you (presence = AFK mode active) | optional YAML: `max_slices`, `notify`, `allow_gates`. Empty file = AFK with defaults. See [`pack/.claude/skills/devrites-lib/reference/standards/afk-hitl.md`](../pack/.claude/skills/devrites-lib/reference/standards/afk-hitl.md). |
 | `.devrites/CHECKPOINT` | unused as a gate | reserved path (not a candidate). After Independent Build review and fail-on-red proof are green (not when a wright returns), `/rite-build` / `/rite-prove` / `/rite-polish` / `/rite-review` land a local `WIP(<slug>): <imperative summary>` commit (serial: checkpoint git recipe or no-op if nothing staged; parallel: `devrites-engine parallel integrate`); `/rite-ship` later collapses an eligible WIP run. See [`pack/.claude/skills/rite-build/reference/checkpoint.md`](../pack/.claude/skills/rite-build/reference/checkpoint.md). |
 | `.devrites/dup-ignore` | you (optional) | One `check dup` cluster hash per line with a `#` reason — the dismissal ledger. Content-derived hashes survive line moves but resurface on structural edits. See [`pack/.claude/skills/devrites-lib/reference/standards/duplicate-code.md`](../pack/.claude/skills/devrites-lib/reference/standards/duplicate-code.md). |
-| `.devrites/claims.jsonl` | `devrites-engine claim add` | Append-only advisory file claims: `{id, session, paths, reason, claimed_at, expires_at}` plus release events. Session-scoped and TTL-bounded — per-checkout state, so gitignore it (a committed ledger exports stale claims to every clone). See [`standards/agents.md`](../pack/.claude/skills/devrites-lib/reference/standards/agents.md). |
+| `.devrites/claims.jsonl` | `devrites-engine claim add` | Append-only advisory file claims: `{id, session, paths, reason, claimed_at, expires_at, host, anchors}` plus release events. Session-scoped and TTL-bounded — per-checkout state, so gitignore it (a committed ledger exports stale claims to every clone). See [`standards/agents.md`](../pack/.claude/skills/devrites-lib/reference/standards/agents.md). |
 
 The shape of this directory is also documented in
 [`flow.md` § Workspace state model](flow.md#7-workspace-state-model).

package/engine/internal/lib/claims.go

@@ -51,6 +51,10 @@ type claimRecord struct {
 	ClaimedAt string   `json:"claimed_at"`
 	ExpiresAt string   `json:"expires_at"`
 	Released  bool     `json:"released,omitempty"`
+	// Host and Anchors identify the claiming session's long-lived processes,
+	// so a later session can prove that holder exited (see holderProbe).
+	Host    string      `json:"host,omitempty"`
+	Anchors []claimProc `json:"anchors,omitempty"`
 }
 
 // RunClaim manages the advisory file-claim ledger.
@@ -299,7 +303,8 @@ func claimAddLocked(path, session, reason string, ttl int, paths []string, stdou
 		return 2
 	}
 	now := time.Now().UTC()
-	conflicts := claimConflicts(liveClaims(latest, order, now), session, paths)
+	probe := newHolderProbe()
+	conflicts := claimConflicts(probe.withoutGone(liveClaims(latest, order, now)), session, paths)
 	if len(conflicts) > 0 {
 		printConflicts(stderr, conflicts)
 		return 3
@@ -311,6 +316,8 @@ func claimAddLocked(path, session, reason string, ttl int, paths []string, stdou
 		Reason:    reason,
 		ClaimedAt: now.Format(time.RFC3339),
 		ExpiresAt: now.Add(time.Duration(ttl) * time.Minute).Format(time.RFC3339),
+		Host:      probe.host,
+		Anchors:   probe.anchors(now),
 	}
 	if err := appendClaim(path, rec); err != nil {
 		fmt.Fprintf(stderr, "claim: %v\n", err)
@@ -389,6 +396,7 @@ func claimList(root string, args []string, stdout, stderr io.Writer) int {
 		return 2
 	}
 	now := time.Now().UTC()
+	probe := newHolderProbe()
 	rows := liveClaims(latest, order, now)
 	if all {
 		rows = rows[:0]
@@ -404,6 +412,8 @@ func claimList(root string, args []string, stdout, stderr io.Writer) int {
 		state := "live"
 		if rec.Released {
 			state = "released"
+		} else if probe.gone(rec) {
+			state = "dead"
 		} else if exp, err := time.Parse(time.RFC3339, rec.ExpiresAt); err != nil || !exp.After(now) {
 			state = "expired"
 		}
@@ -453,7 +463,7 @@ func claimCheck(root string, args []string, stdout, stderr io.Writer) int {
 		fmt.Fprintf(stderr, unparsedLedgerMsg, bad)
 		return 2
 	}
-	conflicts := claimConflicts(liveClaims(latest, order, time.Now().UTC()), session, paths)
+	conflicts := claimConflicts(newHolderProbe().withoutGone(liveClaims(latest, order, time.Now().UTC())), session, paths)
 	if len(conflicts) > 0 {
 		printConflicts(stdout, conflicts)
 		return 3

package/engine/internal/lib/claims_holder.go

@@ -0,0 +1,124 @@
+package lib
+
+import (
+	"os"
+	"os/exec"
+	"slices"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// claimAnchorAge separates a claiming session's long-lived host processes from
+// the per-command shells and launchers that start moments before `claim add`.
+const claimAnchorAge = time.Minute
+
+// claimProc names one process by pid and start time, so a reused pid cannot
+// impersonate it.
+type claimProc struct {
+	PID   int    `json:"pid"`
+	Start string `json:"start"`
+}
+
+type procInfo struct {
+	ppid  int
+	start string
+}
+
+// processTable lists running processes keyed by pid, or nil when the host
+// cannot say. Tests replace it.
+var processTable = psProcessTable
+
+func psProcessTable() map[int]procInfo {
+	cmd := exec.Command("ps", "-A", "-o", "pid=,ppid=,lstart=")
+	cmd.Env = append(os.Environ(), "LC_ALL=C")
+	out, err := cmd.Output()
+	if err != nil {
+		return nil
+	}
+	table := map[int]procInfo{}
+	for _, line := range strings.Split(string(out), "\n") {
+		f := strings.Fields(line)
+		if len(f) != 7 {
+			continue
+		}
+		pid, perr := strconv.Atoi(f[0])
+		ppid, pperr := strconv.Atoi(f[1])
+		start, serr := time.ParseInLocation("Mon Jan 2 15:04:05 2006", strings.Join(f[2:], " "), time.Local)
+		if perr != nil || pperr != nil || serr != nil {
+			continue
+		}
+		table[pid] = procInfo{ppid: ppid, start: start.UTC().Format(time.RFC3339)}
+	}
+	if len(table) == 0 {
+		return nil
+	}
+	return table
+}
+
+// lineage walks from pid up to, but not including, pid 1.
+func lineage(table map[int]procInfo, pid int) []claimProc {
+	var out []claimProc
+	seen := map[int]bool{}
+	for pid > 1 && !seen[pid] {
+		seen[pid] = true
+		p, ok := table[pid]
+		if !ok {
+			break
+		}
+		out = append(out, claimProc{PID: pid, Start: p.start})
+		pid = p.ppid
+	}
+	return out
+}
+
+// holderProbe answers whether a claim's holding session has exited. It only
+// ever proves exit on this host; anything it cannot see counts as alive.
+type holderProbe struct {
+	table map[int]procInfo
+	host  string
+	self  []claimProc
+}
+
+func newHolderProbe() holderProbe {
+	table := processTable()
+	host, _ := os.Hostname()
+	return holderProbe{table: table, host: host, self: lineage(table, os.Getppid())}
+}
+
+// anchors returns the caller's ancestors that started more than
+// claimAnchorAge before now: the session's host processes.
+func (p holderProbe) anchors(now time.Time) []claimProc {
+	var out []claimProc
+	for _, proc := range p.self {
+		start, err := time.Parse(time.RFC3339, proc.Start)
+		if err == nil && now.Sub(start) > claimAnchorAge {
+			out = append(out, proc)
+		}
+	}
+	return out
+}
+
+// gone reports whether rec's holder is proven exited: the claim was taken on
+// this host and every anchor it does not share with the caller has exited.
+func (p holderProbe) gone(rec *claimRecord) bool {
+	if p.table == nil || rec.Host == "" || rec.Host != p.host {
+		return false
+	}
+	unique := 0
+	for _, a := range rec.Anchors {
+		if slices.Contains(p.self, a) {
+			continue
+		}
+		unique++
+		if proc, ok := p.table[a.PID]; ok && proc.start == a.Start {
+			return false
+		}
+	}
+	return unique > 0
+}
+
+// withoutGone drops claims whose holder session has exited.
+func (p holderProbe) withoutGone(claims []*claimRecord) []*claimRecord {
+	return slices.DeleteFunc(claims, p.gone)
+}

package/engine/internal/lib/cli_observe.go

@@ -5,6 +5,7 @@ import (
 	"io"
 
 	"github.com/devrites/devrites/internal/devritespaths"
+	"github.com/devrites/devrites/internal/parallel"
 	"github.com/devrites/devrites/internal/state"
 )
 
@@ -36,6 +37,19 @@ func RunTaskGraphCheck(root, slug string, stdout, stderr io.Writer) int {
 		if over > 0 {
 			recordMetric(root, slug, "define", "size-advisory", "", int64(over))
 		}
+		paths, serial := sliceWritePaths(raw, graph)
+		if rounds := scheduleRounds(graph, paths, root); rounds > 0 {
+			fmt.Fprintf(stdout, "task-graph: schedule: %d slices in %d build rounds at cap %d\n", len(graph.Slices), rounds, parallel.MaxParallelSlices)
+		}
+		if hubs := hubAdvisories(graph, paths, serial); len(hubs) > 0 {
+			for _, line := range hubs[:min(len(hubs), hubAdvisoryShown)] {
+				fmt.Fprintf(stdout, "task-graph: %s\n", line)
+			}
+			if extra := len(hubs) - hubAdvisoryShown; extra > 0 {
+				fmt.Fprintf(stdout, "task-graph: ADVISORY hub: %d more shared paths; fix the ones above first\n", extra)
+			}
+			recordMetric(root, slug, "define", "hub-advisory", "", int64(len(hubs)))
+		}
 	}
 	if edges := edgeAdvisories(graph); len(edges) > 0 {
 		for _, line := range edges {

package/engine/internal/lib/taskgraph.go

@@ -2,8 +2,11 @@ package lib
 
 import (
 	"fmt"
+	"path"
+	"sort"
 	"strings"
 
+	"github.com/devrites/devrites/internal/parallel"
 	"github.com/devrites/devrites/internal/state"
 )
 
@@ -27,6 +30,127 @@ func CheckTaskGraph(root, slug string) (TaskGraphResult, error) {
 	return ParseTaskGraph(raw), nil
 }
 
+// hubAdvisoryMin is how many slices must write one path before it is flagged:
+// slices sharing a write path never share a parallel build round.
+const hubAdvisoryMin = 3
+
+// hubAdvisoryShown caps printed hub lines; the metric still counts every hub.
+const hubAdvisoryShown = 5
+
+// sliceWritePaths returns each slice's write set (Writer allowlist, else Files
+// likely touched) and whether it records a `Serial rationale:`.
+func sliceWritePaths(tasksMarkdown []byte, graph TaskGraphResult) (map[string][]string, map[string]bool) {
+	paths := make(map[string][]string, len(graph.Slices))
+	serial := make(map[string]bool)
+	for _, s := range graph.Slices {
+		block, _ := state.ExtractTaskSlice(tasksMarkdown, s.ID)
+		fields := sliceFields(block)
+		allow, _ := fieldValue(fields, "writer allowlist")
+		paths[s.ID] = pathTokens(allow)
+		if len(paths[s.ID]) == 0 {
+			touched, _ := fieldValue(fields, "files likely touched")
+			paths[s.ID] = pathTokens(touched)
+		}
+		if v, _ := fieldValue(fields, "serial rationale"); v != "" {
+			serial[s.ID] = true
+		}
+	}
+	return paths, serial
+}
+
+// pathTokens keeps the list entries that can be paths; prose and Markdown links
+// (anything with whitespace) are not write paths.
+func pathTokens(raw string) []string {
+	var out []string
+	for _, p := range parsePathList(raw) {
+		if !strings.ContainsAny(p, " \t") {
+			out = append(out, p)
+		}
+	}
+	return out
+}
+
+// scheduleRounds replays /rite-build batch selection at the maximum cap: each
+// round runs the plan-order path-disjoint subset of dependency-ready slices.
+// It returns 0 when a slice has no write paths or parallel select rejects them.
+func scheduleRounds(graph TaskGraphResult, paths map[string][]string, root string) int {
+	done := make(map[string]bool, len(graph.Slices))
+	rounds := 0
+	for len(done) < len(graph.Slices) {
+		var ready []parallel.SlicePaths
+		for _, s := range graph.Slices {
+			if done[s.ID] || !allDone(s.Dependencies, done) {
+				continue
+			}
+			if len(paths[s.ID]) == 0 {
+				return 0
+			}
+			ready = append(ready, parallel.SlicePaths{ID: s.ID, Paths: paths[s.ID]})
+		}
+		if len(ready) == 0 {
+			return 0
+		}
+		picked, err := parallel.SelectGreedy(parallel.MaxParallelSlices, ready, root)
+		if err != nil || len(picked) == 0 {
+			return 0
+		}
+		for _, p := range picked {
+			done[p.ID] = true
+		}
+		rounds++
+	}
+	return rounds
+}
+
+func allDone(ids []string, done map[string]bool) bool {
+	for _, id := range ids {
+		if !done[id] {
+			return false
+		}
+	}
+	return true
+}
+
+// hubAdvisories names each path written by hubAdvisoryMin+ slices that carry
+// no `Serial rationale:`, most-shared first.
+func hubAdvisories(graph TaskGraphResult, paths map[string][]string, serial map[string]bool) []string {
+	writers := map[string][]string{}
+	shown := map[string]string{} // first spelling seen, for display
+	for _, s := range graph.Slices {
+		if serial[s.ID] {
+			continue
+		}
+		seen := map[string]bool{}
+		for _, p := range paths[s.ID] {
+			key := strings.ToLower(path.Clean(strings.ReplaceAll(p, `\`, "/")))
+			if !seen[key] {
+				seen[key] = true
+				writers[key] = append(writers[key], s.ID)
+				if _, ok := shown[key]; !ok {
+					shown[key] = p
+				}
+			}
+		}
+	}
+	hubs := make([]string, 0, len(writers))
+	for p, ids := range writers {
+		if len(ids) >= hubAdvisoryMin {
+			hubs = append(hubs, p)
+		}
+	}
+	sort.Slice(hubs, func(i, j int) bool {
+		if len(writers[hubs[i]]) != len(writers[hubs[j]]) {
+			return len(writers[hubs[i]]) > len(writers[hubs[j]])
+		}
+		return hubs[i] < hubs[j]
+	})
+	lines := make([]string, len(hubs))
+	for i, p := range hubs {
+		lines[i] = fmt.Sprintf("ADVISORY hub: %s is written by %d slices (%s), so they build one at a time; move the shared edit into one seam slice they depend on, or record `Serial rationale:`", shown[p], len(writers[p]), strings.Join(writers[p], ", "))
+	}
+	return lines
+}
+
 // edgeAdvisories names each dependency edge that does not say what crosses it:
 // no `(via <interface>)`, or a via the dependency's Consumes / Produces lacks.
 // An edge the dependent reads nothing across only serializes work.