@staix/agent-hub 0.12.45 → 0.14.0

package/src/cli/console-state.ts

@@ -7,6 +7,9 @@ import { taskProgress } from "../ui/task-progress.ts";
 import type { ProgressStage } from "../ui/task-progress.ts";
 import { sanitize } from "../hub/envelope.ts";
 import type { SettingRow, SettingValue } from "../hub/settings.ts";
+import { symbolFields, overlapFields } from "./console-symbols.ts";
+import { choicePrompt, reviewChoiceFor, reviewHint, reviewRefusal, verdictGuide, verdictInput, type ReviewChoice, type Verdict } from "./console-review.ts";
+import { USAGE_DROP, USAGE_HEAD, usageCells, usageDetail, usagePeers, usageTaskLines, type UsageState } from "./console-usage.ts";
 
 export interface Approval {
   id: string; peer: string; title: string; expiresAt: number;
@@ -45,10 +48,16 @@ export interface ConsoleState {
   tasks: any[]; tasksKnown?: boolean; taskCounts?: Record<string, number>; queue: any[]; detail?: Detail; detailOffset: number; help: boolean; notice: string; noticeAt?: number; noticeTone?: Tone;
   peerFilter?: string; kindFilter?: string; project?: string;
   taskSelection?: number; queueSelection?: string;
+  /** #683 U3: the Usage panel (7): what the `usage` op last answered, and the task that was selected in Tasks when the panel was opened. */
+  usage?: UsageState; usageTask?: number;
   actionLock?: { prefix: string[]; id: string; revision: number; state: string; owner?: string; reserved?: string; reviewer?: string; waiting?: boolean; syntax?: "planning" | "ownerless-return"; revisionField?: "planningRevision" | "flowRevision" };
   confirm?: { type: "permission"; id: string; option: string; peer: string } | { type: "command"; args: string[]; prompt?: string; lock?: ConsoleState["actionLock"] } | { type: "permission_default"; peer: string; source: string };
   optionChoice?: string;
   modeChoice?: string;
+  /** #711: `r` on a task in review opens this choice (a approve, c request changes) the way `m` opens the permission-mode choice. */
+  reviewChoice?: ReviewChoice;
+  /** The guide line above the input after a verdict was chosen; it goes with the input line. */
+  reviewGuide?: string;
   permissionDefaults: PermissionDefault[];
   permissionDefaultsHandled: string[];
 }
@@ -84,7 +93,7 @@ export function syncPermissionDefaults(s: ConsoleState, rows: unknown): boolean
   s.permissionDefaultsHandled = s.permissionDefaultsHandled.filter(fingerprint => current.has(fingerprint));
   const pending = s.confirm;
   if (pending?.type === "permission_default" && !s.permissionDefaults.some(row => row.peer === pending.peer && row.source === pending.source)) s.confirm = undefined;
-  if (s.settingsEdit || s.confirm || s.editing || s.input || s.modeChoice || s.optionChoice || s.help) return false;
+  if (s.settingsEdit || s.confirm || s.editing || s.input || s.modeChoice || s.reviewChoice || s.optionChoice || s.help) return false;
   const next = s.permissionDefaults.find(row => !s.permissionDefaultsHandled.includes(permissionDefaultFingerprint(s, row)));
   if (!next) return false;
   s.confirm = { type: "permission_default", peer: next.peer, source: next.source };
@@ -310,8 +319,19 @@ function fieldLines(fields: [string, unknown][], columns: number, now: number):
     });
   });
 }
-const detailLines = (detail: Detail, columns: number, now: number): Span[][] =>
-  typeof detail === "string" ? wrap(detail, columns).map(text => [span(text)]) : fieldLines(Object.entries(detail), columns, now).flat();
+/**
+ * A task opened from Tasks also gets its "changed symbols" (#684 2b), after its plan so the two read together; a private task gets none. `codeSymbols` is the hub's
+ * raw observation and `symbolOverlaps` is the hub pair projection; formatted blocks replace both raw fields.
+ */
+function taskFields(detail: Record<string, unknown>): [string, unknown][] {
+  const fields = Object.entries(detail).filter(([key]) => key !== "codeSymbols" && key !== "symbolOverlaps");
+  const block = [...symbolFields(detail), ...overlapFields(detail)];
+  if (!block.length) return fields;
+  const at = fields.findIndex(([key]) => key === "plan");
+  return at < 0 ? [...fields, ...block] : [...fields.slice(0, at + 1), ...block, ...fields.slice(at + 1)];
+}
+const detailLines = (detail: Detail, columns: number, now: number, task = false): Span[][] =>
+  typeof detail === "string" ? wrap(detail, columns).map(text => [span(text)]) : fieldLines(task ? taskFields(detail) : Object.entries(detail), columns, now).flat();
 const allowOptions = (a: Approval) => a.options.filter(o => o.kind.startsWith("allow"));
 /** A pushed request as the console keeps it: every agent-supplied field a string, so no draw can throw on one. */
 export function approvalFrom(msg: any): Approval {
@@ -341,10 +361,11 @@ const KEYS: [string, string[]][] = [
   ["Panels", ["1-5 panel", "Left/Right panel", "j/k or Up/Down move", "Home/< first, End/> last", "Enter view", "j/k scroll a view", "w web UI (outside Peers)", "o pet window"]],
   ["Approvals", ["a allow (then y)", "d deny", "v view", "[ ] select"]],
   ["Peers", ["p pause", "r resume", "m permission mode", "w WIP limit", "l make planner (then y)"]],
-  ["Tasks", ["b backlog/open", "n add backlog", "a assign/reserve (then y)", "u unassign (then y)", "r review (in review)", "p pull, e plan (backlog)", "R return to backlog", "c cancel (then y)"]],
-  ["Queue", ["r resolve (reason, then y)", "queued=discard, needs_review=retry"]],
+  ["Tasks", ["b backlog/open", "n add backlog", "a assign/reserve (then y)", "u unassign (then y)", "r approve or request changes (in review; a or c, then a note)", "p pull, e plan (backlog)", "R return to backlog", "c cancel (then y)"]],
+  ["Queue", ["r resolve (reason, then y)", "queued=discard, needs_review=retry", "D discard the peer's whole queued backlog (reason, then y)"]],
   ["Events", ["f peer filter", "g kind filter"]],
   ["Settings", ["6 Settings panel", "e edit", "u undo", "preview, reason, then y"]],
+  ["Usage", ["7 Usage panel", "Enter view a peer", "tokens today/7d/lifetime with sources", "task from Tasks (3)"]],
 ];
 /** The `?` key table: one group per panel, its keys kept whole and packed into the width after the group column. */
 export function keyTable(columns: number, attention = false, characters = false): Span[][] {
@@ -395,7 +416,7 @@ export function parseConsoleCommand(input: string): string[] {
 }
 export function commandNeedsConfirmation(args: string[]): boolean {
   const positional = args.filter(arg => arg !== "--yes");
-  return (args[0] === "backlog" && args[1] !== "list") || (args[0] === "task" && args[1] === "propose" && args.includes("--backlog")) || (positional[0] === "permission" && positional[2] === "never-ask") || (args[0] === "task" && ["assign", "unassign", "cancel"].includes(args[1] ?? "")) || (args[0] === "queue" && args[1] === "resolve") || (args[0] === "permit" && args[2] !== "deny");
+  return (args[0] === "backlog" && args[1] !== "list") || (args[0] === "task" && args[1] === "propose" && args.includes("--backlog")) || (positional[0] === "permission" && positional[2] === "never-ask") || (args[0] === "task" && ["assign", "unassign", "cancel"].includes(args[1] ?? "")) || (args[0] === "queue" && (args[1] === "resolve" || args[1] === "discard")) || (args[0] === "permit" && args[2] !== "deny");
 }
 export function panelRows(s: ConsoleState): any[] {
   if (s.panel === 1) return Object.entries(s.peers).map(([id, peer]) => ({ id, ...peer, budget: s.budget[id] }));
@@ -406,6 +427,7 @@ export function panelRows(s: ConsoleState): any[] {
     return s.tasks.filter(t => states.includes(t.state)).sort((a, b) => states.indexOf(a.state) - states.indexOf(b.state));
   }
   if (s.panel === 6) return [...(s.settingsRows ?? [])].sort((a, b) => a.group.localeCompare(b.group) || a.key.localeCompare(b.key));
+  if (s.panel === 7) return usagePeers(s.usage, s.budget, s.peers);
   if (s.panel === 4) return s.queue.filter(q => q.state === "needs_review" || q.state === "queued");
   return s.events.filter(e => (!s.peerFilter || e.peer === s.peerFilter) && (!s.kindFilter || e.kind === s.kindFilter));
 }
@@ -462,7 +484,7 @@ function lockedCommandPrompt(lock: NonNullable<ConsoleState["actionLock"]>, args
   return `unassign ${role} ${affected} on task #${lock.id} at revision ${lock.revision} -> ${resulting}${guidance}; native work and uncertain deliveries are not stopped or resolved`;
 }
 export function reduceConsole(state: ConsoleState, key: string, now = Date.now()): { state: ConsoleState; effects: ConsoleEffect[] } {
-  const attentionKeyBlocked = !!(state.settingsEdit || state.confirm || state.optionChoice || state.modeChoice || state.help || state.editing || state.input);
+  const attentionKeyBlocked = !!(state.settingsEdit || state.confirm || state.optionChoice || state.modeChoice || state.reviewChoice || state.help || state.editing || state.input);
   // A notice answers the key before this one; one that pruning raises now stays.
   let s = pruneApprovals({ ...state, notice: "" }, now); const effects: ConsoleEffect[] = [];
   const done = () => ({ state: bound(s), effects });
@@ -533,19 +555,47 @@ export function reduceConsole(state: ConsoleState, key: string, now = Date.now()
     }
     return done();
   }
+  if (s.reviewChoice) {
+    const choice = s.reviewChoice;
+    if (key === "\x1b") { s.reviewChoice = undefined; return done(); }
+    const verdict: Verdict | undefined = key === "a" ? "approved" : key === "c" ? "changes_requested" : undefined;
+    if (verdict) {
+      s.reviewChoice = undefined;
+      // The task may have left review while the choice was open: say so instead of prefilling a command the hub will refuse.
+      const current = s.tasks.find(task => task.id === choice.id);
+      if (current && current.state !== "in_review") notify(s, `#${choice.id} is no longer in review (${current.state})`, now);
+      else { s.input = verdictInput(choice.id, verdict); s.reviewGuide = verdictGuide(choice.id, verdict); s.editing = true; }
+    }
+    return done();                                                                            // any other key leaves the choice open
+  }
   if (s.help && s.mode === "panels" && !["?", "\x1b", "q"].includes(key)) return done(); // the key table is modal
   if (s.editing || s.input) {
-    if (key === "\x1b") { s.input = ""; s.editing = false; s.actionLock = undefined; }
+    if (key === "\x1b") { s.input = ""; s.editing = false; s.actionLock = undefined; s.reviewGuide = undefined; }
     else if (key === "\x7f" || key === "\b") s.input = Array.from(s.input).slice(0, -1).join("");
     else if (key === "\x15") s.input = "";
     else if (key === "\x1b[A" || key === "\x1b[B") {
       s.historyIndex = Math.max(0, Math.min(s.history.length, s.historyIndex + (key === "\x1b[A" ? -1 : 1)));
       s.input = s.history[s.historyIndex] ?? "";
     } else if (key === "\r" || key === "\n") {
-      const input = s.input, lock = s.actionLock; s.input = ""; s.editing = false; s.actionLock = undefined;
+      const input = s.input, lock = s.actionLock; s.input = ""; s.editing = false; s.actionLock = undefined; s.reviewGuide = undefined;
       if (!input.trim()) return done();
       try {
         const parsed = parseConsoleCommand(input);
+        if (parsed[0] === "queue" && parsed[1] === "discard") {
+          const reasonAt = parsed.indexOf("--reason"), peer = commandFlag(parsed, "--peer"), state = commandFlag(parsed, "--state") ?? "queued";
+          // The reason is every word after --reason up to the next flag, so a reason typed without quotes ("agy backlog") is whole, not cut to its first word.
+          const words: string[] = [];
+          for (let i = reasonAt + 1; reasonAt >= 0 && i < parsed.length && !parsed[i]!.startsWith("--"); i++) words.push(parsed[i]!);
+          const reason = words.join(" ").trim();
+          if (!peer || !reason) throw new Error("queue discard needs --peer and --reason (it is recorded on every discarded delivery)");
+          const count = s.queue.filter(row => row.peer === peer && row.state === state).length;
+          const args = ["queue", "discard", "--peer", peer, ...(parsed.includes("--state") ? ["--state", state] : []), "--reason", reason, "--yes"];
+          s.history = [...s.history, input].slice(-100); s.historyIndex = s.history.length;
+          s.confirm = { type: "command", args, prompt: `discard all ${count} ${state} deliver${count === 1 ? "y" : "ies"} of ${peer}; no task or native turn is cancelled, other peers are untouched` };
+          return done();
+        }
+        const reviewProblem = reviewRefusal(parsed);                                           // an empty changes note never reaches the hub (#711)
+        if (reviewProblem) throw new Error(reviewProblem);
         const args = parsed[0] === "permission" ? [...parsed.filter(arg => arg !== "--yes"), ...(parsed.includes("--yes") ? ["--yes"] : [])] : parsed;
         if (args[0] === "queue" && args[1] === "resolve") {
           const reason = args.indexOf("--reason"), action = commandFlag(args, "--action");
@@ -614,11 +664,15 @@ export function reduceConsole(state: ConsoleState, key: string, now = Date.now()
   }
   if (key === "\t") { s.mode = s.mode === "panels" ? "stream" : "panels"; s.detail = undefined; s.requestDetail = undefined; return done(); }
   if (key === ":") { s.editing = true; return done(); }
-  const switchPanel = (panel: number) => { s.panel = panel; s.selection = panel === 5 ? newestEvent(s) : 0; s.taskSelection = undefined; s.queueSelection = undefined; s.detail = undefined; s.requestDetail = undefined; return done(); };
-  if (s.mode === "panels" && /^[1-6]$/.test(key) && !s.optionChoice) return switchPanel(Number(key));
+  const switchPanel = (panel: number) => {
+    // The task selected in Tasks is the one the Usage panel shows; switchPanel clears that selection, so it is read first (#683 U3).
+    // With no valid selected row (an empty Tasks panel) the old task is cleared, never kept: the panel must not show a task that is no longer the selection.
+    if (panel === 7 && s.panel === 3) { const task = selectedPanelRow(s); s.usageTask = task && Number.isSafeInteger(Number(task.id)) && Number(task.id) > 0 ? Number(task.id) : undefined; }
+    s.panel = panel; s.selection = panel === 5 ? newestEvent(s) : 0; s.taskSelection = undefined; s.queueSelection = undefined; s.detail = undefined; s.requestDetail = undefined; return done(); };
+  if (s.mode === "panels" && /^[1-7]$/.test(key) && !s.optionChoice) return switchPanel(Number(key));
   // Right and Left are the digit of the next or previous tab, wrapping at both ends (#309); the same guards as the
   // digits apply (the confirm, mode-choice, key-table and editing branches above returned already).
-  if (s.mode === "panels" && (key === "\x1b[C" || key === "\x1b[D") && !s.optionChoice) return switchPanel(s.panel === 6 ? key === "\x1b[C" ? 1 : 5 : (s.panel + (key === "\x1b[C" ? 0 : 3)) % 5 + 1);
+  if (s.mode === "panels" && (key === "\x1b[C" || key === "\x1b[D") && !s.optionChoice) return switchPanel(s.panel >= 6 ? key === "\x1b[C" ? 1 : 5 : (s.panel + (key === "\x1b[C" ? 0 : 3)) % 5 + 1);
   if (s.mode === "panels" && s.panel === 1 && key === "w") {
     const peer = selectedPanelRow(s)?.id;
     if (!peer || s.detail !== undefined) { notify(s, "select a peer row to edit its planner WIP limit", now); return done(); }
@@ -702,6 +756,7 @@ export function reduceConsole(state: ConsoleState, key: string, now = Date.now()
   if (s.mode === "panels" && row && s.detail === undefined && (key === "\r" || key === "\n")) {
     if (s.panel === 3 || s.panel === 4) effects.push({ type: "show", panel: s.panel, id: String(row.id) });
     else if (s.panel === 2) { s.requestDetail = row.id; s.detailOffset = 0; } // the row is the selected request
+    else if (s.panel === 7) { s.detail = { usagePeer: row.id }; s.detailOffset = 0; } // rendered live from s.usage, so a refresh updates it
     else { s.detail = s.panel === 5 ? String(row.text) : { ...row }; s.detailOffset = 0; }
     return done();
   }
@@ -732,8 +787,13 @@ export function reduceConsole(state: ConsoleState, key: string, now = Date.now()
       else s.confirm = { type: "command", args: ["settings", "set", "planner", peer], prompt: `make ${peer} the planner` };
       return done();
     }
-    const prefill = s.panel === 1 && key === "p" ? `pause ${item}` : s.panel === 1 && key === "r" ? `resume ${item}` :
-      s.panel === 3 && key === "r" && selected.state === "in_review" ? `review ${item} ` : undefined;
+    // #711: `r` on a task in review asks which verdict first, from the row or from the open detail, so the person is never left to guess the next word.
+    if (s.panel === 3 && key === "r" && selected.state === "in_review") {
+      const choice = reviewChoiceFor({ ...selected, reviewer: selected.reviewer ?? s.tasks.find(task => task.id === item)?.reviewer, signals: selected.signals ?? s.tasks.find(task => task.id === item)?.signals });
+      if (choice) s.reviewChoice = choice;
+      return done();
+    }
+    const prefill = s.panel === 1 && key === "p" ? `pause ${item}` : s.panel === 1 && key === "r" ? `resume ${item}` : undefined;
     if (prefill) { s.input = prefill; s.editing = true; return done(); }
     if (s.panel === 3 && key === "c") {
       if (!s.features?.includes("task_cancel")) { notify(s, "task cancellation requires a newer hub", now); return done(); }
@@ -754,6 +814,12 @@ export function reduceConsole(state: ConsoleState, key: string, now = Date.now()
       s.input = key === "a" ? `task assign ${item} ${role === "reviewer" ? "--role reviewer " : ""}--revision ${revision} ` : `task unassign ${item} --role ${role} --revision ${revision}`;
       s.editing = true; return done();
     }
+    // #713: D clears the whole queued backlog of the selected row's peer. Nothing runs until a reason is typed and y confirms the count.
+    if (s.panel === 4 && key === "D") {
+      const peer = String(selected.peer ?? "");
+      if (!/^[a-z][a-z0-9-]{0,31}$/.test(peer)) return done();
+      s.input = `queue discard --peer ${peer} --reason `; s.editing = true; return done();
+    }
     if (s.panel === 4 && key === "r") {
       if (!["queued", "needs_review"].includes(selected.state)) return done();
       const revision = selected.revision;
@@ -787,6 +853,7 @@ export const TABLES: Record<number, string[]> = {
   3: ["ID", "STATE", "OWNER", "REVIEWER", "CLASS", "AGE", "TITLE", "STAGE"],
   4: ["ID", "PEER", "STATE", "REV", "AGE"],
   6: ["GROUP", "KEY", "VALUE", "SOURCE", "APPLIES"],
+  7: USAGE_HEAD,
 };
 const showPermissionModes = (s: ConsoleState) => Object.values(s.peers).some(peer => peer.permissionMode && peer.permissionMode !== "ask");
 const count = (n: unknown) => typeof n === "number" && n ? String(n) : "-";
@@ -810,6 +877,10 @@ export function cells(s: ConsoleState, row: any, selected: boolean, now: number,
       span(b?.windows?.length ? b.windows.map((w: any) => `${w.id} ${Math.round(w.used * 100)}%${typeof w.resetsAt === "number" ? ` ${relative(w.resetsAt, now)}` : ""}`).join(", ") : "-"),
       span(row.servedBy ?? row.requestedModel ?? "-")];
   }
+  if (s.panel === 7) {
+    const text = usageCells(s.usage, row.id, s.budget[row.id], at => relative(at, now));
+    return text.map((value, i) => i === 0 ? id(value, "info") : span(value, value === "-" || value === "unknown" || value === "no records" ? "muted" : i === 4 ? "attention" : undefined));
+  }
   if (s.panel === 2) return [id(row.id, "attention"), span(row.peer, "attention"), span(duration(row.expiresAt - now), "muted"), span(row.title)];
   if (s.panel === 3 && s.backlogView) {
     const waits = waitingDeps(s, row);
@@ -884,7 +955,7 @@ function taskHints(row: any): string[] {
   const review = row.state === "in_review";
   const hints = [review ? "a reviewer" : "a assign"];
   if (review ? row.reviewer : row.owner || row.reserved) hints.push("u unassign");
-  if (review) hints.push("r review");
+  if (review) hints.push(reviewHint(row.reviewer));
   if (["proposed", "in_progress"].includes(row.state)) hints.push("R return");
   return hints;
 }
@@ -894,7 +965,7 @@ function panelContext(s: ConsoleState, row: any): string[] {
   if (!row) return [];
   if (s.panel === 6) return ["e edit", ...(s.settingsUndo ? ["u undo"] : [])];
   if (s.panel === 1) return ["p pause", "r resume", "m permission mode", "w WIP limit"];
-  if (s.panel === 4) return [row.state === "queued" ? "r discard" : "r resolve"];
+  if (s.panel === 4) return [row.state === "queued" ? "r discard" : "r resolve"];       // D (the peer's whole backlog) is in the ? key table: it must not push j/k off an 80-column footer
   return [];
 }
 /** The footer's key hint: only keys that act in this mode, panel and state. */
@@ -903,7 +974,9 @@ function hint(s: ConsoleState, columns: number): string {
   if (s.mode === "stream") return [...pending, ...(pending.length ? ["v view"] : []), ...(s.approvals.length > (pending.length ? 1 : 0) ? ["[ ] select"] : []), "Tab panels", ": command", "? keys", "q quit"].join("  ");
   if (s.help) return "? or Esc close  q quit";
   const approvals = s.panel === 2 ? pending : [];
-  if (s.detail !== undefined || s.requestDetail) return [...approvals, "j/k scroll", "Esc back", "? keys", "q quit"].join("  ");
+  // An open task detail names the review action too (#711): the detail is where the person reads the task, so it is where they decide.
+  const shown = s.panel === 3 && s.detail && typeof s.detail === "object" && (s.detail as { state?: unknown }).state === "in_review" ? reviewHint((s.detail as { reviewer?: unknown }).reviewer) : undefined;
+  if (s.detail !== undefined || s.requestDetail) return [...approvals, ...(shown ? [shown] : []), "j/k scroll", "Esc back", "? keys", "q quit"].join("  ");
   const rows = panelRows(s); const row = selectedPanelRow(s);
   const text = [...approvals, ...panelContext(s, row), ...(s.panel === 5 ? ["f peer", "g kind"] : []), ...(rows.length ? ["j/k move"] : []), ...(row ? ["Enter view"] : []), "? keys", ": command", "Tab stream", "q quit"].join("  ");
   if (s.panel === 3 && Bun.stringWidth(text) > columns) {
@@ -918,14 +991,22 @@ function hint(s: ConsoleState, columns: number): string {
 /** The project, then the tabs: the active one in brackets, pending approvals and held deliveries counted. */
 function header(s: ConsoleState, columns: number): Span[] {
   const counts = [0, s.approvals.length, 0, s.queue.filter(q => q.state === "needs_review").length, 0];
-  const tabs: Span[] = [];
-  for (const [i, name] of ["Peers", "Approvals", "Tasks", "Queue", "Events", "Settings"].entries()) {
-    const active = i + 1 === s.panel; const tone = active ? "strong" : "info";
-    tabs.push(span(active ? " [" : "  ", tone), span(`${i + 1} ${name}`, tone));
-    if (counts[i]) tabs.push(span(` ${counts[i]}`, i === 1 ? "attention" : "failure"));
-    tabs.push(span(active ? "]" : " ", tone));
-  }
-  return fitLine([span(fit(s.project ?? "agent-hub", Math.max(0, columns - Bun.stringWidth(tabs.map(t => t.text).join("")))), "info"), ...tabs], columns);
+  const project = s.project ?? "agent-hub";
+  // Seven tabs fill an 80-column line, which would squeeze the project name out: below that, one space before a tab instead of two (#683 U3).
+  const build = (lead: string) => {
+    const tabs: Span[] = [];
+    for (const [i, name] of ["Peers", "Approvals", "Tasks", "Queue", "Events", "Settings", "Usage"].entries()) {
+      const active = i + 1 === s.panel; const tone = active ? "strong" : "info";
+      tabs.push(span(active ? lead.slice(1) + "[" : lead, tone), span(`${i + 1} ${name}`, tone));
+      if (counts[i]) tabs.push(span(` ${counts[i]}`, i === 1 ? "attention" : "failure"));
+      tabs.push(span(active ? "]" : " ", tone));
+    }
+    return tabs;
+  };
+  const width = (tabs: Span[]) => Bun.stringWidth(tabs.map(t => t.text).join(""));
+  let tabs = build("  ");
+  if (columns - width(tabs) < Math.min(Bun.stringWidth(project), 8)) tabs = build(" ");
+  return fitLine([span(fit(project, Math.max(0, columns - width(tabs))), "info"), ...tabs], columns);
 }
 /** The label column is the hub's own: a cut title or option list is marked `(more)` there; Enter shows it whole. */
 const more = (line: Span[], text?: string): Span[] => [span("(more)".padEnd(Bun.stringWidth(line[0]!.text)), "attention"), ...(text === undefined ? line.slice(1) : [span(text)])];
@@ -968,6 +1049,7 @@ export function renderConsoleLines(s: ConsoleState, columns: number, rows = 24,
     prompt = edit.phase === "value" ? `value for ${edit.key} (inherit removes): ${edit.text}` : edit.phase === "preview" ? "checking setting preview; Esc cancels" : edit.phase === "reason" ? `reason: ${edit.text}` : `${edit.undo ? "undo last setting" : `set ${edit.key}`} (${edit.reason})? y/N`;
   }
   if (s.modeChoice) prompt = `permission ${s.modeChoice}: 1 ask  2 ask-when-needed  3 never-ask  Esc cancel`;
+  if (s.reviewChoice) prompt = choicePrompt(s.reviewChoice);
   const choice = s.optionChoice ? s.approvals.find(a => a.id === s.optionChoice) : undefined;
   if (choice) prompt = `allow request ${choice.id} (${choice.peer}) with: ${allowOptions(choice).map((o, i) => `${i + 1} ${quoted(o.name)}`).join("  ")}  Esc cancel`;
   const summary: Span[] = [];
@@ -994,7 +1076,7 @@ export function renderConsoleLines(s: ConsoleState, columns: number, rows = 24,
   const defaultSource = s.confirm?.type === "permission_default" ? s.confirm.source : undefined;
   if (s.confirm?.type === "permission_default") prompt = `enable never-ask default for ${s.confirm.peer}? y/n Esc defer`;
   const footer = [fitLine(neverPeer ? [span(permissionBoundary(neverPeer, undefined, createProjectAdapterCatalog()), "attention")] : summary, columns),
-    fitLine(defaultSource !== undefined ? [span(`source ${quoted(defaultSource.split(/[\\/]/).at(-1))}; stays ask until y`, "attention")] : approvals, columns),
+    fitLine(defaultSource !== undefined ? [span(`source ${quoted(defaultSource.split(/[\\/]/).at(-1))}; stays ask until y`, "attention")] : s.editing && s.reviewGuide ? [span(s.reviewGuide, "info")] : approvals, columns),
     fitLine([span(prompt, s.confirm || s.optionChoice ? "attention" : undefined)], columns)];
   const rule = [span("-".repeat(Math.max(0, columns)), "muted")];
   if (s.mode === "stream") {
@@ -1020,7 +1102,9 @@ export function renderConsoleLines(s: ConsoleState, columns: number, rows = 24,
   }
   else if (s.help) lines.push(...keyTable(columns, !!s.petEnabled || !!s.petChoices?.length, !!s.petChoices?.length));
   else if (s.detail !== undefined || (s.requestDetail && permission)) {
-    const detail = s.detail !== undefined ? detailLines(s.detail, columns, now) : fieldLines(approvalFields(permission!), columns, now).flat();
+    const usagePeer = s.panel === 7 && s.detail && typeof s.detail === "object" ? (s.detail as { usagePeer?: unknown }).usagePeer : undefined;
+    const detail = typeof usagePeer === "string" ? fieldLines(Object.entries(usageDetail(s.usage, usagePeer, s.budget[usagePeer], at => relative(at, now))), columns, now).flat()
+      : s.detail !== undefined ? detailLines(s.detail, columns, now, s.panel === 3) : fieldLines(approvalFields(permission!), columns, now).flat();
     lines.push(...detail.slice(Math.min(s.detailOffset, Math.max(0, detail.length - height))));
   }
   else {
@@ -1031,10 +1115,15 @@ export function renderConsoleLines(s: ConsoleState, columns: number, rows = 24,
     const fits = Math.max(1, height - 5); // table header, one row, rule, one title line, deny
     if (allow.length > fits) allow.splice(fits - 1, Infinity, more(allow[0]!, `${plural(allow.length - fits + 1, "more option")}: Enter shows them all`));
     const tail = [...allow, ...deny];
-    const capacity = Math.max(1, s.panel === 2 ? Math.min(Math.floor(height / 2) - 1, height - 3 - tail.length) : height - (s.panel === 3 ? 2 : 1)); const start = Math.max(0, at - capacity + 1);
+    // The Usage panel's selected-task lines are reserved before the peer table is sized, so many peers can never push them off a short terminal (#683 U3).
+    // At most half the body goes to them; a longer list is cut with a count. The status line and the table header take the other two rows.
+    let taskLines = s.panel === 7 ? usageTaskLines(s.usage, s.usageTask) : [];
+    const taskRoom = Math.max(1, Math.floor(height / 2));
+    if (taskLines.length > taskRoom) taskLines = [...taskLines.slice(0, taskRoom - 1), { text: `  ... ${taskLines.length - taskRoom + 1} more`, tone: "muted" as const }];
+    const capacity = Math.max(1, s.panel === 2 ? Math.min(Math.floor(height / 2) - 1, height - 3 - tail.length) : s.panel === 7 ? height - 2 - taskLines.length : height - (s.panel === 3 ? 2 : 1)); const start = Math.max(0, at - capacity + 1);
     const stages = new Map(progress.stages.map(stage => [stage.id, stage]));
     const cellRows = head ? data.map((row, i) => cells(s, row, i === at, now, stages)) : [];
-    const rowsOf = head ? s.panel === 1 ? optionalTable(head, cellRows, columns) : s.panel === 3 && s.backlogView ? optionalTable(head, cellRows, columns, ["AGE", "CLASS", "DEPS", "PRI"]) : table(head, cellRows, columns) : undefined;
+    const rowsOf = head ? s.panel === 7 ? optionalTable(head, cellRows, columns, USAGE_DROP) : s.panel === 1 ? optionalTable(head, cellRows, columns) : s.panel === 3 && s.backlogView ? optionalTable(head, cellRows, columns, ["AGE", "CLASS", "DEPS", "PRI"]) : table(head, cellRows, columns) : undefined;
     if (s.panel === 6) {
       const row = selectedPanelRow(s);
       const info = s.settingsProblem ?? (!s.settingsKnown ? "settings loading..." : row?.restartReason ?? row?.note ?? row?.label ?? "Settings");
@@ -1045,6 +1134,11 @@ export function renderConsoleLines(s: ConsoleState, columns: number, rows = 24,
         for (const pending of s.retainedConfig) lines.push(fitLine([span(`${pending.key}: ${pending.reason}`, "attention")], columns));
       }
     }
+    if (s.panel === 7) {
+      const note = s.usage?.problem ? `usage unavailable: ${s.usage.problem}` : !s.usage?.life ? "usage loading..." : s.usage.behind ? "usage still catching up with the event log: numbers are partial and refresh in a few seconds"
+        : `usage through ${s.usage.at ? relative(s.usage.at, now) : "now"}: today is the UTC day, 7d the last seven UTC days`;
+      lines.push(fitLine([span(note, s.usage?.problem ? "failure" : !s.usage?.life || s.usage.behind ? "attention" : "info")], columns));
+    }
     if (s.panel === 3 && s.backlogView) {
       lines.push(fitLine([span(s.tasksKnown === false ? "backlog loading..." : `backlog ${data.length}`, s.tasksKnown === false ? "attention" : "info")], columns));
     } else if (s.panel === 3) {
@@ -1065,6 +1159,7 @@ export function renderConsoleLines(s: ConsoleState, columns: number, rows = 24,
       lines.push(fitLine([span(selected ? "> " : "  ", selected ? "strong" : undefined), ...(rowsOf?.[i + 1] ?? cells(s, data[i], selected, now))], columns));
     }
     if (!data.length) lines.push([span("  (empty)")]);
+    if (s.panel === 7) for (const line of taskLines) lines.push(fitLine([span("  " + line.text, line.tone)], columns));
     if (title.length) {
       const room = Math.max(1, height - lines.length - 1 - tail.length);
       if (title.length > room) { title.length = room; title[room - 1] = more(title[room - 1]!); }

package/src/cli/console-symbols.ts

@@ -0,0 +1,74 @@
+import { planSymbolMatches } from "../hub/review-brief.ts";
+
+// #684 2b: the "changed symbols" block of the console's task detail. Pure data to fields, no terminal code. The hub's own observation of the changed
+// symbols (`codeSymbols`, PR #708) is read as it is; nothing is parsed from code here and nothing is asked of the hub beyond `task_show`.
+// Advisory only: ripwire does not report deleted symbols, so these lists never establish that a plan was or was not followed. The plan names are `plan.symbols`,
+// the same list `withCodeSymbols` reads as `planned` in the review brief (daemon.ts passes `task.plan?.symbols`), not a second source.
+
+export interface ChangedSymbol { id: string; path: string; name: string; kind: string }
+export interface SymbolBlock { state: "known" | "unknown"; complete: boolean; head?: string; matching: ChangedSymbol[]; unplanned: ChangedSymbol[]; untouched: string[] }
+
+const MAX_LINES = 40;
+const isPrivate = (task: any): boolean =>
+  !task || (Array.isArray(task.signals) && task.signals.some((s: unknown) => s === "pii" || s === "pii_path")) || task.title === "[pii]";
+const symbolsOf = (task: any): ChangedSymbol[] | undefined => {
+  const received = task?.codeSymbols;
+  if (!received || received.state !== "known" || !Array.isArray(received.symbols)) return undefined;
+  // Only the public receipt (`publicTaskCodeSymbols`, re-screened on every read) is shown. A stored receipt still carries `repositoryKey` and was never screened for
+  // the current policy: a task handed over in that shape reads as unknown, whatever feeds this renderer today (the renderer holds the rule itself).
+  if (Object.hasOwn(received, "repositoryKey")) return undefined;
+  const out: ChangedSymbol[] = [];
+  for (const s of received.symbols) if (s && typeof s.id === "string" && typeof s.path === "string" && typeof s.name === "string" && typeof s.kind === "string") out.push({ id: s.id, path: s.path, name: s.name, kind: s.kind });
+  return out;
+};
+
+/** Each changed symbol as matching the plan or unplanned, and each planned name nothing changed under as untouched. Unknown without code facts. */
+export function classifySymbols(task: any): SymbolBlock {
+  const changed = symbolsOf(task);
+  if (!changed) return { state: "unknown", complete: false, matching: [], unplanned: [], untouched: [] };
+  const plan: string[] = Array.isArray(task?.plan?.symbols) ? task.plan.symbols.filter((v: unknown): v is string => typeof v === "string") : [];
+  const matching = changed.filter(s => plan.some(p => planSymbolMatches(p, s.name)));
+  const unplanned = changed.filter(s => !plan.some(p => planSymbolMatches(p, s.name)));
+  const untouched = plan.filter(p => !changed.some(s => planSymbolMatches(p, s.name)));
+  return { state: "known", complete: task.codeSymbols.complete === true, ...(typeof task.codeSymbols.head === "string" ? { head: task.codeSymbols.head.slice(0, 8) } : {}), matching, unplanned, untouched };
+}
+
+/**
+ * The detail fields for a task (`symbols` and `symbols note`), or none for a private one. Values are objects of single words (`{ matching: name, in: path }`) so the console's field
+ * renderer quotes every agent-written string: a symbol name cannot pass for a hub label. Capped, with the count of what is left out.
+ */
+export function symbolFields(task: any): [string, unknown][] {
+  // Only a task as `task_show` shapes it (a numeric id and a state): any other detail an agent or a test hands the Tasks panel keeps its own layout.
+  if (!task || typeof task.id !== "number" || typeof task.state !== "string" || isPrivate(task)) return [];
+  const block = classifySymbols(task);
+  if (block.state === "unknown") return [["symbols", "changed symbols: unknown (no code facts)"]];
+  const items: Record<string, string>[] = [
+    ...block.matching.map(s => ({ matching: s.name, in: s.path })), ...block.unplanned.map(s => ({ unplanned: s.name, in: s.path })), ...block.untouched.map(name => ({ untouched: name })),
+  ];
+  const shown = items.slice(0, MAX_LINES);
+  const note = [`changed symbols: ${block.matching.length} matching, ${block.unplanned.length} unplanned, ${block.untouched.length} untouched${block.head ? ` at ${block.head}` : ""}`,
+    block.complete ? "" : "incomplete: some changed symbols were not listed, so an untouched one may have changed",
+    "advisory: deleted symbols are not reported"].filter(Boolean).join("; ");
+  return [["symbols", shown.length ? shown : "none observed"], ["symbols note", items.length > shown.length ? `${note}; ${items.length - shown.length} more not shown` : note]];
+}
+
+
+/** Render the hub's read-only pair verdicts; never derive disjointness from a local receipt or plan. */
+export function overlapFields(task: any): [string, unknown][] {
+  if (!task || typeof task.id !== "number" || typeof task.state !== "string" || isPrivate(task) || !Array.isArray(task.symbolOverlaps)) return [];
+  if (!task.symbolOverlaps.length) return [["overlaps", "none"]];
+  const items: Record<string, unknown>[] = [];
+  let invalid = 0;
+  for (const row of task.symbolOverlaps) {
+    if (!row || !Number.isSafeInteger(row.task) || row.task < 1 || !Array.isArray(row.files)
+      || !row.files.every((file: unknown) => typeof file === "string") || typeof row.sameFileDifferentSymbols !== "boolean") { invalid++; continue; }
+    items.push({ task: row.task, files: row.files.slice(0, MAX_LINES),
+      overlap: row.sameFileDifferentSymbols ? "same file, different symbols" : "overlap",
+      ...(row.files.length > MAX_LINES ? { omitted: `${row.files.length - MAX_LINES} files not shown` } : {}) });
+  }
+  if (!items.length) return [["overlaps", "unknown (invalid overlap data)"]];
+  const note = ["observed names only, deleted definitions may be missing",
+    items.length > MAX_LINES ? `${items.length - MAX_LINES} more not shown` : "",
+    invalid ? `${invalid} invalid rows withheld` : ""].filter(Boolean).join("; ");
+  return [["overlaps", items.slice(0, MAX_LINES)], ["overlap note", note]];
+}

package/src/cli/console-usage.ts

@@ -0,0 +1,89 @@
+import type { Counter, LimitsResult, UsageResult, UsageRow } from "../hub/usage-rollup.ts";
+
+// #683 U3: what the console's Usage panel shows, as plain strings. No terminal code and no state import here: console-state.ts renders it.
+// Every number names its source, an unknown counter reads `unknown` (never 0), and a private task is `#id [pii]` with no title.
+
+/** What the console keeps from the `usage` op: one query per period, the limits history and, for the task selected in Tasks, its tokens per peer. */
+export interface UsageState {
+  today?: UsageResult; week?: UsageResult; life?: UsageResult; limits?: LimitsResult;
+  /** The selected task's tokens per peer, with the task id it was asked for. */
+  task?: UsageResult; taskId?: number;
+  at?: number; problem?: string;
+  /** The hub's roll-up was still behind the event log when it answered: the numbers are partial (a later poll catches up). */
+  behind?: boolean;
+}
+export interface UsagePeerRow { id: string }
+
+const TAG: Record<Counter["source"], string> = { native: "native", count: "hub", manual: "manual", partial: "at least", unknown: "unknown" };
+const compact = (n: number): string => n >= 1e7 ? `${Math.round(n / 1e6)}M` : n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1e4 ? `${Math.round(n / 1e3)}k` : String(n);
+/** `1.2M native`, `77 hub`, or `unknown`: a counter nobody reported is never shown as a number. */
+export const counterText = (c: Counter | undefined, exact = false): string => !c || c.value === null ? "unknown" : `${exact ? c.value : compact(c.value)} ${TAG[c.source]}`;
+/** A row's tokens: the provider's total when it reported one, otherwise what the hub counted, otherwise unknown. */
+export const rowTokens = (row: UsageRow | undefined): Counter =>
+  row && row.total.value !== null ? row.total : row && row.counted.value !== null ? row.counted : { value: null, source: "unknown" };
+const periodText = (row: UsageRow | undefined, exact = false): string => row ? counterText(rowTokens(row), exact) : "no records";
+
+const rowOf = (result: UsageResult | undefined, peer: string): UsageRow | undefined => result?.rows.find(row => row.key === peer);
+
+/** Every peer the panel can say something about: peers with usage in any period, and peers with a quota reading. */
+export function usagePeers(usage: UsageState | undefined, budget: Record<string, unknown>, peers: Record<string, unknown>): UsagePeerRow[] {
+  const ids = new Set<string>([...Object.keys(peers), ...Object.keys(budget)]);
+  for (const result of [usage?.today, usage?.week, usage?.life]) for (const row of result?.rows ?? []) ids.add(row.key);
+  return [...ids].sort().map(id => ({ id }));
+}
+
+interface Budget { windows?: { id: string; used: number; resetsAt?: number }[]; paused?: { resetsAt: number } }
+const windowText = (w: { id: string; used: number; resetsAt?: number }, rel: (at: number) => string) =>
+  `${w.id} ${Math.round(w.used * 100)}%${typeof w.resetsAt === "number" ? ` ${rel(w.resetsAt)}` : ""}`;
+const lastResets = (limits: LimitsResult | undefined, peer: string, count: number) =>
+  (limits?.history ?? []).filter(h => h.type === "quota_reset" && h.peer === peer).slice(-count).reverse();
+
+/** One table row: PEER, TODAY, 7D, LIFETIME, PAUSE, QUOTA, LAST RESET (PAUSE before QUOTA: a pause must survive a narrow terminal, the long quota text is what gives way). */
+export function usageCells(usage: UsageState | undefined, peer: string, budget: Budget | undefined, rel: (at: number) => string): string[] {
+  const reset = lastResets(usage?.limits, peer, 1)[0];
+  // The table is tight at 80 columns: a time still to come reads `3h00m`, not `in 3h00m` (the detail view spells it out).
+  const ahead = (at: number) => rel(at).replace(/^in /, "");
+  return [peer, periodText(rowOf(usage?.today, peer)), periodText(rowOf(usage?.week, peer)), periodText(rowOf(usage?.life, peer)),
+    budget?.paused ? ahead(budget.paused.resetsAt) : "-",
+    budget?.windows?.length ? budget.windows.map(w => windowText(w, ahead)).join(", ") : "-",
+    reset ? `${reset.window} ${rel(Date.parse(reset.at))}` : "-"];
+}
+export const USAGE_HEAD = ["PEER", "TODAY", "7D", "LIFETIME", "PAUSE", "QUOTA", "LAST RESET"];
+/** Only the last reset gives way to width; the others are cut shorter instead, so the 7D column and the pause are never dropped. */
+export const USAGE_DROP = ["LAST RESET"];
+
+/** The token split of one period: input, output, cache read, cache write, the total and the hub's own count, each with its source. */
+export function splitText(row: UsageRow | undefined): string {
+  if (!row) return "no records";
+  return [`total ${counterText(row.total, true)}`, `input ${counterText(row.input, true)}`, `output ${counterText(row.output, true)}`,
+    `cache read ${counterText(row.cacheRead, true)}`, `cache write ${counterText(row.cacheWrite, true)}`, `hub count ${counterText(row.counted, true)}`].join(", ");
+}
+export const taskLabel = (usage: UsageState | undefined): string =>
+  usage?.taskId === undefined ? "" : `#${usage.taskId}${usage.task?.taskPii ? " [pii]" : ""}`;
+
+/** The detail of one peer, as labelled one-line-per-field text. Values are hub-built from ids and numbers only. */
+export function usageDetail(usage: UsageState | undefined, peer: string, budget: Budget | undefined, rel: (at: number) => string): Record<string, string> {
+  const resets = lastResets(usage?.limits, peer, 3).map(h => `${h.window} ${rel(Date.parse(h.at))}`);
+  const out: Record<string, string> = {
+    peer,
+    quota: budget?.windows?.length ? budget.windows.map(w => windowText(w, rel)).join(", ") : "no reading",
+    pause: budget?.paused ? `budget pause, resumes ${rel(budget.paused.resetsAt)}` : "none",
+    "last resets": resets.length ? resets.join(", ") : "none recorded",
+    today: splitText(rowOf(usage?.today, peer)),
+    "last 7 days": splitText(rowOf(usage?.week, peer)),
+    lifetime: splitText(rowOf(usage?.life, peer)),
+  };
+  if (usage?.taskId !== undefined) out[`task ${taskLabel(usage)}`] = splitText(rowOf(usage.task, peer));
+  return out;
+}
+
+/** The lines under the table: the task selected in Tasks and its tokens per peer. */
+export function usageTaskLines(usage: UsageState | undefined, selectedTask: number | undefined): { text: string; tone?: "muted" | "info" | "failure" }[] {
+  if (selectedTask === undefined) return [{ text: "task: none selected; pick one in Tasks (3), then open Usage (7)", tone: "muted" }];
+  if (usage?.problem) return [];
+  if (usage?.taskId !== selectedTask || !usage.task) return [{ text: `task #${selectedTask}: loading...`, tone: "muted" }];
+  const rows = usage.task.rows;
+  const head = { text: `task ${taskLabel(usage)}: tokens per peer, all time`, tone: "info" as const };
+  if (!rows.length) return [head, { text: "  no usage recorded for this task", tone: "muted" }];
+  return [head, ...rows.map(row => ({ text: `  ${row.key}  ${counterText(rowTokens(row))}` }))];
+}

package/src/cli/console.ts

@@ -4,6 +4,7 @@ import { StringDecoder } from "node:string_decoder";
 import type { ControlClient } from "../hub/control-client.ts";
 import { contextLine } from "./status-lines.ts";
 import { renderTailEvent } from "./tail-render.ts";
+import { reviewResult } from "./console-review.ts";
 import { syncPermissionDefaults, permissionDefaultText, approvalFrom, initialConsoleState, keyTable, notify, paint, permissionText, plural, pruneApprovals, reduceConsole, renderConsoleLines, resolveColor, stateTone, streamTokens, wrapStreamTokens, terminalText, wrap, captureConsoleSelection, selectedPanelRow, appendEvent, FIRST_KEYS, LAST_KEYS } from "./console-state.ts";
 import type { ConsoleEffect, ConsoleEvent, Detail, Tone } from "./console-state.ts";
 import type { BusEvent } from "../hub/bus.ts";
@@ -192,6 +193,15 @@ export async function runConsole(options: ConsoleOptions): Promise<void> {
         ...(panels ? [client.request({ t: "task", op: "hub_task_list", args: {} }, 3000), client.request({ t: "queue", op: "list" }, 3000), client.request({ t: "task", op: "hub_task_list", args: { ready: true } }, 3000)] : []),
         ...(panels && (state.panel === 1 || state.panel === 6) ? [client.request({ t: "settings_get" }, 3000)] : []),
       ]);
+      // #683 U3: the Usage panel asks the hub's roll-up only while it is open (UTC day, 7 UTC days, lifetime, the limits history and the selected task).
+      // The task is read at the time of the request, so a reply for a task that is no longer selected is dropped below.
+      const usageTask = panels && state.panel === 7 ? state.usageTask : undefined;
+      const usageReplies = panels && state.panel === 7 ? await (async () => {
+        const startOfDay = Date.UTC(new Date().getUTCFullYear(), new Date().getUTCMonth(), new Date().getUTCDate());
+        return Promise.all([client.request({ t: "usage", by: "peer", since: startOfDay }, 5000), client.request({ t: "usage", by: "peer", since: startOfDay - 6 * 86_400_000 }, 5000),
+          client.request({ t: "usage", by: "peer" }, 5000), client.request({ t: "usage", op: "limits", limit: 1000 }, 5000),
+          ...(usageTask !== undefined ? [client.request({ t: "usage", by: "peer", task: usageTask }, 5000)] : [])]);
+      })() : undefined;
       if (!active) return;
       const [status, budget, tasks, queue, ready, settings] = replies;
       captureConsoleSelection(state);
@@ -217,6 +227,12 @@ export async function runConsole(options: ConsoleOptions): Promise<void> {
       }
       if (syncPermissionDefaults(state, status.status?.permissionDefaults) && state.confirm?.type === "permission_default") stream({ text: permissionDefaultText(state.confirm), kind: "permission_default", peer: state.confirm.peer, tone: "attention" });
       if (budget.budget) state.budget = budget.budget;
+      if (usageReplies) {
+        const [today, week, life, limits, task] = usageReplies, failed = usageReplies.find(reply => reply?.ok === false);
+        if (failed || !today?.usage || !week?.usage || !life?.usage || !limits?.limits) state.usage = { ...state.usage, problem: String(failed?.error ?? "usage is unavailable") };
+        else state.usage = { today: today.usage, week: week.usage, life: life.usage, limits: limits.limits, at: Date.now(), ...(usageReplies.some(reply => reply?.behind) ? { behind: true } : {}),
+          ...(usageTask !== undefined && task?.usage && state.usageTask === usageTask ? { task: task.usage, taskId: usageTask } : {}) };
+      }
       if (tasks?.ok) { const parsed = JSON.parse(tasks.text); if (Array.isArray(parsed)) {
           const readyIds = new Set(ready?.ok ? JSON.parse(ready.text).map((task: any) => task.id) : []);
           state.tasks = parsed.map(task => ({ ...task, ready: readyIds.has(task.id) }));
@@ -304,7 +320,16 @@ export async function runConsole(options: ConsoleOptions): Promise<void> {
       let diagnostic = "";
       // Output lines sit at column 4, as message bodies do: what a command prints can carry peer text, and columns 0 and 2 are the hub's.
       const output = (text: string) => { if (active) { diagnostic = (diagnostic + terminalText(text)).slice(-2000); stream({ text: terminalText(text).replace(/\t/g, " ").replace(/\n$/, "").replace(/^/gm, "    "), kind: "command" }); draw(); } };
-      cancelChild = run(action.args, output, (code = 0) => { childRunning = false; cancelChild = undefined; if (active) { if (code) notice(diagnostic.trim() || `command exited ${code}`); void refresh(); } }, Math.max(1, columns - 4));
+      cancelChild = run(action.args, output, (code = 0) => {
+        childRunning = false; cancelChild = undefined;
+        if (active) {
+          // #711: a review's result is a notice in panels mode too (where the stream is not on screen): `#372 approved`, or the CLI's own refusal verbatim.
+          const review = reviewResult(action.args, code, diagnostic.trim());
+          if (review) notify(state, review.text, Date.now(), review.tone === "success" ? "success" : "failure");
+          else if (code) notice(diagnostic.trim() || `command exited ${code}`);
+          void refresh(); draw();
+        }
+      }, Math.max(1, columns - 4));
     } catch (error) { childRunning = false; notice(String((error as Error).message)); draw(); }
   };
   const handle = (key: string) => {