@staix/agent-hub 0.12.17 → 0.12.19

package/src/cli/console-state.ts

@@ -4,7 +4,7 @@ export interface Approval {
   id: string; peer: string; title: string; expiresAt: number;
   options: { optionId: string; name: string; kind: string }[];
 }
-export interface ConsoleEvent { text: string; peer?: string; kind?: string }
+export interface ConsoleEvent { text: string; peer?: string; kind?: string; tone?: Tone }
 export interface ConsoleState {
   mode: "stream" | "panels"; panel: number; selection: number; approvalIndex: number;
   input: string; editing: boolean; history: string[]; historyIndex: number;
@@ -22,11 +22,48 @@ export function initialConsoleState(panels = false): ConsoleState {
 }
 /** Strip terminal controls before any daemon or child output reaches a terminal. Preserve printable Unicode. */
 export function terminalText(value: unknown): string {
-  return sanitize(String(value ?? ""))
+  return sanitize(String(value ?? "")
     .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\|$)/g, "")
     .replace(/\x1b[P_X^][\s\S]*?(?:\x1b\\|$)/g, "")
     .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
-    .replace(/\x1b[^\n]?/g, "").replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, "");
+    .replace(/\x1b[^\n]?/g, "").replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, ""));
+}
+export type Tone = "info" | "strong" | "success" | "attention" | "failure" | "muted";
+export interface Span { text: string; tone?: Tone }
+export const PALETTE: Readonly<Record<Tone, string>> = Object.freeze({
+  info: "\x1b[36m", strong: "\x1b[1;36m", success: "\x1b[32m", attention: "\x1b[33m", failure: "\x1b[31m", muted: "\x1b[90m",
+});
+export function paint(line: Span[], color: boolean): string {
+  return line.map(span => {
+    const text = terminalText(span.text);
+    const sgr = span.tone && Object.hasOwn(PALETTE, span.tone) ? PALETTE[span.tone] : undefined;
+    return color && sgr && text ? sgr + text + "\x1b[0m" : text;
+  }).join("");
+}
+export function resolveColor(flag: string | undefined, env: { isTTY: boolean; TERM?: string; NO_COLOR?: string }): boolean | Error {
+  if (flag === "always") return true;
+  if (flag === "never") return false;
+  if (flag === undefined || flag === "auto") return env.isTTY && env.TERM !== "dumb" && !env.NO_COLOR;
+  return new Error("usage: ahub console [--panels] [--color=auto|always|never]");
+}
+export function stateTone(state: string): Tone | undefined {
+  if (state === "idle" || state === "approved") return "success";
+  if (["busy", "paused", "in_review", "changes_requested", "ready"].includes(state)) return "attention";
+  if (["failed", "check failed", "needs_review"].includes(state)) return "failure";
+  return undefined;
+}
+const span = (text: unknown, tone?: Tone): Span => ({ text: String(text ?? ""), ...(tone ? { tone } : {}) });
+/** Clip only sanitized plain text, then retain the tones of the surviving prefix. */
+function fitLine(line: Span[], columns: number): Span[] {
+  const clean = line.map(s => ({ ...s, text: terminalText(s.text).replace(/\n/g, " ") }));
+  const text = clean.map(s => s.text).join("");
+  const clipped = fit(text, columns);
+  const marker = text === clipped ? "" : ".".repeat(Math.max(0, Math.min(3, columns)));
+  let remaining = clipped.length - marker.length;
+  const out: Span[] = [];
+  for (const s of clean) { const part = s.text.slice(0, Math.max(0, remaining)); if (part) out.push({ ...s, text: part }); remaining -= part.length; }
+  if (marker) out.push(span(marker));
+  return out;
 }
 export function fit(value: unknown, columns: number): string {
   const text = terminalText(value).replace(/\n/g, " ");
@@ -179,35 +216,64 @@ export function reduceConsole(state: ConsoleState, key: string, now = Date.now()
   return done();
 }
 export function renderConsole(s: ConsoleState, columns: number, rows = 24, now = Date.now()): string[] {
+  return renderConsoleLines(s, columns, rows, now).map(line => paint(line, false));
+}
+export function renderConsoleLines(s: ConsoleState, columns: number, rows = 24, now = Date.now()): Span[][] {
   const permission = s.approvals[s.approvalIndex];
   let prompt = s.editing ? `: ${s.input}` : "q quit | Tab panels | : command | a allow d deny v view [ ] select";
   if (s.confirm?.type === "permission") prompt = `allow ${s.confirm.option} for ${s.confirm.peer} (request ${s.confirm.id})? y/N`;
   if (s.confirm?.type === "command") prompt = `${s.confirm.args.join(" ")}? y/N`;
   if (s.optionChoice) prompt = s.approvals.find(a => a.id === s.optionChoice)?.options.filter(o => o.kind.startsWith("allow")).map((o, i) => `${i + 1}:${o.name}`).join(" | ") ?? "";
+  const summary: Span[] = [];
+  for (const [id, p] of Object.entries(s.peers)) {
+    if (summary.length) summary.push(span(" "));
+    summary.push(span(id, p.state === "offline" ? undefined : "info"), span(":"), span(p.state, stateTone(p.state)), span(` q${p.queued ?? 0}`));
+    if (p.needsReview) summary.push(span(` review${p.needsReview}`, "failure"));
+    if (p.paused) summary.push(span(" paused", "attention"));
+  }
   const quotas = Object.entries(s.budget).map(([id, b]) => `${id}:${b.windows?.map((w: any) => `${w.id} ${Math.round(w.used * 100)}%`).join("/") ?? "?"}`).join(" ");
-  const summary = Object.entries(s.peers).map(([id, p]) => `${id}:${p.state} q${p.queued ?? 0}${p.needsReview ? ` review${p.needsReview}` : ""}${p.paused ? " paused" : ""}`).join(" ");
-  const footer = [fit(summary + (quotas ? ` | ${quotas}` : ""), columns), fit(`${s.approvals.length} approvals${permission ? ` | ${permission.peer} ${permission.id} ${Math.max(0, Math.ceil((permission.expiresAt - now) / 1000))}s` : ""}${s.notice ? ` | ${s.notice}` : ""}`, columns), fit(prompt, columns)];
+  if (quotas) summary.push(span(` | ${quotas}`));
+  const approvals = [span(`${s.approvals.length} approvals`, s.approvals.length ? "attention" : undefined)];
+  if (permission) approvals.push(span(` | ${permission.peer} ${permission.id}`, "attention"), span(` ${Math.max(0, Math.ceil((permission.expiresAt - now) / 1000))}s`, "muted"));
+  if (s.notice) approvals.push(span(` | ${s.notice}`));
+  const footer = [fitLine(summary, columns), fitLine(approvals, columns), fitLine([span(prompt, s.confirm || s.optionChoice ? "attention" : undefined)], columns)];
   if (s.mode === "stream") return footer;
-  const title = ["Peers", "Approvals", "Tasks", "Queue", "Events"][s.panel - 1];
-  const lines = [fit(`agent-hub | 1 Peers 2 Approvals 3 Tasks 4 Queue 5 Events | ${title}`, columns), fit(`j/k move Enter detail Esc back ? keys${s.panel === 5 ? ` | f peer:${s.peerFilter ?? "all"} g kind:${s.kindFilter ?? "all"}` : ""}`, columns)];
-  if (s.help) lines.push(...wrap("Tab stream/panels; 1-5 panel; j/k or arrows move; Enter detail; Esc back; : command; q quit. Approvals: a allow (confirm y), d deny, v title, [ ] select. Peers: p pause, r resume. Tasks: a assign (confirm y), r review. Queue: r resolve (reason and confirm y). Events: f peer filter, g kind filter.", columns));
-  else if (s.detail) { const detail = wrap(s.detail, columns); lines.push(...detail.slice(Math.min(s.detailOffset, Math.max(0, detail.length - (rows - 5))))); }
+  const titles = ["Peers", "Approvals", "Tasks", "Queue", "Events"];
+  const title = titles[s.panel - 1];
+  const tabs = [span("agent-hub | ", "info")];
+  for (const [i, name] of titles.entries()) tabs.push(span(`${i + 1} ${name}${i < 4 ? " " : ""}`, i + 1 === s.panel ? "strong" : "info"));
+  tabs.push(span(` | ${title}`, "strong"));
+  const lines: Span[][] = [fitLine(tabs, columns), fitLine([span(`j/k move Enter detail Esc back ? keys${s.panel === 5 ? ` | f peer:${s.peerFilter ?? "all"} g kind:${s.kindFilter ?? "all"}` : ""}`)], columns)];
+  if (s.help) lines.push(...wrap("Tab stream/panels; 1-5 panel; j/k or arrows move; Enter detail; Esc back; : command; q quit. Approvals: a allow (confirm y), d deny, v title, [ ] select. Peers: p pause, r resume. Tasks: a assign (confirm y), r review. Queue: r resolve (reason and confirm y). Events: f peer filter, g kind filter.", columns).map(text => [span(text)]));
+  else if (s.detail) { const detail = wrap(s.detail, columns); lines.push(...detail.slice(Math.min(s.detailOffset, Math.max(0, detail.length - (rows - 5)))).map(text => [span(text)])); }
   else {
     const data = panelRows(s); const capacity = Math.max(1, s.panel === 2 ? Math.floor((rows - 6) / 2) : rows - 6); const start = Math.max(0, s.selection - capacity + 1);
     for (const [i, row] of data.slice(start, start + capacity).entries()) {
-      let text = "";
+      const selected = start + i === s.selection;
+      const line = [span(`${selected ? ">" : " "} `, selected ? "strong" : undefined)];
       if (s.panel === 1) {
         const b = s.budget[row.id];
-        text = `${row.id} ${row.state} ${row.attached === false ? "detached" : "attached"} q:${row.queued ?? 0} !:${row.queuedImportant ?? 0} review:${row.needsReview ?? 0} ${row.paused ? `paused:${JSON.stringify(row.paused)}` : ""} ${b?.paused ? `budget pause ${b.paused.reason} reset:${b.paused.resetsAt}` : ""} ${b?.windows?.map((w: any) => `${w.id}:${Math.round(w.used * 100)}% reset:${w.resetsAt ?? "?"}`).join(" ") ?? "quota:?"} model:${row.servedBy ?? row.requestedModel ?? "?"}`;
-      } else if (s.panel === 2) text = `${row.id} ${row.peer} ${Math.max(0, Math.ceil((row.expiresAt - now) / 1000))}s ${row.title}`;
-      else if (s.panel === 3) { const at = row.history?.at(-1)?.at ?? row.updated ?? row.created; text = `#${row.id} ${row.state}${row.ready ? " ready" : ""} ${row.owner ?? "-"} review:${row.reviewer ?? "-"} ${row.class} age:${at ? Math.max(0, Math.floor((now - at) / 1000)) + "s" : "?"} ${row.title}`; }
-      else if (s.panel === 4) text = `${row.id} ${row.peer} ${row.state} rev:${row.revision} age:${row.createdAt ? Math.max(0, Math.floor((now - row.createdAt) / 1000)) + "s" : "?"}`;
-      else text = row.text;
-      lines.push(fit(`${start + i === s.selection ? ">" : " "} ${text}`, columns));
+        line.push(span(row.id, row.state === "offline" ? undefined : selected ? "strong" : "info"), span(" "), span(row.state, stateTone(row.state)),
+          span(` ${row.attached === false ? "detached" : "attached"} q:${row.queued ?? 0} `), span(`!:${row.queuedImportant ?? 0}`, row.queuedImportant ? "attention" : undefined),
+          span(` review:${row.needsReview ?? 0}`, row.needsReview ? "failure" : undefined), span(" "),
+          span(row.paused ? `paused:${JSON.stringify(row.paused)}` : "", "attention"), span(" "),
+          span(b?.paused ? `budget pause ${b.paused.reason} reset:${b.paused.resetsAt}` : "", "attention"), span(" "),
+          span(b?.windows?.map((w: any) => `${w.id}:${Math.round(w.used * 100)}% reset:${w.resetsAt ?? "?"}`).join(" ") ?? "quota:?"), span(` model:${row.servedBy ?? row.requestedModel ?? "?"}`));
+      } else if (s.panel === 2) line.push(span(`${row.id} ${row.peer}`, "attention"), span(` ${Math.max(0, Math.ceil((row.expiresAt - now) / 1000))}s`, "muted"), span(` ${row.title}`));
+      else if (s.panel === 3) {
+        const last = row.history?.at(-1);
+        const at = last?.at ?? row.updated ?? row.created;
+        const tone = last?.event === "check failed" || last?.event === "failed" ? "failure" : stateTone(row.state);
+        const failure = (last?.event === "check failed" || last?.event === "failed") && row.state !== last.event ? ` ${last.event}` : "";
+        line.push(span(`#${row.id}`, selected ? "strong" : "info"), span(" "), span(row.state, tone), span(failure, "failure"), span(row.ready ? " ready" : "", "attention"),
+          span(` ${row.owner ?? "-"} review:${row.reviewer ?? "-"} ${row.class} `), span(`age:${at ? Math.max(0, Math.floor((now - at) / 1000)) + "s" : "?"}`, "muted"), span(` ${row.title}`));
+      } else if (s.panel === 4) line.push(span(row.id, selected ? "strong" : "info"), span(` ${row.peer} `), span(row.state, stateTone(row.state)), span(` rev:${row.revision} `), span(`age:${row.createdAt ? Math.max(0, Math.floor((now - row.createdAt) / 1000)) + "s" : "?"}`, "muted"));
+      else { const [header, ...body] = String(row.text).split("\n"); line.push(span(header, row.tone)); if (body.length) line.push(span("\n" + body.join("\n"))); }
+      lines.push(fitLine(line, columns));
     }
-    if (!data.length) lines.push("(empty)");
-    if (s.panel === 2 && permission) lines.push(...wrap(permission.title, columns).slice(0, Math.max(0, rows - 3 - lines.length)));
+    if (!data.length) lines.push([span("(empty)")]);
+    if (s.panel === 2 && permission) lines.push(...wrap(permission.title, columns).slice(0, Math.max(0, rows - 3 - lines.length)).map(text => [span(text)]));
   }
-  const body = lines.slice(0, rows - 3); while (body.length < rows - 3) body.push("");
+  const body = lines.slice(0, rows - 3); while (body.length < rows - 3) body.push([]);
   return [...body, ...footer];
 }

package/src/cli/console.ts

@@ -3,8 +3,9 @@ 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 { initialConsoleState, pruneApprovals, reduceConsole, renderConsole, terminalText, wrap } from "./console-state.ts";
-import type { ConsoleEffect, ConsoleEvent } from "./console-state.ts";
+import { initialConsoleState, paint, pruneApprovals, reduceConsole, renderConsoleLines, resolveColor, stateTone, terminalText, wrap } from "./console-state.ts";
+import type { ConsoleEffect, ConsoleEvent, Tone } from "./console-state.ts";
+import type { BusEvent } from "../hub/bus.ts";
 
 export interface ConsoleTerminal {
   columns: number; rows: number; isTTY: boolean; isRaw?: boolean;
@@ -19,11 +20,23 @@ export interface ConsoleOptions {
   client: Pick<ControlClient, "request" | "send" | "close" | "onPush" | "onClose">;
   cwd: string; stateDir: string; panels?: boolean; columns?: number; rows?: number;
   terminal?: ConsoleTerminal;
+  color?: boolean;
   /** Injected command runner must use argv, closed stdin, and return a cancellation handle. */
   runCommand?: (args: string[], output: (text: string) => void, done: () => void) => (() => void);
   pollMs?: number;
 }
 export const RESTORE_CONSOLE = "\x1b[?1049l\x1b[r\x1b[0m\x1b[?25h";
+/** Console-only styling uses event structure; tail text and message bodies are never parsed for meaning. */
+export function eventTone(e: BusEvent): Tone | undefined {
+  if (e.t === "state") return stateTone(e.state);
+  if (e.t === "undeliverable" || e.t === "overflow") return "failure";
+  if (e.t === "envelope") {
+    if (e.dropped === "hop") return "failure";
+    if (e.env.priority === "important" || e.env.kind === "task" || e.env.kind === "review" || e.env.kind === "budget") return "attention";
+    return "info";
+  }
+  return undefined;
+}
 function nativeTerminal(): ConsoleTerminal {
   return {
     get columns() { return process.stdout.columns ?? 80; }, get rows() { return process.stdout.rows ?? 24; },
@@ -46,6 +59,7 @@ function nativeTerminal(): ConsoleTerminal {
 /** One terminal client, no daemon ownership. All text crosses terminalText before writing. */
 export async function runConsole(options: ConsoleOptions): Promise<void> {
   const { client } = options; const terminal = options.terminal ?? nativeTerminal();
+  const color = options.color ?? resolveColor(undefined, { isTTY: terminal.isTTY, TERM: process.env.TERM, NO_COLOR: process.env.NO_COLOR }) === true;
   let state = initialConsoleState(!!options.panels);
   let columns = options.columns ?? terminal.columns; let rows = options.rows ?? terminal.rows;
   let active = true; let inAlternate = false; let plain = !terminal.isTTY || columns < 80 || rows < 24;
@@ -54,15 +68,19 @@ export async function runConsole(options: ConsoleOptions): Promise<void> {
   const removers: (() => void)[] = []; const timers: ReturnType<typeof setInterval>[] = [];
   let resolveDone: () => void = () => {}; const done = new Promise<void>(resolve => { resolveDone = resolve; });
   let pendingStream: ConsoleEvent[] = []; let droppedStream = 0;
-  const safeWrite = (text: string) => terminal.write(terminalText(text));
-  const writeStream = (text: string) => {
+  const safeWrite = (text: string) => terminal.write(paint([{ text }], color));
+  const streamLines = (event: ConsoleEvent) => terminalText(event.text).split("\n").flatMap((text, index) => wrap(text, columns).map(line => [{ text: line, ...(index === 0 && event.tone ? { tone: event.tone } : {}) }]));
+  const writeStream = (event: ConsoleEvent) => {
     terminal.write(`\x1b[${rows - 3};1H`);
-    for (const line of wrap(text, columns)) { safeWrite(line); terminal.write("\r\n"); }
+    for (const line of streamLines(event)) { terminal.write(paint(line, color)); terminal.write("\r\n"); }
   };
   const stream = (event: ConsoleEvent) => {
     state.events = [...state.events, { ...event, text: terminalText(event.text) }].slice(-1000);
-    if (plain) safeWrite(event.text + "\n");
-    else if (state.mode === "stream") writeStream(event.text);
+    if (plain) {
+      const [header, ...body] = terminalText(event.text).split("\n");
+      terminal.write(paint([{ text: header ?? "", tone: event.tone }, ...body.map(text => ({ text: "\n" + text }))], color) + "\n");
+    }
+    else if (state.mode === "stream") writeStream(event);
     else { pendingStream.push(event); if (pendingStream.length > 1000) { pendingStream.shift(); droppedStream++; } }
   };
   const draw = () => {
@@ -70,15 +88,15 @@ export async function runConsole(options: ConsoleOptions): Promise<void> {
     if (state.mode === "panels" && !inAlternate) { terminal.write("\x1b[r\x1b[?1049h\x1b[2J"); inAlternate = true; }
     else if (state.mode === "stream" && inAlternate) {
       terminal.write(`\x1b[?1049l\x1b[1;${rows - 3}r`); inAlternate = false;
-      if (droppedStream) writeStream(`${droppedStream} older panel-mode events omitted from console memory; inspect hub.log for the full stream.`);
-      for (const event of pendingStream) writeStream(event.text);
+      if (droppedStream) writeStream({ text: `${droppedStream} older panel-mode events omitted from console memory; inspect hub.log for the full stream.` });
+      for (const event of pendingStream) writeStream(event);
       pendingStream = []; droppedStream = 0;
     }
     terminal.write(state.mode === "stream" ? `\x1b[1;${rows - 3}r` : "\x1b[r");
-    const lines = renderConsole(state, columns, rows);
+    const lines = renderConsoleLines(state, columns, rows);
     const start = state.mode === "stream" ? rows - 2 : 1;
-    for (const [index, line] of lines.entries()) { terminal.write(`\x1b[${start + index};1H\x1b[2K`); safeWrite(line); }
-    terminal.write(`\x1b[${rows};${Math.min(columns, Bun.stringWidth(lines.at(-1) ?? "") + 1)}H\x1b[?25h`);
+    for (const [index, line] of lines.entries()) { terminal.write(`\x1b[${start + index};1H\x1b[2K`); terminal.write(paint(line, color)); }
+    terminal.write(`\x1b[${rows};${Math.min(columns, Bun.stringWidth(paint(lines.at(-1) ?? [], false)) + 1)}H\x1b[?25h`);
   };
   const stop = (reason?: string) => {
     if (!active) return;
@@ -130,7 +148,11 @@ export async function runConsole(options: ConsoleOptions): Promise<void> {
   });
   const effect = async (action: ConsoleEffect) => {
     if (action.type === "exit") return stop();
-    if (action.type === "permit") { client.send({ t: "permit", surface: "console", id: action.id, ...(action.option ? { option: action.option } : {}) }); return; }
+    if (action.type === "permit") {
+      client.send({ t: "permit", surface: "console", id: action.id, ...(action.option ? { option: action.option } : {}) });
+      if (!action.option) stream({ text: `  ! denial requested for permission ${action.id}`, kind: "permission", tone: "failure" });
+      return;
+    }
     if (action.type === "show") {
       const result = await client.request(action.panel === 3 ? { t: "task", op: "task_show", args: { id: action.id } } : { t: "queue", op: "show", id: action.id }, 3000);
       if (!active) return;
@@ -157,14 +179,15 @@ export async function runConsole(options: ConsoleOptions): Promise<void> {
   client.onPush = msg => {
     if (!active) return;
     try {
-      if (msg.t === "event") stream({ text: renderTailEvent(msg.e), peer: msg.e.peer ?? msg.e.env?.from, kind: msg.e.env?.kind ?? msg.e.t });
+      if (msg.t === "event") stream({ text: renderTailEvent(msg.e), peer: msg.e.peer ?? msg.e.env?.from, kind: msg.e.env?.kind ?? msg.e.t, tone: eventTone(msg.e) });
       else if (msg.t === "context") stream({ text: `  ${msg.peer}: ${contextLine(msg.reading)}`, peer: msg.peer, kind: "context" });
       else if (msg.t === "notice") stream({ text: `  * ${msg.line}`, kind: "notice" });
       else if (msg.t === "permission") {
-        stream({ text: `  ? ${msg.peer} asks permission: ${String(msg.title).replace(/\n/g, "\n      | ")}\n    answer with: ahub permit ${msg.id} <${msg.options.map((o: any) => `${o.optionId} (${o.name})`).join(", ")}> | deny`, peer: msg.peer, kind: "permission" });
+        stream({ text: `  ? ${msg.peer} asks permission: ${String(msg.title).replace(/\n/g, "\n      | ")}\n    answer with: ahub permit ${msg.id} <${msg.options.map((o: any) => `${o.optionId} (${o.name})`).join(", ")}> | deny`, peer: msg.peer, kind: "permission", tone: "attention" });
         if (typeof msg.expiresAt === "number" && msg.expiresAt > Date.now() && !state.approvals.some(a => a.id === msg.id)) state.approvals.push(msg);
       } else if (msg.t === "permission_closed") {
         state.approvals = state.approvals.filter(a => a.id !== msg.id); state = pruneApprovals(state, Date.now());
+        if (msg.reason === "expired" || msg.outcome === "cancelled" || msg.outcome?.startsWith("reject")) stream({ text: `  ! ${msg.peer} permission ${msg.id} ${msg.reason ?? msg.outcome}`, peer: msg.peer, kind: "permission", tone: "failure" });
       }
       draw();
     } catch (error) { stop(`Console error: ${String((error as Error).message)}`); }

package/src/cli/main.ts

@@ -33,12 +33,13 @@ import { setupOllamaModel } from "./models-setup.ts";
 import { unknownContext } from "../hub/context-window.ts";
 import { backendLine, contextLine, peerLine, type BackendRow, type PeerRow } from "./status-lines.ts";
 import { parseSince, readEvents } from "../hub/events.ts";
-import { formatReport, summarize } from "../hub/report.ts";
+import { formatReport, summarize, formatTaskReport, summarizeByTask } from "../hub/report.ts";
 import { hasTree, planUndo, repoOf, restore, Turns } from "../hub/snapshots.ts";
 import { pathWarnings } from "../hub/conflicts.ts";
 import { classifyPeerCommand, cliCommandLabel, detectCliIdentity, peerCommandRefusal } from "./identity.ts";
 import { recordCliAudit } from "./identity-audit.ts";
 import { runConsole } from "./console.ts";
+import { resolveColor } from "./console-state.ts";
 import { renderTailEvent } from "./tail-render.ts";
 
 /** `--since 7d|24h|<iso>` for export and report; everything when absent. */
@@ -61,7 +62,7 @@ const USAGE = `agent-hub ${VERSION}: Claude Code, Codex and Kimi as peers in one
   ahub setup [--yes]            install or update the Claude Code channel plugin from this package, then run doctor
   ahub init [--dry-run --json]   preview or write .agenthub/config.json and the AGENTS.md marker block (drops a legacy CLAUDE.md block)
   ahub up [--unattended] [--no-console]  start the daemon; interactive terminals enter console
-  ahub console [--panels]      enter the human console, leaving the daemon running on exit
+  ahub console [--panels] [--color=auto|always|never]  enter the human console, leaving the daemon running on exit
   ahub upgrade --to <version> [--dry-run] [--yes]   review and upgrade running projects
   ahub restart [--dry-run] [--yes]                 recover this project's runtime
   ahub recovery status|resume|abort <operation-id> inspect, resume or cancel a preflight
@@ -96,7 +97,7 @@ const USAGE = `agent-hub ${VERSION}: Claude Code, Codex and Kimi as peers in one
   ahub queue resolve <delivery-id> --action completed|retry|discard --reason <text>
   ahub status | logs [-f] | doctor | kill
   ahub export [--since 7d|<iso>]  structured events (events.jsonl) as JSON lines; never message bodies
-  ahub report [--since 7d|<iso>] [--json]  turns, tokens, messages, overlaps and task events per period
+  ahub report [--since 7d|<iso>] [--by task] [--json]  turns, tokens, messages, overlaps and task events per period
   ahub check-path <file> [--peer <id>]  other owners' open tasks that claim or changed a file
   ahub check-path --hook        the same as a Claude Code PreToolUse hook (templates/claude-hooks.json); never blocks
   ahub facts --hook             turn-free facts as a Claude Code PreToolUse, PostToolUse and Stop hook (issue #108); never blocks
@@ -491,8 +492,10 @@ const commands: Record<string, () => Promise<void> | void> = {
   },
 
   console: async () => {
-    if (args.some(arg => arg !== "--panels")) fail("usage: ahub console [--panels]");
-    await runConsole({ client: await connect(), cwd, stateDir, panels: args.includes("--panels") });
+    if (args.some(arg => arg !== "--panels" && !arg.startsWith("--color=")) || args.filter(arg => arg.startsWith("--color=")).length > 1) fail("usage: ahub console [--panels] [--color=auto|always|never]");
+    const color = resolveColor(args.find(arg => arg.startsWith("--color="))?.slice("--color=".length), { isTTY: !!process.stdin.isTTY && !!process.stdout.isTTY, TERM: process.env.TERM, NO_COLOR: process.env.NO_COLOR });
+    if (color instanceof Error) return fail(color.message);
+    await runConsole({ client: await connect(), cwd, stateDir, panels: args.includes("--panels"), color });
   },
 
   up: async () => {
@@ -825,7 +828,14 @@ const commands: Record<string, () => Promise<void> | void> = {
     for (const e of readEvents(join(stateDir, "events.jsonl"), since())) console.log(JSON.stringify(e));
   },
   report: () => {
-    const r = summarize(readEvents(join(stateDir, "events.jsonl"), since()));
+    const by = args.indexOf("--by");
+    if (by >= 0 && args[by + 1] !== "task") return fail("--by takes task");
+    const events = readEvents(join(stateDir, "events.jsonl"), since());
+    if (by >= 0) {
+      const r = summarizeByTask(events);
+      return console.log(args.includes("--json") ? JSON.stringify(r, null, 2) : formatTaskReport(r).join("\n"));
+    }
+    const r = summarize(events);
     console.log(args.includes("--json") ? JSON.stringify(r, null, 2) : formatReport(r).join("\n"));
   },
   facts: async () => {

package/src/hub/attribution.ts

@@ -0,0 +1,20 @@
+import type { Envelope } from "./envelope.ts";
+
+export type Attribution = "delivery" | "single_open" | "unattributed";
+export interface TaskAttribution { task?: number; attribution: Attribution; pii?: true }
+
+/** Only one distinct positive task id in the original delivery can identify its turn. */
+export function deliveryTask(originals: Envelope[]): number | undefined {
+  const ids = new Set(originals.flatMap(env => {
+    const id = Number(env.refs?.task);
+    return Number.isSafeInteger(id) && id > 0 ? [id] : [];
+  }));
+  return ids.size === 1 ? ids.values().next().value : undefined;
+}
+
+/** Rule order is deliberate: a delivered review belongs to its task, regardless of ownership. */
+export function attribute(delivery: number | undefined, inProgress: number[]): TaskAttribution {
+  if (delivery !== undefined && Number.isSafeInteger(delivery) && delivery > 0) return { task: delivery, attribution: "delivery" };
+  if (inProgress.length === 1) return { task: inProgress[0]!, attribution: "single_open" };
+  return { attribution: "unattributed" };
+}

package/src/hub/bus.ts

@@ -17,6 +17,8 @@ export type BusEvent =
   | { t: "state"; peer: PeerId; state: PeerState };
 
 export interface BusOptions {
+  /** Observe original envelopes immediately before a transport starts its turn. */
+  onDeliver?: (peer: PeerId, originals: Envelope[]) => void;
   retryMs: number;
   /** A queue this long is delivered without waiting for the batch window. */
   batchMax: number;
@@ -125,6 +127,8 @@ export class Bus {
   onQueues?: () => void;
   /** Actual transport admission, using originals even when a digest was condensed. Never an enqueue metric. */
   onDelivered?: (peer: PeerId, originals: Envelope[]) => void;
+  /** Before deliver's synchronous busy transition, with originals rather than a condensed digest. */
+  onDeliver?: (peer: PeerId, originals: Envelope[]) => void;
   /** Synchronous native failure observation, before queue callbacks can finish turn metrics. */
   onDeliveryFailed?: (peer: PeerId) => void;
   private recoveryHeld = false;
@@ -135,6 +139,7 @@ export class Bus {
 
   constructor(opts: Partial<BusOptions> = {}) {
     this.opts = { ...DEFAULT_BUS, ...opts };
+    this.onDeliver = opts.onDeliver;
     this.journal = opts.journal;
     if (this.journal) {
       const state = this.journal.snapshot();
@@ -753,6 +758,7 @@ export class Bus {
         const deliveryId = crypto.randomUUID();
         if (this.journal) { this.durableHandoff(id, deliveryId, delivery, out); this.activeDeliveries.set(deliveryId, id); }
         try {
+          try { this.onDeliver?.(id, delivery); } catch { /* observation must never affect delivery */ }
           if (this.journal) await peer.deliver(out, deliveryId);
           else { await peer.deliver(out); this.delivered(id, delivery); }
         } catch {

package/src/hub/daemon.ts

@@ -46,6 +46,7 @@ import { DEFAULT_INFERENCE, DIGEST, Inference, type InferenceConfig } from "./in
 import { ask, ASK_NOTE_TITLE, RUN_START } from "./ask.ts";
 import { currentRouting, detectSignals } from "./routing.ts";
 import { Bus } from "./bus.ts";
+import { attribute, deliveryTask, type TaskAttribution } from "./attribution.ts";
 import { DeliveryJournal } from "./delivery-journal.ts";
 import { startDashboard } from "./ui.ts";
 import { PROTOCOL, stateDirFor } from "./control-client.ts";
@@ -956,14 +957,26 @@ export async function startDaemon(opts: DaemonOptions) {
   // Turns and their tokens for telemetry (issue #40). Turn ids carry the hub run, so they stay unique across restarts.
   const runId = Date.now().toString(36);
   let turnSeq = 0;
-  const turns = new Map<PeerId, { id: string; start: number; tokens: number; tree?: string; snapshotMs?: number; private?: boolean }>();
+  const turns = new Map<PeerId, { id: string; start: number; tokens: number; tree?: string; snapshotMs?: number; private?: boolean; deliveryTask?: number; attribution: TaskAttribution }>();
+  const pendingDeliveryTask = new Map<PeerId, number>();
+  const taskAttribution = (peer: PeerId, delivery = turns.get(peer)?.deliveryTask): TaskAttribution => {
+    const result = attribute(delivery, board.list("in_progress").filter(t => t.owner === peer).map(t => t.id));
+    const task = result.task === undefined ? undefined : board.get(result.task);
+    return { ...result, ...(task && tasks.isPii(task) ? { pii: true as const } : {}) };
+  };
   const supervisionTurns = new Map<PeerId, { id: string; at: number; tokens?: number; session?: string }>();
+  bus.onDeliver = (peer, originals) => {
+    pendingDeliveryTask.delete(peer);
+    const task = deliveryTask(originals);
+    if (task !== undefined) pendingDeliveryTask.set(peer, task);
+  };
   bus.onDelivered = (peer, originals) => {
+    pendingDeliveryTask.delete(peer);
     if (!originals.some(env => env.from === HUB && env.refs?.supervision) || supervisionTurns.has(peer)) return;
     const turn = turns.get(peer);
     supervisionTurns.set(peer, { id: turn?.id ?? `supervision-${randomUUID()}`, at: turn?.start ?? Date.now(), ...(turn?.tokens ? { tokens: turn.tokens } : {}), ...(contextSession(peer) ? { session: contextSession(peer) } : {}) });
   };
-  bus.onDeliveryFailed = peer => { supervisionTurns.delete(peer); };
+  bus.onDeliveryFailed = peer => { pendingDeliveryTask.delete(peer); supervisionTurns.delete(peer); };
   const finishSupervisionTurn = (peer: PeerId) => {
     const receipt = supervisionTurns.get(peer);
     if (!receipt) return;
@@ -1000,7 +1013,7 @@ export async function startDaemon(opts: DaemonOptions) {
     const supervisionTurn = supervisionTurns.get(peer);
     if (supervisionTurn && Number.isFinite(n) && n >= 0) supervisionTurn.tokens = (supervisionTurn.tokens ?? 0) + n;
     if (n > 0) {
-      event({ type: "tokens", peer, n });
+      event({ type: "tokens", peer, n, ...taskAttribution(peer) });
       const turn = turns.get(peer);
       if (turn) turn.tokens += n;
     }
@@ -1382,7 +1395,7 @@ export async function startDaemon(opts: DaemonOptions) {
       claudeNativeUsageSeen.add(record.id);
       const reported = claudeReportedTokens(record.usage);
       if (reported !== undefined) addTokens("claude", reported);
-      event({ type: "usage", peer: "claude", source: "claude_transcript", id: record.id, ...record.usage, ...(record.servedModel ? { servedModel: record.servedModel } : {}), ...(record.at ? { measuredAt: record.at } : {}) });
+      event({ type: "usage", peer: "claude", source: "claude_transcript", id: record.id, ...record.usage, ...taskAttribution("claude"), ...(record.servedModel ? { servedModel: record.servedModel } : {}), ...(record.at ? { measuredAt: record.at } : {}) });
     }
   };
   const claudeUsageTimer = setInterval(collectClaudeUsage, 2000);
@@ -1631,6 +1644,9 @@ export async function startDaemon(opts: DaemonOptions) {
       // The adapter's own state: a pause shows a busy peer as paused, and its turn goes on all the same.
       const busy = (bus.peers.get(e.peer)?.state ?? e.state) === "busy";
       if (busy && !open) {
+        const delivery = pendingDeliveryTask.get(e.peer);
+        pendingDeliveryTask.delete(e.peer);
+        const attribution = taskAttribution(e.peer, delivery);
         const id = `${e.peer}#${runId}.${++turnSeq}`;
         // A turn of a peer with a PII task open is not snapshotted: what it writes would stay in git's object store until
         // gc. It is still recorded, without trees, so an overlapping turn's undo knows its changes are unknown.
@@ -1639,7 +1655,7 @@ export async function startDaemon(opts: DaemonOptions) {
         turnTasks.set(id, board.list().filter((t) => t.owner === e.peer && ["proposed", "in_progress", "changes_requested", "in_review"].includes(t.state)).map((t) => t.id));
         const start = turnLog && !pii ? snap(`the start of ${id}`) : undefined; // before the peer is handed anything: the tap runs inside setState
         try { turnLog?.begin(id, e.peer, start?.tree); } catch (error) { log(`turn record ${id}: ${(error as Error).message}`); }
-        turns.set(e.peer, { id, start: Date.now(), tokens: 0, ...(start ? { tree: start.tree, snapshotMs: start.ms } : {}), ...(pii ? { private: true } : {}) });
+        turns.set(e.peer, { id, start: Date.now(), tokens: 0, deliveryTask: delivery, attribution, ...(start ? { tree: start.tree, snapshotMs: start.ms } : {}), ...(pii ? { private: true } : {}) });
         event({ type: "turn_start", peer: e.peer, turn: id });
       } else if (!busy && open) {
         turns.delete(e.peer);
@@ -1658,7 +1674,7 @@ export async function startDaemon(opts: DaemonOptions) {
           if (changed.length) afterTurn = () => detectConflicts(e.peer, open.id, open.start, changed);
         }
         // A lost Claude channel/watchdog is not native completion; only its real Stop closes a counted turn.
-        if (e.peer !== "claude" || (nativeCompletedAt.get(e.peer) ?? -1) >= open.start) event({ type: "turn_end", peer: e.peer, turn: open.id, ms: Date.now() - open.start, ...(open.tokens ? { tokens: open.tokens } : {}), ...(files !== undefined ? { files, snapshotMs } : {}) });
+        if (e.peer !== "claude" || (nativeCompletedAt.get(e.peer) ?? -1) >= open.start) event({ type: "turn_end", peer: e.peer, turn: open.id, ms: Date.now() - open.start, ...open.attribution, ...(open.tokens ? { tokens: open.tokens } : {}), ...(files !== undefined ? { files, snapshotMs } : {}) });
         if (e.peer !== "claude") { // Claude's native turn end is its Stop hook
           if ((bus.peers.get(e.peer)?.state ?? e.state) === "idle") queueMicrotask(() => finishSupervisionTurn(e.peer));
           turnEnded.set(e.peer, Date.now());
@@ -1963,11 +1979,22 @@ export async function startDaemon(opts: DaemonOptions) {
       });
       piReceipts ??= new PiToolReceipts(join(opts.stateDir, "hub.db"));
       let piReply: Envelope | undefined;
+      // Tools the person allowed "always" for this Pi start; a new start gets a new set (#209).
+      const piAlways = new Set<string>();
+      const piPermit = async (title: string, tool: string): Promise<boolean> => {
+        if (piAlways.has(tool)) log(`permission auto-allowed for pi: ${tool} (granted until Pi restarts)`); // the name only, never the arguments
+        else {
+          const picked = await onPermission({ peer: "pi", title, options: [{ optionId: "allow", name: "Allow", kind: "allow_once" }, { optionId: "always", name: `Always allow ${tool} until Pi restarts`, kind: "allow_always" }, { optionId: "deny", name: "Deny", kind: "reject_once" }] });
+          if (picked === "always") piAlways.add(tool);
+          else if (picked !== "allow") return false;
+        }
+        return pi.acceptingTools && bus.peers.get("pi") === pi;
+      };
       const ctx: ToolContext = {
         cwd: opts.cwd, deny: config.local.deny,
         sandboxProfile: profile(opts.cwd, sandboxNetwork, config.local.read_allow, config.local.deny),
         sandboxEnv: { ...proxyEnv(sandboxNetwork), AGENTHUB_PEER_ID: "pi" },
-        permit: (title) => onPermission({ peer: "pi", title, options: [{ optionId: "allow", name: "Allow", kind: "allow_once" }, { optionId: "deny", name: "Deny", kind: "reject_once" }] }).then((picked) => picked === "allow" && pi.acceptingTools && bus.peers.get("pi") === pi),
+        permit: async () => false, // Pi's calls ask through piPermit in executeTool, which knows the tool's name
         send: (text, to) => {
           if (to?.some((id) => !bus.peers.has(id) && id !== USER)) return "error: unknown peer";
           const refused = pi.onMessage?.(text, { inReplyTo: piReply, ...(to?.length ? { to } : {}) });
@@ -1989,12 +2016,12 @@ export async function startDaemon(opts: DaemonOptions) {
             if (!raw || typeof raw !== "object" || Array.isArray(raw)) return "error: invalid tool arguments";
             const nativeTurn = pi.observationTurn;
             const output = TASK_TOOLS.some((t) => t.name === name) || CONDUCTOR_TOOL_NAMES.has(name) ? await taskOp("pi", name, raw as Record<string, unknown>, true) : await runTool(name, JSON.stringify(raw), { ...ctx, signal, permit: async title => {
-              if (!signal) return ctx.permit(title);
+              if (!signal) return piPermit(title, name);
               if (signal.aborted) return false;
               return new Promise<boolean>((resolve, reject) => {
                 const finish = (allowed: boolean) => { signal.removeEventListener("abort", aborted); resolve(allowed && !signal.aborted); };
                 const aborted = () => finish(false); signal.addEventListener("abort", aborted, { once: true });
-                Promise.resolve(ctx.permit(title)).then(finish, error => { signal.removeEventListener("abort", aborted); reject(error); });
+                piPermit(title, name).then(finish, error => { signal.removeEventListener("abort", aborted); reject(error); });
               });
             } });
             if (!signal?.aborted && bus.peers.get("pi") === pi) {
@@ -2087,7 +2114,7 @@ export async function startDaemon(opts: DaemonOptions) {
       const local = new LocalPeer("local", {
         cwd: opts.cwd,
         omni,
-        onUsage: record => event({ type: "usage", peer: "local", source: "omniroute", id: record.id, ...record.usage, requestedModel: record.requestedModel, ...(record.servedModel ? { servedModel: record.servedModel } : {}), ...(record.provider ? { provider: record.provider } : {}), measuredAt: record.at }),
+        onUsage: record => event({ type: "usage", peer: "local", source: "omniroute", id: record.id, ...record.usage, ...taskAttribution("local", record.task), requestedModel: record.requestedModel, ...(record.servedModel ? { servedModel: record.servedModel } : {}), ...(record.provider ? { provider: record.provider } : {}), measuredAt: record.at }),
         admitBudget: async (envs, unit) => tasks.admitExecutionEnvelopes(envs, "local", unit),
         ...(route ? { route } : {}),
         ...(sidecar && route && !route.startsWith("hub/") ? { sidecar } : {}),

package/src/hub/events.ts

@@ -1,4 +1,5 @@
 import { appendFileSync, closeSync, existsSync, fstatSync, openSync, readFileSync, readSync } from "node:fs";
+import type { TaskAttribution } from "./attribution.ts";
 
 /** Bumped whenever a field changes meaning or goes away; new fields and new types do not bump it. */
 export const EVENTS_SCHEMA = 1;
@@ -23,7 +24,7 @@ export type HubEvent =
   | { type: "split"; task: number; where?: "routing" | "cohort"; verdict: "split" | "single" | "unknown"; single?: string; splitS?: number; singleS?: number; reason?: string; trace?: string[] }
   | { type: "state"; peer: string; state: string }
   | { type: "turn_start"; peer: string; turn: string }
-  | { type: "turn_end"; peer: string; turn: string; ms: number; tokens?: number; files?: number; snapshotMs?: number }
+  | ({ type: "turn_end"; peer: string; turn: string; ms: number; tokens?: number; files?: number; snapshotMs?: number } & Partial<TaskAttribution>)
   | { type: "native_turn_end"; peer: string; id?: string }
   | { type: "conduct"; peer: string; action: string; task?: number; target?: string }
   | { type: "agent_cli"; peer: string; command: string; refused: boolean }
@@ -32,8 +33,8 @@ export type HubEvent =
   | { type: "supervision_turn"; peer: string; turn: string; tokens?: number; ms?: number }
   | { type: "hook_stats"; peer: string; n: number; startupMs: number; hubMs: number; maxStartupMs: number }
   | { type: "cohort"; id: number; event: "formed" | "joined" | "lifted"; silent: boolean; tasks: number[]; owners: string[] }
-  | { type: "tokens"; peer: string; n: number }
-  | { type: "usage"; peer: string; source: "omniroute" | "claude_transcript"; id: string; measuredAt?: string; requestedModel?: string; servedModel?: string; provider?: string; inputTokens?: number; outputTokens?: number; cacheReadTokens?: number; cacheWriteTokens?: number; totalTokens?: number }
+  | ({ type: "tokens"; peer: string; n: number } & Partial<TaskAttribution>)
+  | ({ type: "usage"; peer: string; source: "omniroute" | "claude_transcript"; id: string; measuredAt?: string; requestedModel?: string; servedModel?: string; provider?: string; inputTokens?: number; outputTokens?: number; cacheReadTokens?: number; cacheWriteTokens?: number; totalTokens?: number } & Partial<TaskAttribution>)
   | { type: "task"; id: number; event: string; by: string; state: string; owner: string | null; reviewer: string | null; class: string; pii: boolean }
   | { type: "overlap"; task: number; owner: string; others: { task: number; owner: string; paths: string[]; symbols?: string[] }[] }
   | { type: "conflict"; peer: string; task?: number; other: number; owner: string; paths: string[]; concurrent: boolean; turns?: [string, string] }