@plot-pm/board 0.16.3 → 0.17.0

package/plot-fleet-scan.sh

@@ -1,6 +1,9 @@
 #!/usr/bin/env bash
 # Plot helper: fleet pulse — deterministic extractor for wave/claim state.
-# Usage: plot-fleet-scan.sh [--no-fetch] [--offline] [--next] [<slug>]
+# Usage: plot-fleet-scan.sh [--no-fetch] [--offline] [--next] [--slice-names] [<slug>]
+#   --slice-names  print every slice a `waits:` name may wait on, one per line,
+#               and exit: the estate's non-deferred slices of non-terminal plans,
+#               whatever slug is given. No fetch, no host call.
 #   --no-fetch  skip `git fetch`
 #   --offline   same (no fetch) — used for cheap, ambient pulses.
 #               The fetch also PRUNES remote-tracking refs, so skipping it
@@ -76,11 +79,12 @@
 # Branch states — the word each BRANCH carries, distinct from the wave verdicts
 # above. `open`, `wip`, `merged`, `claimed`, `deferred` and `unknown` are read
 # from git and the host. Two more are read from the plan's `waits:` annotation:
-#   waiting     the branch names a prerequisite branch that has not merged. A
+#   waiting     the branch names a prerequisite branch that has not merged —
+#               including a slice some plan names that nobody has started. A
 #               wait with an end: it clears when that branch lands, and the
 #               fleet payload carries `waits_on` so a reader sees on WHAT.
 #   blocked     the branch names a prerequisite the host has never seen a PR
-#               for — a typo, or a branch nobody created. A defect in the plan
+#               for and no plan names as a slice — a typo. A defect in the plan
 #               estate, not progress, which is why it is a separate word: the
 #               first resolves by waiting, the second by editing the plan.
 #               THE SAME WORD AS THE WAVE VERDICT, IN A DIFFERENT VOCABULARY.
@@ -261,6 +265,7 @@ do_fetch=1
 next_only=0
 list_all=0
 why_nothing=0
+slice_names=0
 loose=0
 log_pulse=0
 as_json=0
@@ -295,6 +300,7 @@ while [ $# -gt 0 ]; do
     # about the SAME plans `--next` was silent over — a terminal plan admitted
     # here would answer `not-yet` about work somebody decided was not needed.
     --why-nothing) next_only=1; why_nothing=1 ;;
+    --slice-names) slice_names=1; do_fetch=0 ;;
     # `--json` ASSEMBLES BUT DOES NOT RECORD, and the two flags differ here for
     # a reason. `--stream` is what the BOARD spawns (`fleet.ts:2694`) and
     # `--log-pulse` is what `/plot-pulse` passes: both produce a pulse somebody
@@ -1535,10 +1541,7 @@ merged_by_host() { # $1=branch → 0 when the host reports its PR MERGED
 # backend, a host returning 503 all afternoon — must not manufacture the state
 # that tells a reader to stop looking. It falls through to the local signals,
 # so a branch with work on the floor reads `stalled`: go and look. That is the
-# safe direction for an answer nobody could verify.
-reached_review() { # $1=branch → 0 when an open or merged PR exists
-  case "$(host_pr_state "$1")" in OPEN|MERGED) return 0 ;; *) return 1 ;; esac
-}
+# safe direction for an answer nobody could verify. `worker_of` asks it.
 
 # ---------------------------------------------------------------------------
 # A SLICE THAT WAITS ON ANOTHER PLAN'S BRANCH
@@ -1571,9 +1574,9 @@ reached_review() { # $1=branch → 0 when an open or merged PR exists
 # the branch it was cut from, which is why `plot-pr-merged.sh` reads PRs and not
 # refs, and why this reads the same source.
 #
-# WHAT THE HOST SAID, AND NOT WHAT IT MEANS. This function answered
+# WHAT THE HOST SAID, AND NOT WHAT IT MEANS. The prerequisite reading answered
 # `waiting` / `blocked` / `""` until the derivation moved: the three answers and
-# the reason `NONE` is the only one that means `blocked` are `waitVerdict` in
+# why only `NONE` on a name outside `SLICE_NAMES` means `blocked` are `waitVerdict` in
 # `packages/domain/src/rules/branch-state.ts`, with a test per case. What stays
 # here is the READING and the cost argument above it, which is a fact about
 # this script's host budget rather than about what a wait means.
@@ -1582,9 +1585,8 @@ reached_review() { # $1=branch → 0 when an open or merged PR exists
 # may legitimately omit: its plan may be delivered and its ref gone. The bound
 # is the same one PR #216 set — ABSENT branches, not all branches — and the
 # cache above keeps it at one call per run.
-waits_pr_state() { # $1=prerequisite branch → OPEN|MERGED|CLOSED|NONE|-
-  host_pr_state "$1" --ask
-}
+# `host_pr_state "$name" --ask` → OPEN|MERGED|CLOSED|NONE|-, called once per
+# prerequisite name in the refill below.
 
 # Modification time of a path, in epoch seconds, following symlinks — or "" when
 # it cannot be read.
@@ -2140,10 +2142,10 @@ worker_of() { # $1=branch → "state\tpid\texit"
   #
   # `$st` IS NOT THIS FACT. It answers a ref/ancestry question — a branch under
   # review reads `wip` — and `merged` there can come from a merge subject with
-  # no PR behind it at all. `reached_review` asks the one question that
+  # no PR behind it at all. The PR state below is the one question that
   # outranks the local signals: has this work left the worker's hands?
   local pr_fact=""
-  reached_review "$br" && pr_fact="pr"
+  case "$(host_pr_state "$br")" in OPEN|MERGED) pr_fact="pr" ;; esac
   plot_worker_state "$wt" "$pr_fact"
 }
 
@@ -2993,13 +2995,7 @@ add_ref_plan() { # $1=path in ref
 # `$PLAN_DIR` by default, and their symlinks resolve to files already
 # enumerated — counting both would double every plan. `git ls-tree` without
 # `-r` lists one level, and the worktree glob `"$PLAN_DIR"*.md` does not
-# descend either.
-is_plan_phase() { # $1=normalized phase → 0 when this file is a plan
-  case "$1" in
-    ""|NONE) return 1 ;;
-    *) return 0 ;;
-  esac
-}
+# descend either. `add_plan_by_phase` below applies the rule.
 
 # ---------------------------------------------------------------------------
 # ONE PARSE FOR THE WHOLE ESTATE
@@ -3229,8 +3225,7 @@ for line in sys.stdin:
 # would have changed was never findable and stays unfindable. The compare is
 # literal, so a path holding `[`, `*` or `?` matches itself and never a glob.
 # THE SEARCH ITSELF, assigning to `plan_meta_index_reply`. Run it in the shell
-# whose cursor should advance; `plan_meta_index_of` below is the stdout wrapper
-# for callers that are already inside a `$(…)`.
+# whose cursor should advance.
 plan_meta_index_reply=""
 plan_meta_index_into() { # $1=file → sets plan_meta_index_reply
   plan_meta_index_reply=""
@@ -3259,37 +3254,13 @@ plan_meta_index_into() { # $1=file → sets plan_meta_index_reply
   done
 }
 
-# The stdout form, for the two callers that read it inside a command
-# substitution. The cursor it advances belongs to that subshell and dies with
-# it, which costs those callers nothing: both ask once per live plan, and the
-# weight was never there.
-plan_meta_index_of() { # $1=file → index on stdout, or ""
-  plan_meta_index_into "$1"
-  printf '%s' "$plan_meta_index_reply"
-}
-
-# The phase a file declares, or "" when it is not a plan. Read from the single
-# estate parse above rather than spawned per file.
-plan_phase_of() { # $1=file to parse → normalized phase on stdout
-  local i
-  i=$(plan_meta_index_of "$1")
-  [ -n "$i" ] || { printf ''; return 0; }
-  printf '%s' "${plan_meta_phases[$i]}"
-}
-
-# The same answer, ASSIGNED to `plan_phase_reply` instead of printed.
-#
-# THE CURSOR ONLY ADVANCES IN THE PARENT SHELL. `plan_phase_of` is read as
-# `$(plan_phase_of …)` and `plan_meta_index_of` as `$(plan_meta_index_of …)`,
-# and a subshell's write to `plan_meta_cursor` is discarded when it exits — so
-# the resumable search would restart from 0 on every call and the quadratic
-# shape would survive the fix. This form runs in the caller's own shell, which
-# is where `add_plan_by_phase` runs and where the 416 asks come from.
+# The phase a file declares, or "" when it is not a plan, ASSIGNED to
+# `plan_phase_reply`. Read from the single estate parse above rather than
+# spawned per file.
 #
-# A SECOND FUNCTION RATHER THAN A CHANGED CONTRACT. `plan_phase_of` keeps its
-# stdout form for the slug path at `:3308`, which asks once and whose answer is
-# interpolated into an array append. Rewriting that caller to read a global
-# would trade a one-off subshell for a less obvious assignment.
+# NO STDOUT FORM. A subshell's write to `plan_meta_cursor` is discarded when it
+# exits, so a `$(…)` reader would restart the search from 0 on every call. Every
+# caller of this and of `plan_meta_index_into` runs in the scan's own shell.
 plan_phase_reply=""
 plan_phase_into() { # $1=file to parse → sets plan_phase_reply
   plan_phase_reply=""
@@ -3314,6 +3285,80 @@ is_terminal_phase() { # $1=normalized phase → 0 when finished
   esac
 }
 
+# EVERY PLAN FILE OF THE ESTATE, into `cand_ids` (identity) and `cand_reads`
+# (the file to parse): the plan directory of `origin/$MAIN`, then each prefixed
+# branch's plans the default branch does not carry. A named slug reads one plan
+# and still enumerates the estate, because `SLICE_NAMES` is the estate's set.
+enumerate_estate() {
+  cand_ids=()
+  cand_reads=()
+  if [ "$PLAN_SOURCE" = "ref" ]; then
+    while IFS= read -r plan_path; do
+      [ -n "$plan_path" ] || continue
+      plan_blob=$(ref_plan_file "$plan_path") || continue
+      [ -n "$plan_blob" ] || continue
+      cand_ids+=("$plan_path")
+      cand_reads+=("$plan_blob")
+    done <<< "$(ref_ls "$PLAN_DIR")"
+
+    # THEN EACH PREFIXED BRANCH'S OWN TREE, for the plans `origin/$MAIN` does
+    # not carry. Appended to the SAME candidate arrays, before the one
+    # `parse_plan_estate` call below: a second call would build a second
+    # `plan_meta_files` index and the lookup at the row loop keys on the file
+    # path, so the branch plans would parse and then be unfindable.
+    #
+    # From here the existing pipeline carries the plan unchanged — it names its
+    # branch in `## Slices`, the wave walk finds it, and the branch stops
+    # reaching the report through the plan-less loop in `fleet.ts`.
+    #
+    # THE DEDUP IS THE BOARD'S, COPIED RATHER THAN RE-DERIVED. `on_default` is
+    # every plan path the default branch carries; `seen_branch_plans` is every
+    # path already taken from an earlier branch. Two branches cut from one point
+    # carry the SAME plan file, and without the second test one plan reports as
+    # several — a regression the board measured and fixed, and the reason its
+    # comment exists.
+    #
+    # WHICH BRANCHES: `REMOTE_REFS`, already read once above, filtered by
+    # `PREFIX_RE` — the same population the board calls a prefixed branch. No
+    # second `for-each-ref`. The narrowing to PR-less branches the slice line
+    # offered was WITHDRAWN by the plan's Design section: it was a fallback
+    # against a cost that does not exist. Measured 2026-09-24, one `ls-tree`
+    # over the plan directory is ~0.00 s and the whole addition 0.24 s, 0.4% of
+    # a scan whose wall time is 95% waiting.
+    on_default=$'\n'"$(ref_ls "$PLAN_DIR")"$'\n'
+    seen_branch_plans=$'\n'
+    while IFS=$'\t' read -r branch_name _branch_sha; do
+      [ -n "$branch_name" ] || continue
+      [ "$branch_name" = "HEAD" ] && continue
+      [ "$branch_name" = "$MAIN" ] && continue
+      printf '%s' "$branch_name" | grep -Eq "^($PREFIX_RE)/" || continue
+      while IFS= read -r bp; do
+        [ -n "$bp" ] || continue
+        case "$on_default" in *$'\n'"$bp"$'\n'*) continue ;; esac
+        case "$seen_branch_plans" in *$'\n'"$bp"$'\n'*) continue ;; esac
+        plan_blob=$(branch_plan_file "$branch_name" "$bp") || continue
+        [ -n "$plan_blob" ] || continue
+        # MARKED SEEN ONLY ONCE IT IS TAKEN, matching `board.ts:823`: a blob
+        # that could not be read has not been reported, so a later branch
+        # carrying a readable copy of the same path must still get its turn.
+        seen_branch_plans="${seen_branch_plans}${bp}"$'\n'
+        # THE IDENTITY STAYS THE RELATIVE PATH. The row loop parses
+        # `plan_reads[i]` and never re-reads by the identity in `plans[i]`, so
+        # the `docs/plans/…md` path is a usable id — and the dedup above is what
+        # guarantees it cannot collide with a default-branch plan's.
+        cand_ids+=("$bp")
+        cand_reads+=("$plan_blob")
+      done <<< "$(branch_plan_paths "$branch_name")"
+    done <<< "$REMOTE_REFS"
+  else
+    for plan_path in "$PLAN_DIR"*.md; do
+      [ -e "$plan_path" ] || continue
+      cand_ids+=("$plan_path")
+      cand_reads+=("$plan_path")
+    done
+  fi
+}
+
 if [ -n "$slug" ]; then
   # A NAMED SLUG IS NOT A LIST, so it keeps its own resolution: the caller
   # already said which plan it means, and the phase rule would only be able to
@@ -3348,7 +3393,18 @@ if [ -n "$slug" ]; then
   # because that is where every later question reads its answer from.
   if [ ${#plans[@]} -gt 0 ]; then
     parse_plan_estate "${plan_reads[0]}"
-    plan_phases+=("$(plan_phase_of "${plan_reads[0]}")")
+    plan_phase_into "${plan_reads[0]}"
+    plan_phases+=("$plan_phase_reply")
+  fi
+  # THE WHOLE ESTATE TOO, when a `waits:` name will be looked up in
+  # `SLICE_NAMES` below: a prerequisite that is a slice of ANOTHER plan must
+  # read the same here as on a full scan (#1305). The plan loop reads only
+  # `plans`, so the extra plans change no row. Asked only when needed, because
+  # it is the cost: measured 2026-10-06 on this estate (ref mode, `--offline`),
+  # a slug scan took 1.6 s alone and 5.2 s with the estate enumerated.
+  if [ "$slice_names" = 1 ] || printf '%s' ${plan_meta_waves[@]+"${plan_meta_waves[@]}"} | awk -F'\t' '$5 != "-" { w = 1 } END { exit !w }'; then
+    enumerate_estate
+    [ ${#cand_reads[@]} -gt 0 ] && parse_plan_estate "${cand_reads[@]}"
   fi
 else
   # ---------------------------------------------------------------------------
@@ -3414,7 +3470,8 @@ else
     # lookup cursor's advance, which is the whole saving.
     plan_phase_into "$src"
     ph="$plan_phase_reply"
-    is_plan_phase "$ph" || return 0
+    # NOT A PLAN: no phase parsed — see "What makes a file a plan" above.
+    case "$ph" in ""|NONE) return 0 ;; esac
     if is_terminal_phase "$ph"; then
       [ "$next_only" = 1 ] && return 0
       terminal_plans+=("$id")
@@ -3432,73 +3489,7 @@ else
   # ref mode that means every blob is materialized first: the phase decides the
   # group, so the file must exist before it can be asked, and it must be asked
   # together with all the others rather than one at a time.
-  cand_ids=()
-  cand_reads=()
-  if [ "$PLAN_SOURCE" = "ref" ]; then
-    while IFS= read -r plan_path; do
-      [ -n "$plan_path" ] || continue
-      plan_blob=$(ref_plan_file "$plan_path") || continue
-      [ -n "$plan_blob" ] || continue
-      cand_ids+=("$plan_path")
-      cand_reads+=("$plan_blob")
-    done <<< "$(ref_ls "$PLAN_DIR")"
-
-    # THEN EACH PREFIXED BRANCH'S OWN TREE, for the plans `origin/$MAIN` does
-    # not carry. Appended to the SAME candidate arrays, before the one
-    # `parse_plan_estate` call below: a second call would build a second
-    # `plan_meta_files` index and the lookup at the row loop keys on the file
-    # path, so the branch plans would parse and then be unfindable.
-    #
-    # From here the existing pipeline carries the plan unchanged — it names its
-    # branch in `## Slices`, the wave walk finds it, and the branch stops
-    # reaching the report through the plan-less loop in `fleet.ts`.
-    #
-    # THE DEDUP IS THE BOARD'S, COPIED RATHER THAN RE-DERIVED. `on_default` is
-    # every plan path the default branch carries; `seen_branch_plans` is every
-    # path already taken from an earlier branch. Two branches cut from one point
-    # carry the SAME plan file, and without the second test one plan reports as
-    # several — a regression the board measured and fixed, and the reason its
-    # comment exists.
-    #
-    # WHICH BRANCHES: `REMOTE_REFS`, already read once above, filtered by
-    # `PREFIX_RE` — the same population the board calls a prefixed branch. No
-    # second `for-each-ref`. The narrowing to PR-less branches the slice line
-    # offered was WITHDRAWN by the plan's Design section: it was a fallback
-    # against a cost that does not exist. Measured 2026-09-24, one `ls-tree`
-    # over the plan directory is ~0.00 s and the whole addition 0.24 s, 0.4% of
-    # a scan whose wall time is 95% waiting.
-    on_default=$'\n'"$(ref_ls "$PLAN_DIR")"$'\n'
-    seen_branch_plans=$'\n'
-    while IFS=$'\t' read -r branch_name _branch_sha; do
-      [ -n "$branch_name" ] || continue
-      [ "$branch_name" = "HEAD" ] && continue
-      [ "$branch_name" = "$MAIN" ] && continue
-      printf '%s' "$branch_name" | grep -Eq "^($PREFIX_RE)/" || continue
-      while IFS= read -r bp; do
-        [ -n "$bp" ] || continue
-        case "$on_default" in *$'\n'"$bp"$'\n'*) continue ;; esac
-        case "$seen_branch_plans" in *$'\n'"$bp"$'\n'*) continue ;; esac
-        plan_blob=$(branch_plan_file "$branch_name" "$bp") || continue
-        [ -n "$plan_blob" ] || continue
-        # MARKED SEEN ONLY ONCE IT IS TAKEN, matching `board.ts:823`: a blob
-        # that could not be read has not been reported, so a later branch
-        # carrying a readable copy of the same path must still get its turn.
-        seen_branch_plans="${seen_branch_plans}${bp}"$'\n'
-        # THE IDENTITY STAYS THE RELATIVE PATH. The row loop parses
-        # `plan_reads[i]` and never re-reads by the identity in `plans[i]`, so
-        # the `docs/plans/…md` path is a usable id — and the dedup above is what
-        # guarantees it cannot collide with a default-branch plan's.
-        cand_ids+=("$bp")
-        cand_reads+=("$plan_blob")
-      done <<< "$(branch_plan_paths "$branch_name")"
-    done <<< "$REMOTE_REFS"
-  else
-    for plan_path in "$PLAN_DIR"*.md; do
-      [ -e "$plan_path" ] || continue
-      cand_ids+=("$plan_path")
-      cand_reads+=("$plan_path")
-    done
-  fi
+  enumerate_estate
 
   # ONE INVOCATION FOR THE WHOLE ESTATE. Everything below reads its result.
   [ ${#cand_reads[@]} -gt 0 ] && parse_plan_estate "${cand_reads[@]}"
@@ -3514,6 +3505,19 @@ else
   done
 fi
 
+# EVERY SLICE SOMEBODY MAY STILL START, newline-framed for a `case` lookup: the
+# non-deferred slices (wave field 3) of every parsed plan whose phase is not
+# terminal. Every mode parses the whole estate, so a slug run, `--next` and the
+# full scan hold one set, and `plot-dispatch.sh` asks `--slice-names` for it
+# rather than reading its own plan. A `waits:` name in the set with no pull
+# request reads `waiting`; any other name with none reads `blocked` (#1305).
+# `namedSlices` in `rules/branch-state.ts` states the same rule, and
+# `branch-state.corpus.test.ts` holds the two to one answer.
+live_waves=()
+for _si in "${!plan_meta_files[@]}"; do is_terminal_phase "${plan_meta_phases[$_si]}" || live_waves+=("${plan_meta_waves[$_si]}"); done
+SLICE_NAMES=$'\n'"$(printf '%s' ${live_waves[@]+"${live_waves[@]}"} | awk -F'\t' '$3 != "true" && !seen[$2]++ { print $2 }')"$'\n'
+[ "$slice_names" = 1 ] && { printf '%s' "$SLICE_NAMES" | sed '/^$/d'; exit 0; }
+
 if [ ${#plans[@]} -eq 0 ]; then
   # --next/--list-eligible must stay silent and exit 1: "nothing to start" is
   # the same answer whether the plans are all claimed or there are no plans at
@@ -3687,7 +3691,8 @@ if [ ${#plans[@]} -gt 0 ] && [ -n "$MERGE_SUBJECTS" ]; then
     # — `$plan_reads[i]`, the same key the row loop uses at pass 1a. In ref mode
     # that is a materialized blob under a temp path and not `$PLAN_DIR` at all,
     # so a reconstructed path finds nothing.
-    _sp_meta_i=$(plan_meta_index_of "${plan_reads[$_sp_i]}" 2>/dev/null || echo "")
+    plan_meta_index_into "${plan_reads[$_sp_i]}"
+    _sp_meta_i=$plan_meta_index_reply
     [ -n "$_sp_meta_i" ] || continue
     _sp_branches=""
     while IFS=$'\t' read -r _sp_idx _sp_br _sp_rest; do
@@ -4109,7 +4114,7 @@ branch_readings() { # $1=branch $2=deferred $3=plan-base → readings
 # There is no shell fallback: a second implementation kept "just in case" is
 # the duplication this adoption removes, and it would be the copy nobody tests.
 # `plot-deliver.sh` fails the same way for the same reason.
-ask_branch_states() { # stdin=readings → one `state<TAB>needs` line per branch
+ask_branch_states() { # stdin=readings → one `state<TAB>needs<TAB>own` line per branch
   node "$script_dir/board/plot-branch-state.mjs" 2>/dev/null \
     || { echo "error: cannot read branch states — run 'pnpm build:board'." >&2; exit 2; }
 }
@@ -4227,7 +4232,8 @@ for plan in "${plans[@]}"; do
   # The estate was parsed ONCE, before this loop. A plan absent from that
   # result could not be read at all, which is the same answer the per-plan
   # parse gave by failing — so it is skipped here exactly as it was then.
-  meta_i=$(plan_meta_index_of "$plan_read")
+  plan_meta_index_into "$plan_read"
+  meta_i=$plan_meta_index_reply
   [ -n "$meta_i" ] || continue
 
   # The plan's own phase, carried onto the pulse so a consumer can derive a row
@@ -4339,7 +4345,7 @@ for plan in "${plans[@]}"; do
   # not evidence in either direction. The two were one marker until CI ran the
   # corpus with no token, where every prerequisite answers `-` and every waiting
   # branch read `open`. Reading it
-  # costs a host round trip (`waits_pr_state` passes `--ask`, because a delivered
+  # costs a host round trip (`host_pr_state … --ask`, because a delivered
   # prerequisite's ref is gone and only its PR outlives it), and the scan spends
   # that only where the answer could change the branch's state. Which states
   # those are IS the precedence, so the rule reports it rather than this loop
@@ -4363,7 +4369,7 @@ for plan in "${plans[@]}"; do
     # "-" is the absent marker the shim writes, for the tab-collapse reason
     # above. Normalized here so everything downstream tests emptiness.
     [ "$waits" = "-" ] && waits=""
-    readings+="$(branch_readings "$br" "$deferred" "$plan_base")	${waits:--}	?	$list_complete"$'\n'
+    readings+="$(branch_readings "$br" "$deferred" "$plan_base")	${waits:--}	?	$list_complete	?"$'\n'
     # Read from the readings line just built rather than from the variable: the
     # subshell `branch_readings` runs in cannot export it back.
     # FIELD 6 is the host's own word, in both arms of `branch_readings`:
@@ -4417,7 +4423,7 @@ for plan in "${plans[@]}"; do
   while IFS= read -r rd_line; do
     [ -n "$rd_line" ] || continue
     answer_i=$((answer_i + 1))
-    IFS=$'\t' read -r _st needs \
+    IFS=$'\t' read -r _st needs _ \
       <<< "$(printf '%s\n' "$branch_answers" | sed -n "${answer_i}p")"
     waits_br=$(printf '%s' "$rd_line" | cut -f9)
     if [ "$needs" = "1" ] && [ "$waits_br" != "-" ]; then
@@ -4428,15 +4434,21 @@ for plan in "${plans[@]}"; do
       # run, never one per pass.
       #
       # FIELD 9 IS A LIST, comma-joined, so field 10 answers each prerequisite
-      # IN THE SAME ORDER — one `waits_pr_state` call per name, joined the same
+      # IN THE SAME ORDER — one `host_pr_state … --ask` call per name, joined the same
       # way. `entry/branch-state.ts` reads the two columns as parallel lists of
       # equal length and throws otherwise, so a single answer for several names
-      # would desync them. Field 11 is carried, unreplaced.
-      waits_state=""
+      # would desync them. Field 11 is carried, unreplaced. Field 12 says, in
+      # the same order, whether `SLICE_NAMES` holds each name.
+      #
+      # A NAMED SLICE WITH NO REF IS STILL ASKED. Its ref may be gone because it
+      # merged and `plot-release-refs.sh` reaped it, and only the host's MERGED
+      # clears the wait; skipping the call would hold the branch forever.
+      waits_state="" waits_named=""
       for _wn in ${waits_br//,/ }; do
-        waits_state+="${waits_state:+,}$(waits_pr_state "$_wn")"
+        waits_state+="${waits_state:+,}$(host_pr_state "$_wn" --ask)"
+        case "$SLICE_NAMES" in *$'\n'"$_wn"$'\n'*) waits_named+="${waits_named:+,}true" ;; *) waits_named+="${waits_named:+,}false" ;; esac
       done
-      refill+="$(printf '%s' "$rd_line" | cut -f1-9)	$waits_state	$(printf '%s' "$rd_line" | cut -f11)"$'\n'
+      refill+="$(printf '%s' "$rd_line" | cut -f1-9)	$waits_state	$(printf '%s' "$rd_line" | cut -f11)	$waits_named"$'\n'
     else
       refill+="$rd_line"$'\n'
     fi
@@ -4454,13 +4466,14 @@ for plan in "${plans[@]}"; do
   # record is re-read by two more `read` loops below, and an EMPTY middle
   # column collapses its tab into its neighbour's and shifts every later
   # field left. `$claim` is the only field allowed to be last and optional.
+  # `$own` is the branch's state before its prerequisite, the third answer column.
   states=""
   answer_i=0
   while IFS=$'\t' read -r idx br deferred why waits wname claim; do
     [ -n "$br" ] || continue
     answer_i=$((answer_i + 1))
-    st=$(printf '%s\n' "$branch_answers" | sed -n "${answer_i}p" | cut -f1)
-    states+="$idx	$br	$st	$deferred	$why	$waits	$wname	$claim"$'\n'
+    IFS=$'\t' read -r st _ own <<< "$(printf '%s\n' "$branch_answers" | sed -n "${answer_i}p")"
+    states+="$idx	$br	$st	$deferred	$why	$waits	$wname	${own:-$st}	$claim"$'\n'
   done <<< "$order"
 
   # PASS 1e: A DELIVERY CANDIDATE ASKS THE HOST about its subject-proven branches.
@@ -4519,7 +4532,7 @@ for plan in "${plans[@]}"; do
     outstanding=0
     _loose_degraded_branches=""
     wave_states=""
-    while IFS=$'\t' read -r idx br st deferred why waits nm claim; do
+    while IFS=$'\t' read -r idx br st deferred why waits nm _ claim; do
       [ "$idx" = "$wid" ] || continue
       # EVERY branch, including the deferred ones, and in the order the render
       # loop below will walk them — the claimable flags come back positionally,
@@ -4618,7 +4631,7 @@ for plan in "${plans[@]}"; do
     # `deferred` to tell a branch that will never move from one that has not
     # moved yet.
     outlook_branches=""
-    while IFS=$'\t' read -r idx br st deferred why waits nm claim; do
+    while IFS=$'\t' read -r idx br st deferred why waits nm own claim; do
       [ "$idx" = "$wid" ] || continue
       outlook_branches+="${outlook_branches:+|}$br:$st"
       [ "$claim" = "-" ] && claim=""
@@ -4637,9 +4650,9 @@ for plan in "${plans[@]}"; do
         # whole of what this state adds over `open`.
         waiting)  n_waiting=$((n_waiting + 1))
                   note="waiting on $waits_prose" ;;
-        # A PREREQUISITE NOBODY DECLARED. The sentence says the host was asked
-        # and answered, because that is what separates this from `waiting`: a
-        # host that could not be asked holds the branch at `waiting` instead.
+        # A PREREQUISITE NOBODY DECLARED: no plan names it as a slice, and the
+        # host answered that no PR exists for it. A host that could not be
+        # asked, or a named slice nobody has started, reads `waiting` instead.
         blocked)  n_prereq_missing=$((n_prereq_missing + 1))
                   note="blocked — no PR found for $waits_prose" ;;
         # The REASON, where the plan recorded one. A bare `deferred` beside a
@@ -4683,7 +4696,7 @@ for plan in "${plans[@]}"; do
         # The INTERNAL state ($st), never the prose label ($note): the board
         # must not parse a string that exists for humans to read.
         json_branches+="${json_branches:+,}{\"branch\":\"$(json_str "$br")\""
-        json_branches+=",\"state\":\"$st\",\"deferred\":$deferred"
+        json_branches+=",\"state\":\"$st\",\"own_state\":\"$own\",\"deferred\":$deferred"
         # WHAT PROVED THE LANDING, where the proof is weaker than the host's.
         #
         # EMITTED ONLY WHERE THE BRANCH READS `merged` AND THE HOST HAS NOT