@getpipher/armory-fleet 0.6.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpipher/armory-fleet",
-  "version": "0.6.0",
+  "version": "0.7.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/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;