@getpipher/armory-fleet 0.6.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpipher/armory-fleet",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "private": false,
   "description": "The armory suite's subagent orchestrator for the pi coding agent — a cross-harness, superpowers-native fleet where every agent is armory-native from birth.",
   "license": "MIT",

package/src/engine/run-registry.ts

@@ -20,6 +20,8 @@ export interface RunRecord {
   resumedFrom?: string;
   /** SPEC-5b-1: runId this run forked from (fresh re-run with same agent+task). */
   forkedFrom?: string;
+  /** SPEC-5b-2: cumulative real tokens (input+output+cacheRead+cacheWrite) — live, updated on each message_end. */
+  tokenTotal?: number;
 }
 
 /** runId format: fl-<base36 ms>-<6 random> (SPEC-1 §5.1). */

package/src/engine/spawnSubagent.ts

@@ -26,7 +26,13 @@ export interface ChildSessionEvent {
   message?: {
     role?: string;
     content?: Array<{ type: string; text?: string }>;
-    usage?: { cost?: { total?: number } };
+    usage?: {
+      input?: number;
+      output?: number;
+      cacheRead?: number;
+      cacheWrite?: number;
+      cost?: { total?: number };
+    };
   };
   /** Emitted by a backend on session init (SPEC-3). Drives runRecord.backendSessionId. */
   backendSessionId?: string;
@@ -209,10 +215,15 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
       } else if (e.type === "message_end" && e.message?.role === "assistant") {
         const text = e.message.content?.map((c) => (c.type === "text" ? c.text ?? "" : "")).join("") ?? "";
         if (text) finalText = text;
-        const total = e.message.usage?.cost?.total;
-        if (typeof total === "number") tokenTotal += total;
+        // SPEC-5b-2 (Q9): accumulate REAL tokens (input+output+cacheRead+cacheWrite), not cost.total (dollars).
+        const u = e.message.usage;
+        const turnTokens = (u?.input ?? 0) + (u?.output ?? 0) + (u?.cacheRead ?? 0) + (u?.cacheWrite ?? 0);
+        if (turnTokens > 0) {
+          tokenTotal += turnTokens;
+          opts.runRegistry.update(runId, { tokenTotal });
+        }
         try {
-          opts.runLog?.append(runId, { type: "message", role: "assistant", text, usage: { total }, turnIndex: turnIdx });
+          opts.runLog?.append(runId, { type: "message", role: "assistant", text, usage: { total: turnTokens, input: u?.input, output: u?.output, cacheRead: u?.cacheRead, cacheWrite: u?.cacheWrite }, turnIndex: turnIdx });
         } catch { /* best-effort */ }
       } else if (e.type === "tool_execution_end") {
         try {

package/src/index.ts

@@ -42,6 +42,7 @@ import { reconcileRuns } from "./runtime/reconcile.ts";
 import { Scheduler } from "./scheduling/scheduler.ts";
 import { createFleetResultsTool } from "./tools/fleet-results.ts";
 import { BgRunsStore } from "./panel/bg-runs-store.ts";
+import { FleetWidgetController } from "./panel/fleet-widget.ts";
 
 /** The package builtin agents/ dir, resolved relative to this module. */
 function builtinAgentsDir(): string {
@@ -167,6 +168,9 @@ export default async function (pi: ExtensionAPI): Promise<void> {
   const fleetDir = (cwd: string) => join(cwd, ".pi", "fleet");
   const bgRuns = new BgRunsStore();
   const resultsInbox = new ResultsInbox();
+  // SPEC-5b-2: the live widget (above editor) + FleetView (below editor) controller.
+  // Display-only, independent of the /fleet panel; constructed per-session in session_start.
+  let fleetWidget: FleetWidgetController | null = null;
   // The async runner's runLifecycle adapter: call the real runLifecycle with the worktree as the
   // spawn cwd + override genRunId so the lifecycle runId IS the async runner's runId (Q1=B seam).
   const asyncRunLifecycle: AsyncRunnerDeps["runLifecycle"] = async (task, lifecycleName, opts) => {
@@ -268,6 +272,19 @@ export default async function (pi: ExtensionAPI): Promise<void> {
     if (cands.length > 0) {
       ctx.ui.notify(`${cands.length} interrupted fleet run${cands.length > 1 ? "s" : ""} — open /fleet to resume`, "info");
     }
+    // SPEC-5b-2: live widget (above editor) + FleetView (below editor). Display-only, independent
+    // of the /fleet panel. getTheme is a live getter (EditorTheme gotcha). Disposed on session end.
+    fleetWidget = new FleetWidgetController({
+      runRegistry: deps.runRegistry,
+      bgRuns,
+      ui: ctx.ui as never,
+      getTheme: () => ctx.ui.theme,
+    });
+    fleetWidget.start();
+  });
+
+  pi.on("session_shutdown", () => {
+    if (fleetWidget) { fleetWidget.dispose(); fleetWidget = null; }
   });
 
   pi.on("resources_discover", (event, ctx) => {

package/src/panel/conversation-rows.ts

@@ -0,0 +1,76 @@
+// src/panel/conversation-rows.ts
+// SPEC-5b-3 — pure renderers for the full-message overlay (second level over the 5b-1 timeline).
+// Plain strings, no theme (codebase convention: theming is applied at the SelectList callback layer).
+//
+// Journal fidelity (Q2=C): MessageEvent.text is already the FULL assistant text (5b-1 Q1). Tool
+// args/result are the journaled excerpt (5b-1: args≤200ch, result≤500ch, errors in-full). The
+// toolHeader notes "args/result excerpted" so the asymmetry is honest.
+import type { MessageEvent, ToolEvent } from "../runtime/run-log.ts";
+
+/** Word-wrap `text` to `width` columns. Long tokens (no break opportunity) hard-split at `width`.
+ *  Explicit `\n` is preserved as a row break (multi-line tool results). Empty → [""]; width≤0 → [""].
+ *  Operates on the string by `.length` (UTF-16 code units) — sufficient for the overlay's purposes;
+ *  CJK chars count as 1 col each in most terminals, matching the test expectations. */
+export function wrapToLines(text: string, width: number): string[] {
+  if (width <= 0) return [""];
+  if (text.length === 0) return [""];
+  const out: string[] = [];
+  for (const para of text.split("\n")) {
+    if (para.length === 0) { out.push(""); continue; }
+    const words = para.split(" ");
+    let line = "";
+    for (const w of words) {
+      if (w.length === 0) continue; // collapse runs of spaces
+      if (line.length === 0) {
+        // long token with no break opportunity: hard-split at width
+        let rest = w;
+        while (rest.length > width) {
+          out.push(rest.slice(0, width));
+          rest = rest.slice(width);
+        }
+        line = rest;
+      } else if (line.length + 1 + w.length <= width) {
+        line += " " + w;
+      } else {
+        out.push(line);
+        let rest = w;
+        while (rest.length > width) {
+          out.push(rest.slice(0, width));
+          rest = rest.slice(width);
+        }
+        line = rest;
+      }
+    }
+    out.push(line);
+  }
+  return out;
+}
+
+/** Body for an assistant message: the full text, wrapped. */
+export function messageBody(e: MessageEvent, width: number): string[] {
+  return wrapToLines(e.text, width);
+}
+
+/** Body for a tool event: `args:` + indented args, `result:` + indented result. */
+export function toolBody(e: ToolEvent, width: number): string[] {
+  const inner = Math.max(2, width - 2);
+  const lines: string[] = ["args:"];
+  for (const l of wrapToLines(e.args, inner)) lines.push("  " + l);
+  lines.push("result:");
+  for (const l of wrapToLines(e.result, inner)) lines.push("  " + l);
+  return lines;
+}
+
+/** Header for an assistant message event. Omits the token segment when usage.total is absent. */
+export function messageHeader(e: MessageEvent): string {
+  const turn = Math.max(0, e.turnIndex);
+  const tok = e.usage?.total != null ? ` · ${e.usage.total} tok` : "";
+  return `── assistant · turn ${turn}${tok} ──`;
+}
+
+/** Header for a tool event. Notes "args/result excerpted" (Q2=C honest asymmetry). */
+export function toolHeader(e: ToolEvent): string {
+  const turn = Math.max(0, e.turnIndex);
+  const glyph = e.isError ? "✗" : "✓";
+  return `── tool: ${e.toolName} · turn ${turn} · ${glyph} · args/result excerpted ──`;
+}

package/src/panel/fleet-panel.ts

@@ -13,8 +13,9 @@ import type { AgentDef } from "../registry/frontmatter.ts";
 import { agentsRow, agentInfo, backendsRow, backendInfo, lifecycleRow, lifecyclePhaseTimeline, scheduleRow } from "./rows.ts";
 import { buildFleetItems } from "./fleet-items.ts";
 import { runsRow, runTimelineRow } from "./runs-rows.ts";
+import { messageBody, toolBody, messageHeader, toolHeader } from "./conversation-rows.ts";
 import { buildRunsIndex } from "./runs-index.ts";
-import type { RunLog, RunMeta, RunLogEvent } from "../runtime/run-log.ts";
+import type { RunLog, RunMeta, RunLogEvent, MessageEvent, ToolEvent } from "../runtime/run-log.ts";
 import type { Scheduler, Schedule } from "../scheduling/scheduler.ts";
 import type { BgRunsStore } from "./bg-runs-store.ts";
 import { spawnSubagent, type SpawnResult } from "../engine/spawnSubagent.ts";
@@ -90,6 +91,13 @@ export class FleetPanel extends Container {
   private runTimeline: RunLogEvent[] | null = null;
   private resumeInput: Input | null = null;
   private resumeMode = false;
+  // SPEC-5b-3: full-message overlay (second level over the 5b-1 timeline) + stored SelectList refs
+  // so handleInput can forward keys to the active overlay (Container/TUI routes input only to the
+  // focused component = this panel; children receive keys only if we forward them).
+  private selectedEventIndex: number | null = null;
+  private fullMessageEvent: MessageEvent | ToolEvent | null = null;
+  private timelineList: SelectList | null = null;
+  private messageBodyList: SelectList | null = null;
   /** SPEC-5a proper-fix: store-change subscriptions — fired by RunRegistry + BgRunsStore
    * so the panel re-renders the moment a (fore- or back-ground) run mutates, without a keypress. */
   private readonly unsubs: (() => void)[] = [];
@@ -208,15 +216,50 @@ export class FleetPanel extends Container {
         `nextFire: ${s.nextFire?.toLocaleString() ?? "(none)"}`,
       ]) this.addChild(new Text(this.theme.fg("text", line), 0, 0));
       this.addChild(new Text(this.theme.fg("dim", "  esc:Back"), 0, 0));
+    } else if (this.fullMessageEvent) {
+      // SPEC-5b-3: full-message overlay (top of the stack). Header + scrollable wrapped body.
+      const e = this.fullMessageEvent;
+      const isMsg = e.type === "message";
+      const header = isMsg ? messageHeader(e) : toolHeader(e);
+      this.addChild(new Text(this.theme.fg("dim", `  ${header}`), 0, 0));
+      // Width: the panel renders at the terminal width pi gives ctx.ui.custom. Rows are pre-baked
+      // into SelectItem.label, so wrap now. Fall back to 80 if the live width isn't reachable here
+      // — the list still scrolls; a resize re-wraps on the next renderShell().
+      const width = 80;
+      const bodyLines = isMsg ? messageBody(e, width) : toolBody(e, width);
+      const body = new SelectList(
+        bodyLines.map((line) => ({ value: "", label: line })),
+        Math.min(bodyLines.length, 12),
+        {
+          selectedPrefix: (s: string) => this.theme.fg("accent", s),
+          selectedText: (s: string) => this.theme.fg("accent", s),
+          description: (s: string) => this.theme.fg("muted", s),
+          scrollInfo: (s: string) => this.theme.fg("dim", s),
+          noMatch: (s: string) => this.theme.fg("warning", s),
+        },
+      );
+      // esc → back to timeline. Leave onSelect unset so Enter (tui.select.confirm) is swallowed
+      // silently by SelectList.handleInput — a text line has nothing to drill into.
+      // Do NOT clear selectedEventIndex here: it survives to drive the timeline cursor restore.
+      body.onCancel = () => {
+        this.fullMessageEvent = null;
+        this.messageBodyList = null;
+        this.renderShell();
+      };
+      this.messageBodyList = body;
+      this.addChild(body);
+      this.addChild(new Text(this.theme.fg("dim", "  esc:Back"), 0, 0));
     } else if (this.selectedRun) {
-      // SPEC-5b-1: Runs tab — per-turn timeline replay (read-only); enter reserved for 5b-3 overlay.
+      // SPEC-5b-1/5b-3: Runs tab — per-turn timeline replay. SPEC-5b-3 makes the list interactive
+      // (arrows scroll, enter opens full-message overlay, esc back to Runs list) by forwarding input
+      // to the stored SelectList (see handleInput) — v0.6.0 swallowed all non-escape keys.
       this.addChild(new Text(this.theme.fg("dim", `  ── run ${this.selectedRun.runId} — timeline ──`), 0, 0));
-      const events = (this.runTimeline ?? []).filter((e) => e.type === "message" || e.type === "tool") as Array<RunLogEvent>;
+      const events = (this.runTimeline ?? []).filter((e) => e.type === "message" || e.type === "tool") as Array<MessageEvent | ToolEvent>;
       if (events.length === 0) {
         this.addChild(new Text(this.theme.fg("dim", "  (no conversation events)"), 0, 0));
       } else {
         const tl = new SelectList(
-          events.map((e) => ({ value: "", label: runTimelineRow(e as never) })),
+          events.map((e, idx) => ({ value: String(idx), label: runTimelineRow(e as never) })),
           Math.min(events.length, 12),
           {
             selectedPrefix: (s: string) => this.theme.fg("accent", s),
@@ -226,10 +269,26 @@ export class FleetPanel extends Container {
             noMatch: (s: string) => this.theme.fg("warning", s),
           },
         );
-        tl.onCancel = () => { this.selectedRun = null; this.runTimeline = null; this.renderShell(); };
+        // SPEC-5b-3: enter on a timeline row → open the full-message overlay for that event.
+        tl.onSelect = (item) => {
+          const idx = Number(item.value);
+          const ev = events[idx];
+          if (!ev) { this.onNotify("event no longer available", "warning"); return; }
+          this.selectedEventIndex = idx;
+          this.fullMessageEvent = ev;
+          this.renderShell();
+        };
+        // SPEC-5b-3: restore the cursor to the row we were viewing (one-shot, then clear the token).
+        if (this.selectedEventIndex != null) {
+          tl.setSelectedIndex(this.selectedEventIndex);
+          this.selectedEventIndex = null;
+        }
+        // esc → back to Runs list (replaces the v0.6.0 panel-level escape catch).
+        tl.onCancel = () => { this.selectedRun = null; this.runTimeline = null; this.timelineList = null; this.renderShell(); };
+        this.timelineList = tl;
         this.addChild(tl);
       }
-      this.addChild(new Text(this.theme.fg("dim", "  enter: (5b-3 full message)  esc:Back"), 0, 0));
+      this.addChild(new Text(this.theme.fg("dim", "  enter:Full-message  esc:Back"), 0, 0));
     } else if (this.resumeMode && this.resumeInput) {
       // SPEC-5b-1: Runs tab — resume follow-up input.
       this.addChild(new Text(this.theme.fg("accent", "  follow-up> "), 0, 0));
@@ -260,8 +319,10 @@ export class FleetPanel extends Container {
 
     this.addChild(new Spacer(1));
     const hint =
-      this.infoAgent || this.selectedBackend || this.selectedLifecycle || this.selectedSchedule || this.selectedRun
-        ? (this.selectedRun ? "  enter:(5b-3)  esc:Back" : "  esc:Back")
+      this.fullMessageEvent
+        ? "  esc:Back"
+        : this.infoAgent || this.selectedBackend || this.selectedLifecycle || this.selectedSchedule || this.selectedRun
+          ? (this.selectedRun ? "  enter:Full-message  esc:Back" : "  esc:Back")
         : this.pendingCheckpoint
           ? "  c:Continue  v:Revise  a:Abort"
           : this.lcRevising
@@ -353,6 +414,10 @@ export class FleetPanel extends Container {
     this.selectedSchedule = null;
     this.selectedRun = null;
     this.runTimeline = null;
+    this.selectedEventIndex = null;
+    this.fullMessageEvent = null;
+    this.timelineList = null;
+    this.messageBodyList = null;
     this.list = this.buildList();
     this.renderShell();
   }
@@ -374,9 +439,18 @@ export class FleetPanel extends Container {
       if (matchesKey(data, "escape")) { this.selectedSchedule = null; this.renderShell(); }
       return;
     }
+    if (this.fullMessageEvent) {
+      // SPEC-5b-3: full-message overlay — forward to the body SelectList (arrows scroll; esc via
+      // onCancel back to timeline; enter is a no-op). Replaces the v0.6.0 swallow-all pattern.
+      this.messageBodyList?.handleInput(data);
+      this.invalidate();
+      return;
+    }
     if (this.selectedRun) {
-      // SPEC-5b-1: Runs timeline replay overlay — esc back; enter is a 5b-3 placeholder.
-      if (matchesKey(data, "escape")) { this.selectedRun = null; this.runTimeline = null; this.renderShell(); }
+      // SPEC-5b-3: forward to the timeline SelectList (arrows scroll; enter via onSelect opens the
+      // overlay; esc via onCancel returns to the Runs list). v0.6.0 swallowed all non-escape keys.
+      this.timelineList?.handleInput(data);
+      this.invalidate();
       return;
     }
     if (this.resumeMode && this.resumeInput) {

package/src/panel/fleet-widget.ts

@@ -0,0 +1,114 @@
+// src/panel/fleet-widget.ts
+// SPEC-5b-2 — the live widget (above editor) + FleetView (below editor) controller.
+//
+// Display-only (Q1=A): pi widgets render into a layout container; the editor keeps keyboard
+// focus. No input is routed here — /fleet is the action surface.
+//
+// Lifecycle (Q5/Q6/Q7=A): visible only while ≥1 active run exists; hidden when idle (editor
+// reclaims both slots). A 1s setInterval re-renders for the live duration clock; it starts
+// lazily on the first active render and clears when the fleet goes idle + on dispose.
+//
+// Independent of the /fleet panel: constructed at session_start in index.ts, persists whether
+// the panel is open or closed.
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { RunRegistry } from "../engine/run-registry.ts";
+import type { BgRunsStore } from "./bg-runs-store.ts";
+import {
+  toWidgetRun, toWidgetRunFromBg, renderWidgetLines, renderFleetViewLines,
+} from "./widget-rows.ts";
+
+const WIDGET_KEY = "fleet-active";
+const VIEW_KEY = "fleet-view";
+
+export interface FleetWidgetDeps {
+  runRegistry: RunRegistry;
+  bgRuns?: BgRunsStore;
+  ui: {
+    setWidget: (
+      key: string,
+      content: string[] | undefined,
+      opts?: { placement?: "aboveEditor" | "belowEditor" },
+    ) => void;
+  };
+  /** Live theme getter (EditorTheme gotcha: never capture a factory theme arg). */
+  getTheme: () => Theme;
+  /** Injectable clock + timers for testability. Default to globals. */
+  now?: () => number;
+  setInterval?: (fn: () => void, ms: number) => unknown;
+  clearInterval?: (id: unknown) => void;
+}
+
+export class FleetWidgetController {
+  private readonly deps: FleetWidgetDeps;
+  private readonly now: () => number;
+  private readonly setIntervalFn: (fn: () => void, ms: number) => unknown;
+  private readonly clearIntervalFn: (id: unknown) => void;
+  private readonly unsubs: (() => void)[] = [];
+  private timerId: unknown | null = null;
+  private disposed = false;
+
+  constructor(deps: FleetWidgetDeps) {
+    this.deps = deps;
+    this.now = deps.now ?? (() => Date.now());
+    this.setIntervalFn = deps.setInterval ?? ((fn, ms) => globalThis.setInterval(fn, ms));
+    this.clearIntervalFn = deps.clearInterval ?? ((id) => globalThis.clearInterval(id as any));
+  }
+
+  start(): void {
+    this.unsubs.push(this.deps.runRegistry.subscribe(() => this.render()));
+    if (this.deps.bgRuns) this.unsubs.push(this.deps.bgRuns.subscribe(() => this.render()));
+    this.render(); // initial — shows any runs already active on session_start (e.g. a survived bg run)
+  }
+
+  private activeRuns() {
+    const fg = this.deps.runRegistry.list().map(toWidgetRun);
+    const bg = this.deps.bgRuns ? [...this.deps.bgRuns.values()].map(toWidgetRunFromBg) : [];
+    return [...fg, ...bg];
+  }
+
+  render(): void {
+    if (this.disposed) return;
+    const active = this.activeRuns();
+    const hasActive = active.some((r) => r.status === "running" || r.status === "queued" || r.status === "paused");
+    if (!hasActive) {
+      this.clearTimer();
+      this.setBoth(undefined);
+      return;
+    }
+    this.ensureTimer();
+    const now = this.now();
+    try {
+      this.deps.ui.setWidget(WIDGET_KEY, renderWidgetLines(active, now));
+    } catch { /* best-effort: a render failure never affects runs */ }
+    try {
+      this.deps.ui.setWidget(VIEW_KEY, renderFleetViewLines(active, now), { placement: "belowEditor" });
+    } catch { /* best-effort */ }
+  }
+
+  private setBoth(content: string[] | undefined): void {
+    try { this.deps.ui.setWidget(WIDGET_KEY, content); } catch { /* best-effort */ }
+    try { this.deps.ui.setWidget(VIEW_KEY, content, { placement: "belowEditor" }); } catch { /* best-effort */ }
+  }
+
+  private ensureTimer(): void {
+    if (this.timerId !== null) return;
+    this.timerId = this.setIntervalFn(() => this.render(), 1000);
+  }
+
+  private clearTimer(): void {
+    if (this.timerId !== null) {
+      this.clearIntervalFn(this.timerId);
+      this.timerId = null;
+    }
+  }
+
+  /** Unsubscribe + clear timer + clear both widgets. Idempotent. */
+  dispose(): void {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.clearTimer();
+    for (const u of this.unsubs) u();
+    this.unsubs.length = 0;
+    this.setBoth(undefined);
+  }
+}

package/src/panel/widget-rows.ts

@@ -0,0 +1,79 @@
+// src/panel/widget-rows.ts
+// SPEC-5b-2 — pure render functions for the live widget (above editor) + FleetView (below editor).
+// Both surfaces are display-only; plain strings (no theme) — theming, if wanted, is applied at the
+// setWidget boundary. Mirrors the runs-rows/fleet-items pure-renderer convention (unit-tested, no TUI).
+import { fmtDuration } from "./rows.ts";
+import type { RunRecord } from "../engine/run-registry.ts";
+import type { BgRunStatus } from "./rows.ts";
+
+export interface WidgetRun {
+  runId: string;
+  agent: string;
+  status: "running" | "queued" | "paused" | "completed" | "failed" | "aborted";
+  /** fg runs have startedAt (live duration); bg runs do not (show phase instead). */
+  startedAt?: number;
+  endedAt?: number;
+  tokenTotal?: number;
+  phase?: string;
+  phaseIndex?: number;
+  phaseTotal?: number;
+  kind: "fg" | "bg";
+  backend?: string;
+}
+
+export function toWidgetRun(r: RunRecord): WidgetRun {
+  return {
+    runId: r.runId, agent: r.agent, status: r.status,
+    startedAt: r.startedAt, endedAt: r.endedAt, tokenTotal: r.tokenTotal,
+    kind: "fg",
+  };
+}
+
+export function toWidgetRunFromBg(b: BgRunStatus): WidgetRun {
+  return {
+    runId: b.runId, agent: b.lifecycle, status: b.status,
+    phase: b.phase, phaseIndex: b.phaseIndex, phaseTotal: b.phaseTotal,
+    kind: "bg", backend: b.backend,
+  };
+}
+
+/** Active = not-done = {running, queued, paused}. Newest-first by startedAt desc;
+ *  runs without startedAt (bg) keep stable trailing order. */
+export function filterActive(runs: WidgetRun[]): WidgetRun[] {
+  const active = runs.filter((r) => r.status === "running" || r.status === "queued" || r.status === "paused");
+  return active.sort((a, b) => {
+    const ai = typeof a.startedAt === "number" ? a.startedAt : Number.MIN_SAFE_INTEGER;
+    const bi = typeof b.startedAt === "number" ? b.startedAt : Number.MIN_SAFE_INTEGER;
+    return bi - ai; // newest-first
+  });
+}
+
+const STATUS_GLYPH: Record<WidgetRun["status"], string> = {
+  running: "▶", queued: "⏳", paused: "⏸", completed: "✓", failed: "✗", aborted: "✗",
+};
+
+/** One compact line per active run. */
+function widgetLine(r: WidgetRun, now: number): string {
+  const glyph = STATUS_GLYPH[r.status];
+  const dur = typeof r.startedAt === "number" ? `  ${fmtDuration(now - r.startedAt)}` : "";
+  const tok = r.tokenTotal ? `  ${r.tokenTotal} tok` : "";
+  const phase = r.phase ? `  ●${r.phase} ${r.phaseIndex ?? 0}/${r.phaseTotal ?? 0}` : "";
+  const be = r.backend ? `  ${r.backend}` : "";
+  return `${glyph} ${r.runId}  ${r.agent}${dur}${tok}${phase}${be}`;
+}
+
+/** Above-editor widget: one line per active run, cap 5, overflow → "+N more in /fleet". */
+export function renderWidgetLines(runs: WidgetRun[], now: number = Date.now()): string[] {
+  const active = filterActive(runs);
+  const cap = 5;
+  if (active.length <= cap) return active.map((r) => widgetLine(r, now));
+  const shown = active.slice(0, cap).map((r) => widgetLine(r, now));
+  shown.push(`+${active.length - cap} more in /fleet`);
+  return shown;
+}
+
+/** Below-editor FleetView: active-only list, cap 8, no overflow line (list form). */
+export function renderFleetViewLines(runs: WidgetRun[], now: number = Date.now()): string[] {
+  const active = filterActive(runs);
+  return active.slice(0, 8).map((r) => widgetLine(r, now));
+}

package/src/runtime/run-log.ts

@@ -14,7 +14,8 @@ export interface RunMetaEvent {
 }
 export interface MessageEvent {
   type: "message"; role: string; text: string;
-  usage?: { total?: number }; turnIndex: number;
+  usage?: { total?: number; input?: number; output?: number; cacheRead?: number; cacheWrite?: number };
+  turnIndex: number;
 }
 export interface ToolEvent {
   type: "tool"; toolName: string; args: string; result: string; isError: boolean; turnIndex: number;