#!/bin/bash
# board.sh - cross-repo attention board. Answers the one question no single
# repo's STATE.md can: across ALL repos, which have a live next step, which are
# blocked and on whom, which owe someone a reply, and what each costs to
# advance. Read-only: never writes to a repo, a STATE.md, or the mailbox.
#
# Sources (all pre-existing, nothing invented):
#   STATE.md "NESTE" block   - the next step, per repo (canonical)
#   STATE.md board line      - optional machine-readable field (see below)
#   git status --porcelain   - uncommitted risk
#   git log -1 --format=%ct  - when anything last landed (the SISTE column)
#   ~/.claude/coord/<repo>/inbox - UNHANDLED INBOUND: others addressed this
#                              repo and it has not processed them. This is an
#                              obligation the repo owes outward - NOT evidence
#                              that the repo is waiting on anyone. The mailbox
#                              format has no reply-to/thread field, so
#                              outbound waiting is not derivable from it at
#                              all; that is exactly what blocked-on carries.
#
# Board line (optional, one per STATE.md, directly under the NESTE heading):
#
#   <!-- board: status=in-progress; blocked-on=-; next-cost=Sonnet 5/xhigh -->
#
#   status     planned | in-progress | blocked | deferred | done
#   blocked-on <repo-name> or - (only meaningful with status=blocked)
#   next-cost  <model>/<effort>, the model spelled EXACTLY as the global rubric
#              spells it: Sonnet 5/xhigh, Opus 5/high. The parser below accepts
#              any spelling, but this field is compared across repos by eye, so
#              one form is the whole point - and a second spelling documented
#              here is how a field with no write path drifts.
#              The field now HAS a write path: route.sh emits it, and the set of
#              legal values is that script's row table - not this comment, which
#              shows the form only. `route.sh --help` is the authority; the two
#              ends are pinned together by route-selftest.sh section 6.
#
# TWO AGE COLUMNS, ONE MEANING EACH. ALDER is the STATE.md mtime - when the
# plan was last touched - and is blank for a repo that has none. SISTE is the
# last commit, read for every repo. They were one column once, and it meant
# whichever of the two the repo's branch happened to compute: a repo WITH a
# STATE.md showed only its plan's age, so one that had not committed in a year
# was indistinguishable from one worked on this morning. Both are evidence for
# the reader and neither is a ranking input - the buckets and the sort are
# unchanged by this column.
#
# ATTENTION AXIS, NOT A TOPIC AXIS. This status vocabulary is deliberately NOT
# the vocabulary a cross-repo TOPIC register uses. A topic register answers
# "what is this repo's status on subject X (has it adopted convention Y?)";
# this line answers "does this REPO's own next step need me?". Topic tokens do
# not transfer: `not-applicable` is meaningless about a repo's next step, and a
# topic-level `partial` carries an ownership-and-next-step rule that belongs to
# the register, not here. Conflating the two axes is a real defect class - the
# board reads only its own axis, so keep them separate.
#
# --brief is a SECOND RENDERING of the same scan, never a second scan. The
# table answers "what is the state of every repo"; the briefing answers the
# narrower question an unattended nightly job can answer without judgement:
# which repos have an unhandled inbox, what their next step says IN FULL, and
# the exact command to start a session there. The 38-char cut is the table
# column's property, not the record's, so the briefing prints NESTE uncut. Each
# command is derived by CALLING route.sh with that repo's own four traits -
# next-cost alone cannot yield it, since the advisor flag is a property of the
# ROW. A repo with no route line is told so rather than handed a guess.
#
# --brief is still read-only: it writes nothing. The file write lives in
# brief-nightly.sh, which renders to a temp file and renames it into place, and
# refuses to overwrite a good briefing with an empty render.
#
# --plan is a THIRD rendering of that same scan, and the only one that takes a
# position: it answers which repos to open a tab for today and in what order.
# It prints key=value blocks, not prose, because it has two consumers - the
# operator pasting commands, and a separate repo driving a terminal from it.
# Ordering is deterministic and there is no cutoff, so nothing is hidden. It is
# FIVE ORDERED GROUPS, each a lookup over a field the scan already read:
#
#   1. chain-root credit - repos released transitively (see below)
#   2. unhandled inbox messages, most-owed first, WHATEVER the status
#   3. planned
#   4. in-progress
#   5. undeclared status ('?' / MALFORMED) - last, and labelled
#
# Within a group: the quantity that group is about (released, then owed), then a
# Sonnet next-cost (cheap to move under quota pressure), then oldest plan first.
#
# 0.19.0 shipped a weighted score here instead, and 0.20.0 replaced it. The score
# expressed one thing this cannot - "owes one message AND releases two others" as
# a single quantity - and the operator accepted losing that. What a score could
# not do was hold still for the second consumer: re-tuning 40 against 15 here
# would silently reorder a parser living in another repo, and no test in THIS one
# could catch it. Groups 3 and 4 are inverted from every version before 0.20.0
# (planned above in-progress), also by operator decision: a decided but unstarted
# step is what converts a decision into motion; live work is already moving.
#
# CHAIN-ROOT CREDIT is the term that needed blocked-on to stop being a display
# string. For every blocked repo the edge is followed transitively to the ROOT
# of the chain - the first repo not itself blocked - and only the root is
# credited. Opening a blocked repo releases nobody, since its own next step is
# by definition waiting; opening the root releases everything behind it. A
# cycle, a blocked-on naming an unscanned repo, and a blocked repo with no
# target all credit NOBODY: inventing a root there would look like a working
# plan while sending the operator to the wrong repo.
#
# Debt is deliberately UNCAPPED and never excluded. A cap was proposed with the
# credit and declined by the operator: owing a reply is the other axis from a
# repo's own next step, and answering is often what unblocks a chain. Being one
# group below chain-root credit is NOT a cap - the debtor keeps its tab, its
# most-owed-first position among the other debtors, and its `why=inbox:N`. A
# change that dropped a debtor from the plan would be the declined cap wearing
# this decision as a disguise, and section 12 of the selftest pins that half.
#
# why= names the GROUP that put the repo in the plan. Under the score it named
# the dominant TERM, because a score has no single rule that admitted a repo;
# under groups the admitting rule is the group, so the two coincide wherever the
# chain-root group applies and the field is unchanged for both consumers.
# Read-only like the rest: --plan writes nothing, in the repo or the mailbox.
#
# --focus "<prose>" narrows --plan to the repos whose STATE.md DECLARES a
# matching topic marker (`<slug>: <status>`), and is the only cutoff this
# format has. It is therefore required to report what it held back: the same
# run prints fokus= (the slugs the prose resolved to), fokus_droppet= (how
# many blocks the cutoff removed), fokus_utenfor= (the repos that MENTION a
# resolved slug with no marker line, named - that class is where the decisive
# find came from), and fokus_rekkevidde= (how many STATE.md were searched;
# board opens no other file). Each surviving block carries fokus_treff=, the
# declaration it survived on. Prose matching no declared slug prints the FULL
# plan plus fokus_ikke_brukt= - never an empty one, since the prose arrives
# verbatim from the operator and a typo must not empty the morning.
#
# Usage: board.sh [--roots <dir>[,<dir>...]] [--plain] [--brief|--plan]
#                 [--focus "<prose>"]
# Env:   CLAUDE_COORD_DIR overrides the mailbox root.
#        BOARD_ROOTS      overrides the default scan roots.
# ASCII only, bash 3.2 safe.
set -u
export LC_ALL=C

COORD="${CLAUDE_COORD_DIR:-$HOME/.claude/coord}"
ROOTS="${BOARD_ROOTS:-$HOME/repos}"
NESTE_WIDTH=38
BRIEF=0
PLAN=0
FOCUS=""

# Sibling calculator, invoked rather than reimplemented: the rubric that turns
# four traits into a model has exactly one copy, and it is route.sh's row
# table. Bare form on purpose - a ${VAR:-fallback} here is the 0.12.1 defect.
SELFDIR="$(cd "$(dirname "$0")" && pwd)"
ROUTE="$SELFDIR/route.sh"

while [ $# -gt 0 ]; do
  case "$1" in
    # bash 3.2: `shift 2` past the end of $# is a no-op -> would loop forever.
    --roots) [ $# -ge 2 ] || { echo "board: --roots requires a value" >&2; exit 2; }
             ROOTS="$2"; shift 2 ;;
    # Three renderings of one scan, so exactly one may be selected: last wins.
    --brief) BRIEF=1; PLAN=0; shift ;;
    --plan)  PLAN=1; BRIEF=0; shift ;;
    # Raw operator prose, forwarded verbatim by the driver: it does not
    # tokenize, match or normalize, so every bit of that work is here. Same
    # `shift 2` guard as --roots, for the same bash 3.2 reason.
    --focus) [ $# -ge 2 ] || { echo "board: --focus requires a value" >&2; exit 2; }
             FOCUS="$2"; shift 2 ;;
    --plain) shift ;;
    -h|--help) grep '^#' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
    *) echo "board: unknown argument: $1 (ignored)" >&2; shift ;;
  esac
done

NOW="$(date +%s)"

# Truncate to N CHARACTERS (not bytes). A byte cut splits multibyte prose and
# emits mojibake; macOS `cut -c` is character-aware under a UTF-8 locale.
trunc() { printf '%s' "$1" | LC_ALL=en_US.UTF-8 cut -c1-"$2"; }

# --- Discovery: git repos at depth 1, plus depth 2 under polyrepo dirs ------
# A directory that is itself a git repo is one repo; a directory that is not
# but contains git repos is a polyrepo container (the plugin marketplace) and
# contributes its children, never itself.
#
# "Is a repo" tests .git with -e, not -d: a worktree or submodule has .git as a
# FILE. A plain `git worktree add <root>/feature-x` lands a depth-1 sibling that
# can CARRY its own STATE.md - a -d test drops it silently. Kept identical in
# the rollup builder (catalog) on purpose: two readers, one name.
REPOS=""
# Split on comma via IFS + `set --` rather than an unquoted $(...) expansion:
# unquoted word-splitting would also split roots containing spaces. Arg parsing
# is finished above, so clobbering the positional parameters is safe here.
OLD_IFS="$IFS"; IFS=','
set -- $ROOTS
IFS="$OLD_IFS"
for root in "$@"; do
  [ -d "$root" ] || continue
  for entry in "$root"/*; do
    [ -d "$entry" ] || continue
    if [ -e "$entry/.git" ]; then
      REPOS="$REPOS
$entry"
    else
      for child in "$entry"/*; do
        [ -e "$child/.git" ] || continue
        REPOS="$REPOS
$child"
      done
    fi
  done
done

[ -n "$(printf '%s' "$REPOS" | tr -d '[:space:]')" ] || exit 0

# --- Collect one record per repo -------------------------------------------
# Record: bucket|sortkey|name|status|cost|inbox|dirty|age|neste
RECORDS=""
MALFORMED=""

printf '%s\n' "$REPOS" | while IFS= read -r d; do
  [ -n "$d" ] || continue
  name="$(basename "$d")"
  state="$d/STATE.md"

  dirty="$(git -C "$d" status --porcelain 2>/dev/null | wc -l | tr -d ' ')"
  [ -n "$dirty" ] || dirty=0

  inbox=0
  if [ -d "$COORD/$name/inbox" ]; then
    inbox="$(ls "$COORD/$name/inbox"/*.md 2>/dev/null | wc -l | tr -d ' ')"
    [ -n "$inbox" ] || inbox=0
  fi

  # Read for EVERY repo, not just the STATE-less ones: a repo whose plan file
  # is fresh can still have been silent for a year, and that is precisely the
  # repo no other column reports. A repo with no commits at all has no reading
  # to give - printing a day count there would be a fabricated one.
  lastct="$(git -C "$d" log -1 --format=%ct 2>/dev/null)"
  if [ -n "$lastct" ]; then
    lastd=$(( (NOW - lastct) / 86400 )); lastcol="${lastd}d"
  else
    lastd=-1; lastcol="-"
  fi

  if [ ! -f "$state" ]; then
    # No plan file, so no plan age: ALDER is blank rather than quietly showing
    # the commit age under a heading that means something else everywhere else
    # in the table. The sort key keeps using it - order is unchanged.
    printf '5|%06d|%s|-|-|%s|%s|-|%s|%s|-|(ingen STATE.md)\n' \
      "$lastd" "$name" "$inbox" "$dirty" "$lastcol" "$d"
    continue
  fi

  mtime="$(stat -f %m "$state" 2>/dev/null)"
  if [ -n "$mtime" ]; then age=$(( (NOW - mtime) / 86400 )); else age=0; fi

  # Anchored to the exact comment form, NOT a substring search: unanchored
  # 'board:' also matches prose like "dashboard: ..." and -m1 would let a
  # lookalike higher up the file win over the real line.
  line="$(grep -m1 '^<!-- board:' "$state" 2>/dev/null)"
  status=""; blockedon=""; cost=""
  if [ -n "$line" ]; then
    status="$(printf '%s' "$line" | sed -n 's/.*status=\([a-z-]*\).*/\1/p')"
    blockedon="$(printf '%s' "$line" | sed -n 's/.*blocked-on=\([A-Za-z0-9._-]*\).*/\1/p')"
    # Value runs to the next ';' or the closing '-->', NOT to the first
    # non-lowercase byte: the rubric names models "Sonnet 5 / xhigh", so a
    # lowercase-only class silently drops spec-conformant values to "?".
    cost="$(printf '%s' "$line" | sed -n 's/.*next-cost=\([^;>]*\).*/\1/p' \
            | sed -e 's/--$//' -e 's/[[:space:]]*$//' -e 's/^[[:space:]]*//')"
  fi

  case "$status" in
    planned|in-progress|blocked|deferred|done) ;;
    "") status="?" ;;
    *) status="MALFORMED:$status" ;;
  esac
  [ -n "$cost" ] || cost="?"

  # First content line under the NESTE heading: skip blanks, HTML comments and
  # the heading itself; strip markdown bold/bullet noise. Anchored to the
  # heading form (measured 26/27 real repos, decided 2026-08-02) so a prose
  # line that merely mentions the word is never mistaken for the marker.
  #
  # A comment is tracked to its CLOSER, not just recognised on its opening line.
  # Skipping only lines that start with the opener left every continuation line
  # of a wrapped comment looking like prose, so the excerpt became comment
  # internals - the board line and the route line both wrap easily, and this
  # repo was the one of 28 that hit it, held down only by writing them on one
  # line. What this does NOT do, and cannot: an HTML comment body may not
  # contain the closer at all, so a route rationale that quotes it still ends
  # its own comment early. That is the format, not a defect left here.
  neste="$(awk '
    /^#+[[:space:]].*NESTE/ { flag=1; next }
    flag {
      if (incomment) { if ($0 ~ /-->/) incomment=0; next }
      if ($0 ~ /^[[:space:]]*$/) next
      if ($0 ~ /^[[:space:]]*<!--/) { if ($0 !~ /-->/) incomment=1; next }
      if ($0 ~ /^#/) next
      print; exit
    }' "$state" 2>/dev/null \
    | sed -e 's/^[[:space:]]*>[[:space:]]*//' -e 's/\*\*//g' \
          -e 's/^[[:space:]]*[-*][[:space:]]*//' -e 's/^[[:space:]]*//' -e 's/`//g')"
  # Stored WHOLE. Truncation is a property of the table's 38-char column, so it
  # belongs to that renderer alone - the briefing is a second rendering of this
  # same record and exists precisely to carry the line uncut. Cutting here once
  # meant the only copy of the text was the cut one.
  [ -n "$neste" ] || neste="(tom NESTE-blokk)"

  disp="$status"
  if [ "$status" = "blocked" ] && [ -n "$blockedon" ] && [ "$blockedon" != "-" ]; then
    disp="blocked>$blockedon"
  fi

  case "$status" in
    blocked)      bucket=1 ;;
    MALFORMED:*)  bucket=2 ;;
    in-progress|planned|"?") bucket=2 ;;
    deferred)     bucket=3 ;;
    done)         bucket=4 ;;
    *)            bucket=2 ;;
  esac

  # blocked-on is a FIELD, not just the display string above: --plan follows the
  # edge to find who a session would release, and the edge cannot be recovered
  # from `blocked>X` alone (a repo can be blocked with no target, and a repo can
  # name a target the scan never produced). Inserted BEFORE `neste`, never after:
  # `neste` is free prose lifted out of a STATE.md and may contain a literal '|'
  # from a markdown table, so it has to stay the last field on the line.
  printf '%s|%06d|%s|%s|%s|%s|%s|%sd|%s|%s|%s|%s\n' \
    "$bucket" "$age" "$name" "$disp" "$cost" "$inbox" "$dirty" "$age" "$lastcol" "$d" \
    "${blockedon:--}" "$neste"
done > "${TMPDIR:-/tmp}/board.$$"

RECORDS="${TMPDIR:-/tmp}/board.$$"
UNBLOCKS="${TMPDIR:-/tmp}/board-unblocks.$$"
trap '/bin/rm -f "$RECORDS" "$UNBLOCKS" 2>/dev/null' EXIT

# --- Chain-root credit -----------------------------------------------------
# For every blocked repo, walk `blocked-on` up to the ROOT of the chain - the
# first repo that is not itself blocked - and credit that root with one repo
# released. The credit is transitive and lands ONLY on the root, because that
# is the only node where opening a session changes anything: every other link
# is by definition waiting on someone further up.
#
# Three cases must credit NOBODY rather than credit a guess:
#   - a cycle (A waits on B waits on A): no root exists, so the hop limit is
#     the terminating condition, not a safety net that also happens to fire.
#   - a blocked-on naming a repo the scan never produced: nothing validates
#     that field, so a typo is the expected case. There is no directory to
#     open, so a tab for it would be unrunnable.
#   - a blocked repo with no target at all (`blocked-on=-`).
# Silently inventing a root in any of these is worse than skipping it: the plan
# would look correct and send the operator to the wrong repo.
: > "$UNBLOCKS"
awk -F'|' '$4 ~ /^blocked/ && $11 != "-" && $11 != "" {print $11}' "$RECORDS" \
| while read -r cr_target; do
    cr_cur="$cr_target"; cr_hops=0; cr_root=""
    while [ "$cr_hops" -lt 20 ]; do
      cr_line="$(awk -F'|' -v n="$cr_cur" '$3==n {print; exit}' "$RECORDS")"
      [ -n "$cr_line" ] || break          # dangling target: no root
      cr_st="$(printf '%s' "$cr_line" | cut -d'|' -f4)"
      case "$cr_st" in
        blocked*)
          cr_nxt="$(printf '%s' "$cr_line" | cut -d'|' -f11)"
          [ -n "$cr_nxt" ] && [ "$cr_nxt" != "-" ] || break
          cr_cur="$cr_nxt"; cr_hops=$((cr_hops + 1)) ;;
        *) cr_root="$cr_cur"; break ;;
      esac
    done
    [ -n "$cr_root" ] && printf '%s\n' "$cr_root"
  done | sort | uniq -c | awk '{print $2 "|" $1}' > "$UNBLOCKS"

hdr() {
  printf '\n%s\n' "$1"
  printf '%-32s %-34s %-14s %4s %4s %6s %6s  %s\n' \
    "REPO" "STATUS" "KOST" "INN" "DRT" "ALDER" "SISTE" "NESTE"
}

rows() {
  awk -F'|' -v b="$1" '$1==b' "$RECORDS" | sort -t'|' -k2,2n | \
  while IFS='|' read -r bucket sortkey name status cost inbox dirty age last dir blockedon neste; do
    printf '%-32s %-34s %-14s %4s %4s %6s %6s  %s\n' \
      "$name" "$status" "$cost" "$inbox" "$dirty" "$age" "$last" "$(trunc "$neste" "$NESTE_WIDTH")"
  done
}

# --- Briefing rendering (--brief) ------------------------------------------
# The startup command for one repo, derived from that repo's OWN route line by
# calling route.sh. Deriving it from next-cost instead would not work even in
# principle: the advisor flag is a property of the ROW, and two rows can share
# a model/effort pair while differing on it. A repo with no route line gets its
# next-cost printed and is told where the command comes from - a guessed
# command would read as authoritative while being a guess, which is worse than
# no command at all.
# Shared by --brief and --plan, because there is one route line grammar and it
# gets one reader. Two no-command cases, and callers must keep them apart:
#   exit 1            - no route line at all
#   exit 0, empty out - a route line route.sh rejects (a typo'd trait value)
# Neither may become a guessed command, and neither may become a bare command
# marker: a driver reading `command=` would type an empty line into a live pane.
route_cmd_for() {
  rc_line="$(grep -m1 '^<!-- route:' "$1/STATE.md" 2>/dev/null)"
  [ -n "$rc_line" ] || return 1
  rc_p="$(printf '%s' "$rc_line" | sed -n 's/.*path=\([a-z-]*\).*/\1/p')"
  rc_v="$(printf '%s' "$rc_line" | sed -n 's/.*verification=\([a-z-]*\).*/\1/p')"
  rc_r="$(printf '%s' "$rc_line" | sed -n 's/.*reversibility=\([a-z-]*\).*/\1/p')"
  rc_s="$(printf '%s' "$rc_line" | sed -n 's/.*scope=\([a-z-]*\).*/\1/p')"
  bash "$ROUTE" --path "$rc_p" --verification "$rc_v" \
       --reversibility "$rc_r" --scope "$rc_s" --rationale brief 2>/dev/null \
    | sed -n 's/^command=//p'
  return 0
}

brief_cmd() {
  if bc_cmd="$(route_cmd_for "$1")"; then
    if [ -n "$bc_cmd" ]; then
      printf '$ %s' "$bc_cmd"
    else
      printf 'KOST: %s   (route-linjen kunne ikke tolkes)' "$2"
    fi
  else
    printf 'KOST: %s   (ingen route-linje - kjor route-skillen i det repoet)' "$2"
  fi
}

# The repo scan and the mailbox are two different populations, and the gap
# between them is silent by default. board.sh discovers git REPOS; a mailbox
# can carry a name no scan will ever produce - a declared non-git surface
# (CLAUDE_COORD_REPO, e.g. ~/repos itself) or a checkout outside the roots.
# Such a mailbox is invisible in every column this script prints, so a briefing
# that only walks the scan answers "who is waiting on you" with a number it
# quietly knows is short. Measured on the real mailbox: 11 repos / 21 messages
# against coord-count's 12 mailboxes / 22 pending, the missing one being the
# declared surface `repos`.
#
# coord-count.sh is the right source and the only safe one: it counts without
# delivering, where coord-inbox.sh would mark broadcasts seen just by looking.
brief_orphans() {
  bo_count="$SELFDIR/coord-count.sh"
  [ -f "$bo_count" ] || return 0
  bo_tab="$(printf '\t')"
  bo_out="$(bash "$bo_count" 2>/dev/null \
    | awk -F"$bo_tab" '$2+0>0 {print $1"'"$bo_tab"'"$2}' \
    | while IFS="$bo_tab" read -r bo_name bo_n; do
        [ -n "$bo_name" ] || continue
        awk -F'|' -v n="$bo_name" '$3==n {f=1} END{exit !f}' "$RECORDS" \
          || printf '  %-32s INN %s\n' "$bo_name" "$bo_n"
      done)"
  [ -n "$bo_out" ] || return 0
  echo ""
  echo "UTENFOR REPO-SKANNEN - postkasser uten et repo i treet:"
  printf '%s\n' "$bo_out"
  echo "Disse har ingen STATE.md og derfor intet neste steg. En deklarert flate"
  echo "(CLAUDE_COORD_REPO) eller et checkout utenfor scan-roten."
}

brief() {
  n_owe="$(awk -F'|' '$6+0 > 0' "$RECORDS" | wc -l | tr -d ' ')"
  tot_msg="$(awk -F'|' '$6+0 > 0 {s+=$6} END{print s+0}' "$RECORDS")"

  echo "BRIEFING $(date '+%Y-%m-%d %H:%M') - repo som skylder et svar"
  echo "Kilder: STATE.md (NESTE + route-linje), git, coord-innboks. 0 modellkall."
  echo ""

  if [ "${n_owe:-0}" -eq 0 ]; then
    echo "Ingen repo har uhaandtert innboks. Ingen skylder noen et svar i dag."
    # Still checked: "no repo owes" and "no mailbox is pending" are different
    # claims, and only the second one is the good news it reads as.
    brief_orphans
    echo ""
    echo "MERK: INN teller hva ANDRE venter paa fra deg. Hva et repo venter PAA"
    echo "staar kun i dets egen board-linje (blocked-on) - postkassen har ikke"
    echo "noe reply-to-felt, saa utgaaende venting er ikke utledbar derfra."
    return 0
  fi

  # Most-owed first: the repo holding up the most other sessions is read first.
  awk -F'|' '$6+0 > 0' "$RECORDS" | sort -t'|' -k6,6nr | \
  while IFS='|' read -r bucket sortkey name status cost inbox dirty age last dir blockedon neste; do
    printf '  %-32s INN %-4s %s\n' "$name" "$inbox" "$status"
    # Wrapped, not cut - the whole line is the point, but a 500-character one
    # is unreadable in a file nobody watched being written. Locale is set for
    # the same reason trunc sets it: under LC_ALL=C fold counts BYTES and can
    # split a multibyte character into mojibake.
    # Trailing newline via '%s\n': fold copies its input's lack of one, and the
    # command line below would then start on the tail of the NESTE text.
    printf '%s\n' "$neste" | LC_ALL=en_US.UTF-8 fold -s -w 84 \
      | sed -e '1s/^/    NESTE: /' -e '2,$s/^/           /'
    printf '    %s\n\n' "$(brief_cmd "$dir" "$cost")"
  done

  printf '%s repo skylder svar, %s meldinger totalt.\n' "$n_owe" "$tot_msg"
  brief_orphans
  echo ""
  echo "MERK: INN teller hva ANDRE venter paa fra deg. Hva et repo venter PAA"
  echo "staar kun i dets egen board-linje (blocked-on) - postkassen har ikke"
  echo "noe reply-to-felt, saa utgaaende venting er ikke utledbar derfra."
}

if [ "$BRIEF" -eq 1 ]; then
  brief
  exit 0
fi

# --- Focus resolution (--focus) --------------------------------------------
# --focus is the first CUTOFF this format has ever had, and the plan documents
# at length that it has none: it takes one position (the order), it hides
# nothing, and it LABELS what it cannot rank rather than dropping it. A filter
# that stayed silent about what fell outside it would break that property
# outright, so the report is not a refinement of the feature - it is the
# condition the feature was allowed to exist under.
#
# The topic marker grammar belongs to the register, not here. board.sh only
# ever READS a declaration, and reads it from STATE.md alone: the slug
# vocabulary is whatever the scanned STATE.md files themselves declare, so no
# new file is opened and the "STATE.md and nothing else" invariant survives.
# It also means the reader must accept the marker as operators actually write
# it - bold, backticked, bulleted - because the strict form is what the
# register's own grep looks for, and the single most consequential repo in the
# measurement behind this feature was invisible to exactly that grep.
FOCUS_STATUS='planned|in-progress|partial|blocked|deferred|done|not-applicable'

# The emphasis is optional on BOTH halves. Accepting `**slug**: done` but not
# `slug: **done**` is not a rule, only whichever example happened to be in front
# of us - and the second form is in live use, where it makes a repo that HAS
# declared look silent.
focus_marker_re() {
  printf '^[[:space:]]*[-*]?[[:space:]]*\**`?%s`?\**:[[:space:]]+\**(%s)\**([[:space:]]|$)' \
    "$1" "$FOCUS_STATUS"
}

# Every slug declared anywhere in the scanned tree. Field 10 of RECORDS is the
# repo directory; a repo with no STATE.md simply contributes nothing.
focus_slugs() {
  awk -F'|' '{print $10}' "$RECORDS" | while read -r fs_d; do
    [ -n "$fs_d" ] && [ -f "$fs_d/STATE.md" ] || continue
    grep -hE "$(focus_marker_re '[a-z0-9][a-z0-9-]*')" "$fs_d/STATE.md" 2>/dev/null
  done | sed -E 's/^[[:space:]]*[-*]?[[:space:]]*\**`?([a-z0-9][a-z0-9-]*)`?\**:.*/\1/' \
       | sort -u
}

# Prose -> slugs. Two normalisations, because both readings occur: the operator
# types a slug ("some-subject-guard") or a bare word out of their own day
# ("guard"). Matching is never narrowed to one winner - an ambiguous phrase
# widens the answer and every slug it resolved to is named in the output,
# because silently picking one would make the cutoff lie about its own size.
focus_resolve() {
  fr_words=" $(printf '%s' "$1" | tr '[:upper:]' '[:lower:]' | tr -c 'a-z0-9-' ' ') "
  fr_parts=" $(printf '%s' "$fr_words" | tr '-' ' ') "
  focus_slugs | while read -r fr_s; do
    [ -n "$fr_s" ] || continue
    case "$fr_words" in
      *" $fr_s "*) printf '%s\n' "$fr_s"; continue ;;
    esac
    for fr_p in $(printf '%s' "$fr_s" | tr '-' ' '); do
      # Two-character parts match far too much prose to be evidence of intent.
      [ "${#fr_p}" -ge 3 ] || continue
      case "$fr_parts" in
        *" $fr_p "*) printf '%s\n' "$fr_s"; break ;;
      esac
    done
  done | sort -u
}

# Does this repo DECLARE any of the resolved slugs? (survives the cutoff)
focus_declares() {
  for fd_s in $FOCUS_SLUGS; do
    grep -qE "$(focus_marker_re "$fd_s")" "$1/STATE.md" 2>/dev/null && return 0
  done
  return 1
}

# What a surviving block survived ON. This is the per-block evidence that
# closed `topics=`: the need was real, but a field in all 27 blocks on every
# day the operator has no focus is noise, while the same fact inside a focused
# run is the reason the block is there.
focus_evidence() {
  for fe_s in $FOCUS_SLUGS; do
    fe_line="$(grep -m1 -E "$(focus_marker_re "$fe_s")" "$1/STATE.md" 2>/dev/null)"
    if [ -n "$fe_line" ]; then
      # Reported unwrapped: the emphasis is markdown the operator typed, not
      # part of the token, and "**done**" in a key=value field reads as a value.
      fe_st="$(printf '%s' "$fe_line" | sed -E "s/.*:[[:space:]]+\**($FOCUS_STATUS)\**.*/\1/")"
      printf '%s: %s\n' "$fe_s" "$fe_st"
      return 0
    fi
  done
  return 1
}

# The held-back population: STATE.md MENTIONS a resolved slug and declares no
# marker line for it. The wording is a constraint, not a style choice - this
# is a fact about text found in a file, and board.sh has no grounds whatever
# for a claim about relevance, so it says "nevner" and never "dekker". The
# class is NAMED rather than counted, because in the measurement that produced
# this feature the decisive find - a heavy consumer pinning the library in its
# build file - appeared only once the population was enumerated. Reasoning
# about it had missed it entirely.
focus_heldback() {
  awk -F'|' '{print $3 "|" $10}' "$RECORDS" | while IFS='|' read -r fh_n fh_d; do
    [ -n "$fh_d" ] && [ -f "$fh_d/STATE.md" ] || continue
    focus_declares "$fh_d" && continue
    for fh_s in $FOCUS_SLUGS; do
      if grep -qF -- "$fh_s" "$fh_d/STATE.md" 2>/dev/null; then
        printf '%s\n' "$fh_n"
        break
      fi
    done
  done
}

# --- Day-plan rendering (--plan) -------------------------------------------
# A THIRD rendering of the same scan, built on exactly the argument --brief was:
# it is a lookup over data the scan already holds, it costs zero model calls,
# and route.sh already derives the per-repo command. The table says what the
# state of every repo is; the briefing says who is waiting; the plan says which
# repos to open a tab for today, in what order, with which command.
#
# key=value blocks, not prose, because the plan has TWO consumers: the operator
# pasting commands, and a separate repo driving a terminal from it. Prose would
# make the rendered FORMAT an API, and no test in this repo could hold it stable
# for a consumer living in another one. Comment lines all start with '#', so a
# consumer drops them with one rule.
#
# ORDER IS THE POSITION THIS RENDERING TAKES, and it is the only one it takes -
# there is no cutoff, so nothing is hidden. Five groups, all deterministic over
# fields the scan already read:
#   1. chain-root credit - repos this one releases transitively, most first.
#      Above debt because it is the only move that frees sessions other than
#      your own; a blocked repo is never credited, since its own next step is
#      by definition waiting.
#   2. INN > 0, most-owed first, WHATEVER the status. A message owed is an
#      obligation to another session. Excluding `blocked` is about a repo's own
#      next step, which by definition cannot be moved; answering is a different
#      axis, and is frequently what unblocks it.
#   3. planned - a decided but unstarted next step.
#   4. in-progress - live work, oldest plan first.
#   5. '?' and MALFORMED - no declared status. Planned LAST, and labelled. The
#      table already prints a MERK line about repos with no board line; a plan
#      that dropped them silently would repeat exactly that defect.
# Groups 3 and 4 are in that order by operator decision at 0.20.0, inverted from
# every earlier version: turning a decision into motion is the slow step, and
# live work is already moving. Deciding it the other way is a policy change, not
# a sort fix.
# Excluded: done, deferred, blocked-without-debt, and repos with no STATE.md and
# no debt - a tab that cannot be moved is not a plan entry.
# Two lines for two consumers, and they are not redundant. A driver cd's the
# pane itself and then types the command, so it needs them apart; the operator
# needs ONE thing to select and paste, because assembling `cd <dir>` from one
# field and the command from another is precisely where a tab ends up started
# in the wrong repo. paste= is emitted only alongside command= - `paste=cd X && `
# with nothing after it would run the cd and then a bare newline, leaving the
# operator in the right directory with no session and no error.
plan_cmd() {
  if pc_cmd="$(route_cmd_for "$1")"; then
    if [ -n "$pc_cmd" ]; then
      printf 'command=%s\n' "$pc_cmd"
      printf 'paste=cd %s && %s\n' "$1" "$pc_cmd"
    else
      printf 'command_missing=route-linjen kunne ikke tolkes (kost: %s)\n' "$2"
    fi
  else
    printf 'command_missing=ingen route-linje - kjor route-skillen der (kost: %s)\n' "$2"
  fi
}

plan() {
  # FIVE ORDERED GROUPS, not a weighted score. Each group is a lookup over a
  # field the scan already read, so two readers can disagree about the order but
  # never about how it was produced - and a selftest can pin the outcome rather
  # than a coefficient.
  #
  # THE COST THIS FORM ACCEPTS, recorded because it is real and was argued at
  # length before it was chosen: a group order cannot express "this repo owes one
  # message AND releases two others" as a single quantity. The 0.19.0 score could,
  # and that was its point. What it could not do was stay stable for a consumer in
  # another repo - re-tuning 40 against 15 here silently reorders `morning`,
  # `--brief` and `brief-nightly`, and no test in THIS repo can hold a weighted
  # ranking still for a parser in that one. The operator weighed both and chose
  # the lookup (2026-08-03). This paragraph exists so a later session reads the
  # objection as ANSWERED rather than as an unfixed defect and "restores" a score.
  #
  # Group 1 is chain-root credit, and it sits ABOVE debt: opening the root of a
  # blocked chain is the only move that releases sessions other than your own.
  # Group 3 is `planned` ABOVE group 4 `in-progress` - inverted from every prior
  # version by operator decision the same day. The reason is that a decided but
  # unstarted next step is the step that turns a decision into motion, while live
  # work is already moving. It is a policy call, not a sort that drifted.
  #
  # Debt is neither capped nor excluded - it is group 2, ranked most-owed-first,
  # WHATEVER the status. A cap was proposed and declined; being outranked by a
  # chain root is not a cap, because the debtor keeps its tab, its position among
  # the other debtors, and its `why=inbox:N`.
  #
  # `cheap` carries the one property 0.19.0 added that no one asked to remove:
  # under quota pressure a Sonnet row moves for less. It is the LAST tiebreak,
  # below the group's own magnitude and above age, so it separates repos that are
  # otherwise equal and can never lift one past another that owes or releases
  # more.
  #
  # The three sort keys are prefixed as fields 1-3 and stripped again afterwards;
  # `why` then becomes field 1 exactly as every previous version left it, so the
  # read loop below and both consumers see an unchanged block. Prefixing rather
  # than appending is deliberate - `neste` is the last field and is free prose, so
  # anything added after it could be swallowed by a stray separator.
  pf="${TMPDIR:-/tmp}/board-plan.$$"
  : > "$pf"
  awk -F'|' -v OFS='|' '
    NR==FNR { ub[$1] = $2 + 0; next }
    {
      name = $3; status = $4; cost = $5; inbox = $6 + 0
      # A blocked repo is credited with nothing even if something waits on it:
      # it cannot move its own next step, so opening it releases no one. The
      # credit already went to the root of its chain.
      blockedp = (status ~ /^blocked/)
      u = (!blockedp && (name in ub)) ? ub[name] : 0

      # Membership is unchanged: a repo that releases someone is planned even
      # when it owes nothing and its own status would otherwise exclude it, and
      # done, deferred, blocked and no-STATE repos with no debt stay out.
      keep = (inbox > 0) || (u > 0) || (status == "in-progress") || \
             (status == "planned") || (status == "?") || (status ~ /^MALFORMED:/)
      if (!keep) next

      # The group IS the reason, so why= is the group and needs no separate rule.
      # `mag` orders within a group by the quantity that group is about - released
      # in group 1, messages owed in group 2 - and is 0 where the group has no
      # quantity, leaving those to the tiebreaks below.
      if      (u > 0)                   { grp = 1; mag = u;     why = "unblocks:" u }
      else if (inbox > 0)               { grp = 2; mag = inbox; why = "inbox:" inbox }
      else if (status == "planned")     { grp = 3; mag = 0;     why = "planned" }
      else if (status == "in-progress") { grp = 4; mag = 0;     why = "in-progress" }
      else                              { grp = 5; mag = 0;     why = "uavklart" }

      # Cheap-to-move first under quota pressure. Sorted ascending, so 0 = cheap.
      cheap = (cost ~ /[Ss]onnet/) ? 0 : 1

      print grp, mag, cheap, why, $0
    }
  ' "$UNBLOCKS" "$RECORDS" \
    | sort -t'|' -k1,1n -k2,2nr -k3,3n -k6,6n \
    | cut -d'|' -f4- >> "$pf"

  # The cutoff, and its disclosure, computed together - they are one feature.
  FOCUS_SLUGS=""
  fp_applied=0
  fp_before="$(awk 'END{print NR+0}' "$pf")"
  if [ -n "$FOCUS" ]; then
    FOCUS_SLUGS="$(focus_resolve "$FOCUS" | tr '\n' ' ')"
    [ -n "$(printf '%s' "$FOCUS_SLUGS" | tr -d ' ')" ] && fp_applied=1
  fi
  if [ "$fp_applied" -eq 1 ]; then
    fp_names="${TMPDIR:-/tmp}/board-focusnames.$$"
    fp_kept="${TMPDIR:-/tmp}/board-planfocus.$$"
    awk -F'|' '{print $3 "|" $10}' "$RECORDS" | while IFS='|' read -r fp_n fp_d; do
      [ -n "$fp_d" ] && [ -f "$fp_d/STATE.md" ] || continue
      focus_declares "$fp_d" && printf '%s\n' "$fp_n"
    done > "$fp_names"
    awk -F'|' 'NR==FNR{keep[$0]=1;next} keep[$4]' "$fp_names" "$pf" > "$fp_kept"
    /bin/rm -f "$fp_names" 2>/dev/null
    mv "$fp_kept" "$pf"
  fi

  echo "# PLAN $(date '+%Y-%m-%d %H:%M') - en blokk per tab, i den rekkefolgen"
  echo "# Kilder: STATE.md (NESTE + route-linje), git, coord-innboks. 0 modellkall."
  echo "# Rekkefolge: 5 grupper - kjede-rot, innboks, planned, in-progress, uavklart."
  # "uten gjeld" governs the WHOLE list, not just the token nearest to it: a
  # done or deferred repo that owes mail IS planned, and the real tree has two.
  # Read the other way this line calls its own tab 4 a bug.
  echo "# Utelatt naar repoet verken skylder svar eller losner noen: done, deferred,"
  echo "# blocked, uten STATE.md. Et blokkert repo faar aldri kreditt - den gaar til rota."
  # Emitted as key=value, not as a '#' comment, because the format's second
  # consumer drops every comment line by rule - a disclosure written as a
  # comment would reach the operator on the terminal path and vanish on the
  # driver path, which is the one case where the cutoff is applied unseen.
  if [ -n "$FOCUS" ]; then
    fp_state="$(awk -F'|' '{print $10}' "$RECORDS" | while read -r fp_sd; do
                  [ -n "$fp_sd" ] && [ -f "$fp_sd/STATE.md" ] && echo x
                done | wc -l | tr -d ' ')"
    if [ "$fp_applied" -eq 1 ]; then
      printf 'fokus=%s\n' "$(printf '%s' "$FOCUS_SLUGS" | sed 's/[[:space:]]*$//' | tr ' ' ',')"
      printf 'fokus_droppet=%s av %s blokker\n' \
        "$((fp_before - $(awk 'END{print NR+0}' "$pf")))" "$fp_before"
      fp_hb="$(focus_heldback | sort -u)"
      fp_hbn="$(printf '%s' "$fp_hb" | grep -c . | tr -d ' ')"
      # Nobody held back is an answer, and it has to LOOK like one. sed cannot
      # supply the placeholder: with an empty string there is no input line for
      # a substitution to run on, so the field would end at a bare colon - the
      # exact shape command_missing= exists to keep out of this format.
      fp_hbl="$(printf '%s' "$fp_hb" | tr '\n' ' ' | sed 's/[[:space:]]*$//')"
      [ -n "$fp_hbl" ] || fp_hbl="(ingen)"
      # "nevner", never "dekker": this states what was found in a file, and
      # says which files were searched rather than implying it searched repos.
      # One repo in the real measurement carries its strongest evidence in a
      # README, which this scan never opens.
      printf 'fokus_utenfor=%s repo nevner %s uten markorlinje: %s\n' \
        "$fp_hbn" "$(printf '%s' "$FOCUS_SLUGS" | sed 's/[[:space:]]*$//' | tr ' ' ',')" \
        "$fp_hbl"
      printf 'fokus_rekkevidde=sokt i %s STATE.md - board leser ingen andre filer\n' "$fp_state"
    else
      # No declared slug matched. The full plan is printed: the driver forwards
      # operator prose verbatim, so a typo must not silently produce a morning
      # with no tabs at all.
      printf 'fokus_ikke_brukt=%s traff ingen deklarert slug i %s STATE.md - hele planen vises\n' \
        "$FOCUS" "$fp_state"
    fi
  fi
  echo ""

  pn=0
  while IFS='|' read -r why bucket sortkey name status cost inbox dirty age last dir blockedon neste; do
    [ -n "$name" ] || continue
    pn=$((pn + 1))
    printf 'tab=%s\n' "$pn"
    printf 'repo=%s\n' "$name"
    # Absolute, and the driver must cd into it explicitly: a new terminal pane
    # inherits its anchor's working directory, so a plan that omitted this would
    # look right and point at the wrong repo.
    printf 'dir=%s\n' "$dir"
    printf 'why=%s\n' "$why"
    if [ "$fp_applied" -eq 1 ]; then
      fp_ev="$(focus_evidence "$dir")" && printf 'fokus_treff=%s\n' "$fp_ev"
    fi
    printf 'status=%s\n' "$status"
    printf 'neste=%s\n' "$neste"
    plan_cmd "$dir" "$cost"
    echo ""
  done < "$pf"
  /bin/rm -f "$pf" 2>/dev/null

  printf '# %s tabber.\n' "$pn"

  # An orphan mailbox has no directory to cd into, so it cannot BE a tab - but
  # omitting it lets the plan claim a completeness it knows it lacks. Reported
  # as commentary, reusing the briefing's single copy of that cross-check.
  po="$(brief_orphans)"
  if [ -n "$po" ]; then
    printf '%s\n' "$po" | sed -e 's/^/# /' -e 's/^# *$/#/'
  fi
  echo "# MERK: INN teller hva ANDRE venter paa fra deg. Hva et repo venter PAA"
  echo "# staar kun i dets egen board-linje (blocked-on)."
}

if [ "$PLAN" -eq 1 ]; then
  plan
  exit 0
fi

count() { awk -F'|' -v b="$1" '$1==b' "$RECORDS" | wc -l | tr -d ' '; }

echo "BOARD - tverr-repo oppmerksomhetstavle ($(awk 'END{print NR}' "$RECORDS") repo)"
echo "INN = uhaandtert innboks (andre venter paa DEG). DRT = ukommiterte filer."
echo "ALDER = dager siden STATE.md endret. SISTE = dager siden siste commit."

[ "$(count 1)" -gt 0 ] && { hdr "BLOKKERT (venter paa ekstern avhengighet)"; rows 1; }
[ "$(count 2)" -gt 0 ] && { hdr "AKTIV (reelt neste steg)"; rows 2; }
[ "$(count 3)" -gt 0 ] && { hdr "UTSATT (deferred - bevisst valg, ikke venting)"; rows 3; }
[ "$(count 4)" -gt 0 ] && { hdr "FERDIG"; rows 4; }
[ "$(count 5)" -gt 0 ] && { hdr "UTEN STATE.md (sovende / ubestemt tilstand)"; rows 5; }

# Obligations and risk read across buckets, so they get their own roll-up.
tot_in="$(awk -F'|' '{s+=$6} END{print s+0}' "$RECORDS")"
tot_dirty="$(awk -F'|' '{s+=$7} END{print s+0}' "$RECORDS")"
n_mal="$(grep -c 'MALFORMED' "$RECORDS" 2>/dev/null | tr -d ' ')"
n_nofield="$(awk -F'|' '$4=="?"' "$RECORDS" | wc -l | tr -d ' ')"

printf '\nSUM: %s uhaandterte innboks-meldinger, %s ukommiterte filer.\n' "$tot_in" "$tot_dirty"
[ "${n_mal:-0}" -gt 0 ] && printf 'ADVARSEL: %s repo har MALFORMED status-token (utenfor det lukkede settet).\n' "$n_mal"
[ "${n_nofield:-0}" -gt 0 ] && printf 'MERK: %s repo mangler board-linje - status/kost er ukjent (?), NESTE-utdrag brukes.\n' "$n_nofield"

exit 0