@staix/agent-hub 0.16.0 → 0.18.0

package/src/cli/sdlc-output.ts

@@ -0,0 +1,242 @@
+// Human output for the `ahub sdlc` read commands (#814 T1). Pure: data in, spans out, no I/O and no clock but `now`.
+// Layout follows #284: aligned columns from the shared `table`, long text wrapped under its label (never cut),
+// semantic tones, readable times (`2026-10-25 14:20 UTC (3h05m ago)`, never a raw ISO string). `--json` is the caller's
+// branch and prints the hub's reply untouched, so nothing here may be the only copy of a field.
+import { duration, plural, relative, table, terminalText, wrap, type Span, type Tone } from "./console-state.ts";
+
+type Line = Span[];
+const s = (value: unknown, tone?: Tone): Span => ({ text: terminalText(value).replace(/[\n\t]/g, " "), ...(tone ? { tone } : {}) });
+const room = (columns?: number) => columns ?? Infinity;
+const list = (value: unknown): any[] => Array.isArray(value) ? value : [];
+const yes = (value: unknown) => value === true ? "yes" : value === false ? "no" : "unknown";
+const short = (sha: unknown) => typeof sha === "string" && sha ? sha.slice(0, 8) : "-";
+const count = (n: unknown) => typeof n === "number" && Number.isFinite(n) ? (Number.isInteger(n) ? String(n) : n.toFixed(1)) : "unknown";
+const percent = (rate: unknown) => typeof rate === "number" && Number.isFinite(rate) ? `${Math.round(rate * 100)}%` : "unknown";
+/** `2026-10-25 14:20 UTC (3h05m ago)`: an absolute minute and how long ago, never the raw ISO string. */
+export function moment(at: unknown, now: number): string {
+  if (typeof at !== "number" || !Number.isFinite(at)) return "unknown";
+  const iso = new Date(at).toISOString();
+  return `${iso.slice(0, 10)} ${iso.slice(11, 16)} UTC (${relative(at, now)})`;
+}
+const span = (ms: unknown) => typeof ms === "number" && Number.isFinite(ms) ? duration(ms) : "unknown";
+
+/** Text wrapped to the width, continuation lines hanging under `indent`. */
+function para(text: string, columns: number | undefined, tone?: Tone, indent = "", hang = 2): Line[] {
+  return wrap(indent + text, room(columns), hang).map(line => [s(line, tone)]);
+}
+/**
+ * `label  value`, the value wrapped beside its own label so narrow terminals never separate them. When the longest word of
+ * the value does not fit in the room left of the label column, the value moves under the label instead, so a path or id
+ * is broken only when it is wider than the whole terminal.
+ */
+function pair(label: string, value: unknown, columns: number | undefined, labelWidth: number, tone?: Tone, indent = ""): Line[] {
+  const text = terminalText(value).replace(/[\n\t]/g, " ");
+  const head = indent + label.padEnd(labelWidth) + "  ";
+  const longest = Math.max(0, ...text.split(/\s+/).map(textWidth));
+  if (columns !== undefined && head.length + longest > columns && text) {
+    const under = indent.length + 1 + longest <= columns ? indent + " " : "";
+    return [[s(indent + label, "muted")], ...wrap(under + text, columns, under.length).map((line): Line => [s(line, tone)])];
+  }
+  const lines = wrap(head + text, room(columns), head.length);
+  return lines.map((line, i) => i === 0 ? [s(line.slice(0, head.length), "muted"), s(line.slice(head.length), tone)] : [s(line, tone)]);
+}
+/** Items under a label, one per line, wrapped under the dash. */
+function bullets(label: string, items: readonly unknown[], columns: number | undefined, tone?: Tone, indent = ""): Line[] {
+  if (!items.length) return [];
+  return [[s(indent + label, "muted")], ...items.flatMap(item => para(`- ${terminalText(item)}`, columns, tone, indent + (columns !== undefined && indent.length + 2 + 2 + Math.max(0, ...terminalText(item).split(/\s+/).map(textWidth)) > columns ? "" : "  "), 2))];
+}
+const GAP = 2;
+const textWidth = (text: string) => Bun.stringWidth(text);
+/**
+ * A table that fits the terminal and never cuts a character. At its natural widths when they fit; otherwise the
+ * widest cells wrap inside their column (a PR linked to thirty tasks wraps its TASKS cell, it does not push the
+ * table to 134 columns); and when even each column's longest unbreakable word cannot fit, one labelled block per row.
+ */
+function grid(head: string[], data: Span[][], columns: number | undefined): Line[] {
+  const natural = head.map((name, i) => Math.max(textWidth(name), ...data.map(row => textWidth(row[i]?.text ?? ""))));
+  const gaps = GAP * (head.length - 1);
+  if (columns === undefined || natural.reduce((sum, n) => sum + n, 0) + gaps <= columns) return table(head, data, room(columns), natural);
+  const floor = head.map((name, i) => Math.max(textWidth(name), ...data.flatMap(row => (row[i]?.text ?? "").split(/\s+/).map(textWidth))));
+  if (floor.reduce((sum, n) => sum + n, 0) + gaps > columns) return blocks(head, data, columns);
+  // Hand the spare width to the column that is cut most, one cell at a time, so the wide list cell wraps and the short ones do not.
+  const widths = [...floor];
+  for (let spare = columns - widths.reduce((sum, n) => sum + n, 0) - gaps; spare > 0; spare--) {
+    let at = -1;
+    for (let i = 0; i < widths.length; i++) if (widths[i]! < natural[i]! && (at < 0 || natural[i]! - widths[i]! > natural[at]! - widths[at]!)) at = i;
+    if (at < 0) break;
+    widths[at]!++;
+  }
+  const physical = data.flatMap(row => {
+    const cells = row.map((cell, i) => wrap(cell.text, widths[i]!, 0));
+    return Array.from({ length: Math.max(1, ...cells.map(lines => lines.length)) }, (_, n) => head.map((_, i): Span => ({ ...(row[i] ?? s("")), text: cells[i]?.[n] ?? "" })));
+  });
+  return table(head, physical, columns, widths);
+}
+/** Narrow terminal: each row becomes its own block, the first column as its heading and every other column beside its label. */
+function blocks(head: string[], data: Span[][], columns: number): Line[] {
+  const label = Math.max(...head.slice(1).map(textWidth));
+  return data.flatMap((row, n) => [...(n ? [blank] : []), ...wrap(row[0]?.text ?? "", columns, 2).map((line): Line => [{ ...(row[0] ?? s("")), text: line }]),
+    ...head.slice(1).flatMap((name, i) => pair(name.toLowerCase(), row[i + 1]?.text ?? "", columns, label, row[i + 1]?.tone, "  "))]);
+}
+/** A heading wraps to the width like any paragraph; a long repository name never pushes it past the terminal. */
+const heading = (text: string, columns?: number): Line[] => wrap(text, room(columns), 2).map(line => [s(line, "strong")]);
+const blank: Line = [s("")];
+const readyTone = (ready: unknown): Tone => ready === true ? "success" : "attention";
+
+// ---- sdlc status / explain ----------------------------------------------------------------------------------------
+
+function receiptLine(receipt: any): string {
+  const parts = [receipt?.repo && receipt?.issue ? `${receipt.repo}#${receipt.issue}` : receipt?.issue ? `issue #${receipt.issue}` : undefined,
+    receipt?.pr ? `PR #${receipt.pr}` : undefined, receipt?.head ? `head ${short(receipt.head)}` : undefined].filter(Boolean);
+  return parts.length ? parts.join(", ") : "no issue or PR recorded";
+}
+function taskBlock(row: any, columns: number | undefined, detail: boolean): Line[] {
+  const id = `#${row.id}`;
+  const out: Line[] = para(`${id}  ${row.title ?? ""}`, columns, undefined, "", 6)
+    .map((line, i) => i === 0 ? [s(id, "taskRef"), s(line[0]!.text.slice(id.length), "strong")] : line);
+  out.push(...pair("lifecycle", `stage ${row.stage ?? "unknown"}, mode ${row.mode ?? "unknown"}, ready ${yes(row.ready)}, actor ${row.actor ?? "unknown"}`, columns, 11, readyTone(row.ready), "  "));
+  out.push(...pair("next", row.next ?? "unknown", columns, 11, undefined, "  "));
+  out.push(...pair("receipt", receiptLine(row.receipt), columns, 11, undefined, "  "));
+  out.push(...bullets("blockers", list(row.blockers), columns, "attention", "  "));
+  if (!detail) return out;
+  if (row.spec) out.push(...pair("spec", `issue #${row.spec.issue}, ${row.spec.state}`, columns, 11, undefined, "  "));
+  if (row.playbook) out.push(...pair("playbook", row.playbook, columns, 11, undefined, "  "));
+  if (row.definition?.name || row.definition?.id) out.push(...pair("stage", row.definition.name ?? row.definition.id, columns, 11, undefined, "  "));
+  out.push(...bullets("entry", list(row.entry), columns, undefined, "  "), ...bullets("exit", list(row.exit), columns, undefined, "  "));
+  const f = row.findings;
+  if (f) out.push(...pair("findings", `${plural(f.important ?? 0, "important")} (${f.openImportant ?? 0} open), ${plural(f.nit ?? 0, "nit")} (${f.openNit ?? 0} open), ${f.fixed ?? 0} fixed, ${f.falsePositive ?? 0} false positive, ${f.accepted ?? 0} accepted`, columns, 11, f.openImportant ? "attention" : undefined, "  "));
+  const p = row.planConformance;
+  if (p) {
+    out.push(...pair("plan files", `${p.state}${p.accepted ? ", departure accepted" : ""}, ${list(p.outside).length} outside the plan, ${list(p.untouched).length} planned and untouched`, columns, 11, p.state === "departure" && !p.accepted ? "attention" : undefined, "  "));
+    out.push(...bullets("outside the plan", list(p.outside), columns, "attention", "    "), ...bullets("untouched", list(p.untouched), columns, "muted", "    "));
+  }
+  const t = row.testIntegrity;
+  if (t) {
+    out.push(...pair("tests", `${t.applicability === "bug" ? "bug fix" : t.applicability === "not_bug" ? "not a bug fix" : "bug status unknown"}, red-first ${String(t.redFirst).replace("_", " ")}, files ${t.fileState}`, columns, 11, undefined, "  "));
+    out.push(...bullets("modified tests", list(t.modifiedTests), columns, undefined, "    "), ...bullets("test blockers", list(t.blockers), columns, "attention", "    "));
+  }
+  const c = row.criteria;
+  if (c) {
+    out.push(...pair("criteria", `${c.ready ? "all met" : "not all met"}${c.id ? `, checklist ${c.id}` : ""}${c.note ? `, ${c.note}` : ""}`, columns, 11, readyTone(c.ready), "  "));
+    out.push(...bullets("unmet", list(c.blockers), columns, "attention", "    "));
+  }
+  return out;
+}
+function lifecycleView(reply: any, columns: number | undefined, detail: boolean): Line[] {
+  const rows = list(reply?.rows);
+  const out: Line[] = [...heading(`SDLC lifecycle, mode ${reply?.mode ?? "unknown"}`, columns)];
+  if (!rows.length) return [...out, [s("no task has lifecycle state yet", "muted")]];
+  if (!detail || rows.length > 1) {
+    out.push(...grid(["ID", "STAGE", "READY", "ACTOR", "PR"], rows.map(row => [s(`#${row.id}`, "taskRef"), s(row.stage ?? "unknown"), s(yes(row.ready), readyTone(row.ready)), s(row.actor ?? "-"), s(row.receipt?.pr ? `#${row.receipt.pr}` : "-")]), columns));
+  }
+  for (const row of rows) out.push(blank, ...taskBlock(row, columns, detail));
+  if (reply?.truncated) out.push(blank, ...para("showing the first 100 tasks; name a task to read one", columns, "muted"));
+  return out;
+}
+/** `ahub sdlc status [task]`: one row per task, then each task's next step and blockers. */
+export const renderSdlcStatus = (reply: unknown, columns?: number, _now = Date.now()): Span[][] => lifecycleView(reply, columns, false);
+/** `ahub sdlc explain <task>`: the same task with every gate the hub read. */
+export const renderSdlcExplain = (reply: unknown, columns?: number, _now = Date.now()): Span[][] => lifecycleView(reply, columns, true);
+
+// ---- sdlc queue / release -----------------------------------------------------------------------------------------
+
+/** `ahub sdlc queue <repo>`: the merge order, then each open PR's gates. */
+export function renderSdlcQueue(reply: unknown, columns?: number, _now = Date.now()): Span[][] {
+  const report = (reply as any)?.report ?? {};
+  const rows = list(report.rows);
+  const out: Line[] = [...heading(`Merge queue ${report.repo ?? "unknown repository"}`, columns)];
+  if (report.complete === false) out.push(...para("incomplete: a read failed or the board changed during it; do not merge from this order", columns, "attention"));
+  if (report.truncated) out.push(...para("truncated: more open PRs than one read covers", columns, "attention"));
+  if (!rows.length) return [...out, [s("no open PR is linked to a task", "muted")]];
+  out.push(...pair("order", list(report.order).length ? list(report.order).map((pr: number) => `#${pr}`).join(", ") : "none decided", columns, 9));
+  if (list(report.unordered).length) out.push(...pair("unordered", list(report.unordered).map((pr: number) => `#${pr}`).join(", "), columns, 9, "attention"));
+  out.push(blank, ...grid(["PR", "TASKS", "READY", "HEAD", "AFTER"], rows.map(row => [s(`#${row.pr}`, "issueRef"), s(list(row.tasks).map((id: number) => `#${id}`).join(" ") || "-", "taskRef"), s(yes(row.ready), readyTone(row.ready)), s(row.private ? "private" : short(row.head)), s(list(row.after).map((pr: number) => `#${pr}`).join(" ") || "-")]), columns));
+  for (const row of rows) {
+    if (!list(row.blockers).length && !row.findings?.openImportant) continue;
+    out.push(blank, [s(`#${row.pr}`, "issueRef")], ...bullets("blockers", list(row.blockers), columns, "attention", "  "));
+  }
+  if (list(report.conflicts).length) out.push(blank, ...bullets("file conflicts", list(report.conflicts).map((c: any) => `#${c.left} and #${c.right} share ${plural(c.files ?? 0, "file")} (${c.order === "person_required" ? "the person orders them" : "dependency order"})`), columns, "attention"));
+  return out;
+}
+/** `ahub sdlc release <repo> [live-issue...]`: source, document, issue and authorization evidence, then what blocks the release. */
+export function renderSdlcRelease(reply: unknown, columns?: number, now = Date.now()): Span[][] {
+  const r = (reply as any)?.report ?? {};
+  const out: Line[] = [...heading(`Release readiness ${r.repo ?? "unknown repository"}`, columns)];
+  const w = 12;
+  out.push(...pair("version", r.version ?? "unknown", columns, w), ...pair("head", short(r.head), columns, w), ...pair("tag", r.tag ? `${r.tag} at ${short(r.tagCommit)}` : "none", columns, w));
+  out.push(...pair("source ready", yes(r.sourceReady), columns, w, readyTone(r.sourceReady)), ...pair("native", String(r.native ?? "unverified"), columns, w, "attention"), ...pair("release ready", yes(r.ready), columns, w, readyTone(r.ready)));
+  out.push(...pair("commits", `${plural(list(r.commits).length, "commit")} since the last tag`, columns, w));
+  if (list(r.mergedPrs).length) out.push(...pair("merged PRs", list(r.mergedPrs).map((p: any) => `#${p.pr}`).join(", "), columns, w));
+  const docs = r.documents;
+  out.push(blank, ...pair("documents", docs ? `${docs.fresh ? "fresh" : "not fresh"}, ${plural(docs.errors ?? 0, "error")}, ${plural(list(docs.documents).length, "document")}` : "not read", columns, w, docs?.fresh ? "success" : "attention"));
+  for (const d of list(docs?.documents)) if (d.state !== "fresh") out.push(...pair(d.state, `${d.path ?? "(path withheld)"}${d.dirty ? " (uncommitted changes)" : ""}`, columns, w, "attention", "  "));
+  if (list(r.liveIssues).length) out.push(blank, ...grid(["ISSUE", "STATE"], list(r.liveIssues).map((i: any) => [s(`#${i.id}`, "issueRef"), s(i.state, i.state === "closed" ? "success" : "attention")]), columns));
+  const a = r.authorization;
+  if (a) out.push(blank, ...pair("authorization", `${a.state}: version ${a.receipt?.version ?? "unknown"} at ${short(a.receipt?.commit)}, approved ${moment(a.receipt?.at, now)}`, columns, w, a.state === "matched" ? "success" : "attention"));
+  else out.push(blank, ...pair("authorization", "none recorded: run ahub sdlc authorize-release <version>", columns, w, "muted"));
+  for (const t of list(r.trains)) out.push(...pair(`train #${t.release?.id ?? "?"}`, `${t.readiness?.trigger ?? "unknown"}${list(t.readiness?.blockers).length ? `, ${list(t.readiness.blockers).join("; ")}` : ""}`, columns, w, list(t.readiness?.blockers).length ? "attention" : undefined));
+  out.push(...bullets("blockers", list(r.blockers), columns, "attention"));
+  return out;
+}
+
+// ---- sdlc metrics / costs -----------------------------------------------------------------------------------------
+
+const SUMMARY_ROWS: [string, string, boolean][] = [
+  ["acceptance_to_plan_ms", "acceptance to plan", true], ["acceptance_to_first_review_ms", "acceptance to first review", true], ["acceptance_to_merge_ms", "acceptance to merge", true],
+  ["rework_rounds", "rework rounds", false], ["same_head_ci_reruns", "same-head CI reruns", false], ["stale_head_re_reviews", "stale-head re-reviews", false],
+];
+const BAND_TONE: Record<string, Tone> = { ok: "success", log: "muted", diagnose: "attention", propose: "failure" };
+/** `ahub sdlc metrics [--since ...]`: times and counts from board history, the two approval rates, stalls and band tiers. */
+export function renderSdlcMetrics(result: unknown, columns?: number, now = Date.now()): Span[][] {
+  const m = result as any;
+  const out: Line[] = [...heading("SDLC metrics", columns)];
+  out.push(...pair("window", m?.since === null || m?.since === undefined ? "all recorded history" : `since ${moment(m.since, now)}`, columns, 10),
+    ...pair("tasks", `${m?.tasks ?? 0} counted${m?.withheldPrivate ? `, ${m.withheldPrivate} private withheld` : ""}`, columns, 10));
+  const metrics = m?.metrics ?? {};
+  const value = (n: unknown, time: boolean) => time ? span(n) : count(n);
+  out.push(blank, ...grid(["METRIC", "N", "UNKNOWN", "MEAN", "MEDIAN", "P90", "MAX"], SUMMARY_ROWS.map(([key, label, time]) => {
+    const x = metrics[key] ?? {};
+    return [s(label), s(count(x.n)), s(count(x.unknown), x.unknown ? "attention" : "muted"), s(value(x.mean, time)), s(value(x.median, time)), s(value(x.p90, time)), s(value(x.max, time))];
+  }), columns));
+  out.push(blank, ...grid(["RATE", "N", "UNKNOWN", "VALUE"], [["first_pass_approval", "first-pass approval"], ["first_pass_check", "first-pass check"]].map(([key, label]) => {
+    const x = metrics[key!] ?? {};
+    return [s(label), s(count(x.n)), s(count(x.unknown), x.unknown ? "attention" : "muted"), s(percent(x.rate), x.rate === null || x.rate === undefined ? "muted" : "number")];
+  }), columns));
+  const st = m?.stalls;
+  if (st) out.push(blank, ...pair("stalls", `${st.open ?? 0} open${Object.keys(st.byKind ?? {}).length ? ` (${Object.entries(st.byKind).map(([k, n]) => `${k} ${n}`).join(", ")})` : ""}, ${st.doneWithoutWrites ?? 0} done without writes`, columns, 10, st.open ? "attention" : undefined));
+  if (m?.bands === "off" || m?.bands === undefined) out.push(...pair("bands", "off", columns, 10, "muted"));
+  else {
+    out.push(blank, ...grid(["BAND", "TIER", "BASELINE", "LAST", "Z", "TASK"], list(m.bands).map((b: any) => [s(String(b.metric).replaceAll("_", " ")), s(b.tier, BAND_TONE[b.tier] ?? undefined), s(count(b.baseline)), s(count(b.last)), s(count(b.z)), s(b.lastTask ? `#${b.lastTask}` : "-", "taskRef")]), columns));
+    for (const b of list(m.bands)) if (b.reason && b.tier !== "ok") out.push(...para(`${String(b.metric).replaceAll("_", " ")}: ${b.reason}`, columns, "muted", "  ", 2));
+  }
+  return out;
+}
+/** `ahub sdlc costs [repo]`: review and CI cost of each linked merged PR, grouped by repository. */
+export function renderSdlcCosts(result: unknown, columns?: number, _now = Date.now()): Span[][] {
+  const c = result as any;
+  const rows = list(c?.rows);
+  const out: Line[] = [...heading("SDLC costs", columns)];
+  if (!rows.length) out.push([s("no linked merged PR has cost evidence", "muted")]);
+  const repos = [...new Set(rows.map(row => String(row.repo)))];
+  for (const repo of repos) {
+    out.push(...(out.length > 1 ? [blank] : []), ...wrap(repo, room(columns), 2).map((line): Line => [s(line, "info")]), ...grid(["PR", "ROUNDS", "CI", "RERUNS", "FULL", "DELTA", "REVIEW", "UNK", "OK"], rows.filter(row => String(row.repo) === repo).map(row => [
+      s(`#${row.pr}`, "issueRef"), s(count(row.reviewRounds)), s(count(row.ciRuns)), s(count(row.ciReruns)), s(count(row.fullReReviews)), s(count(row.deltaReviews)), s(span(row.reviewMs)),
+      s(count(row.unknownReviewScopes), row.unknownReviewScopes ? "attention" : "muted"), s(row.complete ? "yes" : "no", row.complete ? "success" : "attention")]), columns));
+  }
+  if (c?.truncated) out.push(blank, ...para("truncated: more PRs than one read covers, or a read was incomplete", columns, "attention"));
+  if (c?.privateTasks === "withheld") out.push(...para("private tasks are withheld", columns, "muted"));
+  return out;
+}
+
+// ---- sdlc authorize-release ---------------------------------------------------------------------------------------
+
+/** `ahub sdlc authorize-release <version>`: what the person just approved. */
+export function renderAuthorization(authorization: unknown, columns?: number, now = Date.now()): Span[][] {
+  const a = authorization as any;
+  const w = 8;
+  return [...heading("Release authorized", columns),
+    ...pair("version", a?.version ?? "unknown", columns, w), ...pair("commit", short(a?.commit), columns, w), ...pair("by", a?.by ?? "unknown", columns, w),
+    ...pair("at", moment(a?.at, now), columns, w), ...pair("docs", a?.docs ? `${a.docs.fresh ? "fresh" : "not fresh"}, ${plural(a.docs.documents ?? 0, "document")}, digest ${short(a.docs.digest)}` : "unknown", columns, w),
+    ...pair("id", a?.id ?? "unknown", columns, w, "muted"), blank,
+    ...para("A daemon restart revokes this authorization.", columns, "muted")];
+}

package/src/cli/task-output.ts

@@ -0,0 +1,212 @@
+// Human output for `ahub task show|cancel`, the backlog mutations and grooming, and the release commands (#814 T2).
+// Pure: parsed hub-tool JSON in, spans out. The hub tools keep returning JSON to agents; the CLI parses the text and
+// renders it, and `--json` prints that text untouched. Built from the same primitives as sdlc-output.ts (#814 T1), so
+// every table fits the terminal and no identifier is cut. A private task arrives from the hub as a stub (`[pii]` title
+// and detail, empty refs and plan): this module shows that stub and never asks for more.
+import { type Span, type Tone, plural, table, terminalText, wrap } from "./console-state.ts";
+import { moment } from "./sdlc-output.ts";
+
+type Line = Span[];
+// Local copies of the layout primitives of sdlc-output.ts (#814 T1), the source of these helpers: that file stays untouched by this task
+// (its plan names no edit), so a change to a primitive there is made here too. `moment` is already exported there and imported.
+const s = (value: unknown, tone?: Tone): Span => ({ text: terminalText(value).replace(/[\n\t]/g, " "), ...(tone ? { tone } : {}) });
+const room = (columns?: number) => columns ?? Infinity;
+const list = (value: unknown): any[] => Array.isArray(value) ? value : [];
+const yes = (value: unknown) => value === true ? "yes" : value === false ? "no" : "unknown";
+const short = (sha: unknown) => typeof sha === "string" && sha ? sha.slice(0, 8) : "-";
+const count = (n: unknown) => typeof n === "number" && Number.isFinite(n) ? (Number.isInteger(n) ? String(n) : n.toFixed(1)) : "unknown";
+
+/** Text wrapped to the width, continuation lines hanging under `indent`. */
+function para(text: string, columns: number | undefined, tone?: Tone, indent = "", hang = 2): Line[] {
+  return wrap(indent + text, room(columns), hang).map(line => [s(line, tone)]);
+}
+/**
+ * `label  value`, the value wrapped beside its own label so narrow terminals never separate them. When the longest word of
+ * the value does not fit in the room left of the label column, the value moves under the label instead, so a path or id
+ * is broken only when it is wider than the whole terminal.
+ */
+function pair(label: string, value: unknown, columns: number | undefined, labelWidth: number, tone?: Tone, indent = ""): Line[] {
+  const text = terminalText(value).replace(/[\n\t]/g, " ");
+  const head = indent + label.padEnd(labelWidth) + "  ";
+  const longest = Math.max(0, ...text.split(/\s+/).map(textWidth));
+  if (columns !== undefined && head.length + longest > columns && text) {
+    const under = indent.length + 1 + longest <= columns ? indent + " " : "";
+    return [[s(indent + label, "muted")], ...wrap(under + text, columns, under.length).map((line): Line => [s(line, tone)])];
+  }
+  const lines = wrap(head + text, room(columns), head.length);
+  return lines.map((line, i) => i === 0 ? [s(line.slice(0, head.length), "muted"), s(line.slice(head.length), tone)] : [s(line, tone)]);
+}
+/** Items under a label, one per line, wrapped under the dash. */
+function bullets(label: string, items: readonly unknown[], columns: number | undefined, tone?: Tone, indent = ""): Line[] {
+  if (!items.length) return [];
+  return [[s(indent + label, "muted")], ...items.flatMap(item => para(`- ${terminalText(item)}`, columns, tone, indent + (columns !== undefined && indent.length + 2 + 2 + Math.max(0, ...terminalText(item).split(/\s+/).map(textWidth)) > columns ? "" : "  "), 2))];
+}
+const GAP = 2;
+const textWidth = (text: string) => Bun.stringWidth(text);
+/**
+ * A table that fits the terminal and never cuts a character. At its natural widths when they fit; otherwise the
+ * widest cells wrap inside their column (a PR linked to thirty tasks wraps its TASKS cell, it does not push the
+ * table to 134 columns); and when even each column's longest unbreakable word cannot fit, one labelled block per row.
+ */
+function grid(head: string[], data: Span[][], columns: number | undefined): Line[] {
+  const natural = head.map((name, i) => Math.max(textWidth(name), ...data.map(row => textWidth(row[i]?.text ?? ""))));
+  const gaps = GAP * (head.length - 1);
+  if (columns === undefined || natural.reduce((sum, n) => sum + n, 0) + gaps <= columns) return table(head, data, room(columns), natural);
+  const floor = head.map((name, i) => Math.max(textWidth(name), ...data.flatMap(row => (row[i]?.text ?? "").split(/\s+/).map(textWidth))));
+  if (floor.reduce((sum, n) => sum + n, 0) + gaps > columns) return blocks(head, data, columns);
+  // Hand the spare width to the column that is cut most, one cell at a time, so the wide list cell wraps and the short ones do not.
+  const widths = [...floor];
+  for (let spare = columns - widths.reduce((sum, n) => sum + n, 0) - gaps; spare > 0; spare--) {
+    let at = -1;
+    for (let i = 0; i < widths.length; i++) if (widths[i]! < natural[i]! && (at < 0 || natural[i]! - widths[i]! > natural[at]! - widths[at]!)) at = i;
+    if (at < 0) break;
+    widths[at]!++;
+  }
+  const physical = data.flatMap(row => {
+    const cells = row.map((cell, i) => wrap(cell.text, widths[i]!, 0));
+    return Array.from({ length: Math.max(1, ...cells.map(lines => lines.length)) }, (_, n) => head.map((_, i): Span => ({ ...(row[i] ?? s("")), text: cells[i]?.[n] ?? "" })));
+  });
+  return table(head, physical, columns, widths);
+}
+/** Narrow terminal: each row becomes its own block, the first column as its heading and every other column beside its label. */
+function blocks(head: string[], data: Span[][], columns: number): Line[] {
+  const label = Math.max(...head.slice(1).map(textWidth));
+  return data.flatMap((row, n) => [...(n ? [blank] : []), ...wrap(row[0]?.text ?? "", columns, 2).map((line): Line => [{ ...(row[0] ?? s("")), text: line }]),
+    ...head.slice(1).flatMap((name, i) => pair(name.toLowerCase(), row[i + 1]?.text ?? "", columns, label, row[i + 1]?.tone, "  "))]);
+}
+/** A heading wraps to the width like any paragraph; a long repository name never pushes it past the terminal. */
+const heading = (text: string, columns?: number): Line[] => wrap(text, room(columns), 2).map(line => [s(line, "strong")]);
+const blank: Line = [s("")];
+const dash = (value: unknown) => value === undefined || value === null || value === "" ? "-" : String(value);
+const ids = (values: unknown) => list(values).map(id => `#${id}`).join(" ") || "none";
+const when = (at: unknown, now: number) => typeof at === "number" && Number.isFinite(at) ? moment(at, now) : "-";
+const STATE_TONE: Record<string, Tone> = { approved: "success", in_review: "attention", in_progress: "info", proposed: "muted", backlog: "muted", cancelled: "muted", blocked: "failure" };
+const stateTone = (state: unknown): Tone | undefined => typeof state === "string" ? STATE_TONE[state] : undefined;
+const isStub = (task: any) => task?.title === "[pii]" && task?.detail === "[pii]";
+
+/** The first task of a result: a stub when the hub withheld it, which says so in one line and points at the console. */
+function stubNote(task: any, columns: number | undefined): Line[] {
+  return isStub(task) ? [blank, ...para(`private task: the title, detail, paths and plan are withheld here. Read it where it is allowed: \`ahub task show ${task.id}\` in a console terminal.`, columns, "muted")] : [];
+}
+const planBlock = (plan: any, columns: number | undefined): Line[] => {
+  const keys = ["paths", "symbols", "signatures", "insertion_points", "sections", "sources", "claims"];
+  return keys.flatMap(key => bullets(key.replace("_", " "), list(plan?.[key]), columns, undefined, "  "));
+};
+const historyRows = (history: any[], now: number): Span[][] => history.map(entry => [s(when(entry.at, now), "muted"), s(entry.by ?? "-"), s(entry.event ?? "-", entry.event === "approved" ? "success" : entry.event === "changes_requested" ? "attention" : undefined), s(dash(entry.note))]);
+
+/** The one task block: identity, who holds it, what it waits for, then plan, receipt and history. */
+function taskBlock(task: any, columns: number | undefined, now: number, detail: boolean): Line[] {
+  const id = `#${task?.id ?? "?"}`;
+  const out: Line[] = [...para(`${id}  ${dash(task?.title)}`, columns, undefined, "", 6).map((line, i): Line => i === 0 ? [s(id, "taskRef"), s(line[0]!.text.slice(id.length), "strong")] : line)];
+  const w = 10;
+  out.push(...pair("state", `${dash(task?.state)}${task?.cancelled ? " (cancelled)" : ""}`, columns, w, stateTone(task?.state), "  "),
+    ...pair("class", dash(task?.class), columns, w, undefined, "  "), ...pair("owner", dash(task?.owner), columns, w, undefined, "  "), ...pair("reviewer", dash(task?.reviewer), columns, w, undefined, "  "));
+  if (task?.planner) out.push(...pair("planner", task.planner, columns, w, undefined, "  "));
+  if (task?.reserved) out.push(...pair("reserved", task.reserved, columns, w, undefined, "  "));
+  out.push(...pair("after", ids(task?.deps), columns, w, undefined, "  "));
+  if (typeof task?.release === "number") out.push(...pair("release", `#${task.release}`, columns, w, undefined, "  "));
+  if (typeof task?.rank === "number" || typeof task?.priority === "number") out.push(...pair("planning", [typeof task.rank === "number" ? `rank ${task.rank}` : "", typeof task.priority === "number" ? `priority P${task.priority}` : "", task.pinned ? "pinned" : ""].filter(Boolean).join(", "), columns, w, undefined, "  "));
+  // The operands the next command needs: backlog plan|pin|split|pull-ready|undo take the planning revision (0 on an unedited card),
+  // task cancel and assign --revision take the flow revision. A person must not have to switch to --json to read them.
+  if (task?.state === "backlog" || typeof task?.planningRevision === "number") out.push(...pair("planning rev", count(task?.planningRevision ?? 0), columns, w, undefined, "  "));
+  if (typeof task?.flowRevision === "number") out.push(...pair("flow rev", count(task.flowRevision), columns, w, undefined, "  "));
+  out.push(...pair("created", when(task?.created, now), columns, w, undefined, "  "), ...pair("updated", when(task?.updated, now), columns, w, undefined, "  "));
+  if (!detail) return out;
+  out.push(...stubNote(task, columns));
+  if (!isStub(task) && task?.detail) out.push(blank, [s("detail", "muted")], ...para(String(task.detail), columns, undefined, "  ", 2));
+  const refs = task?.refs ?? {};
+  const refText = [refs.repo, refs.branch ? `branch ${refs.branch}` : "", refs.commit ? `commit ${short(refs.commit)}` : ""].filter(Boolean).join(", ");
+  if (refText) out.push(blank, ...pair("refs", refText, columns, w, undefined, "  "));
+  out.push(...bullets("ref paths", list(refs.paths), columns, undefined, "  "));
+  const plan = planBlock(task?.plan, columns);
+  if (plan.length) out.push(blank, [s("plan", "muted")], ...plan);
+  const sdlc = task?.sdlc;
+  if (sdlc) out.push(blank, ...pair("lifecycle", [sdlc.stage ? `stage ${sdlc.stage}` : "", sdlc.repo && sdlc.issue ? `${sdlc.repo}#${sdlc.issue}` : "", sdlc.pr ? `PR #${sdlc.pr}` : "", sdlc.head ? `head ${short(sdlc.head)}` : ""].filter(Boolean).join(", ") || "recorded", columns, w, undefined, "  "));
+  if (task?.relatedMemory) out.push(...pair("memory", `${task.relatedMemory.state}${typeof task.relatedMemory.count === "number" ? `, ${plural(task.relatedMemory.count, "related note")}` : ""}`, columns, w, undefined, "  "));
+  // Tasks.symbolOverlaps: { task, files, sameFileDifferentSymbols } per overlapping task, public file names only.
+  if (list(task?.symbolOverlaps).length) out.push(...bullets("overlaps", list(task.symbolOverlaps).map((o: any) => `#${o?.task ?? "?"} touches ${list(o?.files).join(", ") || "files withheld"}${o?.sameFileDifferentSymbols ? " (same file, different symbols)" : ""}`), columns, "attention", "  "));
+  // Tasks.deliverableStatus: { state, changedSinceReview, files: [{ id, sha256, state, path?, format, version?, private? }] }.
+  const delivered = task?.deliverables;
+  if (delivered) {
+    out.push(blank, ...pair("deliverables", `${dash(delivered.state)}${delivered.changedSinceReview ? ", changed since review" : ""}`, columns, w, delivered.changedSinceReview ? "attention" : undefined, "  "));
+    out.push(...grid(["FILE", "FORMAT", "STATE", "SHA256"], list(delivered.files).map((file: any) => [s(file.private ? "(private)" : dash(file.path ?? file.id)), s(`${dash(file.format)}${file.version ? ` ${file.version}` : ""}`), s(dash(file.state), file.state === "changed" || file.state === "missing" ? "attention" : undefined), s(short(file.sha256))]), columns));
+  }
+  const reviews = list(task?.reviews);
+  if (reviews.length) out.push(blank, [s("reviews", "muted")], ...grid(["KIND", "REVIEWER", "AT"], reviews.map((r: any) => [s(r.kind, r.kind === "approved" ? "success" : "attention"), s(r.reviewer), s(when(r.at, now), "muted")]), columns));
+  const history = list(task?.history);
+  if (history.length) out.push(blank, [s(`history (${plural(history.length, "entry")}${typeof task?.flowRevision === "number" && task.flowRevision > history.length ? `, last ${history.length} shown` : ""})`, "muted")], ...grid(["AT", "BY", "EVENT", "NOTE"], historyRows(history, now), columns));
+  return out;
+}
+
+/** `ahub task show <id>`: the full block. A task that does not exist arrives as a JSON string and prints as that sentence. */
+export function renderTaskShow(task: unknown, columns?: number, now = Date.now()): Span[][] {
+  if (typeof task === "string") return para(task, columns);
+  return taskBlock(task, columns, now, true);
+}
+
+/** `ahub task cancel`: the cancelled task, with who superseded it and why. */
+export function renderTaskCancel(task: unknown, columns?: number, now = Date.now()): Span[][] {
+  const t = task as any;
+  const out = [...heading(`Task #${t?.id ?? "?"} cancelled`, columns), ...taskBlock(t, columns, now, false)];
+  const c = t?.cancelled;
+  if (c) out.push(...pair("reason", dash(c.reason), columns, 10, undefined, "  "), ...(c.supersededBy ? pair("superseded", String(c.supersededBy), columns, 10, undefined, "  ") : []));
+  return out;
+}
+
+const BACKLOG_HEAD: Record<string, string> = { plan: "Backlog card planned", pin: "Backlog card pinned", "return-untouched": "Task returned to the backlog", "pull-ready": "Backlog card pulled and routed", undo: "Planning change undone", split: "Backlog card split" };
+/** The backlog mutations: the card as the hub now holds it; a split shows its parent and each child. */
+export function renderBacklogResult(op: keyof typeof BACKLOG_HEAD, result: unknown, columns?: number, now = Date.now()): Span[][] {
+  const r = result as any;
+  const out: Line[] = [...heading(BACKLOG_HEAD[op] ?? "Backlog", columns)];
+  if (op === "split") {
+    out.push(...taskBlock(r?.parent, columns, now, false));
+    const children = list(r?.children);
+    out.push(blank, [s(`${plural(children.length, "child card")}`, "muted")], ...grid(["ID", "STATE", "AFTER", "TITLE"], children.map((c: any) => [s(`#${c.id}`, "taskRef"), s(dash(c.state), stateTone(c.state)), s(ids(c.deps)), s(dash(c.title))]), columns));
+    return out;
+  }
+  out.push(...taskBlock(r, columns, now, false), ...stubNote(r, columns));
+  const last = list(r?.history).at(-1);
+  if (last?.note) out.push(...pair("note", String(last.note), columns, 10, "muted", "  "));
+  return out;
+}
+
+const GROOM_TEXT: Record<string, string> = { "text-dependency": "text names a dependency the card does not declare", overlap: "overlaps other open work", duplicate: "may duplicate another card", "over-wip": "its owner is over the WIP limit", stale: "has not moved for a long time", superseded: "was superseded", blocked: "cannot be routed", "closed-issue": "its issue is closed" };
+/** `ahub backlog groom`: what the planner would look at, one line per finding. */
+export function renderGroom(digest: unknown, columns?: number, _now = Date.now()): Span[][] {
+  const d = digest as any;
+  const items = list(d?.items);
+  const out: Line[] = [...heading("Backlog grooming", columns)];
+  if (!items.length) out.push([s("nothing to groom", "muted")]);
+  else out.push(...grid(["TASK", "FINDING", "RELATED", "CODE"], items.map((i: any) => [s(`#${i.task}`, "taskRef"), s(GROOM_TEXT[i.kind] ?? String(i.kind)), s(i.related?.length ? ids(i.related) : "-"), s(dash(i.code), "muted")]), columns));
+  for (const item of items) if (item.personCommand) out.push(...pair(`#${item.task}`, String(item.personCommand), columns, 6, "info", ""));
+  if (list(d?.unknown).length) out.push(blank, ...pair("unknown", `${ids(d.unknown)}: not enough evidence to judge`, columns, 8, "attention"));
+  if (d?.truncated) out.push(...para("truncated: the board has more cards than one grooming pass reads", columns, "attention"));
+  if (d?.privateTasks === "withheld") out.push(...para("private tasks are withheld", columns, "muted"));
+  return out;
+}
+
+const RELEASE_TONE: Record<string, Tone> = { active: "success", frozen: "attention", shipped: "muted", dropped: "muted", planned: "info" };
+function releaseBlock(row: any, columns: number | undefined, now: number): Line[] {
+  const w = 14, out: Line[] = [...para(`#${row?.id ?? "?"}  ${dash(row?.name)}`, columns, undefined, "", 6).map((line, i): Line => i === 0 ? [s(`#${row?.id ?? "?"}`, "issueRef"), s(line[0]!.text.slice(`#${row?.id ?? "?"}`.length), "strong")] : line)];
+  out.push(...pair("state", dash(row?.state), columns, w, RELEASE_TONE[row?.state], "  "), ...pair("goal", dash(row?.goal), columns, w, undefined, "  "), ...pair("order", count(row?.order), columns, w, undefined, "  "), ...pair("revision", count(row?.revision), columns, w, undefined, "  "));
+  out.push(...pair("planned start", when(row?.plannedStart, now), columns, w, undefined, "  "), ...pair("cut", when(row?.cut, now), columns, w, undefined, "  "), ...pair("ship", when(row?.ship, now), columns, w, undefined, "  "));
+  const tasks = list(row?.tasks);
+  out.push(...pair("scope", tasks.length ? `${plural(tasks.length, "task")}: ${tasks.map((t: any) => `#${t.id} ${t.state}`).join(", ")}` : "no task assigned", columns, w, undefined, "  "));
+  if (row?.afterCut !== undefined && row?.afterCut !== null) out.push(...pair("after the cut", `${count(row.afterCutCount)} approved outside this release: ${ids(row.afterCut)}${row.afterCutCount > list(row.afterCut).length ? " and more" : ""}`, columns, w, row.afterCutCount ? "attention" : undefined, "  "));
+  if (row?.afterCutUnknownCount) out.push(...pair("unknown date", `${count(row.afterCutUnknownCount)} approved without a recorded date: ${ids(row.afterCutUnknown)}`, columns, w, "attention", "  "));
+  if (row?.train) out.push(...pair("train", `${yes(row.train.active)} active${row.train.hotfix ? `, hotfix ${row.train.hotfix}` : ""}`, columns, w, undefined, "  "));
+  return out;
+}
+/** `ahub release list`: one block per release, in order. */
+export function renderReleaseList(rows: unknown, columns?: number, now = Date.now()): Span[][] {
+  const releases = list(rows);
+  if (!releases.length) return [[s("no releases")]];
+  return releases.flatMap((row, i): Line[] => [...(i ? [blank] : []), ...releaseBlock(row, columns, now)]);
+}
+/** `ahub release show <name>` and the result of `release new|plan|activate|freeze|ship|drop`: the release as the hub holds it. */
+export function renderReleaseShow(row: unknown, columns?: number, now = Date.now()): Span[][] {
+  if (typeof row === "string") return para(row, columns);
+  return releaseBlock(row, columns, now);
+}
+export const renderReleaseChange = (row: unknown, columns?: number, now = Date.now()): Span[][] => [...heading("Release updated", columns), ...renderReleaseShow(row, columns, now)];
+export const renderReleaseNew = (row: unknown, columns?: number, now = Date.now()): Span[][] => [...heading("Release created", columns), ...renderReleaseShow(row, columns, now)];

package/src/cli/upgrade-output.ts

@@ -0,0 +1,57 @@
+// Human output for the commands #814 T3 converts: the non-interactive restart/upgrade plan, `recovery status`, and
+// `budget execution configure|disable`. Pure: data in, lines out. It only composes the renderers the interactive
+// screens already use (`planLines`, `renderPlan`, `renderOperation`, `renderBlocked`, `choiceInstruction`), so the
+// non-interactive text never says something the screens would not. `--json` is the caller's branch and prints the
+// document exactly as before.
+import { planLines } from "./upgrade-interactive.ts";
+import { choiceInstruction, renderBlocked, renderOperation, renderPlan, type RecoveryPresentationOptions } from "./upgrade-presentation.ts";
+import { paint, terminalText, wrap, type Span, type Tone } from "./console-state.ts";
+import { renderExecutionBudgetStatus } from "./output.ts";
+import type { NextChoice, RecoveryOperation, UpgradePlan } from "./upgrade.ts";
+
+const columnsOf = (options: RecoveryPresentationOptions) => Number.isFinite(options.columns) ? Math.max(2, Math.floor(options.columns)) : 80;
+const text = (value: string, tone: Tone, options: RecoveryPresentationOptions): string[] =>
+  wrap(terminalText(value), columnsOf(options)).map(line => paint([{ text: line, tone }], options.color));
+
+/**
+ * The plan `restart` or `upgrade` would apply, for a person reading a pipe or a `--dry-run`: the same rows the plan
+ * screen shows (a peer per line with how it runs and what happens to it), every blocker, and what the plan will not do.
+ * Blockers, reconnect-only sessions and fresh starts are part of the rows, so none of them is stderr-only any more.
+ */
+export function renderUpgradePlan(plan: UpgradePlan, current: string, options: RecoveryPresentationOptions): string[] {
+  const out = renderPlan(plan, current, options, planLines(plan, current));
+  const blocked = plan.blockers.length > 0 || plan.projects.some(project => project.blockers.length > 0);
+  if (!plan.projects.length) out.push(...text(plan.kind === "upgrade"
+    ? `No hub is running, so nothing is carried over: install with \`bun add -g @staix/agent-hub@${plan.version}\`, then \`ahub setup\`.`
+    : "This project's hub is not running: `ahub up` starts it.", "muted", options));
+  out.push(...text(blocked
+    ? "Blocked: take the next action each blocker names, then run this again. Nothing was changed."
+    : "Nothing was changed. Apply with `--yes`.", blocked ? "failure" : "muted", options));
+  return out;
+}
+
+/**
+ * `ahub recovery status [<id>]`: the receipt's step and projects, then what the person can do about it. A blocked
+ * operation also says what happened, why and what to do, exactly as the coordinator's screen does; the wait and
+ * resume choices come from `nextChoices`, never from this module.
+ */
+export function renderRecoveryStatus(op: RecoveryOperation, runner: number | "unknown" | undefined, choices: readonly NextChoice[], options: RecoveryPresentationOptions): string[] {
+  if (op.phase === "blocked") return [...renderOperation(op, runner, options), ...renderBlocked(op, choices, options)];
+  const out = renderOperation(op, runner, options);
+  if (op.phase !== "completed" && op.phase !== "cancelled") {
+    if (op.error) out.push(...text(`Recorded error: ${op.error.split("; next actions: ")[0]}`, "attention", options));
+    if (choices.length) out.push(...text("Next:", "strong", options));
+    for (const choice of choices) out.push(...text(`  ${choiceInstruction(op, choice, options)}`, choice.kind === "stop" || choice.kind === "fresh" ? "failure" : "info", options));
+  }
+  return out;
+}
+
+/**
+ * `ahub budget execution configure|disable`: the stored budget, or whether one was disabled. A configured budget is shown
+ * by the same renderer `budget execution status` uses, so its fields read identically before and after a change.
+ */
+export function renderBudgetResult(op: "configure" | "disable", result: unknown, columns?: number, now = Date.now()): Span[][] {
+  if (op === "configure") return [[{ text: "Execution budget configured", tone: "strong" }], ...renderExecutionBudgetStatus(result, columns, now).slice(1)];
+  const disabled = (result as { disabled?: unknown } | undefined)?.disabled === true;
+  return [[{ text: "Execution budget", tone: "strong" }], [{ text: disabled ? "Disabled: it no longer limits model calls." : "No matching execution budget; nothing was disabled.", tone: disabled ? "success" : "muted" }]];
+}

package/src/cli/upgrade.ts

@@ -143,8 +143,8 @@ export interface RecoveryOperation {
   /** Positive typed store observation; disposal rechecks it before accepting a repaired-session loss. */
   missingRecordedSession?: { projectId: string; peer: RecoveryNativePeer; sessionId: string; kind: "rollout" | "transcript"; checkedPath?: string };
   freshOverride?: { peer: RecoveryNativePeer; evidence: NonNullable<RecoveryOperation["missingRecordedSession"]>; checked: "missing"; at: number };
-  /** #215: every human disposition, in order. Operator reasons only; never task or message text. */
-  audit?: { at: number; action: "fresh-session" | "stop-and-archive"; reason: string; peer?: string; projects: string[] }[];
+  /** #215: every human disposition, in order. Operator reasons only; never task or message text. #776: `cause` is the operation's own `error` at that moment, the text the receipt already held. */
+  audit?: { at: number; action: "fresh-session" | "stop-and-archive"; reason: string; peer?: string; cause?: string; projects: string[] }[];
   disposition?: { choice: "stop-and-archive"; at: number; projects: Record<string, string>; continuity?: Record<string, "not-archived" | "unavailable"> };
   /** #215: a refusal no resume can get past was recorded (FinalRefusal); `next` no longer offers resume. */
   final?: boolean;
@@ -1070,7 +1070,8 @@ export async function disposeRecovery(id: string, choice: { fresh: string } | {
     delete op.blockedReattachment;
     delete op.presentationCause;
     abandoned(op); // #227: in the same write as the disposition
-    (op.audit ??= []).push({ at, action: "stop-and-archive", reason, projects: acts.map((a) => a.planned.project.id) });
+    // #776: the error that blocked the operation is cleared on disposal, so the audit keeps it.
+    (op.audit ??= []).push({ at, action: "stop-and-archive", reason, ...(op.error ? { cause: op.error } : {}), projects: acts.map((a) => a.planned.project.id) });
     // Recorded before the first act: a crash inside a stop leaves a disposition that resume refuses to override.
     delete op.failure;
     op.updatedAt = driver.now(); writeOperation(id, op, home);

package/src/hub/board.ts

@@ -339,6 +339,23 @@ export class Board {
     return row.n;
   }
 
+  /**
+   * #784 AC3: what `plannerWip` counts, split per peer in ONE grouped query (no per-peer or per-task reads on the status hot path). `active` is owned work that is not
+   * waiting for review, `reviewWait` is owned work in `in_review`, `reserved` is unowned proposed work a planner pull reserved. For every peer the three add up to
+   * `plannerWip(peer)`: this is a read-only view, admission keeps using `plannerWip` unchanged.
+   */
+  plannerWipBreakdown(): Record<string, { active: number; reviewWait: number; reserved: number }> {
+    const rows = this.db.query(`SELECT peer, kind, COUNT(*) AS n FROM (
+      SELECT owner AS peer, CASE WHEN state = 'in_review' THEN 'reviewWait' ELSE 'active' END AS kind FROM tasks WHERE state NOT IN ('approved', 'cancelled', 'backlog') AND owner IS NOT NULL
+      UNION ALL
+      SELECT reserved AS peer, 'reserved' AS kind FROM tasks WHERE state = 'proposed' AND owner IS NULL AND reserved IS NOT NULL AND
+        json_extract((SELECT value FROM json_each(tasks.history) WHERE json_extract(value, '$.event') IN ('backlog pulled', 'backlog returned') ORDER BY CAST(key AS INTEGER) DESC LIMIT 1), '$.planning.pull') = 1
+    ) GROUP BY peer, kind`).all() as { peer: string; kind: "active" | "reviewWait" | "reserved"; n: number }[];
+    const result: Record<string, { active: number; reviewWait: number; reserved: number }> = {};
+    for (const row of rows) (result[row.peer] ??= { active: 0, reviewWait: 0, reserved: 0 })[row.kind] = row.n;
+    return result;
+  }
+
   recordTaskOffer(id: number, offer: TaskOffer, expectedFlowRevision: number): void {
     const task = this.get(id);
     if (!task || task.owner !== offer.owner || isClosedTaskState(task.state) || task.history.length !== expectedFlowRevision || offer.assignmentFlowRevision !== expectedFlowRevision) throw new Error("task offer changed");