@staix/agent-hub 0.12.44 → 0.13.0

package/src/adapters/registry.ts

@@ -11,14 +11,9 @@ import type { AdapterDefinition, KindMap, ProjectAdapterCatalog } from "./regist
 import { types } from "node:util";
 
 export type * from "./registry-types.ts";
-export const ADAPTER_API = 1;
+import { ADAPTER_API } from "./adapter-api.ts";
+export { ADAPTER_API };
 
-/** Ordered compatibility projections stay typed independently of definition implementation inference. */
-export const KNOWN_PEERS = ["claude", "codex", "kimi", "pi", "local"] as const;
-export const OPTIONAL_PEERS = ["qwen", "jcode", "agy"] as const;
-export const SUPPORTED_PEERS = [...KNOWN_PEERS, ...OPTIONAL_PEERS] as const;
-export const START_MODE_PEERS = ["pi", "codex", "kimi", "jcode"] as const;
-export const OFFICE_PEER_ORDER: readonly string[] = KNOWN_PEERS;
 
 
 function immutable<T>(value: T, seen = new WeakSet<object>()): T {
@@ -38,6 +33,31 @@ export const ADAPTERS: readonly AdapterDefinition[] = immutable([
   ...NATIVE_BUILTIN_DEFINITIONS_WITHOUT_QWEN.filter(definition => definition.kind === "jcode"),
   AGY_DEFINITION,
 ]);
+export interface AdapterLists {
+  readonly KNOWN_PEERS: readonly string[]; readonly OPTIONAL_PEERS: readonly string[]; readonly SUPPORTED_PEERS: readonly string[];
+  readonly START_MODE_PEERS: readonly string[]; readonly ROLE_ORDER: readonly string[]; readonly HELP_ORDER: readonly string[]; readonly PLANNER_PEERS: readonly string[];
+}
+/** Pure builtin projections. Unranked definitions retain their source order after ranked definitions. */
+export function deriveAdapterLists(definitions: readonly AdapterDefinition[]): AdapterLists {
+  const ordered = (field: "roleRank" | "startRank" | "helpRank", eligible = (_definition: AdapterDefinition) => true) => definitions
+    .map((definition, index) => ({ definition, index })).filter(({ definition }) => eligible(definition))
+    .sort((left, right) => {
+      const a = left.definition.projection?.[field], b = right.definition.projection?.[field];
+      if (a === undefined) return b === undefined ? left.index - right.index : 1;
+      if (b === undefined) return -1;
+      return a - b || left.index - right.index;
+    }).map(({ definition }) => definition.kind);
+  const KNOWN_PEERS = definitions.filter(definition => !definition.optional).map(definition => definition.kind);
+  const OPTIONAL_PEERS = definitions.filter(definition => definition.optional).map(definition => definition.kind);
+  return immutable({ KNOWN_PEERS, OPTIONAL_PEERS, SUPPORTED_PEERS: [...KNOWN_PEERS, ...OPTIONAL_PEERS],
+    START_MODE_PEERS: ordered("startRank", definition => definition.start.forms.includes("tui") && definition.start.forms.includes("headless")),
+    ROLE_ORDER: ordered("roleRank"), HELP_ORDER: ordered("helpRank"),
+    PLANNER_PEERS: definitions.filter(definition => definition.projection?.plannerEligible === true).map(definition => definition.kind),
+  });
+}
+export const { KNOWN_PEERS, OPTIONAL_PEERS, SUPPORTED_PEERS, START_MODE_PEERS, ROLE_ORDER, PLANNER_PEERS } = deriveAdapterLists(ADAPTERS);
+export const OFFICE_PEER_ORDER: readonly string[] = KNOWN_PEERS;
+
 // Unavailable declarations are metadata, not supported native peers or launchers.
 const declarationOnlyDefinitions: readonly AdapterDefinition[] = immutable([]);
 const definitions = new Map<string, AdapterDefinition>();
@@ -101,14 +121,21 @@ export function familyOf(id: string, instances?: KindMap): string | undefined {
 }
 
 /** Compile one captured, host-trusted declaration set; never register native policy globally. */
-export function createProjectAdapterCatalog(rawAdapters?: unknown): ProjectAdapterCatalog {
+export function createProjectAdapterCatalog(rawAdapters?: unknown, externalDefinitions: readonly AdapterDefinition[] = []): ProjectAdapterCatalog {
   const configured = configuredAcpDefinitions(rawAdapters, [...definitions.keys()]);
   for (const definition of configured) { assertDefinitionCoherence(definition); assertNativeCapabilityScope(definition); }
-  const entries = Object.freeze([...ADAPTERS, ...configured]);
-  const catalog = new Map([...definitions, ...configured.map(definition => [definition.kind, definition] as const)]);
+  const seen = new Set([...definitions.keys(), ...configured.map(item => item.kind)]);
+  for (const definition of externalDefinitions) {
+    if (definition.api !== ADAPTER_API || seen.has(definition.kind)) throw new Error("external adapter kind or API collision");
+    assertDefinitionCoherence(definition); assertNativeCapabilityScope(definition);
+    seen.add(definition.kind);
+  }
+  const external = immutable([...externalDefinitions]);
+  const entries = Object.freeze([...ADAPTERS, ...configured, ...external]);
+  const catalog = new Map([...definitions, ...[...configured, ...external].map(definition => [definition.kind, definition] as const)]);
   const kindOf = (id: string, instances?: KindMap): string | undefined => catalog.has(id) ? id : typeof id === "string" ? declaredKind(id, instances, catalog) : undefined;
   const definitionOf = (id: string, instances?: KindMap): AdapterDefinition | undefined => resolvedDefinition(id, kindOf(id, instances), instances, catalog);
-  return Object.freeze({ definitions: entries, kindOf, definitionOf,
+  return Object.freeze({ definitions: entries, externalDefinitions: external, kindOf, definitionOf,
     familyOf: (id: string, instances?: KindMap) => definitionOf(id, instances)?.family,
     isSupportedPeer: (id: unknown, instances?: KindMap): id is string => {
       if (typeof id !== "string") return false;
@@ -119,8 +146,7 @@ export function createProjectAdapterCatalog(rawAdapters?: unknown): ProjectAdapt
 }
 
 /** Compatibility projection order is observable in default role maps and planner selection. */
-const ROLE_ORDER = ["claude", "codex", "kimi", "local", "pi", "qwen", "jcode", "agy"] as const;
-export const PLANNER_PEERS = ["claude", "codex", "kimi", "qwen", "jcode"] as const;
+
 
 /** Callers own their role arrays, independent of immutable native policy. */
 export function defaultPeerRoles(includeOptional = false): Record<string, string[]> {
@@ -159,6 +185,12 @@ export function assertDefinitionCoherence(definition: AdapterDefinition): void {
   if (definition.turnEnd === "native-hook" && definition.transport !== "claude-channel" && !definition.hooks?.factsHook) {
     fail("turnEnd", "native-hook requires the Claude transport or a native factsHook");
   }
+  const projection = definition.projection;
+  if (projection !== undefined) {
+    if (!projection || typeof projection !== "object" || Array.isArray(projection) || Object.keys(projection).some(key => !["roleRank", "startRank", "helpRank", "plannerEligible"].includes(key))) fail("projection", "invalid projection metadata");
+    for (const field of ["roleRank", "startRank", "helpRank"] as const) if (projection[field] !== undefined && (typeof projection[field] !== "number" || !Number.isFinite(projection[field]))) fail(`projection.${field}`, "rank must be finite");
+    if (projection.plannerEligible !== undefined && typeof projection.plannerEligible !== "boolean") fail("projection.plannerEligible", "boolean required");
+  }
   const attach = definition.attach, pullOnly = attach?.pullOnlyForms;
   if (pullOnly !== undefined) {
     if (!Array.isArray(pullOnly) || pullOnly.some(form => !definition.start.forms.includes(form))) fail("attach.pullOnlyForms", "each pull-only form must be a supported start form");
@@ -199,9 +231,14 @@ export function assertNativeCapabilityScope(definition: AdapterDefinition): void
     ["session.crashIdentity", declared(definition.session, "crashIdentity")],
     ["start.daemonPort pi-rpc", definition.start.daemonPort === "pi-rpc"],
     ["routing", definition.routing !== undefined],
+    ["projection", definition.projection !== undefined],
+    ["instances.nativeHome", declared(definition.instances, "nativeHome")], // #685: a fixed-builtin assumption, one native data home per declared instance
     ["reviewerVariant", definition.reviewerVariant !== undefined],
     ["reviewer", definition.reviewer !== undefined],
     ["hooks.factsHook", declared(definition.hooks, "factsHook")],
+    ["cli.entry", declared(definition.cli, "entry")],
+    ["cli.preview", declared(definition.cli, "preview")],
+    ["cli.usage", declared(definition.cli, "usage")],
   ];
   const field = restricted.find(([, present]) => present)?.[0];
   if (field) throw new Error(`${field} is restricted to fixed builtin adapter definitions`);
@@ -236,8 +273,8 @@ export function builtinPreviewOf(id: string) {
 /** Fixed builtin doctor metadata and pure observed-value projections; the CLI retains all probe effects. */
 export { DOCTOR_TOOL_PROBES, DOCTOR_MEMORY_CAPTURE_PEERS, DOCTOR_PLUGIN_PROBE, nativeDoctorCheck, nativeDoctorRecoveryIdentity, nativeDoctorOptionalProbes } from "./definitions/native-cli-doctor.ts";
 
-/** Internal fixed builtin CLI entries; public AdapterDefinition and NativeHooks expose no execution extension. */
-export const BUILTIN_CLI_ENTRIES = Object.freeze(builtinCliEntries.map(entry => {
+/** Definition-owned CLI entries are restricted to fixed builtins, never config or external execution extensions. */
+export const BUILTIN_CLI_ENTRIES = Object.freeze(builtinCliEntries(ADAPTERS).map(entry => {
   const definition = definitionOf(entry.command);
   if (!definition) throw new Error("builtin CLI entry has no adapter definition");
   return Object.freeze({ ...entry, definition });

package/src/cli/agents.ts

@@ -0,0 +1,40 @@
+import { spawnSync } from "node:child_process";
+import { assessVersion, COMPAT, describe, isCompatId, readTrust, trustFile, writeTrust, type CompatId, type CompatVerdict } from "../adapters/compat.ts";
+
+/** #691: what `ahub agents` and `ahub doctor` show for each gated native CLI. */
+export interface AgentVersionRow { id: CompatId; executable?: string; verdict: CompatVerdict; policy: string }
+
+/** `commands` carries the configured argv (codex_bin, jcode_cmd, qwen_cmd); the probe words follow it. */
+export function agentVersions(commands: Partial<Record<CompatId, readonly string[]>> = {}): AgentVersionRow[] {
+  const trusted = readTrust();
+  return (Object.keys(COMPAT) as CompatId[]).map(id => {
+    const [defaultBin, ...words] = COMPAT[id].probe;
+    const [bin = defaultBin, ...prefix] = commands[id] ?? [defaultBin];
+    const executable = Bun.which(bin) ?? undefined;
+    if (!executable) return { id, verdict: { ok: false, state: "unknown", reason: `${COMPAT[id].label} not found on PATH` }, policy: describe(id) };
+    const result = spawnSync(executable, [...prefix, ...words], { encoding: "utf8", timeout: 10_000, maxBuffer: 64 * 1024, env: { ...process.env, JCODE_NO_TELEMETRY: "1", JCODE_DISABLE_CLAUDE_MCP: "1" } });
+    return { id, executable, verdict: assessVersion(id, result.status === 0 ? COMPAT[id].parse(result.stdout ?? "") : undefined, trusted), policy: describe(id) };
+  });
+}
+
+export function runAgents(args: string[], commands: Partial<Record<CompatId, readonly string[]>>, fail: (message: string) => never): void {
+  const [sub, id, version, ...rest] = args.filter(arg => arg !== "--json");
+  if (sub === "trust") {
+    const revoke = rest.includes("--revoke");
+    if (!isCompatId(id) || !version || rest.some(arg => arg !== "--revoke")) fail(`usage: ahub agents trust <${Object.keys(COMPAT).join("|")}> <version> [--revoke]`);
+    // The issue requires saying what trust covers before it is recorded.
+    if (!revoke) console.log(`${COMPAT[id].label} ${version}: ${COMPAT[id].trustNote}`);
+    let rows;
+    try { rows = writeTrust(id, version, revoke); } catch (error) { fail((error as Error).message); }
+    if (revoke) return console.log(`revoked: ${id} ${version} (${rows.length} trusted on this machine, ${trustFile()})`);
+    console.log(`trusted on this machine: ${COMPAT[id].label} ${version}\nUndo: ahub agents trust ${id} ${version} --revoke`);
+    return;
+  }
+  if (sub !== undefined) fail("usage: ahub agents [--json] | ahub agents trust <id> <version> [--revoke]");
+  const rows = agentVersions(commands);
+  if (args.includes("--json")) return console.log(JSON.stringify(rows.map(row => ({ id: row.id, executable: row.executable ?? null, ...row.verdict, policy: row.policy })), null, 2));
+  for (const row of rows) {
+    const v = row.verdict;
+    console.log(`${row.id.padEnd(13)} ${(v.version ?? "-").padEnd(10)} ${v.state.padEnd(9)} ${row.policy}${v.ok ? (v.note ? `\n${" ".repeat(14)}${v.note}` : "") : `\n${" ".repeat(14)}${v.reason}`}`);
+  }
+}

package/src/cli/console-review.ts

@@ -0,0 +1,54 @@
+// #711 / #380: the console's review guidance. Pure strings and decisions, no terminal code and no state import: console-state.ts renders them.
+// Nothing here changes authority: the console runs `ahub review` as the person, and the hub decides.
+
+export type Verdict = "approved" | "changes_requested";
+/** The task a review choice was opened for, taken from the selected row or the open detail. */
+export interface ReviewChoice { id: number; title: string; reviewerIsUser: boolean }
+
+const MAX_TITLE = 40;
+const clean = (text: string) => text.replace(/[\p{Cc}\p{Cf}]/gu, " ").replace(/\s+/g, " ").trim();
+/** The title as the choice line shows it: quoted, one line, cut to the width; a private task is `[pii]`. */
+export function choiceTitle(row: { title?: unknown; signals?: unknown }): string {
+  const priv = (Array.isArray(row.signals) && row.signals.some(s => s === "pii" || s === "pii_path")) || row.title === "[pii]";
+  if (priv) return "[pii]";
+  const text = clean(String(row.title ?? ""));
+  return JSON.stringify(text.length > MAX_TITLE ? `${text.slice(0, MAX_TITLE - 3)}...` : text);
+}
+
+/** The choice for a task row, or undefined when it is not one the person can review (not in review). */
+export function reviewChoiceFor(row: any): ReviewChoice | undefined {
+  if (!row || row.state !== "in_review" || !Number.isSafeInteger(Number(row.id)) || Number(row.id) <= 0) return undefined;
+  return { id: Number(row.id), title: choiceTitle(row), reviewerIsUser: row.reviewer === "user" };
+}
+
+/** The prompt line while the choice is open (#711 change 1). The title is already quoted. */
+export const choicePrompt = (c: ReviewChoice): string => `review #${c.id} ${c.title}: a approve  c request changes  Esc cancel`;
+/** What `a` and `c` prefill on the input line. The trailing space is where the note goes. */
+export const verdictInput = (id: number, verdict: Verdict): string => `review ${id} ${verdict} `;
+/** The guide line shown above the input after a choice (#711 change 1). */
+export const verdictGuide = (id: number, verdict: Verdict): string =>
+  verdict === "approved" ? `Enter approves #${id}. You can type a note first. Esc cancels.` : "Say what to fix, then Enter. Esc cancels.";
+
+/** The footer hint for a task in review (#711 change 2): the verb, and whose review it is when it is the person's. */
+export const reviewHint = (reviewer: unknown): string => reviewer === "user" ? "your review: r approve or request changes" : "r approve or request changes";
+
+/**
+ * A `review <id> <verdict> [note]` line the person typed, checked before it is sent: a changes request must say what to fix (#711 change 1). Returns the refusal,
+ * or undefined when the line is fine or is not a review line at all (other commands are validated where they always were).
+ */
+export function reviewRefusal(args: readonly string[]): string | undefined {
+  if (args[0] !== "review") return undefined;
+  const verdict = args[2];
+  if (verdict !== "changes_requested") return undefined;
+  const note = args.slice(3).filter(word => !word.startsWith("--")).join(" ").trim();
+  return note ? undefined : "say what to fix before requesting changes";
+}
+
+/** The notice after a review command finished: `#372 approved`, `#372 changes requested`, or the CLI's own refusal verbatim (#711 change 3). */
+export function reviewResult(args: readonly string[], code: number, diagnostic: string): { text: string; tone: "success" | "failure" } | undefined {
+  if (args[0] !== "review" || !/^\d+$/.test(args[1] ?? "")) return undefined;
+  const verdict = args[2];
+  if (verdict !== "approved" && verdict !== "changes_requested") return undefined;
+  if (code) return { text: clean(diagnostic) || `command exited ${code}`, tone: "failure" };
+  return { text: `#${args[1]} ${verdict === "approved" ? "approved" : "changes requested"}`, tone: "success" };
+}

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]!); }