@plot-pm/board 0.11.0 → 0.13.0

package/plot-plan-meta.sh

@@ -20,9 +20,17 @@
 # Two plan formats are recognized:
 #
 #   canonical    the plan template's `## Status` body section:
-#                    - **Phase:** Approved
+#                    - **State:** Approved
 #                    - **Type:** feature
-#                (bullet, bold, and plain `Phase: ...` variants all accepted)
+#                (bullet, bold, and plain `State: ...` variants all accepted)
+#
+#                `State:` is the field Plot writes. `Phase:` is the name it
+#                carried until 2026-09-07 and is read as the alternate, the
+#                same way front matter reads `status:` over `phase:` below.
+#                THE DUAL READ IS PERMANENT, NOT SCAFFOLDING: a plan file may
+#                have been written a year ago or copied from another project,
+#                and a Plot that refused to read `Phase:` would be worse at its
+#                own job than the one that confused two words.
 #
 #   frontmatter  YAML front matter at the top of the file:
 #                    ---
@@ -88,7 +96,8 @@
 #                  which is a queue. (`ready-for-review`/`in-review` DO
 #                  normalize onto `approved` — those are synonyms; this is not.)
 #   phase_alt_raw  secondary value when the file carries two (front matter
-#                  status: AND phase:), else ""
+#                  status: AND phase:, or a `## Status` body carrying both
+#                  State: AND Phase:), else ""
 #   phase_alt      normalized phase_alt_raw (NONE when absent)
 #   type           normalized plan type (feature|bug|docs|infra or "")
 #   title          plan title: front matter `title:` wins, else the first H1
@@ -128,6 +137,19 @@
 #                  says: a prerequisite no plan declares still parses, and the
 #                  scan is what turns that into a verdict. `waits:` and
 #                  `deferred:` are independent — a branch may carry both.
+#                  `<!-- builds: normalizeVersion, a shared helper -->` names
+#                  what this slice BUILDS, reported as
+#                  `waves[].branches[].builds`. OPTIONAL, like `Sprint:` and
+#                  `Story:` — a docs plan, a rejection or a measurement builds
+#                  nothing nameable, and nothing warns about its absence. The
+#                  key is ABSENT where none was written, never "". The value
+#                  runs to the closing marker rather than stopping at the first
+#                  space the way `waits:` does: a prerequisite is a branch NAME
+#                  and a deliverable is a name plus enough words to search for.
+#                  An annotation rather than a `Builds:` field line precisely
+#                  BECAUSE annotations already work in both slice dialects from
+#                  one block of code — a field line would need two spellings,
+#                  and the template writes the list dialect.
 #   prs            PR numbers, sorted and unique, read from EITHER spelling:
 #                  `→ #NNN` / `→ owner/repo#NNN` links in the `## Branches`
 #                  section, OR `PR: #NNN` in a `## Waves` `### ` heading. The
@@ -382,7 +404,7 @@ function reset_state() {
   fm_review = ""; fm_impl = ""; fm_approved = ""; fm_started = ""; fm_released = ""
   fm_delivered = ""; fm_design = ""
   fm_rounds = ""
-  canon_phase = ""; canon_type = ""
+  canon_state = ""; canon_phase = ""; canon_type = ""
   canon_sprint = ""; canon_story = ""; canon_assignee = ""
   canon_review = ""; canon_impl = ""; canon_approved = ""; canon_released = ""
   canon_delivered = ""; canon_design = ""
@@ -401,6 +423,7 @@ function reset_state() {
   delete wave_names; delete wave_of; delete wave_seq; delete wave_count
   delete deferred_of; delete deferred_why; delete claimed_of; delete ordered_b; n_waves = 0
   delete waits_of; delete waits_set
+  delete builds_of; delete builds_set
   delete started; n_started = 0
   fm_changelog = ""
   delete changelog; n_changelog = 0; changelog_seen = 0; cl_open = 0
@@ -411,8 +434,14 @@ function emit_record(   fmt, praw, palt_raw, traw, title, sprint, story, assigne
     praw = (fm_status != "") ? fm_status : fm_phase
     palt_raw = (fm_status != "" && fm_phase != "") ? fm_phase : ""
     traw = fm_type
-  } else if (canon_phase != "") {
-    fmt = "canonical"; praw = canon_phase; palt_raw = ""; traw = canon_type
+  } else if (canon_state != "" || canon_phase != "") {
+    # `State:` is primary and `Phase:` the alternate, exactly as front matter
+    # reads `status:` over `phase:`. A file carrying both reports the
+    # disagreement rather than hiding it.
+    fmt = "canonical"
+    praw = (canon_state != "") ? canon_state : canon_phase
+    palt_raw = (canon_state != "" && canon_phase != "") ? canon_phase : ""
+    traw = canon_type
   } else {
     fmt = "none"; praw = ""; palt_raw = ""; traw = ""
   }
@@ -551,6 +580,10 @@ function emit_record(   fmt, praw, palt_raw, traw, title, sprint, story, assigne
       # reading `waits_on` gets a branch name or nothing — never a blank string
       # that reads as a prerequisite with no name.
       if (waits_set[i] == 1) out = out ",\"waits_on\":\"" jesc(waits_of[i]) "\""
+      # ABSENT, NOT EMPTY, for the same reason `waits_on` is: a slice that
+      # names no deliverable emits no key, so a consumer reads a name or
+      # nothing. An empty string would read as a deliverable called "".
+      if (builds_set[i] == 1) out = out ",\"builds\":\"" jesc(builds_of[i]) "\""
       out = out "}"
       first = 0
     }
@@ -748,7 +781,8 @@ in_comment {
 }
 section == "status" {
   lower = tolower($0)
-  if (lower ~ /^[ \t]*[-*]?[ \t]*\**phase[:*]/ && canon_phase == "") canon_phase = val_after_colon($0)
+  if (lower ~ /^[ \t]*[-*]?[ \t]*\**state[:*]/ && canon_state == "") canon_state = val_after_colon($0)
+  else if (lower ~ /^[ \t]*[-*]?[ \t]*\**phase[:*]/ && canon_phase == "") canon_phase = val_after_colon($0)
   else if (lower ~ /^[ \t]*[-*]?[ \t]*\**type[:*]/ && canon_type == "") canon_type = val_after_colon($0)
   else if (lower ~ /^[ \t]*[-*]?[ \t]*\**sprint[:*]/ && canon_sprint == "") canon_sprint = val_after_colon($0)
   else if (lower ~ /^[ \t]*[-*]?[ \t]*\**story[:*]/ && canon_story == "") canon_story = val_after_colon($0)
@@ -925,6 +959,39 @@ section == "slices" && slice_shape != "heading" {
   # `has_waits` carries presence separately from the value, because ABSENT and
   # EMPTY are different answers — a branch declaring no prerequisite emits no
   # `waits_on` key at all.
+  # WHAT THIS SLICE BUILDS: `<!-- builds: normalizeVersion, a shared helper -->`.
+  #
+  # AN ANNOTATION, NOT A FIELD LINE, and that is what makes it work in BOTH
+  # slice dialects with no dialect-specific code. Annotations bind to the line
+  # carrying the branch name — the list item in one spelling, the `### `
+  # heading in the other — and both dialects already read `deferred:`,
+  # `claimed:` and `waits:` with the identical block. A `Builds:` field line
+  # would have had two spellings to parse, and the template writes the LIST
+  # dialect, so the heading-only version would be absent from every plan
+  # created from it.
+  #
+  # IT BELONGS TO THE SLICE, NEVER TO THE PLAN. A plan builds several things
+  # and each slice builds one; a plan-level list is searched as a whole and
+  # reported against the wrong slice.
+  #
+  # The value runs to the closing marker, the way `deferred:` does and unlike
+  # `waits:`. A prerequisite is a branch NAME and stops at whitespace; a
+  # deliverable is a name plus enough words to search for — `normalizeVersion,
+  # a shared helper` — and cutting it at the first space would leave the half
+  # that identifies it.
+  #
+  # `has_builds` carries presence separately from the value, exactly as
+  # `waits:` does: a slice declaring nothing emits no key, so a consumer reads
+  # a deliverable or nothing and never a blank string that looks like one.
+  builds_note = ""
+  has_builds = 0
+  if ($0 ~ /<!--[ \t]*builds:[ \t]*/) {
+    _bl = $0
+    sub(/^.*<!--[ \t]*builds:[ \t]*/, "", _bl)
+    sub(/[ \t]*-->.*$/, "", _bl)
+    builds_note = trim(_bl)
+    if (builds_note != "") has_builds = 1
+  }
   waits_note = ""
   has_waits = 0
   if ($0 ~ /<!--[ \t]*waits:[ \t]*/) {
@@ -982,6 +1049,8 @@ section == "slices" && slice_shape != "heading" {
     # so a branch that declares none emits no key.
     waits_of[n_branches] = waits_note
     waits_set[n_branches] = has_waits
+    builds_of[n_branches] = builds_note
+    builds_set[n_branches] = has_builds
     ordered_b[n_branches] = b
   }
   line = $0
@@ -1066,6 +1135,39 @@ section == "slices" && slice_shape == "heading" {
   # The prerequisite, read exactly as the list-item spelling reads it. Both
   # dialects emit the same waves[], so a field added to one only would break
   # that contract the first time a plan migrated.
+  # WHAT THIS SLICE BUILDS: `<!-- builds: normalizeVersion, a shared helper -->`.
+  #
+  # AN ANNOTATION, NOT A FIELD LINE, and that is what makes it work in BOTH
+  # slice dialects with no dialect-specific code. Annotations bind to the line
+  # carrying the branch name — the list item in one spelling, the `### `
+  # heading in the other — and both dialects already read `deferred:`,
+  # `claimed:` and `waits:` with the identical block. A `Builds:` field line
+  # would have had two spellings to parse, and the template writes the LIST
+  # dialect, so the heading-only version would be absent from every plan
+  # created from it.
+  #
+  # IT BELONGS TO THE SLICE, NEVER TO THE PLAN. A plan builds several things
+  # and each slice builds one; a plan-level list is searched as a whole and
+  # reported against the wrong slice.
+  #
+  # The value runs to the closing marker, the way `deferred:` does and unlike
+  # `waits:`. A prerequisite is a branch NAME and stops at whitespace; a
+  # deliverable is a name plus enough words to search for — `normalizeVersion,
+  # a shared helper` — and cutting it at the first space would leave the half
+  # that identifies it.
+  #
+  # `has_builds` carries presence separately from the value, exactly as
+  # `waits:` does: a slice declaring nothing emits no key, so a consumer reads
+  # a deliverable or nothing and never a blank string that looks like one.
+  builds_note = ""
+  has_builds = 0
+  if ($0 ~ /<!--[ \t]*builds:[ \t]*/) {
+    _bl = $0
+    sub(/^.*<!--[ \t]*builds:[ \t]*/, "", _bl)
+    sub(/[ \t]*-->.*$/, "", _bl)
+    builds_note = trim(_bl)
+    if (builds_note != "") has_builds = 1
+  }
   waits_note = ""
   has_waits = 0
   if ($0 ~ /<!--[ \t]*waits:[ \t]*/) {
@@ -1107,6 +1209,8 @@ section == "slices" && slice_shape == "heading" {
     claimed_of[n_branches] = claim_note
     waits_of[n_branches] = waits_note
     waits_set[n_branches] = has_waits
+    builds_of[n_branches] = builds_note
+    builds_set[n_branches] = has_builds
     ordered_b[n_branches] = b
   }
 

package/plot-pr-merged.sh

@@ -0,0 +1,180 @@
+#!/usr/bin/env bash
+# Plot helper: the ONE answer to "did the host merge ANY PR for this branch?"
+#
+# SOURCED, NOT RUN. `. "$script_dir/plot-pr-merged.sh"` defines `pr_merged` and
+# `pr_open`; the file does nothing else on load. That is what makes sourcing it
+# safe, and it is the same shape — and the same reason — as
+# `plot-worker-state.sh`: the logic could not simply stay in `plot-reap.sh`,
+# because that file parses `$@` and `exit 2`s on an unknown argument at load
+# time, so sourcing it would run the reaper's argument parser against its
+# caller's arguments.
+#
+# FOUR CALLERS. `plot-reap.sh`, `plot-release-refs.sh`, `plot-dispatch.sh`, and
+# `plot-quiet-stretch.sh` — the last sourcing it guarded and calling it behind
+# `command -v pr_merged`, so it still works with this file absent.
+#
+# WHY IT WAS EXTRACTED. `plot-reap.sh` and `plot-release-refs.sh` gate on the
+# SAME fact — has this branch's work landed — and they must never disagree
+# about it. The reaper removes a checkout, which is re-creatable with
+# `git worktree add`; ref deletion is not re-creatable at all. A second
+# implementation that drifted toward permissive would therefore fail in the
+# direction that cannot be undone. One function, one answer, no drift.
+#
+# THIS FILE IS NOW THE ADAPTER, AND THE DECISION IS THE DOMAIN'S. The two
+# functions still ask the host, because the host is asked in shell; what they no
+# longer do is decide. Each turns its lookup into one of three READINGS —
+# `found`, `none`, `unaskable` — and hands the pair to
+# `board/plot-landed.mjs`, which bundles `rules/landed.ts`. The layering runs
+# one way: caller → this adapter → the rule.
+#
+# WHAT MOVED IS THE COUPLING. `pr_merged` and `pr_open` fail in the SAME
+# direction and to OPPOSITE effect — an unreachable host makes the first refuse
+# a removal and the second release its veto — so neither is safe alone and the
+# pair is. That was a comment in this file and could not be checked. It is now
+# `mayRemove` in the rule, asserted over all nine combinations of the two
+# readings, and exactly one of them permits a removal.
+#
+# WHY THIS STILL ASKS `gh` AND NOT `plot-host.sh`. Measured 2026-09-06, and it
+# is the answer to a question this file's exemption in
+# `scripts/check-host-cli-callers.sh` was left open for.
+#
+# `plot-host.sh pr-merged` prints `merged`/`not-merged`/`unknown`, three words
+# that read like the three readings below. THEY DO NOT MATCH. An ABSENT CLI
+# arrives from the adapter as `not-merged`, where `_plot_merged_lookup` answers
+# `unaskable`:
+#
+#   plot-host.sh pr-merged <branch>   → not-merged (exit 0)
+#   _plot_merged_lookup <branch>      → unaskable
+#
+# The cause is the adapter's `is_lookup_miss`. A missing binary makes the shell
+# say `bash: gh: command not found`, and that matches the same `not found` it
+# uses to recognise a genuine "no pull requests found" — one phrase covering two
+# conditions the rule below exists to keep apart.
+#
+# THE DIRECTION IS WHY IT BLOCKS RATHER THAN ANNOYS. `not-merged` reads as
+# `none` — the host spoke and said nothing merged — so `mayRemove` may permit a
+# removal where `unaskable` refuses. `plot-release-refs.sh` deletes remote refs
+# on this answer and a deleted ref is not re-creatable.
+#
+# AND `pr_open` HAS NO OP TO CALL AT ALL. It needs found/none/unaskable about
+# ANY open PR; `pr-state` answers about ONE — the newest — and reports a failed
+# lookup with the same `state:"NONE"` payload as a real absence. It can express
+# neither "any" nor "unaskable".
+#
+# THE COST WAS MEASURED TOO, and it is the smaller objection. Ten sequential
+# calls on this machine: 4.75 s direct, 9.25 s through the adapter — +450 ms per
+# branch, from the connector's slot and budget accounting rather than from the
+# spawn. Across the 48 branches the fleet scan walks that is ~21 s. Real, but it
+# is the correctness gap above that decides this, not the clock.
+#
+# Both halves are pinned in `test/reconcile/host.test.mjs`, so the exemption
+# rests on tests that fail when it stops being true.
+#
+# `mergedAt` IS READ, NEVER `state`. A merged PR reports state CLOSED, and
+# trusting `state` would refuse every squash-merged branch — which is the whole
+# population these scripts exist for. Squash-merge rewrites the commits, so the
+# branch stays "ahead of main" forever and ancestry alone can never clear it.
+#
+# AND THE QUESTION IS "ANY", NOT "THE NEWEST". This asked with `--limit 1`
+# until 2026-08-27, which returns only the most recent PR — so a newer,
+# unmerged PR sitting in front of the real merge reported `no merged PR` about
+# a branch whose work was on main. Measured that day against the live host:
+#
+#   an-unreachable-host-says-so         newest #473 null → real merge #446
+#   the-scan-sees-a-stale-sprint-tally  newest #464 null → real merge #463
+#   a-plan-cites-a-jira-key             newest #476 null → real merge #447
+#
+# The masking PRs were ones the fleet opened ITSELF on already-merged waves,
+# which closes a loop: a leftover worktree lets auto-dispatch adopt a merged
+# branch, its worker opens a duplicate, the duplicate is newer, the reaper
+# keeps the worktree — the input to step one. Reading only the newest PR is the
+# SAME error as reading `state`, one level out: the newest PR is not the merge,
+# just as the state is not the merge.
+#
+# 100 rather than unbounded: `gh` has no "all" sentinel, and this runs on paths
+# where the estate may hold dozens of branches. A branch carrying more than 100
+# PRs whose only merge is the oldest would still be missed — a far narrower
+# window than "any duplicate at all", and it fails SAFE, toward keeping.
+
+# Where the rule lives, resolved from THIS file rather than from the cwd.
+#
+# Both callers run with their cwd wherever the operator invoked them, and the
+# reconcile suite runs them against sandbox repos in the temp directory. The
+# artifact sits beside this script in the plot checkout and in the published
+# npm package alike, which is why both are vendored together.
+_plot_landed_mjs="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)/board/plot-landed.mjs"
+
+# Ask the rule about one branch's two lookups.
+#
+# $1=merged reading, $2=open reading, both `found`/`none`/`unaskable`.
+# Prints the rule's two words; returns non-zero when it could not be asked at
+# all, which every caller below reads as the refusing direction.
+_plot_landed() {
+  [ -f "$_plot_landed_mjs" ] || return 1
+  printf '%s\t%s\n' "$1" "$2" | node "$_plot_landed_mjs" 2>/dev/null
+}
+
+# What the host says about ANY PR on this branch: found / none / unaskable.
+#
+# A MISSING CLI, AN UNAUTHED ONE AND A NETWORK FAILURE ARE ALL `unaskable`, and
+# they are not `none`. The whole rule turns on that difference — a lookup that
+# ran and matched nothing is the host speaking, while a lookup that did not run
+# is silence, and silence is never permission.
+_plot_merged_lookup() {
+  local br="$1" out
+  command -v gh >/dev/null 2>&1 || { echo unaskable; return; }
+  out=$(gh pr list --head "$br" --state all --limit 100 --json mergedAt 2>/dev/null) \
+    || { echo unaskable; return; }
+  case "$out" in *'"mergedAt":"'*) echo found ;; *) echo none ;; esac
+}
+
+# What the host says about an OPEN PR on this branch: found / none / unaskable.
+_plot_open_lookup() {
+  local br="$1" out
+  command -v gh >/dev/null 2>&1 || { echo unaskable; return; }
+  out=$(gh pr list --head "$br" --state open --limit 1 --json number 2>/dev/null) \
+    || { echo unaskable; return; }
+  case "$out" in *'"number"'*) echo found ;; *) echo none ;; esac
+}
+
+# Did the host merge ANY PR for this branch?
+#
+# Returns 0 (merged) / 1 (not merged, or the host cannot be asked). The failure
+# direction is deliberate and load-bearing: an unreachable host, an unauthed
+# `gh`, a missing CLI all answer "not merged", so every caller KEEPS what it
+# was considering removing. Silence is never permission.
+#
+# The rule answers `unknown` on that silence and this function reports it as a
+# refusal, which is the same contract the four callers were written against —
+# `plot-reap.sh:385` says so explicitly. A rule that cannot be reached at all
+# refuses here too, for the same reason.
+pr_merged() {
+  local answer
+  answer=$(_plot_landed "$(_plot_merged_lookup "$1")" none) || return 1
+  case "$answer" in landed*) return 0 ;; *) return 1 ;; esac
+}
+
+# Does the branch have an OPEN PR right now?
+#
+# A DIFFERENT question from `pr_merged`, and it exists for a case measured by
+# hand on 2026-08-28. `changeset-release/main` is merged — repeatedly — and
+# Changesets RECREATES and reuses the very same branch for the next release.
+# Its ref carries a live release PR while an older PR of its own has merged, so
+# the merged gate alone says "delete" about a branch somebody is actively
+# using.
+#
+# So an open PR VETOES a deletion even where an older one merged. That is
+# strictly narrower than the merge gate rather than a second opinion on it: it
+# can only ever keep a ref, never release one.
+#
+# Returns 0 when an open PR exists. An unreachable host returns 1 — and note
+# that this is the SAME direction as `pr_merged`'s failure, but it has the
+# OPPOSITE effect, since this answer vetoes. The safety therefore does not come
+# from this function: it comes from `pr_merged` already having refused on the
+# same silence, so a host that cannot be asked deletes nothing regardless.
+# `mayRemove` is where that pair is now asserted rather than described.
+pr_open() {
+  local answer
+  answer=$(_plot_landed none "$(_plot_open_lookup "$1")") || return 1
+  case "$answer" in *"	open-pr") return 0 ;; *) return 1 ;; esac
+}

package/plot-reap.sh

@@ -18,6 +18,15 @@
 # whose agent never existed, and 2 dirty desks holding 52 and 1 files that
 # every run refused and nothing ever resolved.
 #
+# AND ONE THING IT ONLY REPORTS: a worktree git lists whose directory is gone.
+# `git worktree list --porcelain` calls it `prunable`, and it is NOT a sixth
+# refusal. A refusal says *do not remove this* and sends an operator to look; a
+# vanished entry says *there is nothing to remove and the entry is stale*, with
+# `git worktree prune` as the repair. It is reported before the refusals are
+# asked, because it is the prior question: four of the five measure something
+# inside a tree that is not there. Measured 2026-09-06 on this estate, 3 of 20
+# worktrees were prunable and this script named none of them.
+#
 # EVERY KIND KEEPS ONE SHAPE: `--dry-run` by default, acting on `--yes`,
 # bounded by `--max N`. The bound is PER KIND, because the kinds are different
 # acts on different populations — a run bounded to five worktrees has not
@@ -317,12 +326,41 @@ manifest_for() {
   return 1
 }
 
-reap=0; kept=0; removed=0; cleared=0
+reap=0; kept=0; removed=0; cleared=0; vanished=0
 printf '%-8s %-52s %s\n' "verdict" "branch" "why"
 
-while IFS=$'\t' read -r wt br; do
+while IFS=$'\t' read -r wt br prunable; do
   [ -n "$wt" ] || continue
   short=${br#refs/heads/}
+  [ "$wt" = "$ROOT" ] && continue
+
+  # 4a. GIT'S OWN ANSWER THAT THE DIRECTORY IS GONE, and it is a REPORT rather
+  #     than a sixth refusal. The five below each say *do not remove this* and
+  #     send an operator to look; this says *there is nothing to remove and the
+  #     entry is stale*, and names the repair. Blurring the two would tell
+  #     somebody to go and inspect a directory that is not there.
+  #
+  #     IT IS ASKED FIRST because it is the PRIOR question. Four of the five
+  #     refusals measure something inside the tree — a pid file, a marker, the
+  #     porcelain status, the checked-out branch — and every one of them is
+  #     unanswerable here. `rules/reapable.ts` says the same thing in the
+  #     domain: a `vanished` tree makes those four conditions `unknown`.
+  #
+  #     AND IT IS ASKED BEFORE THE DISPATCH-TREE FILTER, which would otherwise
+  #     hide exactly this population. That filter accepts a tree by its
+  #     `.plot-worker.pid` file or its legacy `plot-wt-` path — and a vanished
+  #     desk under `Worktree root` has neither, the pid file having gone with
+  #     the directory. Measured 2026-09-06: 3 of 20 worktrees here were
+  #     prunable and the reaper reported none of them.
+  #
+  #     NOTHING IS PRUNED ON THIS PATH. The reading came from the listing the
+  #     loop already makes, no `git` call was added for it, and whether to
+  #     prune stays the operator's decision — the same discipline that makes
+  #     every refusal a measurement rather than an act.
+  if [ "$prunable" = "yes" ]; then
+    printf '%-8s %-52s %s\n' "vanished" "$short" "directory gone — 'git worktree prune' clears the entry"
+    vanished=$((vanished+1)); continue
+  fi
 
   # 5. Only dispatch trees. A hand-made worktree and the main checkout are not
   #    this script's to remove, whatever state they are in.
@@ -346,7 +384,6 @@ while IFS=$'\t' read -r wt br; do
   if [ ! -f "$wt/.plot-worker.pid" ]; then
     case "$wt" in *"/plot-wt-"*) ;; *) continue ;; esac
   fi
-  [ "$wt" = "$ROOT" ] && continue
 
   # THE READINGS. Everything from here to the rule call MEASURES; nothing
   # decides. Each of the four sources that can answer is read once, into a
@@ -514,7 +551,10 @@ NODE_EOF
     fi
   fi
 done < <(git worktree list --porcelain \
-          | awk '/^worktree /{p=$2} /^branch /{print p"\t"$2}')
+          | awk '/^worktree /{ if (br != "") print p"\t"br"\t"pr; p=$2; br=""; pr="no"; next }
+                 /^branch /  { br=$2; next }
+                 /^prunable/ { pr="yes"; next }
+                 END         { if (br != "") print p"\t"br"\t"pr }')
 
 [ "$DRY" -eq 0 ] && git worktree prune 2>/dev/null
 
@@ -900,5 +940,5 @@ fi
 # which is why `plot-release-refs.sh` deletes those, plan-scoped, under its own
 # licence and its own five guards. The asymmetry between the kinds is the whole
 # safety argument and it stays.
-echo "summary: reapable=$reap removed=$removed kept=$kept cleared=$cleared branches=$swept_branches branches_deleted=$deleted_branches branches_kept=$kept_branches claims=$swept_claims claims_deleted=$deleted_claims claims_kept=$kept_claims dirty_trees=$dirty_trees dry_run=$DRY"
+echo "summary: reapable=$reap removed=$removed kept=$kept vanished=$vanished cleared=$cleared branches=$swept_branches branches_deleted=$deleted_branches branches_kept=$kept_branches claims=$swept_claims claims_deleted=$deleted_claims claims_kept=$kept_claims dirty_trees=$dirty_trees dry_run=$DRY"
 exit 0