Kjell Tore Guttormsen
dde392d79d
board.sh's status classifier and route_cmd_for()'s four-trait extraction both used a [a-z-]* sed capture that stops at the first byte outside that class instead of running to the field's real boundary. status=done2 silently classified as done (excluded from --plan like a real done repo, shown green); status=Planned captured as empty and read as "?" (no board line at all), feeding the MERK footer a false count. route_cmd_for() had the same defect on all four traits: path=known2 truncated to known, which route.sh's own exact-match validation then accepted, producing a safely-worded but WRONG startup command instead of a refusal. Fixed by capturing to the next ';' or the closing '-->' (the same [^;>]* + trim shape next-cost already used), so the exact-match case statements downstream see the real, un-truncated value. Selftest: repo-status-prefix, repo-status-case, repo-trait-prefix and repo-revers-prefix pin all four cases, with known-positive controls that a genuinely absent board line still reads ? and a genuinely valid route line still derives a real command. All four suites green: coord 220, board 229, route 69, guard 40. Verified no MALFORMED regression against the real ~/repos tree (empty set before and after). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DxLmbNN6qswBuu6XkSYVrt
1332 lines
69 KiB
Bash
Executable file
1332 lines
69 KiB
Bash
Executable file
#!/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.
|
|
#
|
|
# --inbox-plan is a FOURTH rendering, ordered by morning-driver
|
|
# (20260814T175317Z, corrected 20260814T180854Z) as a fix for its OWN
|
|
# regression, not a feature request: --plan answers "which repos deserve a
|
|
# tab today" (admission, ranking, a cap); --inbox-plan answers "which repos
|
|
# have unhandled post" (population, no judgement, no cap) - and deriving the
|
|
# second from the first was always a shortcut, one that broke the moment
|
|
# --plan's admission narrowed in 0.22.0. It is a superset of --plan's
|
|
# candidates, not a complement: an already-admitted repo still gets a block.
|
|
#
|
|
# ONE BLOCK PER NAME WITH PENDING MAIL, independent of --plan's admission
|
|
# gate entirely. Each block carries `class=` distinguishing the three reasons
|
|
# a block might be unopenable, per the work order's explicit ask - a repo
|
|
# without STATE.md and a mailbox without a directory are NOT the same fact
|
|
# for the operator, and collapsing them into one undifferentiated "kan ikke
|
|
# aapnes" is the defect this mode exists to fix:
|
|
# repo - dir, .git and STATE.md all present; may still lack a
|
|
# route line, in which case command_missing= says so
|
|
# (same route_cmd_for() every other rendering uses).
|
|
# no-state - a scanned git repo with no STATE.md at all, so no NESTE
|
|
# and no route line can ever exist for it.
|
|
# orphan-mailbox - a mailbox name with no matching directory anywhere in
|
|
# the scanned roots; there is no dir= to cd into.
|
|
# `pending=` and `owed=` surface coord-count.sh's two counts directly (its
|
|
# debt field, not re-derived) so a caller can tell a request from a notice
|
|
# without recomputing it - the second explicit ask.
|
|
#
|
|
# --dispatch is a FIFTH rendering, and the only one that carries a task INTO a
|
|
# repo rather than reporting on it: "start a session in repo X, on order Y, at
|
|
# cost Z". It is here, and not in a script of its own, because the block format
|
|
# has exactly ONE generator and this file already is it - a second emitter of
|
|
# tab=/repo=/dir=/command=/paste= would be two copies of one format drifting
|
|
# apart. Read-only is untouched: every check is a read, and the two writes a
|
|
# dispatch needs (the prompt file, the plan file) stay with the caller, exactly
|
|
# as brief-nightly.sh owns the briefing's write.
|
|
#
|
|
# board.sh --dispatch --repo <name> --prompt-file <abs path>
|
|
# --target-pane <yes|no>
|
|
# --path P --verification V --reversibility R --scope S
|
|
# --rationale "why"
|
|
#
|
|
# Model, effort and --advisor come from route.sh's row table, never from a
|
|
# --model/--effort pair: the advisor flag is a property of the ROW, and a
|
|
# dispatch that took the model directly would have no honest source for it.
|
|
# --target-pane is a MEASUREMENT (morning --probe-panes) and has no default -
|
|
# see the dispatch() comment for what happens when it is guessed.
|
|
#
|
|
# Usage: board.sh [--roots <dir>[,<dir>...]] [--plain]
|
|
# [--brief|--plan|--inbox-plan|--dispatch ...]
|
|
# [--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
|
|
INBOX_PLAN=0
|
|
FOCUS=""
|
|
DISPATCH=0
|
|
D_REPO=""; D_PROMPT=""; D_PANE=""
|
|
D_PATH=""; D_VER=""; D_REV=""; D_SCOPE=""; D_RAT=""
|
|
|
|
# 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 ;;
|
|
# Four renderings of one scan, so exactly one may be selected: last wins.
|
|
--brief) BRIEF=1; PLAN=0; INBOX_PLAN=0; shift ;;
|
|
--plan) PLAN=1; BRIEF=0; INBOX_PLAN=0; shift ;;
|
|
--inbox-plan) INBOX_PLAN=1; BRIEF=0; PLAN=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 ;;
|
|
# Dispatch rendering: one repo, one prompt file, one startup command. Same
|
|
# `shift 2` guard as every other value flag, for the same bash 3.2 reason.
|
|
--dispatch) DISPATCH=1; BRIEF=0; PLAN=0; INBOX_PLAN=0; shift ;;
|
|
--repo) [ $# -ge 2 ] || { echo "board: --repo requires a value" >&2; exit 2; }
|
|
D_REPO="$2"; shift 2 ;;
|
|
--prompt-file) [ $# -ge 2 ] || { echo "board: --prompt-file requires a value" >&2; exit 2; }
|
|
D_PROMPT="$2"; shift 2 ;;
|
|
--target-pane) [ $# -ge 2 ] || { echo "board: --target-pane requires a value" >&2; exit 2; }
|
|
D_PANE="$2"; shift 2 ;;
|
|
--path) [ $# -ge 2 ] || { echo "board: --path requires a value" >&2; exit 2; }
|
|
D_PATH="$2"; shift 2 ;;
|
|
--verification) [ $# -ge 2 ] || { echo "board: --verification requires a value" >&2; exit 2; }
|
|
D_VER="$2"; shift 2 ;;
|
|
--reversibility) [ $# -ge 2 ] || { echo "board: --reversibility requires a value" >&2; exit 2; }
|
|
D_REV="$2"; shift 2 ;;
|
|
--scope) [ $# -ge 2 ] || { echo "board: --scope requires a value" >&2; exit 2; }
|
|
D_SCOPE="$2"; shift 2 ;;
|
|
--rationale) [ $# -ge 2 ] || { echo "board: --rationale requires a value" >&2; exit 2; }
|
|
D_RAT="$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
|
|
# Captures to the next ';' or the closing '-->', NOT to the first
|
|
# non-[a-z-] byte: a prefix class stops early on a value that is one byte
|
|
# past a valid token ("done2" -> "done") and silently accepts it as that
|
|
# token, or on a case variant ("Planned") and captures empty - the exact
|
|
# bugs F3 closes. The case statement below still does an EXACT match, so
|
|
# anything out of vocabulary lands in MALFORMED with its real value intact.
|
|
status="$(printf '%s' "$line" | sed -n 's/.*status=\([^;>]*\).*/\1/p' \
|
|
| sed -e 's/--$//' -e 's/[[:space:]]*$//' -e 's/^[[:space:]]*//')"
|
|
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.$$"
|
|
OWED="${TMPDIR:-/tmp}/board-owed.$$"
|
|
ALLMAIL="${TMPDIR:-/tmp}/board-allmail.$$"
|
|
DEADLETTERS="${TMPDIR:-/tmp}/board-deadletters.$$"
|
|
trap '/bin/rm -f "$RECORDS" "$UNBLOCKS" "$OWED" "$ALLMAIL" "$DEADLETTERS" 2>/dev/null' EXIT
|
|
|
|
# --- Owed lookup (name -> messages that actually owe a reply) --------------
|
|
# `inbox` (field 6 of RECORDS) is raw pending-file count and stays that way -
|
|
# it is what the TABLE means by INN, "what is the state of every repo". Group
|
|
# 2 of --plan and the whole of --brief mean something narrower, "who is
|
|
# waiting on you", and a pending message is not automatically that: a sender
|
|
# can declare reply-expected: no. Measured on the live mailbox 2026-08-13: 27
|
|
# of 72 pending messages (37.5%) are notices, not requests - conflating the two
|
|
# admitted done/deferred/blocked repos into --plan on FYI mail alone and
|
|
# mislabeled --brief's own "repo som skylder svar" line with the same number.
|
|
# coord-count.sh already separates them (pending, then debt) for exactly this
|
|
# reason; this is that value, joined by name like chain-root credit above.
|
|
#
|
|
# Built only for --brief and --plan, the only two consumers: the plain table
|
|
# view scans a repo tree and prints raw INN by design, never touching the
|
|
# mailbox beyond what RECORDS already read, and paying an extra coord-count.sh
|
|
# subprocess on every invocation would tax that path for a lookup it never
|
|
# uses.
|
|
# HAVE_COUNT, computed once: a missing sibling (the 0.12.1 deployed-copy
|
|
# incident shape - review finding 1, 2026-08-14) must never read as "coord-
|
|
# count.sh ran and found nothing". Every site below that would otherwise
|
|
# treat an empty $OWED/$DEADLETTERS/$ALLMAIL as a confident zero checks this
|
|
# flag first and warns instead - see brief(), plan(), inbox_plan().
|
|
HAVE_COUNT=1
|
|
[ -f "$SELFDIR/coord-count.sh" ] || HAVE_COUNT=0
|
|
|
|
: > "$OWED"
|
|
if { [ "$BRIEF" -eq 1 ] || [ "$PLAN" -eq 1 ]; } && [ "$HAVE_COUNT" -eq 1 ]; then
|
|
ow_tab="$(printf '\t')"
|
|
bash "$SELFDIR/coord-count.sh" 2>/dev/null \
|
|
| awk -F"$ow_tab" -v OFS='|' '{print $1, $3}' > "$OWED"
|
|
fi
|
|
|
|
# --- Dead-letter lookup (name -> age in days), --brief only ----------------
|
|
# coord-count.sh's fourth column (WP1d, .claude 2026-08-14) reports the age in
|
|
# days of the oldest pending message in a mailbox with no .origin - a mailbox
|
|
# no session has EVER read via the normal SessionStart path. "-" (has .origin,
|
|
# or age unreadable) is filtered out here; only mailboxes actually past the
|
|
# 3-day threshold reach $DEADLETTERS, so brief_deadletters() below never has to
|
|
# re-parse the raw column or re-apply the threshold itself.
|
|
: > "$DEADLETTERS"
|
|
if [ "$BRIEF" -eq 1 ] && [ "$HAVE_COUNT" -eq 1 ]; then
|
|
dl_tab="$(printf '\t')"
|
|
bash "$SELFDIR/coord-count.sh" 2>/dev/null \
|
|
| awk -F"$dl_tab" -v OFS='|' '$4 != "-" && $4+0 >= 3 {print $1, $4}' > "$DEADLETTERS"
|
|
fi
|
|
|
|
# --- All-mail lookup (name -> pending, owed), --inbox-plan only ------------
|
|
# --inbox-plan's whole population is "every name coord-count.sh reports", so
|
|
# unlike $OWED (which only needs the debt column) this keeps BOTH integers -
|
|
# pending is the population test, owed is the per-block ask #2 marker. Built
|
|
# only for --inbox-plan, the only consumer, for the same reason $OWED is
|
|
# gated: an extra coord-count.sh subprocess on every table/plain invocation
|
|
# would tax a path that never reads it.
|
|
: > "$ALLMAIL"
|
|
if [ "$INBOX_PLAN" -eq 1 ] && [ "$HAVE_COUNT" -eq 1 ]; then
|
|
am_tab="$(printf '\t')"
|
|
bash "$SELFDIR/coord-count.sh" 2>/dev/null \
|
|
| awk -F"$am_tab" -v OFS='|' '{print $1, $2, $3}' > "$ALLMAIL"
|
|
fi
|
|
|
|
# --- 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
|
|
# Captures to the next ';' or '-->', NOT to the first non-[a-z-] byte: a
|
|
# prefix class silently truncates "known2" to "known", which route.sh's own
|
|
# exact-match validation then ACCEPTS - a safely-worded but WRONG command
|
|
# instead of the refusal this defect (F4) exists to force. route.sh still
|
|
# does the real rejection; this only stops the value from being mangled
|
|
# into something valid before it gets there.
|
|
rc_p="$(printf '%s' "$rc_line" | sed -n 's/.*path=\([^;>]*\).*/\1/p' \
|
|
| sed -e 's/--$//' -e 's/[[:space:]]*$//' -e 's/^[[:space:]]*//')"
|
|
rc_v="$(printf '%s' "$rc_line" | sed -n 's/.*verification=\([^;>]*\).*/\1/p' \
|
|
| sed -e 's/--$//' -e 's/[[:space:]]*$//' -e 's/^[[:space:]]*//')"
|
|
rc_r="$(printf '%s' "$rc_line" | sed -n 's/.*reversibility=\([^;>]*\).*/\1/p' \
|
|
| sed -e 's/--$//' -e 's/[[:space:]]*$//' -e 's/^[[:space:]]*//')"
|
|
rc_s="$(printf '%s' "$rc_line" | sed -n 's/.*scope=\([^;>]*\).*/\1/p' \
|
|
| sed -e 's/--$//' -e 's/[[:space:]]*$//' -e 's/^[[:space:]]*//')"
|
|
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() {
|
|
if [ "$HAVE_COUNT" -ne 1 ]; then
|
|
echo ""
|
|
echo "UTENFOR REPO-SKANNEN: kan ikke sjekke - coord-count.sh mangler."
|
|
return 0
|
|
fi
|
|
bo_tab="$(printf '\t')"
|
|
bo_out="$(bash "$SELFDIR/coord-count.sh" 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."
|
|
}
|
|
|
|
# WP1d detection half (.claude, 2026-08-14): $DEADLETTERS already carries only
|
|
# the mailboxes past the 3-day threshold, pre-filtered - this function only
|
|
# renders. A mailbox here has NO .origin, meaning no session has ever read it
|
|
# via the normal per-repo injection; the message sits there regardless of
|
|
# whether it also happens to have a repo in the scan tree (dead-letter-repo,
|
|
# claimed-repo in board-selftest.sh section 16 both do). The action half
|
|
# (report to sender / retract) is unapproved design and is not built here.
|
|
brief_deadletters() {
|
|
if [ "$HAVE_COUNT" -ne 1 ]; then
|
|
echo ""
|
|
echo "ALDRI LEST: kan ikke sjekke - coord-count.sh mangler."
|
|
return 0
|
|
fi
|
|
[ -s "$DEADLETTERS" ] || return 0
|
|
echo ""
|
|
echo "ALDRI LEST - postkasser uten .origin med post eldre enn 3 dogn:"
|
|
awk -F'|' '{printf " %-32s %s dogn\n", $1, $2}' "$DEADLETTERS"
|
|
echo "Ingen sesjon har noensinne kjort coord-inbox for disse - posten blir"
|
|
echo "aldri injisert av den vanlige SessionStart-veien."
|
|
}
|
|
|
|
brief() {
|
|
# OWED, not raw pending (field 6): this briefing is titled "repo som skylder
|
|
# et svar" (repos that owe a reply), and a pending message that declared
|
|
# reply-expected: no is not that - it is a notice. Joined by FILENAME, never
|
|
# NR==FNR (see plan()'s comment on the same join): $OWED can legitimately be
|
|
# empty on a debt-free day, and NR==FNR misroutes an entire subsequent file
|
|
# when the file before it was empty.
|
|
n_owe="$(awk -F'|' -v OWF="$OWED" '
|
|
FILENAME==OWF { ow[$1] = $2 + 0; next }
|
|
{ name = $3; if ((name in ow) && ow[name] > 0) print }
|
|
' "$OWED" "$RECORDS" | wc -l | tr -d ' ')"
|
|
tot_msg="$(awk -F'|' -v OWF="$OWED" '
|
|
FILENAME==OWF { ow[$1] = $2 + 0; next }
|
|
{ name = $3; if ((name in ow) && ow[name] > 0) s += ow[name] }
|
|
END { print s+0 }
|
|
' "$OWED" "$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 ""
|
|
|
|
# A missing coord-count.sh sibling (review finding 1, 2026-08-14 - the
|
|
# 0.12.1 deployed-copy incident shape) must never be read as "checked, zero
|
|
# debt": $OWED is empty for the same reason it would be on a genuinely
|
|
# debt-free day, and continuing into the branch below actively mislabeled a
|
|
# reply-owing repo as FYI-only (inbox>0, owed==0 looks identical either way).
|
|
if [ "$HAVE_COUNT" -ne 1 ]; then
|
|
echo "ADVARSEL: coord-count.sh mangler - kan ikke avgjore hvem som skylder svar."
|
|
echo "Gjeldstall er IKKE null, bare ikke beregnet. Se ${SELFDIR}/coord-count.sh."
|
|
brief_orphans
|
|
brief_deadletters
|
|
return 0
|
|
fi
|
|
|
|
if [ "${n_owe:-0}" -eq 0 ]; then
|
|
# Only the debt claim, never "no repo has unhandled inbox": n_owe counts
|
|
# OWED repos since 0.22.0, so this branch can fire while a repo still
|
|
# holds FYI-only mail - real, re-injected, just not an obligation. The
|
|
# comment this replaces already named the two claims as different; the
|
|
# code used to make both anyway.
|
|
echo "Ingen repo skylder noen et svar i dag."
|
|
fyi_only="$(awk -F'|' -v OWF="$OWED" '
|
|
FILENAME==OWF { ow[$1] = $2 + 0; next }
|
|
{ name = $3; inbox = $6 + 0; owed = (name in ow) ? ow[name] : 0
|
|
if (inbox > 0 && owed == 0) print name }
|
|
' "$OWED" "$RECORDS")"
|
|
if [ -n "$fyi_only" ]; then
|
|
echo "Disse har bare FYI-post (ingen skylder svar, men posten er reell):"
|
|
printf '%s\n' "$fyi_only" | sed 's/^/ /'
|
|
fi
|
|
brief_orphans
|
|
brief_deadletters
|
|
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'|' -v OFS='|' -v OWF="$OWED" '
|
|
FILENAME==OWF { ow[$1] = $2 + 0; next }
|
|
{ name = $3; owed = (name in ow) ? ow[name] : 0; if (owed > 0) print owed, $0 }
|
|
' "$OWED" "$RECORDS" | sort -t'|' -k1,1nr | \
|
|
while IFS='|' read -r owed bucket sortkey name status cost inbox dirty age last dir blockedon neste; do
|
|
printf ' %-32s INN %-4s %s\n' "$name" "$owed" "$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
|
|
brief_deadletters
|
|
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
|
|
|
|
# --- Dispatch rendering (--dispatch) ---------------------------------------
|
|
# The FOURTH rendering, and the only one that carries a task INTO another repo:
|
|
# "start a session in repo X, on order Y, at cost Z". It lives here because the
|
|
# block format has exactly ONE generator and this file already is it - a second
|
|
# emitter of tab=/repo=/dir=/command=/paste= would be two copies of one format,
|
|
# which is the drift defect this repo's CLAUDE.md warns about, and a second
|
|
# place to get `paste=` wrong.
|
|
#
|
|
# Read-only holds. Everything below is a read; the two FILE WRITES a dispatch
|
|
# needs - the prompt file and the plan file - stay with the caller, exactly as
|
|
# brief-nightly.sh already owns the briefing's write.
|
|
#
|
|
# THE COST COMES FROM route.sh's ROW TABLE, never from a --model/--effort pair
|
|
# handed in. That is not tidiness: `--advisor opus` is a property of the ROW,
|
|
# two rows share a model/effort pair while differing on it, and the CLI accepts
|
|
# a wrong advisor silently (it drops it for a Fable main model without failing).
|
|
# A dispatch that took the model directly would have no source for that flag,
|
|
# and both available guesses are wrong in the same direction - a session that
|
|
# looks peer-reviewed without being. Scoring the four traits is the caller's
|
|
# judgement; turning them into a command is this lookup.
|
|
dispatch() {
|
|
# --target-pane is REQUIRED and has no default, the same rule route.sh's
|
|
# --last-effort carries: it is a MEASUREMENT of the world (does the target
|
|
# repo already have a Ghostty pane), and this script must never learn to look
|
|
# for a terminal. Defaulting would be worst at "no": that is the plan-file
|
|
# form, and morning's plan_drop_open (morning:1788) silently drops a plan
|
|
# block for a repo that already has a pane - "0 of 1", which reads as a
|
|
# broken plan file. Measured four times on one day, 2026-08-16, by two
|
|
# different repos.
|
|
case "$D_PANE" in
|
|
yes|no) ;;
|
|
"") echo "board: --dispatch requires --target-pane yes|no - measure it (morning --probe-panes), never guess it" >&2; exit 2 ;;
|
|
*) echo "board: --target-pane must be yes or no (got: $D_PANE)" >&2; exit 2 ;;
|
|
esac
|
|
[ -n "$D_REPO" ] || { echo "board: --dispatch requires --repo <name>" >&2; exit 2; }
|
|
[ -n "$D_PROMPT" ] || { echo "board: --dispatch requires --prompt-file <path> - the order the session is dispatched ON" >&2; exit 2; }
|
|
[ -n "$D_RAT" ] || { echo "board: --dispatch requires --rationale (route.sh requires it, and for the same reason: a score with no stated why cannot be audited)" >&2; exit 2; }
|
|
|
|
# The prompt PATH is what has to be shell-clean, not the prompt CONTENT.
|
|
# Verified directly 2026-08-16: "$(cat f)" hands the file's bytes to the
|
|
# session as ONE argv element with no re-evaluation, so $(...), backticks,
|
|
# quotes and UTF-8 in the BODY are inert - which is exactly why the prompt
|
|
# goes in argv instead of being inlined. The path sits inside those quotes
|
|
# and IS evaluated, so a space or a quote there splits the command.
|
|
# Absolute, because a relative path resolves against whatever directory the
|
|
# pane happens to be in - which for the paste-only form is a repo this
|
|
# script never sees.
|
|
case "$D_PROMPT" in
|
|
/*) ;;
|
|
*) echo "board: --prompt-file must be an absolute path (a relative one resolves against the pane's directory, not this one): $D_PROMPT" >&2; exit 2 ;;
|
|
esac
|
|
case "$D_PROMPT" in
|
|
*[!A-Za-z0-9/._-]*) echo "board: --prompt-file path is not shell-clean; it is expanded inside the command: $D_PROMPT" >&2; exit 2 ;;
|
|
esac
|
|
[ -f "$D_PROMPT" ] || { echo "board: no prompt file at $D_PROMPT" >&2; exit 2; }
|
|
# test -s, not test -e: an empty prompt file starts a session and then tells
|
|
# it nothing, which from the far end is indistinguishable from a session
|
|
# waiting for a Go that will never come.
|
|
[ -s "$D_PROMPT" ] || { echo "board: the prompt file is empty: $D_PROMPT (a dispatched session would be started and told nothing)" >&2; exit 2; }
|
|
|
|
d_rec="$(awk -F'|' -v n="$D_REPO" '$3==n {print; exit}' "$RECORDS")"
|
|
[ -n "$d_rec" ] || { echo "board: no repo named '$D_REPO' in the scanned roots ($ROOTS)" >&2; exit 2; }
|
|
d_status="$(printf '%s' "$d_rec" | cut -d'|' -f4)"
|
|
d_dir="$(printf '%s' "$d_rec" | cut -d'|' -f10)"
|
|
d_neste="$(printf '%s' "$d_rec" | cut -d'|' -f12-)"
|
|
[ -d "$d_dir" ] || { echo "board: the directory for $D_REPO does not exist: $d_dir" >&2; exit 2; }
|
|
|
|
# Rejected traits REFUSE. Degrading to a command without them is the worst
|
|
# available outcome: a command missing --advisor is indistinguishable from a
|
|
# row that legitimately has none.
|
|
d_route="$(bash "$ROUTE" --path "$D_PATH" --verification "$D_VER" \
|
|
--reversibility "$D_REV" --scope "$D_SCOPE" --rationale "$D_RAT" 2>&1)" || {
|
|
echo "board: route.sh rejected the traits, so there is no command to give:" >&2
|
|
printf '%s\n' "$d_route" >&2
|
|
exit 2
|
|
}
|
|
d_cmd="$(printf '%s\n' "$d_route" | sed -n 's/^command=//p')"
|
|
d_cost="$(printf '%s\n' "$d_route" | sed -n 's/^next-cost=//p')"
|
|
[ -n "$d_cmd" ] || { echo "board: route.sh produced no command for those traits" >&2; exit 2; }
|
|
|
|
# The prompt in argv is the whole point. A bare model+effort command forces
|
|
# the operator to type Go, and the session then has to GUESS its task out of
|
|
# STATE.md instead of being handed it - delivered bare twice on 2026-08-16
|
|
# before the operator corrected it ("gi meg alltid komplette
|
|
# oppstartskommandoer for nye sesjoner").
|
|
d_full="$d_cmd \"\$(cat $D_PROMPT)\""
|
|
|
|
if [ "$D_PANE" = "no" ]; then
|
|
printf '# DISPATCH %s - plan-file form (target has no pane)\n' "$D_REPO"
|
|
printf '# Write this whole output to a file and run: morning --plan-file <fil> --no-go\n'
|
|
printf 'form=plan-file\n'
|
|
printf '\n'
|
|
printf 'tab=1\n'
|
|
printf 'repo=%s\n' "$D_REPO"
|
|
printf 'dir=%s\n' "$d_dir"
|
|
printf 'why=dispatch\n'
|
|
printf 'status=%s\n' "$d_status"
|
|
printf 'neste=%s\n' "$d_neste"
|
|
printf 'next-cost=%s\n' "$d_cost"
|
|
printf 'command=%s\n' "$d_full"
|
|
printf 'paste=cd %s && %s\n' "$d_dir" "$d_full"
|
|
printf '\n'
|
|
# --no-go semantics, in the OUTPUT and not only in a comment: it stops the
|
|
# Go MESSAGE, never the work. morning:806 is exact - "--no-go says nothing
|
|
# is typed once the startup command is in" - so the startup command, prompt
|
|
# in argv and all, is typed regardless and the session starts working by
|
|
# itself. An operator decided on the opposite premise once already
|
|
# (2026-08-16) and it had to be corrected before the run.
|
|
printf 'note=--no-go stops only the follow-up Go message. The startup command - prompt in argv included - is typed regardless (morning:806), so the dispatched session starts working on its own.\n'
|
|
# What the dry-run does and does not prove, measured rather than assumed
|
|
# (2026-08-16, this dispatch run through the real morning): it validates
|
|
# that the block parses and that a command comes out - "opening: 1 of 1".
|
|
# It does NOT validate the pane question. Run from a Claude session there
|
|
# is no tty, so morning prints "window: unknown (no terminal to measure),
|
|
# assuming an empty window" and plan_drop_open never fires at all. A gate
|
|
# built on the dry-run would therefore pass the self-dispatch case every
|
|
# single time, which is the case it was supposed to catch.
|
|
printf 'note=Verify before running: morning --plan-file <fil> --dry-run must report 1 of 1. That proves the block parses and yields a command - it does NOT prove the target has no pane: run from a Claude session there is no tty, morning assumes an empty window and plan_drop_open never fires (measured 2026-08-16).\n'
|
|
printf 'note=The pane question is answered by morning --probe-panes, whose DIR column works without a tty. That measurement is what --target-pane carries.\n'
|
|
else
|
|
printf '# DISPATCH %s - paste-only form (target ALREADY has a pane)\n' "$D_REPO"
|
|
printf '# No plan file, deliberately: run from a real terminal, morning plan_drop_open\n'
|
|
printf '# (morning:1788) drops a block whose repo already has a pane and reports\n'
|
|
printf '# "0 of 1", which reads as a broken plan file. Hand the operator the line\n'
|
|
printf '# instead. (Without a tty morning cannot see the panes at all, so a dry-run\n'
|
|
printf '# from a Claude session would report 1 of 1 and prove nothing.)\n'
|
|
printf 'form=paste-only\n'
|
|
printf 'repo=%s\n' "$D_REPO"
|
|
printf 'dir=%s\n' "$d_dir"
|
|
printf 'next-cost=%s\n' "$d_cost"
|
|
# No cd: one repo per terminal tab, and the operator is already standing in
|
|
# that one. A cd here is noise at best and a session started in the wrong
|
|
# directory at worst.
|
|
printf 'paste=%s\n' "$d_full"
|
|
printf '\n'
|
|
printf 'note=Run this in the existing tab AFTER /exit - it starts a new session in the pane that is already there.\n'
|
|
printf 'note=Deliberately no tab= key: a block carrying one is a plan block, and a plan block for this repo is exactly what plan_drop_open discards.\n'
|
|
printf 'note=morning --relaunch bypasses the filter but opens a SECOND tab beside the existing one (morning:1784), which is rarely what is wanted when the operator is already sitting there.\n'
|
|
fi
|
|
}
|
|
|
|
if [ "$DISPATCH" -eq 1 ]; then
|
|
dispatch
|
|
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"
|
|
# Both lookup files are matched by FILENAME, never by NR==FNR: that idiom
|
|
# silently breaks when the FIRST file is empty (zero blocked repos is a real,
|
|
# common tree state) - FNR then stays equal to NR for the entire NEXT file
|
|
# too, not just its first line, so every record in it is misrouted into the
|
|
# ub[] branch and dropped via `next`. Measured against 0.21.0: one in-progress
|
|
# repo with an unhandled inbox message, zero blocked repos anywhere, produced
|
|
# "0 tabber". FILENAME comparison never depends on how many lines a prior
|
|
# file contributed, empty or not.
|
|
awk -F'|' -v OFS='|' -v UBF="$UNBLOCKS" -v OWF="$OWED" '
|
|
FILENAME==UBF { ub[$1] = $2 + 0; next }
|
|
FILENAME==OWF { ow[$1] = $2 + 0; next }
|
|
{
|
|
name = $3; status = $4; cost = $5
|
|
# OWED, not raw pending (field 6): a message can decline a reply
|
|
# (reply-expected: no), and that declaration is what group 2 is FOR - an
|
|
# obligation to another session, not merely a file in the inbox.
|
|
owed = (name in ow) ? ow[name] : 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 = (owed > 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 (owed > 0) { grp = 2; mag = owed; why = "inbox:" owed }
|
|
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" "$OWED" "$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.
|
|
# Same rule applies to the coord-count.sh warning below (review finding 1,
|
|
# 2026-08-14): a missing sibling makes `owed` 0 for every repo above, which
|
|
# can silently drop a done/deferred debtor from group 2 - `keep` itself is
|
|
# intentionally left unchanged (a policy change to a format the operator
|
|
# decided has a second consumer elsewhere), but the driver must be able to
|
|
# see that the omission happened rather than read a shorter list as complete.
|
|
[ "$HAVE_COUNT" -eq 1 ] || printf 'advarsel=coord-count.sh mangler - gjeldsvekting (gruppe 2, inbox:N) er ikke beregnet\n'
|
|
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
|
|
|
|
# --- Inbox-plan rendering (--inbox-plan) ------------------------------------
|
|
# See the file-header comment for the full rationale. One block per NAME with
|
|
# pending>0 in $ALLMAIL, joined against $RECORDS by FILENAME (never NR==FNR -
|
|
# the plan()'s own regression comment above explains why: the first file being
|
|
# empty silently misroutes the entire second file's lines, and $RECORDS here
|
|
# is never empty but the general idiom is worth staying consistent about).
|
|
#
|
|
# class is read off $RECORDS' own bucket, not recomputed: bucket 5 is exactly
|
|
# "no STATE.md" (see the discovery loop's own `printf '5|...'` line above), and
|
|
# a name absent from $RECORDS entirely never had a directory in the scan.
|
|
inbox_plan() {
|
|
ipf="${TMPDIR:-/tmp}/board-inboxplan.$$"
|
|
awk -F'|' -v OFS='|' -v RCF="$RECORDS" '
|
|
FILENAME==RCF {
|
|
name = $3
|
|
rc_bucket[name] = $1; rc_status[name] = $4; rc_cost[name] = $5
|
|
rc_dir[name] = $10; rc_neste[name] = $12
|
|
next
|
|
}
|
|
{
|
|
name = $1; pend = $2 + 0; owed = $3 + 0
|
|
if (name in rc_bucket) {
|
|
cls = (rc_bucket[name] == 5) ? "no-state" : "repo"
|
|
dir = rc_dir[name]; status = rc_status[name]; cost = rc_cost[name]
|
|
neste = rc_neste[name]
|
|
} else {
|
|
cls = "orphan-mailbox"; dir = "-"; status = "-"; cost = "-"; neste = "-"
|
|
}
|
|
print owed, pend, name, cls, dir, status, cost, neste
|
|
}
|
|
' "$RECORDS" "$ALLMAIL" | sort -t'|' -k1,1nr -k2,2nr -k3,3 > "$ipf"
|
|
|
|
echo "# INBOX-PLAN $(date '+%Y-%m-%d %H:%M') - en blokk per repo/mailbox med uhaandtert post"
|
|
echo "# Kilder: coord-count.sh (pending+owed), STATE.md, git. 0 modellkall."
|
|
echo "# Populasjon: alt med pending>0, uavhengig av --plan sin admisjon - ingen tak,"
|
|
echo "# ingen dom. Et repo --plan alt admitterer er fortsatt med (overmengde, ikke komplement)."
|
|
echo "# class=repo (STATE.md finnes) | no-state (repo finnes, STATE.md mangler) |"
|
|
echo "# orphan-mailbox (ingen katalog for postkassen i det skannede omraadet)."
|
|
echo "# pending=meldinger totalt, owed=derav skylder svar (resten er FYI)."
|
|
echo ""
|
|
|
|
# Review finding 1 (2026-08-14): a missing coord-count.sh sibling leaves
|
|
# $ALLMAIL empty, and the population below is entirely $ALLMAIL rows - the
|
|
# measured effect was 1 block silently becoming 0, not an empty population
|
|
# rendered as such. key=value, not '#', for the same reason as plan()'s
|
|
# advarsel= line: the driver consumer drops comment lines by rule.
|
|
[ "$HAVE_COUNT" -eq 1 ] || printf 'advarsel=coord-count.sh mangler - populasjonen er ikke beregnet, ikke tom\n'
|
|
|
|
ipn=0
|
|
while IFS='|' read -r owed pend name cls dir status cost neste; do
|
|
[ -n "$name" ] || continue
|
|
ipn=$((ipn + 1))
|
|
printf 'tab=%s\n' "$ipn"
|
|
printf 'repo=%s\n' "$name"
|
|
printf 'dir=%s\n' "$dir"
|
|
printf 'class=%s\n' "$cls"
|
|
printf 'pending=%s\n' "$pend"
|
|
printf 'owed=%s\n' "$owed"
|
|
printf 'status=%s\n' "$status"
|
|
printf 'neste=%s\n' "$neste"
|
|
case "$cls" in
|
|
# Same route_cmd_for()/plan_cmd() every other rendering uses - one copy
|
|
# of "how a command is derived from a route line", not a second guess.
|
|
repo) plan_cmd "$dir" "$cost" ;;
|
|
# No STATE.md means no route line can exist - naming that plainly is
|
|
# the whole point of a separate class, not a guessed command.
|
|
no-state) printf 'command_missing=ingen STATE.md - repoet finnes, men har ingen plan\n' ;;
|
|
orphan-mailbox) printf 'command_missing=ingen katalog for denne postkassen i det skannede omraadet\n' ;;
|
|
esac
|
|
echo ""
|
|
done < "$ipf"
|
|
/bin/rm -f "$ipf" 2>/dev/null
|
|
|
|
printf '# %s blokker.\n' "$ipn"
|
|
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 [ "$INBOX_PLAN" -eq 1 ]; then
|
|
inbox_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
|