@getpipher/armory-fleet 0.3.0 → 0.5.0

package/src/panel/fleet-panel.ts

@@ -10,15 +10,20 @@ import {
   type SelectItem,
 } from "@earendil-works/pi-tui";
 import type { AgentDef } from "../registry/frontmatter.ts";
-import type { RunRecord } from "../engine/run-registry.ts";
-import { fleetRow, agentsRow, agentInfo, backendsRow, backendInfo } from "./rows.ts";
+import { agentsRow, agentInfo, backendsRow, backendInfo, lifecycleRow, lifecyclePhaseTimeline, scheduleRow } from "./rows.ts";
+import { buildFleetItems } from "./fleet-items.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";
 import type { Backend, BackendRegistry } from "../backend/port.ts";
 import type { RunRegistry } from "../engine/run-registry.ts";
 import type { SingleSlotLock } from "../engine/concurrency-lock.ts";
 import type { TodoSyncPort } from "../todo-sync/port.ts";
+import type { LifecycleDef, LifecycleRunRecord, CheckpointDecision, PhaseRecord } from "../lifecycle/lifecycle-types.ts";
+import type { LifecycleRunDeps, CheckpointFn } from "../lifecycle/run-lifecycle.ts";
+import { runLifecycle } from "../lifecycle/run-lifecycle.ts";
 
-type View = "fleet" | "agents" | "backends";
+type View = "fleet" | "lifecycle" | "agents" | "backends" | "scheduled";
 
 export interface FleetPanelDeps {
   registry: Map<string, AgentDef>;
@@ -28,6 +33,14 @@ export interface FleetPanelDeps {
   backendRegistry: BackendRegistry;   // SPEC-3: replaces childFactory
   parentModel: { provider: string; id: string };
   parentCwd: string;
+  /** SPEC-4: lifecycle registry + active/recent run records + deps to drive checkpoints. */
+  lifecycleRegistry: Map<string, LifecycleDef>;
+  lifecycleRuns: Map<string, LifecycleRunRecord>;
+  lifecycleDeps: Omit<LifecycleRunDeps, "spawn">;
+  /** SPEC-5a: scheduler for the scheduled tab. Optional — panel degrades to an empty list when absent. */
+  scheduler?: Scheduler;
+  /** SPEC-5a: live bg run status rows for the fleet tab. Optional. */
+  bgRuns?: BgRunsStore;
 }
 
 export interface FleetPanelOpts {
@@ -50,6 +63,27 @@ export class FleetPanel extends Container {
   private linkPhase: "task" | "link" = "task";
   private infoAgent: AgentDef | null = null;
   private selectedBackend: Backend | null = null;   // SPEC-3: Backends view i:Info
+  private selectedLifecycle: LifecycleRunRecord | null = null;   // SPEC-4: Lifecycle view i:Info
+  // SPEC-4: Run-lifecycle inline input state
+  private lcRunMode = false;
+  private lcTaskInput: Input | null = null;
+  private lcNameInput: Input | null = null;
+  private lcPhase: "task" | "name" = "task";
+  // SPEC-4: pending checkpoint (interactive Continue/Revise/Abort)
+  private pendingCheckpoint: { phase: PhaseRecord; resolve: (d: CheckpointDecision) => void } | null = null;
+  private lcReviseInput: Input | null = null;
+  private lcRevising = false;
+  // SPEC-5a: scheduled tab — add-schedule inline input state + selected schedule for i:Info
+  private schedRunMode = false;
+  private schedTaskInput: Input | null = null;
+  private schedExprInput: Input | null = null;
+  private schedNameInput: Input | null = null;
+  private schedPhase: "task" | "expr" | "name" = "task";
+  private selectedSchedule: Schedule | 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)[] = [];
+  private closed = false;   // SPEC-5a proper-fix: guard against double-close calling onDone twice
 
   constructor(opts: FleetPanelOpts) {
     super();
@@ -63,15 +97,25 @@ export class FleetPanel extends Container {
     this.addChild(new Spacer(1));
     this.list = this.buildList();
     this.renderShell();
+
+    // SPEC-5a proper-fix: subscribe to run-registry + bg-runs mutations → live refresh.
+    // Covers both the model-invoked foreground case (spawnSubagent updates runRegistry)
+    // and the async/bg case (onProgress mutates BgRunsStore while the parent is idle).
+    this.unsubs.push(this.deps.runRegistry.subscribe(() => this.refresh()));
+    if (this.deps.bgRuns) this.unsubs.push(this.deps.bgRuns.subscribe(() => this.refresh()));
   }
 
   private buildList(): SelectList {
     const items: SelectItem[] =
       this.view === "fleet"
-        ? this.deps.runRegistry.list().map((r: RunRecord) => ({ value: r.runId, label: fleetRow(r) }))
-        : this.view === "agents"
-          ? [...this.deps.registry.values()].map((a: AgentDef) => ({ value: a.name, label: agentsRow(a) }))
-          : this.deps.backendRegistry.list().map((b: Backend) => ({ value: b.id, label: backendsRow(b) }));
+        ? buildFleetItems({ runRegistry: this.deps.runRegistry, bgRuns: this.deps.bgRuns })
+        : this.view === "lifecycle"
+          ? [...this.deps.lifecycleRuns.values()].map((l: LifecycleRunRecord) => ({ value: l.runId, label: lifecycleRow(l) }))
+          : this.view === "agents"
+            ? [...this.deps.registry.values()].map((a: AgentDef) => ({ value: a.name, label: agentsRow(a) }))
+            : this.view === "scheduled"
+              ? (this.deps.scheduler?.list() ?? []).map((s: Schedule) => ({ value: s.id, label: scheduleRow(s) }))
+              : this.deps.backendRegistry.list().map((b: Backend) => ({ value: b.id, label: backendsRow(b) }));
     const fresh = new SelectList(items, 12, {
       selectedPrefix: (s: string) => this.theme.fg("accent", s),
       selectedText: (s: string) => this.theme.fg("accent", s),
@@ -80,16 +124,36 @@ export class FleetPanel extends Container {
       noMatch: (s: string) => this.theme.fg("warning", s),
     });
     fresh.onSelect = (item: SelectItem) => this.onSelect(item.value);
-    fresh.onCancel = () => this.onDone();
+    fresh.onCancel = () => this.close();
     return fresh;
   }
 
+  /** SPEC-5a proper-fix: re-pull from the run-registry + bg-runs stores and re-render.
+   * Called by the store-change subscriptions (constructor) on every mutation, so the
+   * fleet tab reflects completion/status changes without a keypress. Safe to call
+   * mid-overlay: renderShell preserves the active overlay (input/info/checkpoint). */
+  private refresh(): void {
+    this.list = this.buildList();
+    this.renderShell();
+  }
+
+  /** SPEC-5a proper-fix: tear down store subscriptions then close the panel.
+   * Every exit path routes here so listeners never leak past the panel's lifetime.
+   * Idempotent — safe to call multiple times (esc + q + pi teardown). */
+  private close(): void {
+    if (this.closed) return;
+    this.closed = true;
+    for (const u of this.unsubs) u();
+    this.unsubs.length = 0;
+    this.onDone();
+  }
+
   private renderShell(): void {
     const keep = this.children.slice(0, 2);
     this.children.length = 0;
     this.children.push(...keep);
     const accent = (s: string): string => this.theme.fg("accent", s);
-    const tabs = (["fleet", "agents", "backends"] as View[])
+    const tabs = (["fleet", "lifecycle", "agents", "backends", "scheduled"] as View[])
       .map((v) => (v === this.view ? this.theme.fg("accent", this.theme.bold(`[${v}]`)) : this.theme.fg("dim", v)))
       .join("  ");
     this.addChild(new Text(accent(this.theme.bold("  FLEET")) + "  " + tabs, 0, 0));
@@ -112,19 +176,66 @@ export class FleetPanel extends Container {
         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.selectedLifecycle) {
+      // SPEC-4: i:Info detail pane (lifecycle view) — phase timeline
+      this.addChild(new Text(this.theme.fg("dim", "  ── lifecycle phases ──"), 0, 0));
+      for (const line of lifecyclePhaseTimeline(this.selectedLifecycle).split("\n")) {
+        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.selectedSchedule) {
+      // SPEC-5a: i:Info detail pane (scheduled view)
+      this.addChild(new Text(this.theme.fg("dim", "  ── schedule info ──"), 0, 0));
+      const s = this.selectedSchedule;
+      for (const line of [
+        `id: ${s.id}`,
+        `expression: ${s.expression}`,
+        `lifecycle: ${s.lifecycle}`,
+        `task: "${s.task}"`,
+        `paused: ${s.paused}`,
+        `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.schedRunMode && (this.schedTaskInput || this.schedExprInput || this.schedNameInput)) {
+      const prompt = this.schedPhase === "task" ? "  task> " : this.schedPhase === "expr" ? "  schedule (cron | interval | one-shot ISO)> " : "  lifecycle (blank=default)> ";
+      this.addChild(new Text(this.theme.fg("accent", prompt), 0, 0));
+      this.addChild(this.schedPhase === "task" ? this.schedTaskInput! : this.schedPhase === "expr" ? this.schedExprInput! : this.schedNameInput!);
+      this.addChild(new Text(this.theme.fg("dim", "  enter submit • esc cancel"), 0, 0));
+    } else if (this.lcRunMode && (this.lcTaskInput || this.lcNameInput)) {
+      const prompt = this.lcPhase === "task" ? "  task> " : "  lifecycle name (blank=default)> ";
+      this.addChild(new Text(this.theme.fg("accent", prompt), 0, 0));
+      this.addChild(this.lcPhase === "task" ? this.lcTaskInput! : this.lcNameInput!);
+      this.addChild(new Text(this.theme.fg("dim", "  enter submit • esc cancel"), 0, 0));
+    } else if (this.pendingCheckpoint && !this.lcRevising) {
+      const pc = this.pendingCheckpoint;
+      this.addChild(new Text(this.theme.fg("dim", `  ── checkpoint: phase '${pc.phase.name}' (${pc.phase.status}) ──`), 0, 0));
+      this.addChild(new Text(this.theme.fg("text", `  ${pc.phase.summary.slice(0, 200)}`), 0, 0));
+      this.addChild(new Text(this.theme.fg("dim", "  c:Continue  v:Revise  a:Abort"), 0, 0));
+    } else if (this.lcRevising && this.lcReviseInput) {
+      this.addChild(new Text(this.theme.fg("accent", "  revise feedback> "), 0, 0));
+      this.addChild(this.lcReviseInput);
+      this.addChild(new Text(this.theme.fg("dim", "  enter submit • esc cancel"), 0, 0));
     } else {
       this.addChild(this.list);
     }
 
     this.addChild(new Spacer(1));
     const hint =
-      this.infoAgent || this.selectedBackend
+      this.infoAgent || this.selectedBackend || this.selectedLifecycle || this.selectedSchedule
         ? "  esc:Back"
-        : this.view === "fleet"
-          ? "  r:Run-new  s:Stop  o:Open-todo  tab:Agents  q:Quit"
-          : this.view === "agents"
-            ? "  r:Run  e:Edit  i:Info  d:Reload  tab:Backends  q:Quit"
-            : "  r:Refresh  i:Info  tab:Fleet  q:Quit";
+        : 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"
+              : this.view === "lifecycle"
+                ? "  r:Run-lifecycle  i:Info  tab:Agents  q:Quit"
+                : this.view === "agents"
+                  ? "  r:Run  e:Edit  i:Info  d:Reload  tab:Backends  q:Quit"
+                  : this.view === "scheduled"
+                    ? "  a:Add  p:Pause/resume  d:Delete  i:Info  tab:Fleet  q:Quit"
+                    : "  r:Refresh  i:Info  tab:Fleet  q:Quit";
     this.addChild(new Text(this.theme.fg("dim", hint), 0, 0));
     this.addChild(new Spacer(1));
     this.addChild(new DynamicBorder(accent));
@@ -190,8 +301,13 @@ export class FleetPanel extends Container {
   }
 
   private switchView(): void {
-    this.view = this.view === "fleet" ? "agents" : this.view === "agents" ? "backends" : "fleet";
+    this.view = this.view === "fleet" ? "lifecycle"
+      : this.view === "lifecycle" ? "agents"
+      : this.view === "agents" ? "backends"
+      : this.view === "backends" ? "scheduled" : "fleet";
     this.selectedBackend = null;
+    this.selectedLifecycle = null;
+    this.selectedSchedule = null;
     this.list = this.buildList();
     this.renderShell();
   }
@@ -205,15 +321,44 @@ export class FleetPanel extends Container {
       if (matchesKey(data, "escape")) { this.selectedBackend = null; this.renderShell(); }
       return;
     }
+    if (this.selectedLifecycle) {
+      if (matchesKey(data, "escape")) { this.selectedLifecycle = null; this.renderShell(); }
+      return;
+    }
+    if (this.selectedSchedule) {
+      if (matchesKey(data, "escape")) { this.selectedSchedule = null; this.renderShell(); }
+      return;
+    }
+    if (this.schedRunMode && (this.schedTaskInput || this.schedExprInput || this.schedNameInput)) {
+      if (matchesKey(data, "escape")) { this.cancelScheduleAdd(); return; }
+      (this.schedPhase === "task" ? this.schedTaskInput! : this.schedPhase === "expr" ? this.schedExprInput! : this.schedNameInput!).handleInput(data);
+      this.invalidate();
+      return;
+    }
+    if (this.lcRunMode && (this.lcTaskInput || this.lcNameInput)) {
+      if (matchesKey(data, "escape")) { this.cancelLifecycleRun(); return; }
+      (this.lcPhase === "task" ? this.lcTaskInput! : this.lcNameInput!).handleInput(data);
+      this.invalidate();
+      return;
+    }
     if (this.runMode && (this.taskInput || this.linkInput)) {
       if (matchesKey(data, "escape")) { this.cancelRun(); return; }
       (this.linkPhase === "task" ? this.taskInput! : this.linkInput!).handleInput(data);
       this.invalidate();
       return;
     }
-    if (matchesKey(data, "escape")) { this.onDone(); return; }
+    if (matchesKey(data, "escape")) {
+      // SPEC-4: if a lifecycle checkpoint is pending, resolve it as abort so runLifecycle
+      // doesn't hang + the lifecycle TODO is reverted (not orphaned) when the panel closes.
+      if (this.pendingCheckpoint) {
+        this.pendingCheckpoint.resolve({ action: "abort" });
+        this.pendingCheckpoint = null;
+      }
+      this.close();
+      return;
+    }
     if (matchesKey(data, "tab")) { this.switchView(); return; }
-    if (matchesKey(data, "q")) { this.onDone(); return; }
+    if (matchesKey(data, "q")) { this.close(); return; }
     if (matchesKey(data, "r") && this.view === "agents") {
       const sel = this.list.getSelectedItem();
       if (sel) this.startRun(sel.value);
@@ -234,9 +379,180 @@ export class FleetPanel extends Container {
       this.renderShell();
       return;
     }
+    // SPEC-4: Lifecycle view — i:Info + r:Run-lifecycle
+    if (matchesKey(data, "i") && this.view === "lifecycle") {
+      const sel = this.list.getSelectedItem();
+      if (sel) { this.selectedLifecycle = this.deps.lifecycleRuns.get(sel.value) ?? null; this.renderShell(); }
+      return;
+    }
+    if (matchesKey(data, "r") && this.view === "lifecycle") {
+      this.startLifecycleRun();
+      return;
+    }
+    // SPEC-5a: scheduled view — a:Add p:Pause/resume d:Delete i:Info
+    if (this.view === "scheduled" && this.deps.scheduler) {
+      if (matchesKey(data, "a")) { this.startScheduleAdd(); return; }
+      if (matchesKey(data, "i")) {
+        const sel = this.list.getSelectedItem();
+        if (sel) { this.selectedSchedule = this.deps.scheduler.list().find((x) => x.id === sel.value) ?? null; this.renderShell(); }
+        return;
+      }
+      if (matchesKey(data, "p")) {
+        const sel = this.list.getSelectedItem();
+        if (sel) {
+          const s = this.deps.scheduler.list().find((x) => x.id === sel.value);
+          if (s) { s.paused ? this.deps.scheduler.resume(sel.value) : this.deps.scheduler.pause(sel.value); this.list = this.buildList(); this.renderShell(); }
+        }
+        return;
+      }
+      if (matchesKey(data, "d")) {
+        const sel = this.list.getSelectedItem();
+        if (sel) { this.deps.scheduler.delete(sel.value); this.list = this.buildList(); this.renderShell(); }
+        return;
+      }
+    }
+    // SPEC-4: pending checkpoint keys (c/v/a)
+    if (this.pendingCheckpoint && !this.lcRevising) {
+      if (matchesKey(data, "c")) { this.pendingCheckpoint.resolve({ action: "continue" }); this.pendingCheckpoint = null; this.renderShell(); return; }
+      if (matchesKey(data, "a")) { this.pendingCheckpoint!.resolve({ action: "abort" }); this.pendingCheckpoint = null; this.renderShell(); return; }
+      if (matchesKey(data, "v")) {
+        this.lcRevising = true;
+        this.lcReviseInput = new Input();
+        this.lcReviseInput.onSubmit = (fb: string) => {
+          this.lcRevising = false;
+          this.lcReviseInput = null;
+          this.pendingCheckpoint!.resolve({ action: "revise", feedback: fb });
+          this.pendingCheckpoint = null;
+          this.renderShell();
+        };
+        this.lcReviseInput.onEscape = () => { this.lcRevising = false; this.lcReviseInput = null; this.renderShell(); };
+        this.renderShell();
+        return;
+      }
+    }
+    if (this.lcRevising && this.lcReviseInput) {
+      if (matchesKey(data, "escape")) { this.lcRevising = false; this.lcReviseInput = null; this.renderShell(); return; }
+      this.lcReviseInput.handleInput(data);
+      this.invalidate();
+      return;
+    }
     this.list.handleInput(data);
     this.invalidate();
   }
+
+  /** SPEC-5a: open the Add-schedule inline inputs (task → expression → lifecycle name → register). */
+  private startScheduleAdd(): void {
+    this.schedPhase = "task";
+    this.schedTaskInput = new Input();
+    this.schedTaskInput.onSubmit = (task: string) => {
+      if (!task.trim()) { this.cancelScheduleAdd(); return; }
+      this.schedPhase = "expr";
+      this.schedExprInput = new Input();
+      this.schedExprInput.onSubmit = (expr: string) => {
+        if (!expr.trim()) { this.cancelScheduleAdd(); return; }
+        this.schedPhase = "name";
+        this.schedNameInput = new Input();
+        this.schedNameInput.onSubmit = (name: string) => {
+          const lcName = name.trim() || "default";
+          this.executeScheduleAdd(task.trim(), expr.trim(), lcName);
+        };
+        this.schedNameInput.onEscape = () => { this.executeScheduleAdd(task.trim(), expr.trim(), "default"); };
+        this.renderShell();
+      };
+      this.schedExprInput.onEscape = () => this.cancelScheduleAdd();
+      this.renderShell();
+    };
+    this.schedTaskInput.onEscape = () => this.cancelScheduleAdd();
+    this.schedRunMode = true;
+    this.renderShell();
+  }
+
+  private cancelScheduleAdd(): void {
+    this.schedRunMode = false;
+    this.schedTaskInput = null;
+    this.schedExprInput = null;
+    this.schedNameInput = null;
+    this.renderShell();
+  }
+
+  private executeScheduleAdd(task: string, expression: string, lifecycleName: string): void {
+    this.schedRunMode = false;
+    this.schedTaskInput = null;
+    this.schedExprInput = null;
+    this.schedNameInput = null;
+    if (!this.deps.scheduler) { this.onNotify("scheduling not configured", "error"); this.renderShell(); return; }
+    try {
+      const id = this.deps.scheduler.register({ task, expression, lifecycle: lifecycleName, auto: true });
+      this.list = this.buildList();
+      this.renderShell();
+      const entry = this.deps.scheduler.list().find((s) => s.id === id);
+      this.onNotify(`scheduled: ${id} · next fire: ${entry?.nextFire?.toLocaleString() ?? "(paused)"}`, "info");
+    } catch (e) {
+      this.onNotify(`schedule register failed: ${(e as Error).message}`, "error");
+    }
+    this.renderShell();
+  }
+
+  /** SPEC-4: open the Run-lifecycle inline inputs (task → lifecycle name → start runLifecycle). */
+  private startLifecycleRun(): void {
+    this.lcPhase = "task";
+    this.lcTaskInput = new Input();
+    this.lcTaskInput.onSubmit = (task: string) => {
+      if (!task.trim()) { this.cancelLifecycleRun(); return; }
+      this.lcPhase = "name";
+      this.lcNameInput = new Input();
+      this.lcNameInput.onSubmit = (name: string) => {
+        const lcName = name.trim() || "default";
+        void this.executeLifecycleRun(task.trim(), lcName);
+      };
+      this.lcNameInput.onEscape = () => { void this.executeLifecycleRun(task.trim(), "default"); };
+      this.renderShell();
+    };
+    this.lcTaskInput.onEscape = () => this.cancelLifecycleRun();
+    this.lcRunMode = true;
+    this.renderShell();
+  }
+
+  private cancelLifecycleRun(): void {
+    this.lcRunMode = false;
+    this.lcTaskInput = null;
+    this.lcNameInput = null;
+    this.renderShell();
+  }
+
+  private async executeLifecycleRun(task: string, lifecycleName: string): Promise<void> {
+    this.lcRunMode = false;
+    this.lcTaskInput = null;
+    this.lcNameInput = null;
+    this.renderShell();
+    if (!this.deps.lifecycleRegistry.has(lifecycleName)) {
+      this.onNotify(`lifecycle '${lifecycleName}' not found; available: ${[...this.deps.lifecycleRegistry.keys()].sort().join(", ")}`, "error");
+      return;
+    }
+    const onCheckpoint: CheckpointFn = (phase) => new Promise<CheckpointDecision>((resolve) => {
+      this.pendingCheckpoint = { phase, resolve };
+      this.renderShell();
+    });
+    const lifecycleFullDeps: LifecycleRunDeps = {
+      ...this.deps.lifecycleDeps,
+      spawn: async (o) => {
+        const { spawnSubagent } = await import("../engine/spawnSubagent.ts");
+        return spawnSubagent({
+          agent: o.agent, task: o.task, lifecycleTodoId: o.lifecycleTodoId, model: o.model,
+            skillsOverride: o.skills, backendOverride: o.backend,
+          registry: this.deps.registry, todoSync: this.deps.todoSync, runRegistry: this.deps.runRegistry, lock: this.deps.lock,
+          backendRegistry: this.deps.backendRegistry, parentModel: this.deps.parentModel, parentCwd: this.deps.parentCwd,
+        });
+      },
+    };
+    const res = await runLifecycle(task, lifecycleName, { deps: lifecycleFullDeps, mode: "checkpointed", onCheckpoint });
+    this.pendingCheckpoint = null;
+    // record the run so the Lifecycle view shows it
+    this.deps.lifecycleRuns.set(res.runId, res);
+    this.list = this.buildList();
+    this.renderShell();
+    this.onNotify(`lifecycle ${res.status}: ${res.runId}${res.error ? " — " + res.error : ""}`, res.status === "completed" ? "info" : "warning");
+  }
 }
 
 /** Factory used by src/index.ts to open the panel via ctx.ui.custom. */

package/src/panel/rows.ts

@@ -82,3 +82,93 @@ export function backendInfo(b: Backend): string {
   lines.push(`  vision: ${b.hookParity.vision}  (${b.hookParity.vision === "✓" ? "describe_image fallback injected" : "pass-through only; no describe_image fallback — customTools not injectable into claude -p"})`);
   return lines.join("\n");
 }
+
+import type { LifecycleRunRecord, LifecycleStatus } from "../lifecycle/lifecycle-types.ts";
+
+
+// SPEC-5a §11 — bg run row status (Q8=A). The fleet tab gains live status icons + phase progress
+// for async/bg runs; foreground rows are unchanged.
+export type BgStatus = "running" | "paused" | "completed" | "failed" | "queued";
+
+export interface BgRunStatus {
+  runId: string;
+  lifecycle: string;
+  status: BgStatus;
+  phase: string;
+  phaseIndex: number;
+  phaseTotal: number;
+  mode: "auto" | "checkpointed";
+  backend: string;
+  task: string;
+  branch?: string;
+  elapsedMs?: number;
+}
+
+export function bgStatusIcon(s: BgStatus): string {
+  switch (s) {
+    case "running": return "▶";
+    case "paused": return "⏸";
+    case "completed": return "✓";
+    case "failed": return "✗";
+    case "queued": return "⏳";
+  }
+}
+
+export function renderBgRow(r: BgRunStatus): string {
+  const icon = bgStatusIcon(r.status);
+  const phase = r.phase ? `●${r.phase} ${r.phaseIndex}/${r.phaseTotal}` : `${r.phaseIndex}/${r.phaseTotal}`;
+  const branch = r.branch ? `  ${r.branch}` : "";
+  const elapsed = r.elapsedMs ? `  ${fmtDuration(r.elapsedMs)}` : "";
+  const task = r.task.length > 30 ? r.task.slice(0, 29) + "…" : r.task;
+  return `${icon} ${r.runId}  ${r.lifecycle}  ${phase}  ${r.mode}${elapsed}  ${r.backend}${branch}  "${task}"`;
+}
+
+// SPEC-5a §11 — scheduled tab row rendering.
+export interface ScheduleRow {
+  id: string;
+  expression: string;
+  lifecycle?: string;
+  task: string;
+  nextFire: Date | null;
+  paused: boolean;
+}
+
+export function scheduleRow(s: ScheduleRow): string {
+  const icon = s.paused ? "⏸" : "▶";
+  const next = s.nextFire ? `next: ${s.nextFire.toLocaleString()}` : "paused";
+  const task = s.task.length > 24 ? s.task.slice(0, 23) + "…" : s.task;
+  const lc = s.lifecycle ?? "default";
+  return `${icon}  ${s.expression}  ${lc}  "${task}"  ${next}  ${s.id}`;
+}
+
+const LC_GLYPH: Record<LifecycleStatus, string> = {
+  running: "▶", checkpoint: "⏸", completed: "✓", failed: "✗", aborted: "✗",
+};
+
+export function lifecycleRow(r: LifecycleRunRecord): string {
+  const dur = r.endedAt ? fmtDuration(r.endedAt - r.startedAt) : "—";
+  const curIdx = r.phases.findIndex((p) => p.status === "running");
+  const cur = curIdx >= 0 ? r.phases[curIdx] : r.phases[r.phases.length - 1];
+  const curName = cur ? `●${cur.name}` : "—";
+  // N/M = current phase position / total (1-indexed); falls back to last phase when none running.
+  const counts = `${(curIdx >= 0 ? curIdx + 1 : r.phases.length)}/${r.phases.length}`;
+  return `${LC_GLYPH[r.status]} ${r.runId}  ${r.lifecycleName}  ${curName} ${counts}  ${r.mode}  ${dur}  ${r.backend}  "${r.task}"`;
+}
+
+export function lifecyclePhaseTimeline(r: LifecycleRunRecord): string {
+  const lines: string[] = [
+    `Lifecycle ${r.runId} — ${r.lifecycleName} — "${r.task}"`,
+    `Backend: ${r.backend} · Mode: ${r.mode} · Status: ${r.status}`,
+    "",
+    "Phases:",
+  ];
+  for (const p of r.phases) {
+    const mark = p.reviseCount > 0 ? "[~]" : p.status === "completed" ? "[x]" : "[ ]";
+    const art = p.paths.length ? ` → ${p.paths.join(", ")}` : "";
+    lines.push(`  ${mark} ${p.name}  ${p.status}${art}${p.paths.length ? "  [Open]" : ""}`);
+  }
+  if (r.status === "checkpoint") {
+    lines.push("", "── Checkpoint ──", "[Continue]  [Revise]  [Abort]");
+  }
+  return lines.join("\n");
+}

package/src/runtime/async-runner.ts

@@ -0,0 +1,123 @@
+// src/runtime/async-runner.ts
+// SPEC-5a §2/§6/§7/§8/§10 — the async/bg path. Layers ABOVE the unchanged runLifecycle:
+// creates a worktree, journals events, drives runLifecycle with the worktree cwd, discovers
+// artifacts via DiffService, commits on completion, pushes to the inbox, notifies.
+import type { WorktreeService } from "../worktree/worktree-service.ts";
+import type { DiffService } from "../worktree/diff-service.ts";
+import type { RunJournal, JournalEvent } from "./run-journal.ts";
+import type { ConcurrencyPool } from "./concurrency-pool.ts";
+import type { ResultsInbox, RunResult } from "./results-inbox.ts";
+import { execSync } from "node:child_process";
+
+// Thin shape of the LifecycleRunResult we need (avoids importing the full type here — the
+// real adapter in index.ts maps the full LifecycleRunResult to this shape).
+export interface FakeLifecycleResult {
+  runId: string;
+  lifecycleName: string;
+  task: string;
+  status: "completed" | "failed" | "aborted";
+  phases: Array<{ name: string; status: string; summary: string; paths: string[]; reviseCount: number }>;
+  todoId: string | null;
+  error?: string;
+}
+
+export interface RunLifecycleOpts {
+  runId: string;
+  worktreePath: string;
+  branch: string;
+  mode: "auto" | "checkpointed";
+}
+
+export type RunLifecycleFn = (task: string, lifecycleName: string, opts: RunLifecycleOpts) => Promise<FakeLifecycleResult>;
+
+export interface AsyncRunnerDeps {
+  worktree: WorktreeService;
+  diff: DiffService;
+  journal: RunJournal;
+  pool: ConcurrencyPool;
+  inbox: ResultsInbox;
+  runLifecycle: RunLifecycleFn;
+  notify: (msg: string, level?: "info" | "warning" | "error") => void;
+  genRunId: () => string;
+  /** SPEC-5a: called at each run/phase transition so the host (index.ts) can update the live bgRuns map. */
+  onProgress?: (runId: string, status: import("../panel/rows.ts").BgRunStatus) => void;
+}
+
+export interface RunBackgroundOpts {
+  deps: AsyncRunnerDeps;
+  lifecycle: string;
+  mode: "auto" | "checkpointed";
+}
+
+export interface RunBackgroundHandle {
+  runId: string;
+  status: "background";
+}
+
+function emitProgress(deps: AsyncRunnerDeps, runId: string, partial: Partial<import("../panel/rows.ts").BgRunStatus> & { status: import("../panel/rows.ts").BgStatus; phase: string; phaseIndex: number; phaseTotal: number }): void {
+  if (!deps.onProgress) return;
+  deps.onProgress(runId, {
+    runId,
+    lifecycle: "",
+    mode: "auto",
+    backend: "pi",
+    task: "",
+    ...partial,
+  });
+}
+
+function sh(cmd: string, cwd: string): void {
+  execSync(cmd, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+}
+
+export function runBackground(task: string, opts: RunBackgroundOpts): RunBackgroundHandle {
+  const { deps } = opts;
+  const runId = deps.genRunId();
+  const baseRef = "HEAD";
+
+  // Fire-and-forget: the pool gates concurrency; the journal records the run.
+  void deps.pool.withSlot(async () => {
+    let wt: { path: string; branch: string } | null = null;
+    try {
+      wt = deps.worktree.create(runId, baseRef);
+      const ev0: JournalEvent = { type: "run:started", runId, task, lifecycle: opts.lifecycle, worktree: { path: wt.path, branch: wt.branch }, mode: opts.mode, ts: Date.now() };
+      deps.journal.append(runId, ev0);
+      emitProgress(deps, runId, { status: "running", phase: "", phaseIndex: 0, phaseTotal: 0, lifecycle: opts.lifecycle, mode: opts.mode, task });
+
+      const res = await deps.runLifecycle(task, opts.lifecycle, { runId, worktreePath: wt.path, branch: wt.branch, mode: opts.mode });
+
+      if (res.status === "completed") {
+        // commit the worktree to the branch (lifecycle finish phase or single-delegate completion)
+        try { sh("git add -A && git commit -m 'fleet run complete'", wt.path); } catch { /* nothing to commit */ }
+        deps.journal.append(runId, { type: "run:completed", runId, branch: wt.branch, ts: Date.now() });
+        const total = res.phases.length;
+        const lastIdx = total; // completed = past the last phase
+        emitProgress(deps, runId, { status: "completed", phase: res.phases[total - 1]?.name ?? "finish", phaseIndex: lastIdx, phaseTotal: total, lifecycle: opts.lifecycle, mode: opts.mode, task, branch: wt.branch });
+        const lastPhase = res.phases[res.phases.length - 1];
+        const result: RunResult = {
+          runId, task, status: "completed",
+          summary: lastPhase?.summary ?? "",
+          paths: res.phases.flatMap((p) => p.paths),
+          branch: wt.branch, completedAt: Date.now(),
+        };
+        deps.inbox.push(result);
+        deps.notify(`fleet run ${runId} completed`, "info");
+        // SPEC-5a: the worktree dir is temporary scaffolding; remove it but keep the branch for merge/inspection.
+        deps.worktree.removeWorktree(runId);
+      } else {
+        deps.journal.append(runId, { type: "run:aborted", runId, reason: res.error ?? res.status, ts: Date.now() });
+        deps.worktree.remove(runId);
+        emitProgress(deps, runId, { status: "failed", phase: "", phaseIndex: 0, phaseTotal: res.phases.length, lifecycle: opts.lifecycle, mode: opts.mode, task });
+        deps.notify(`fleet run ${runId} ${res.status}: ${res.error ?? ""}`, "warning");
+      }
+    } catch (e) {
+      const msg = (e as Error).message;
+      deps.journal.append(runId, { type: "run:aborted", runId, reason: msg, ts: Date.now() });
+      if (wt) deps.worktree.remove(runId);
+      deps.notify(`fleet run ${runId} failed: ${msg}`, "error");
+      emitProgress(deps, runId, { status: "failed", phase: "", phaseIndex: 0, phaseTotal: 0, lifecycle: opts.lifecycle, mode: opts.mode, task });
+    }
+  });
+
+  return { runId, status: "background" };
+}