@getpipher/armory-fleet 0.7.0 → 0.9.0

package/package.json

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

@@ -1,5 +1,6 @@
 // src/engine/run-registry.ts
 import type { FleetRunStatus } from "../todo-sync/port.ts";
+import type { LiveSessionHandle } from "./spawnSubagent.ts";
 
 export interface RunRecord {
   runId: string;
@@ -22,6 +23,10 @@ export interface RunRecord {
   forkedFrom?: string;
   /** SPEC-5b-2: cumulative real tokens (input+output+cacheRead+cacheWrite) — live, updated on each message_end. */
   tokenTotal?: number;
+  /** SPEC-5b-4: live session handle while status === "running"; cleared by finishRun.
+   *  Transient, in-memory only — never written to RunLog (the journal append constructs
+   *  a plain object, not RunRecord). */
+  session?: LiveSessionHandle;
 }
 
 /** runId format: fl-<base36 ms>-<6 random> (SPEC-1 §5.1). */

package/src/engine/spawnSubagent.ts

@@ -43,6 +43,33 @@ export interface ChildSession {
   subscribe(handler: (event: ChildSessionEvent) => void): () => void;
   abort(): Promise<void>;
   dispose(): void;
+  /** SPEC-5b-4: optional mid-run steering. Pi backend forwards the native SDK `steer()`; claude omits. */
+  steer?(text: string): Promise<void>;
+  /** SPEC-5b-4: optional live streaming flag. Pi backend forwards the native SDK getter; claude omits. */
+  readonly isStreaming?: boolean;
+}
+
+/** SPEC-5b-4: narrow live-session handle retained on RunRecord while status === "running".
+ *  Exposes only redirect/cancel/observe/liveness — deliberately no `prompt` or `dispose`
+ *  (the panel must not start new prompts or tear down the session). */
+export interface LiveSessionHandle {
+  steer(text: string): Promise<void>;
+  abort(): Promise<void>;
+  subscribe(handler: (e: ChildSessionEvent) => void): () => void;
+  readonly isStreaming: boolean;
+  readonly supportsSteer: boolean;
+}
+
+/** SPEC-5b-4: wrap a ChildSession into a narrow LiveSessionHandle for the panel.
+ *  `supportsSteer` is derived from whether the backend implemented the optional `steer`. */
+export function toLiveHandle(session: ChildSession): LiveSessionHandle {
+  return {
+    steer: (text) => session.steer ? session.steer(text) : Promise.reject(new Error("steer not supported on this backend")),
+    abort: () => session.abort(),
+    subscribe: (h) => session.subscribe(h),
+    get isStreaming() { return session.isStreaming ?? false; },
+    get supportsSteer() { return typeof session.steer === "function"; },
+  };
 }
 
 export interface ChildSessionOpts {
@@ -193,6 +220,10 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
       visionPort,
     });
 
+    // SPEC-5b-4: retain a narrow live-session handle on the run record so the panel can
+    // steer/abort mid-flight. Cleared by finishRun in the same patch as the terminal status.
+    opts.runRegistry.update(runId, { session: toLiveHandle(session) });
+
     const budget = createTurnBudget(maxTurns);
     let finalText = "";
     let tokenTotal = 0;
@@ -281,6 +312,7 @@ async function finishRun(
   opts.runRegistry.update(runId, {
     status, endedAt, resultSummary: finalText.slice(0, 120),
     resumedFrom: opts.resumeLink, forkedFrom: opts.forkLink,
+    session: undefined,   // SPEC-5b-4: clear the live handle (invariant: session ⟺ running)
   });
   try {
     opts.runLog?.append(runId, {

package/src/index.ts

@@ -61,6 +61,9 @@ function wrapPiSession(inner: ChildSession, backendSessionId: string): ChildSess
       handler({ type: "session_init", backendSessionId });
       return inner.subscribe(handler);
     },
+    // SPEC-5b-4: forward the native SDK steer + isStreaming to the real pi session.
+    steer: (t) => inner.steer ? inner.steer(t) : Promise.reject(new Error("pi session has no steer")),
+    get isStreaming() { return inner.isStreaming ?? false; },
   };
 }
 

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,16 @@ export class FleetPanel extends Container {
   private runTimeline: RunLogEvent[] | null = null;
   private resumeInput: Input | null = null;
   private resumeMode = false;
+  // SPEC-5b-4: Steer inline input state (mid-run redirect; mirrors resumeMode/resumeInput).
+  private steerInput: Input | null = null;
+  private steerMode = 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 +219,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 +272,31 @@ 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.steerMode && this.steerInput) {
+      // SPEC-5b-4: Fleet tab — mid-run steer input.
+      this.addChild(new Text(this.theme.fg("accent", "  steer> "), 0, 0));
+      this.addChild(this.steerInput);
+      this.addChild(new Text(this.theme.fg("dim", "  enter submit • esc cancel"), 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,14 +327,16 @@ 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
             ? "  enter:Submit-feedback  esc:Cancel"
             : this.view === "fleet"
-              ? "  r:Run-new  s:Stop  o:Open-todo  tab:Lifecycle  q:Quit"
+              ? "  r:Run-new  s:Steer  x:Stop  o:Open-todo  tab:Lifecycle  q:Quit"
               : this.view === "lifecycle"
                 ? "  r:Run-lifecycle  i:Info  tab:Runs  q:Quit"
                 : this.view === "runs"
@@ -353,6 +422,12 @@ 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.steerMode = false;       // SPEC-5b-4: drop any in-flight steer input on tab switch
+    this.steerInput = null;
     this.list = this.buildList();
     this.renderShell();
   }
@@ -374,9 +449,24 @@ 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.steerMode && this.steerInput) {
+      if (matchesKey(data, "escape")) { this.cancelSteer(); return; }
+      this.steerInput.handleInput(data);
+      this.invalidate();
       return;
     }
     if (this.resumeMode && this.resumeInput) {
@@ -435,6 +525,11 @@ export class FleetPanel extends Container {
       this.renderShell();
       return;
     }
+    // SPEC-5b-4: Fleet view — s:Steer (pi-only) + x:Stop (any backend) on the selected running row.
+    if (this.view === "fleet") {
+      if (matchesKey(data, "s")) { this.startSteer(); return; }
+      if (matchesKey(data, "x")) { this.executeStop(); return; }
+    }
     // SPEC-5b-1: Runs view — enter/i:Replay  R:Resume  F:Fork
     if (this.view === "runs" && this.deps.runLog) {
       if (matchesKey(data, "enter") || matchesKey(data, "i")) {
@@ -587,6 +682,63 @@ export class FleetPanel extends Container {
     this.renderShell();
   }
 
+  /** SPEC-5b-4: Steer — open the inline "steer> " input for the selected running row (pi-only). */
+  private startSteer(): void {
+    const sel = this.list.getSelectedItem();
+    if (!sel) return;
+    const run = this.deps.runRegistry.get(sel.value);
+    if (!run || run.status !== "running") { this.onNotify("run already finished", "warning"); return; }
+    if (!run.session) { this.onNotify("run already finished", "warning"); return; }
+    if (!run.session.supportsSteer) { this.onNotify("steer not supported on claude backend", "warning"); return; }
+    this.steerInput = new Input();
+    this.steerInput.onSubmit = (text: string) => {
+      if (!text.trim()) { this.cancelSteer(); return; }
+      void this.executeSteer(run.runId, text.trim());
+    };
+    this.steerInput.onEscape = () => this.cancelSteer();
+    this.steerMode = true;
+    this.renderShell();
+  }
+
+  private cancelSteer(): void {
+    this.steerMode = false;
+    this.steerInput = null;
+    this.renderShell();
+  }
+
+  private async executeSteer(runId: string, text: string): Promise<void> {
+    // Re-check: the run may have finished between pressing s and submitting.
+    const run = this.deps.runRegistry.get(runId);
+    if (!run || !run.session) { this.onNotify("run already finished", "warning"); this.cancelSteer(); return; }
+    if (!run.session.supportsSteer) { this.onNotify("steer not supported on claude backend", "warning"); this.cancelSteer(); return; }
+    this.steerMode = false;
+    this.steerInput = null;
+    this.renderShell();
+    try {
+      await run.session.steer(text);
+      this.onNotify("steer queued; lands after current tool calls", "info");
+    } catch (e) {
+      this.onNotify(`steer failed: ${(e as Error).message}`, "error");
+    }
+  }
+
+  /** SPEC-5b-4: Stop — abort the selected running row (any backend). */
+  private executeStop(): void {
+    const sel = this.list.getSelectedItem();
+    if (!sel) return;
+    const run = this.deps.runRegistry.get(sel.value);
+    if (!run || run.status !== "running") { this.onNotify("run already finished", "warning"); return; }
+    if (!run.session) { this.onNotify("run already finished", "warning"); return; }
+    void (async () => {
+      try {
+        await run.session!.abort();
+        this.onNotify("run aborted", "info");
+      } catch (e) {
+        this.onNotify(`abort failed: ${(e as Error).message}`, "error");
+      }
+    })();
+  }
+
   private async executeResume(prior: RunMeta, followUp: string): Promise<void> {
     this.resumeMode = false;
     this.resumeInput = null;