@getpipher/armory-fleet 0.8.0 → 0.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpipher/armory-fleet",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "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,10 +220,18 @@ 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. Wrap abort so the local `aborted` flag is set when the panel
+    // calls handle.abort() (not just the signal path) — otherwise finishRun reports
+    // "completed" instead of "aborted" on a user-initiated Stop. Cleared by finishRun.
+    let aborted = false;
+    const handle = toLiveHandle(session);
+    handle.abort = async () => { aborted = true; await session.abort(); };
+    opts.runRegistry.update(runId, { session: handle });
+
     const budget = createTurnBudget(maxTurns);
     let finalText = "";
     let tokenTotal = 0;
-    let aborted = false;
     let turnIdx = -1;
 
     const onSignalAbort = (): void => { aborted = true; void session.abort(); };
@@ -281,6 +316,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/fleet-panel.ts

@@ -91,6 +91,9 @@ 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).
@@ -289,6 +292,11 @@ export class FleetPanel extends Container {
         this.addChild(tl);
       }
       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));
@@ -328,7 +336,7 @@ export class FleetPanel extends Container {
           : 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"
@@ -418,6 +426,8 @@ export class FleetPanel extends Container {
     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();
   }
@@ -453,6 +463,12 @@ export class FleetPanel extends Container {
       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) {
       if (matchesKey(data, "escape")) { this.cancelResume(); return; }
       this.resumeInput.handleInput(data);
@@ -509,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")) {
@@ -661,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;