@getpipher/armory-fleet 0.12.2 → 0.12.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpipher/armory-fleet",
-  "version": "0.12.2",
+  "version": "0.12.3",
   "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

@@ -40,6 +40,14 @@ export interface RunRecord {
    *  Transient, in-memory only — never written to RunLog (the journal append constructs
    *  a plain object, not RunRecord). */
   session?: LiveSessionHandle;
+  /** #23: liveness — current turn count (1-indexed; live, updated on turn_start). */
+  turnCount?: number;
+  /** #23: the run's max turn budget (set at spawn; for the widget's `turn N/max`). */
+  turnMax?: number;
+  /** #23: the last event class seen (e.g. "tool:edit", "assistant", "turn") — liveness only, no content. */
+  lastEventClass?: string;
+  /** #23: timestamp (ms) of the last event — liveness heartbeat ("are events still arriving?"). */
+  lastEventAt?: number;
 }
 
 /** runId format: fl-<base36 ms>-<6 random> (SPEC-1 §5.1). */
@@ -76,4 +84,4 @@ export class RunRegistry {
   private emit(): void {
     for (const fn of this.listeners) fn();
   }
-}
+}

package/src/engine/spawnSubagent.ts

@@ -294,7 +294,7 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
     let aborted = false;
     const handle = toLiveHandle(session);
     handle.abort = async () => { aborted = true; await session.abort(); };
-    opts.runRegistry.update(runId, { session: handle });
+    opts.runRegistry.update(runId, { session: handle, turnMax: maxTurns });
 
     const budget = createTurnBudget(maxTurns);
     let finalText = "";
@@ -307,6 +307,18 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
     let modelError: string | undefined;   // model-call failure surfaced via stopReason "error"
     let sawAssistantMessage = false;      // #22: did the child emit any assistant message_end at all?
 
+    // #23: liveness — classify events into a short, content-free class string for the widget.
+    // Names the tool (safe — tool name is not args/result) so the operator sees "what's happening"
+    // without leaking prompt content, secrets, or full tool arguments/results (per #23 acceptance).
+    const classifyEvent = (e: ChildSessionEvent): string => {
+      if (e.type === "turn_start") return "turn";
+      if (e.type === "turn_end") return "turn_end";
+      if (e.type === "message_end") return e.message?.role === "assistant" ? "assistant" : (e.message?.role ?? "message");
+      if (e.type === "tool_execution_end") return `tool:${(e as { toolName?: string }).toolName ?? "?"}`;
+      if (e.type === "session_init") return "init";
+      return e.type;
+    };
+
     const onSignalAbort = (): void => { aborted = true; void session.abort(); };
     opts.signal?.addEventListener("abort", onSignalAbort);
 
@@ -357,6 +369,15 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
           opts.runLog?.append(runId, buildToolEvent((e as any).toolName, (e as any).args, (e as any).result, (e as any).isError ?? false, turnIdx));
         } catch { /* best-effort */ }
       }
+      // #23: liveness heartbeat — update the run record on meaningful events so the fleet widget
+      // can show turn count + last-event class + "events still arriving" without leaking content.
+      if (e.type === "turn_start" || e.type === "message_end" || e.type === "tool_execution_end") {
+        opts.runRegistry.update(runId, {
+          turnCount: Math.max(0, turnIdx + 1),
+          lastEventClass: classifyEvent(e),
+          lastEventAt: Date.now(),
+        });
+      }
       opts.onEvent?.(e);
     });
 
@@ -375,7 +396,13 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
     let error: string | undefined;
     if (aborted) {
       status = "aborted";
-      error = tier?.costCap && costTotal > tier.costCap ? `budget_exceeded (cost $${costTotal.toFixed(4)} > cap $${tier.costCap})` : "aborted by user";
+      // #23: distinguish TODO-status reversion from filesystem rollback. A foreground run is in-place
+      // (no worktree isolation — that's a background-run concern), so an abort reverts the linked TODO
+      // to open (retryable) but leaves any partial file edits in the working dir for inspection.
+      const rollbackNote = " — TODO reverted to open (retryable); in-place file changes NOT rolled back (inspect the working dir for partial work)";
+      error = tier?.costCap && costTotal > tier.costCap
+        ? `budget_exceeded (cost $${costTotal.toFixed(4)} > cap $${tier.costCap})${rollbackNote}`
+        : `aborted by user${rollbackNote}`;
     } else if (budget.count() >= maxTurns) {
       // #25: surface a coherent partial, not a mid-sentence 200-char cut. The controller reads
       // `res.error` (the tool surfaces error, not finalText, for failed runs), so the partial must

package/src/panel/widget-rows.ts

@@ -11,6 +11,12 @@ import { fmtDuration, fmtTokens } from "./rows.ts";
 import type { RunRecord } from "../engine/run-registry.ts";
 import type { BgRunStatus } from "./rows.ts";
 
+/** #23: liveness segments (turn count, last-event class, abort warning) appear only after a run
+ *  has been active this long — keeps short foreground runs concise (per #23 acceptance criteria). */
+export const LIVENESS_THRESHOLD_MS = 30_000;
+/** #23: a run whose last event is older than this is flagged stale ("are events still arriving?"). */
+export const STALE_THRESHOLD_MS = 60_000;
+
 export interface WidgetRun {
   runId: string;
   agent: string;
@@ -32,6 +38,14 @@ export interface WidgetRun {
   maxContext?: number;
   /** SPEC-6-1: cumulative $ (for the $ segment). */
   costTotal?: number;
+  /** #23: liveness — current turn count (1-indexed). */
+  turnCount?: number;
+  /** #23: liveness — max turn budget (for `turn N/max`). */
+  turnMax?: number;
+  /** #23: liveness — last event class (e.g. "tool:edit", "assistant", "turn"). */
+  lastEventClass?: string;
+  /** #23: liveness — timestamp (ms) of the last event ("events still arriving?"). */
+  lastEventAt?: number;
 }
 
 export function toWidgetRun(r: RunRecord): WidgetRun {
@@ -40,6 +54,7 @@ export function toWidgetRun(r: RunRecord): WidgetRun {
     startedAt: r.startedAt, endedAt: r.endedAt, tokenTotal: r.tokenTotal,
     kind: "fg",
     task: r.task, costTotal: r.costTotal, contextTokens: r.contextTokens,
+    turnCount: r.turnCount, turnMax: r.turnMax, lastEventClass: r.lastEventClass, lastEventAt: r.lastEventAt,
   };
 }
 
@@ -88,16 +103,36 @@ function widgetLine(r: WidgetRun, now: number): string {
   // fg: task excerpt as primary label (fallback to runId if no task)
   const label = r.task ? `"${r.task.slice(0, 40)}"` : r.runId;
   const agentSeg = r.agent && r.agent !== "general-purpose" ? `  · ${r.agent}` : "";
-  return `${glyph} ${label}${agentSeg}${dur}${tok}${ctx}${cost}`;
+  // #23: liveness — only after LIVENESS_THRESHOLD_MS, to keep short runs concise (per acceptance).
+  // turn N/max + last-event class (no prompt content, no args/results — only the tool name)
+  // + a stale indicator if no event has arrived for STALE_THRESHOLD_MS ("events still arriving?").
+  const elapsed = typeof r.startedAt === "number" ? now - r.startedAt : 0;
+  let liveness = "";
+  if (elapsed > LIVENESS_THRESHOLD_MS) {
+    const turn = (r.turnCount != null && r.turnMax != null) ? `  turn ${r.turnCount}/${r.turnMax}` : (r.turnCount != null ? `  turn ${r.turnCount}` : "");
+    const ev = r.lastEventClass ? `  ●${r.lastEventClass}` : "";
+    const stale = (r.lastEventAt != null && now - r.lastEventAt > STALE_THRESHOLD_MS) ? "  ⏰stale" : "";
+    liveness = `${turn}${ev}${stale}`;
+  }
+  return `${glyph} ${label}${agentSeg}${dur}${liveness}${tok}${ctx}${cost}`;
 }
 
-/** Above-editor widget: one line per active run, cap 5, overflow → "+N more in /fleet". */
+/** Above-editor widget: one line per active run, cap 5, overflow → "+N more in /fleet".
+ *  #23: when an active foreground run has been running longer than LIVENESS_THRESHOLD_MS, append an
+ *  explicit abort-warning footer naming its runId (so the controller can distinguish active work
+ *  from a hang without cancelling, and knows submitting a message will abort it). */
 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;
+  const lines = active.length <= cap
+    ? active.map((r) => widgetLine(r, now))
+    : [...active.slice(0, cap).map((r) => widgetLine(r, now)), `+${active.length - cap} more in /fleet`];
+  // #23: abort-warning footer — only when a RUNNING foreground run is active long enough that
+  // a controller might worry it's hung. Paused/queued fg runs aren't aborted by a new message.
+  const longFg = active.find((r) => r.kind === "fg" && r.status === "running" && typeof r.startedAt === "number" && now - r.startedAt > LIVENESS_THRESHOLD_MS);
+  if (longFg) {
+    lines.push(`⚠ submitting a message aborts the foreground run · ${longFg.runId} · /fleet to inspect`);
+  }
+  return lines;
 }