@staix/agent-hub 0.12.16 → 0.12.18

package/src/adapters/local-worker.ts

@@ -4,7 +4,7 @@ import type { RouteLabelEvent, RouteTurnOutcome } from "../models/route/labels.t
 import type { ToolObservation } from "../models/route/signals.ts";
 import { randomUUID } from "node:crypto";
 import { renderDigest, replyAudience, replyParent, STANDING_INSTRUCTION, USER, type Envelope, type EnvelopeOpts, type PeerId } from "../hub/envelope.ts";
-import { TASK_TOOL_NAMES, TASK_TOOLS } from "../hub/hub-tools.ts";
+import { CONDUCTOR_TOOL_NAMES, CONDUCTOR_TOOLS, TASK_TOOL_NAMES, TASK_TOOLS } from "../hub/hub-tools.ts";
 import { BasePeer } from "../hub/peers.ts";
 import { profile, proxyEnv, type SandboxNetwork } from "../local/sandbox.ts";
 import { runTool, toolResultFailed, TOOL_SCHEMAS, touchedPaths, type ToolContext } from "../local/tools.ts";
@@ -35,7 +35,7 @@ export interface LocalOptions {
   /** Runs a hub task tool (hub_task_*, hub_review, hub_remember) as this peer. Absent = the tools are not offered. */
   taskTool?: (name: string, args: Record<string, unknown>, turn: { pii: boolean }) => Promise<string>;
   /** Successful provider responses only; usage may be absent when the gateway omits it. Never includes prompt data. */
-  onUsage?: (record: { id: string; at: string; usage?: ChatResult["usage"]; requestedModel: string; servedModel?: string; provider?: string }) => void;
+  onUsage?: (record: { id: string; at: string; usage?: ChatResult["usage"]; requestedModel: string; servedModel?: string; provider?: string; task?: number }) => void;
   /** Atomic task/run admission immediately before every model request or tool execution. */
   admitBudget?: (envs: Envelope[], unit: "model_calls" | "tool_calls") => Promise<ExecutionBudgetDecision[]>;
   /** Per-turn policy from the task the delivery carries: the class's route, and whether it is a PII task. */
@@ -76,6 +76,7 @@ export class LocalPeer extends BasePeer {
   private readonly routes: HubRouteRuntime;
   private routeEnvs: Envelope[] = [];
   private routePii = false;
+  private routeTask?: number;
   private labelTurnId?: string;
   private turn = 0; // generation guard, as in acp.ts: a turn aborted by the watchdog must not touch the next one
   private abort: AbortController | undefined;
@@ -94,13 +95,13 @@ export class LocalPeer extends BasePeer {
     this.routes = new HubRouteRuntime({
       execute: async (model, messages, judge, signal, maxTokens) => {
         if (signal.aborted) throw new Error("turn cancelled before model request");
-        const envs = this.routeEnvs, pii = this.routePii, generation = this.turn;
+        const envs = this.routeEnvs, pii = this.routePii, generation = this.turn, task = this.routeTask;
         await this.requireBudget(envs, "model_calls");
         if (generation !== this.turn) throw new Error("route belongs to an ended turn");
         if (signal.aborted) throw new Error("turn cancelled before model request");
-        const tools = judge ? undefined : [...TOOL_SCHEMAS, ...(this.opts.taskTool ? TASK_TOOLS.map(asFunction) : [])];
+        const tools = judge ? undefined : [...TOOL_SCHEMAS, ...(this.opts.taskTool ? [...TASK_TOOLS, ...CONDUCTOR_TOOLS].map(asFunction) : [])];
         const result = await this.opts.omni.chat({ model, messages, ...(tools ? { tools } : {}), ...(judge ? { max_tokens: maxTokens ?? 2048 } : {}) }, { signal, ...(pii ? { onCampusOnly: true } : {}) });
-        this.recordUsage(result, model);
+        this.recordUsage(result, model, task);
         if (generation !== this.turn) throw new Error("route belongs to an ended turn");
         this.lastServedBy = `hub ${model} (provider ${result.provider ?? "?"})`;
         return result;
@@ -250,7 +251,7 @@ export class LocalPeer extends BasePeer {
             await this.requireBudget(envs, "tool_calls");
             if (turnSignal.aborted) throw new ExecutionBudgetStop(this.budgetStopReason || "turn cancelled before tool execution");
           } catch (error) { clearInterval(alive); throw error; }
-          const running = TASK_TOOL_NAMES.has(name) && this.opts.taskTool ? this.opts.taskTool(name, safeParse(call.function.arguments), { pii: !!policy?.pii }).catch((e: Error) => `error: ${e.message}`) : runTool(name, call.function.arguments, ctx);
+          const running = (TASK_TOOL_NAMES.has(name) || CONDUCTOR_TOOL_NAMES.has(name)) && this.opts.taskTool ? this.opts.taskTool(name, safeParse(call.function.arguments), { pii: !!policy?.pii }).catch((e: Error) => `error: ${e.message}`) : runTool(name, call.function.arguments, ctx);
           const output = await running.finally(() => clearInterval(alive));
           if (turn !== this.turn) return "";
           this.touch();
@@ -281,7 +282,7 @@ export class LocalPeer extends BasePeer {
         });
       },
       sandboxProfile: this.sandboxProfile,
-      sandboxEnv: proxyEnv(this.opts.tools.bashNetwork ?? false),
+      sandboxEnv: { ...proxyEnv(this.opts.tools.bashNetwork ?? false), AGENTHUB_PEER_ID: this.id },
       signal: turnSignal,
       send: (text, to) => {
         const refused = this.onMessage?.(text, pii ? reply : { inReplyTo: replyParent(envs), to: to?.length ? to : replyAudience(envs) });
@@ -329,12 +330,13 @@ export class LocalPeer extends BasePeer {
   }
 
   /** L2 when the sidecar is up, otherwise (or when a call through it fails) the fixed model on L3. */
-  private async call(turnMsgs: ChatMessage[], policy: { route?: string; fixedModel?: string; pii?: boolean } | undefined, envs: Envelope[]): Promise<ChatResult> {
+  private async call(turnMsgs: ChatMessage[], policy: { route?: string; fixedModel?: string; pii?: boolean; task?: string } | undefined, envs: Envelope[]): Promise<ChatResult> {
     const { omni, sidecar } = this.opts;
     // A task turn asks for its class's route; a route needs the sidecar, which exists only when the worker was started with one.
     const route = policy?.route ?? this.opts.route;
     const fixedModel = policy?.fixedModel ?? this.opts.fixedModel;
-    const tools = [...TOOL_SCHEMAS, ...(this.opts.taskTool ? TASK_TOOLS.map(asFunction) : [])];
+    const task = policy?.task === undefined ? undefined : Number(policy.task);
+    const tools = [...TOOL_SCHEMAS, ...(this.opts.taskTool ? [...TASK_TOOLS, ...CONDUCTOR_TOOLS].map(asFunction) : [])];
     const signal = this.abort!.signal;
     const messages: ChatMessage[] = [{ role: "system", content: system(this.opts.cwd, this.opts.preamble) }, ...this.history, ...turnMsgs];
     const routed = await this.hubCall(route, messages, policy, signal);
@@ -345,7 +347,7 @@ export class LocalPeer extends BasePeer {
       try {
         const res = await omni.chat({ model: route!, messages, tools }, { via, sessionId: this.sessionId, signal });
         this.lastServedBy = `switchyard ${route} -> ${res.selectedModel ?? "?"}`;
-        this.recordUsage(res, route!);
+        this.recordUsage(res, route!, task);
         return res;
       } catch (e) {
         if (signal.aborted) throw e;
@@ -355,7 +357,7 @@ export class LocalPeer extends BasePeer {
     await this.requireBudget(envs, "model_calls");
     const res = await omni.chat({ model: fixedModel, messages, tools }, { signal, ...(policy?.pii ? { onCampusOnly: true } : {}) });
     this.lastServedBy = `omniroute ${fixedModel} (provider ${res.provider ?? "?"})`;
-    this.recordUsage(res, fixedModel);
+    this.recordUsage(res, fixedModel, task);
     return res;
   }
 
@@ -364,6 +366,7 @@ export class LocalPeer extends BasePeer {
     try { id = this.opts.turnId?.(); } catch { /* optional host metadata */ }
     id ??= `${this.id}#${this.sessionId}.${generation}`;
     const number = task ? Number(task) : undefined;
+    this.routeTask = Number.isSafeInteger(number) && number! > 0 ? number : undefined;
     this.labelTurnId = id;
     this.routes.beginTurn({ turn: id, pii, ...(Number.isSafeInteger(number) && number! > 0 ? { task: number } : {}) });
     return id;
@@ -418,13 +421,14 @@ export class LocalPeer extends BasePeer {
     } catch { /* optional research observations */ }
   }
 
-  private recordUsage(res: ChatResult, requestedModel: string): void {
+  private recordUsage(res: ChatResult, requestedModel: string, task?: number): void {
     try {
       this.opts.onUsage?.({
         id: randomUUID(),
         at: new Date().toISOString(),
         ...(res.usage ? { usage: res.usage } : {}),
         requestedModel: safeModelLabel(requestedModel) ?? "unknown",
+        ...(Number.isSafeInteger(task) && task! > 0 ? { task } : {}),
         ...(safeModelLabel(res.servedModel ?? res.selectedModel) ? { servedModel: safeModelLabel(res.servedModel ?? res.selectedModel)! } : {}),
         ...(safeModelLabel(res.provider) ? { provider: safeModelLabel(res.provider)! } : {}),
       });

package/src/cli/console-state.ts

@@ -0,0 +1,279 @@
+import { sanitize } from "../hub/envelope.ts";
+
+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; tone?: Tone }
+export interface ConsoleState {
+  mode: "stream" | "panels"; panel: number; selection: number; approvalIndex: number;
+  input: string; editing: boolean; history: string[]; historyIndex: number;
+  approvals: Approval[]; events: ConsoleEvent[]; peers: Record<string, any>; budget: Record<string, any>;
+  tasks: any[]; queue: any[]; detail?: string; detailOffset: number; help: boolean; notice: string;
+  peerFilter?: string; kindFilter?: string;
+  confirm?: { type: "permission"; id: string; option: string; peer: string } | { type: "command"; args: string[] };
+  optionChoice?: string;
+}
+export type ConsoleEffect = { type: "exit" } | { type: "permit"; id: string; option?: string } |
+  { type: "command"; args: string[] } | { type: "show"; panel: number; id: string };
+export function initialConsoleState(panels = false): ConsoleState {
+  return { mode: panels ? "panels" : "stream", panel: 1, selection: 0, approvalIndex: 0,
+    input: "", editing: false, history: [], historyIndex: 0, approvals: [], events: [], peers: {}, budget: {}, tasks: [], queue: [], detailOffset: 0, help: false, notice: "" };
+}
+/** 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 ?? "")
+    .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, ""));
+}
+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, " ");
+  if (columns <= 0) return "";
+  if (Bun.stringWidth(text) <= columns) return text;
+  let result = ""; const marker = ".".repeat(Math.min(3, columns));
+  for (const char of text) { if (Bun.stringWidth(result + char) > columns - marker.length) break; result += char; }
+  return result + marker;
+}
+export function wrap(value: unknown, columns: number): string[] {
+  const lines: string[] = [];
+  for (const part of terminalText(value).split("\n")) {
+    let line = "";
+    for (const char of part) {
+      if (Bun.stringWidth(line + char) > columns) { lines.push(line); line = ""; }
+      line += char;
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+export function pruneApprovals(s: ConsoleState, now: number): ConsoleState {
+  const approvals = s.approvals.filter(a => a.expiresAt > now);
+  const live = (id: string) => approvals.some(a => a.id === id);
+  return { ...s, approvals, approvalIndex: Math.min(s.approvalIndex, Math.max(0, approvals.length - 1)),
+    ...(s.confirm?.type === "permission" && !live(s.confirm.id) ? { confirm: undefined } : {}),
+    ...(s.optionChoice && !live(s.optionChoice) ? { optionChoice: undefined } : {}) };
+}
+const COMMANDS = new Set(["status", "board", "task", "review", "say", "pause", "resume", "budget", "queue", "permit", "ask", "remember", "route", "turns", "undo", "check-path", "report"]);
+/** A tiny argv parser, never a shell. Quotes group arguments; backslash escapes one character. */
+export function parseConsoleCommand(input: string): string[] {
+  const words: string[] = []; let word = ""; let quote = ""; let escaped = false; let started = false;
+  for (const char of input.trim()) {
+    if (escaped) { word += char; escaped = false; started = true; }
+    else if (char === "\\") { escaped = true; started = true; }
+    else if (quote) { if (char === quote) quote = ""; else word += char; }
+    else if (char === '"' || char === "'") { quote = char; started = true; }
+    else if (/\s/.test(char)) { if (started) { words.push(word); word = ""; started = false; } }
+    else { word += char; started = true; }
+  }
+  if (quote || escaped) throw new Error("unfinished quote or escape");
+  if (started) words.push(word);
+  if (!COMMANDS.has(words[0] ?? "")) throw new Error("use another shell for this command");
+  if (words.some(w => w === "--project" || w.startsWith("--project="))) throw new Error("console commands stay in the selected project");
+  return words;
+}
+export function commandNeedsConfirmation(args: string[]): boolean {
+  return (args[0] === "task" && args[1] === "assign") || (args[0] === "queue" && args[1] === "resolve") || (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] }));
+  if (s.panel === 2) return s.approvals;
+  if (s.panel === 3) {
+    const states = ["proposed", "in_progress", "in_review", "changes_requested"];
+    return s.tasks.filter(t => states.includes(t.state)).sort((a, b) => states.indexOf(a.state) - states.indexOf(b.state));
+  }
+  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));
+}
+export function reduceConsole(state: ConsoleState, key: string, now = Date.now()): { state: ConsoleState; effects: ConsoleEffect[] } {
+  let s = pruneApprovals({ ...state }, now); const effects: ConsoleEffect[] = [];
+  const done = () => ({ state: s, effects });
+  if (key === "\x03") { effects.push({ type: "exit" }); return done(); }
+  if (s.confirm) {
+    const confirm = s.confirm; s.confirm = undefined;
+    if (key === "y") {
+      if (confirm.type === "command") effects.push({ type: "command", args: confirm.args });
+      else if (s.approvals.some(a => a.id === confirm.id && a.options.some(o => o.optionId === confirm.option && o.kind.startsWith("allow")))) {
+        effects.push({ type: "permit", id: confirm.id, option: confirm.option });
+        s.approvals = s.approvals.filter(a => a.id !== confirm.id);
+      }
+    }
+    return done();
+  }
+  if (s.editing || s.input) {
+    if (key === "\x1b") { s.input = ""; s.editing = false; }
+    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; s.input = ""; s.editing = false;
+      if (!input.trim()) return done();
+      try {
+        const args = parseConsoleCommand(input);
+        if (args[0] === "queue" && args[1] === "resolve") {
+          const reason = args.indexOf("--reason");
+          if (reason < 0 || !args[reason + 1]?.trim()) throw new Error("queue resolve requires --reason");
+        }
+        s.history = [...s.history, input].slice(-100); s.historyIndex = s.history.length;
+        if (commandNeedsConfirmation(args)) s.confirm = { type: "command", args };
+        else effects.push({ type: "command", args });
+      } catch (error) { s.notice = String((error as Error).message); }
+    } else if (!key.startsWith("\x1b")) s.input += terminalText(key).replace(/\n/g, "");
+    return done();
+  }
+  if (key === "q") { effects.push({ type: "exit" }); return done(); }
+  if (key === "\t") { s.mode = s.mode === "panels" ? "stream" : "panels"; s.detail = undefined; return done(); }
+  if (key === ":") { s.editing = true; return done(); }
+  if (s.mode === "panels" && /^[1-5]$/.test(key) && !s.optionChoice) { s.panel = Number(key); s.selection = 0; s.detail = undefined; return done(); }
+  if (key === "?") { s.help = !s.help; return done(); }
+  if (key === "\x1b") { s.detail = undefined; s.help = false; s.optionChoice = undefined; return done(); }
+  if (s.mode === "panels" && ["j", "k", "\x1b[A", "\x1b[B"].includes(key)) {
+    if (s.detail) { s.detailOffset = Math.max(0, s.detailOffset + (["j", "\x1b[B"].includes(key) ? 1 : -1)); return done(); }
+    s.selection = Math.max(0, Math.min(panelRows(s).length - 1, s.selection + (["j", "\x1b[B"].includes(key) ? 1 : -1)));
+    if (s.panel === 2) s.approvalIndex = s.selection;
+    return done();
+  }
+  if (key === "[" || key === "]") {
+    s.approvalIndex = (s.approvalIndex + (key === "[" ? -1 : 1) + s.approvals.length) % Math.max(1, s.approvals.length); return done();
+  }
+  const approval = s.approvals[s.approvalIndex];
+  if (s.optionChoice) {
+    const a = s.approvals.find(a => a.id === s.optionChoice); const options = a?.options.filter(o => o.kind.startsWith("allow")) ?? [];
+    const option = options[Number(key) - 1];
+    if (/^[1-9]$/.test(key) && a && option) { s.confirm = { type: "permission", id: a.id, peer: a.peer, option: option.optionId }; s.optionChoice = undefined; }
+    return done();
+  }
+  if (approval && (s.mode === "stream" || s.panel === 2)) {
+    if (key === "d") { effects.push({ type: "permit", id: approval.id }); s.approvals = s.approvals.filter(a => a.id !== approval.id); return done(); }
+    if (key === "a") {
+      const options = approval.options.filter(o => o.kind.startsWith("allow"));
+      if (options.length === 1) s.confirm = { type: "permission", id: approval.id, peer: approval.peer, option: options[0]!.optionId };
+      else if (options.length) s.optionChoice = approval.id;
+      return done();
+    }
+    if (key === "v") { s.detail = approval.title; s.detailOffset = 0; return done(); }
+  }
+  const row = panelRows(s)[s.selection];
+  if (s.mode === "panels" && row) {
+    if (key === "\r" || key === "\n") {
+      if (s.panel === 3 || s.panel === 4) effects.push({ type: "show", panel: s.panel, id: String(row.id) });
+      else { s.detail = s.panel === 2 ? row.title : s.panel === 5 ? row.text : JSON.stringify(row, null, 2); s.detailOffset = 0; }
+      return done();
+    }
+    const prefill = s.panel === 1 && key === "p" ? `pause ${row.id}` : s.panel === 1 && key === "r" ? `resume ${row.id}` :
+      s.panel === 3 && key === "a" ? `task assign ${row.id} ` : s.panel === 3 && key === "r" ? `review ${row.id} ` :
+      s.panel === 4 && key === "r" ? `queue resolve ${row.id} --action retry --reason ` : undefined;
+    if (prefill) { s.input = prefill; s.editing = true; return done(); }
+  }
+  if (s.mode === "panels" && s.panel === 5 && (key === "f" || key === "g")) {
+    const field = key === "f" ? "peer" : "kind"; const current = key === "f" ? s.peerFilter : s.kindFilter;
+    const values = [...new Set(s.events.map(e => e[field]).filter((x): x is string => !!x))];
+    const next = values[values.indexOf(current ?? "") + 1];
+    if (key === "f") s.peerFilter = next; else s.kindFilter = next;
+    s.selection = 0; return done();
+  }
+  if (s.mode === "stream" && !key.startsWith("\x1b")) { s.editing = true; s.input = terminalText(key).replace(/\n/g, ""); }
+  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(" ");
+  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 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()) {
+      const selected = start + i === s.selection;
+      const line = [span(`${selected ? ">" : " "} `, selected ? "strong" : undefined)];
+      if (s.panel === 1) {
+        const b = s.budget[row.id];
+        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([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([]);
+  return [...body, ...footer];
+}

package/src/cli/console.ts

@@ -0,0 +1,224 @@
+import { fileURLToPath } from "node:url";
+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, 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;
+  write(text: string): void;
+  raw(enabled: boolean): void;
+  onData(listener: (text: string) => void): () => void;
+  onResize(listener: () => void): () => void;
+  onSignal(listener: () => void): () => void;
+  onError?(listener: (error: Error) => void): () => void;
+}
+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; },
+    get isTTY() { return !!process.stdin.isTTY && !!process.stdout.isTTY; }, get isRaw() { return process.stdin.isRaw; },
+    write: text => { process.stdout.write(text); }, raw: enabled => { process.stdin.setRawMode(enabled); },
+    onData: listener => {
+      const decoder = new StringDecoder("utf8"); const onData = (data: Buffer) => listener(decoder.write(data));
+      process.stdin.on("data", onData); process.stdin.resume();
+      return () => { process.stdin.off("data", onData); process.stdin.pause(); };
+    },
+    onResize: listener => { process.stdout.on("resize", listener); return () => { process.stdout.off("resize", listener); }; },
+    onError: listener => {
+      const rejected = (reason: unknown) => listener(reason instanceof Error ? reason : new Error(String(reason)));
+      process.on("uncaughtException", listener); process.on("unhandledRejection", rejected);
+      return () => { process.off("uncaughtException", listener); process.off("unhandledRejection", rejected); };
+    },
+    onSignal: listener => { process.on("SIGINT", listener); process.on("SIGTERM", listener); return () => { process.off("SIGINT", listener); process.off("SIGTERM", listener); }; },
+  };
+}
+/** 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;
+  let polling = false; let childRunning = false; let cancelChild: (() => void) | undefined;
+  const priorPush = client.onPush; const priorClose = client.onClose; const priorRaw = !!terminal.isRaw;
+  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(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 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) {
+      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 = () => {
+    if (!active || plain) return;
+    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({ 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 = 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`); 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;
+    active = false;
+    for (const timer of timers) clearInterval(timer);
+    for (const remove of removers) remove();
+    cancelChild?.(); cancelChild = undefined;
+    client.onPush = priorPush; client.onClose = priorClose;
+    if (terminal.isTTY) {
+      try { terminal.raw(priorRaw); } finally { terminal.write(RESTORE_CONSOLE + "\r\n"); }
+    }
+    client.close();
+    safeWrite(`${reason ? reason + "\n" : ""}Left console; the hub keeps running (ahub kill stops it).\n`);
+    resolveDone();
+  };
+  const refresh = async () => {
+    if (polling || !active) return; polling = true;
+    try {
+      const panels = state.mode === "panels" && !plain;
+      const replies = await Promise.all([
+        client.request({ t: "status" }, 3000), client.request({ t: "budget" }, 3000),
+        ...(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)] : []),
+      ]);
+      if (!active) return;
+      const [status, budget, tasks, queue, ready] = replies;
+      if (status.status?.peers) state.peers = status.status.peers;
+      if (budget.budget) state.budget = budget.budget;
+      if (tasks?.ok && state.mode === "panels") { 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) }));
+        } }
+      if (queue?.ok && state.mode === "panels" && Array.isArray(queue.deliveries)) state.queue = queue.deliveries;
+      const error = replies.find(reply => reply.ok === false)?.error; if (error) state.notice = String(error);
+      draw();
+    } catch (error) { if (active) { state.notice = String((error as Error).message); draw(); } }
+    finally { polling = false; }
+  };
+  const run = options.runCommand ?? ((args, output, finished) => {
+    const child = Bun.spawn([process.execPath, fileURLToPath(new URL("./main.ts", import.meta.url)), "--project", options.cwd, ...args], {
+      cwd: options.cwd, stdin: "ignore", stdout: "pipe", stderr: "pipe",
+    });
+    const read = async (source: ReadableStream<Uint8Array>) => {
+      const decoder = new TextDecoder(); const reader = source.getReader();
+      try { while (true) { const { value, done } = await reader.read(); if (done) break; output(decoder.decode(value, { stream: true })); } const end = decoder.decode(); if (end) output(end); }
+      finally { reader.releaseLock(); }
+    };
+    void Promise.all([read(child.stdout), read(child.stderr), child.exited]).then(([, , code]) => { if (code) output(`command exited ${code}`); }).catch(error => output(String(error.message))).finally(finished);
+    return () => { child.kill(); };
+  });
+  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 } : {}) });
+      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;
+      state.detailOffset = 0;
+      state.detail = result.ok === false ? String(result.error) : action.panel === 3 ? String(result.text) : JSON.stringify(result.delivery, null, 2);
+      draw(); return;
+    }
+    if (childRunning) { state.notice = "a command is already running"; draw(); return; }
+    childRunning = true;
+    stream({ text: `> ${action.args.join(" ")}`, kind: "command" });
+    try {
+      cancelChild = run(action.args, text => { if (active) { stream({ text, kind: "command" }); draw(); } }, () => { childRunning = false; cancelChild = undefined; if (active) void refresh(); });
+    } catch (error) { childRunning = false; state.notice = String((error as Error).message); draw(); }
+  };
+  const handle = (key: string) => {
+    if (!active) return;
+    const result = reduceConsole(state, key); state = result.state;
+    if (state.mode === "panels" && (plain || columns < 80 || rows < 24)) { state.mode = "stream"; state.notice = "panels need at least 80x24"; }
+    for (const action of result.effects) void effect(action).catch(error => stop(`Console error: ${String(error.message)}`));
+    draw();
+    if (key === "v" && state.detail && state.mode === "stream") { stream({ text: state.detail, kind: "permission" }); state.detail = undefined; draw(); }
+    if (key === "\t") void refresh();
+  };
+  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, 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", 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)}`); }
+  };
+  client.onClose = (_code, reason) => stop(`Hub connection closed${reason ? `: ${reason}` : ""}`);
+  try {
+    if (plain) { state.mode = "stream"; safeWrite("Console panels need a terminal of at least 80x24; showing the plain stream.\n"); }
+    if (terminal.isTTY) {
+      terminal.raw(true);
+      removers.push(terminal.onData(text => {
+        // A pasted chunk can only edit text, never approve, confirm or run commands. Bracketed-paste delimiters are stripped.
+        if (Array.from(text).length > 1 && !["\x1b[A", "\x1b[B", "\x1b[C", "\x1b[D"].includes(text)) {
+          state.confirm = undefined; state.optionChoice = undefined; state.editing = true;
+          state.input += terminalText(text.replace(/\x1b\[20[01]~/g, "")).replace(/\n/g, " "); draw();
+        } else handle(text);
+      }));
+      removers.push(terminal.onResize(() => {
+        columns = terminal.columns; rows = terminal.rows; plain = columns < 80 || rows < 24;
+        if (plain) {
+          if (inAlternate) { terminal.write("\x1b[?1049l"); inAlternate = false; }
+          terminal.write("\x1b[r"); state.mode = "stream"; state.notice = "panels need at least 80x24";
+          safeWrite("\nTerminal below 80x24; showing the plain stream.\n");
+        }
+        draw();
+      }));
+    }
+    removers.push(terminal.onSignal(() => stop()));
+    if (terminal.onError) removers.push(terminal.onError(error => { process.exitCode = 1; stop(`Console error: ${error.message}`); }));
+    timers.push(setInterval(() => { try { state = pruneApprovals(state, Date.now()); draw(); } catch (error) { stop(`Console error: ${String((error as Error).message)}`); } }, 1000));
+    timers.push(setInterval(() => void refresh(), Math.max(2000, options.pollMs ?? 4000)));
+    draw(); client.send({ t: "tail" }); void refresh(); await done;
+  } catch (error) { stop(`Console error: ${String((error as Error).message)}`); }
+  finally { stop(); }
+}