@getpipher/armory-fleet 0.4.0 → 0.5.1

package/package.json

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

@@ -23,11 +23,15 @@ export function genRunId(): string {
   return "fl-" + Date.now().toString(36) + "-" + Math.random().toString(36).slice(2, 8);
 }
 
+export type RunRegistryChangeListener = () => void;
+
 export class RunRegistry {
   private readonly runs = new Map<string, RunRecord>();
+  private readonly listeners = new Set<RunRegistryChangeListener>();
 
   add(r: RunRecord): void {
     this.runs.set(r.runId, r);
+    this.emit();
   }
   get(id: string): RunRecord | undefined {
     return this.runs.get(id);
@@ -38,6 +42,14 @@ export class RunRegistry {
   }
   update(id: string, patch: Partial<Omit<RunRecord, "runId">>): void {
     const r = this.runs.get(id);
-    if (r) this.runs.set(id, { ...r, ...patch });
+    if (r) { this.runs.set(id, { ...r, ...patch }); this.emit(); }
+  }
+  /** SPEC-5a proper-fix: subscribe to add/update mutations. Returns an unsubscribe fn. */
+  subscribe(fn: RunRegistryChangeListener): () => void {
+    this.listeners.add(fn);
+    return () => { this.listeners.delete(fn); };
+  }
+  private emit(): void {
+    for (const fn of this.listeners) fn();
   }
 }

package/src/index.ts

@@ -30,6 +30,16 @@ import { discoverLifecycles } from "./lifecycle/registry.ts";
 import { DEFAULT_LIFECYCLE, builtinLifecyclesDir } from "./lifecycle/default.ts";
 import type { LifecycleDef } from "./lifecycle/lifecycle-types.ts";
 import type { LifecycleRunDeps } from "./lifecycle/run-lifecycle.ts";
+import { WorktreeService } from "./worktree/worktree-service.ts";
+import { DiffService } from "./worktree/diff-service.ts";
+import { RunJournal } from "./runtime/run-journal.ts";
+import { ConcurrencyPool } from "./runtime/concurrency-pool.ts";
+import { ResultsInbox } from "./runtime/results-inbox.ts";
+import { runBackground, type AsyncRunnerDeps } from "./runtime/async-runner.ts";
+import { scanResumeCandidates } from "./runtime/resume.ts";
+import { Scheduler } from "./scheduling/scheduler.ts";
+import { createFleetResultsTool } from "./tools/fleet-results.ts";
+import { BgRunsStore } from "./panel/bg-runs-store.ts";
 
 /** The package builtin agents/ dir, resolved relative to this module. */
 function builtinAgentsDir(): string {
@@ -151,6 +161,35 @@ export default async function (pi: ExtensionAPI): Promise<void> {
   deps.lifecycleDeps.registry = deps.lifecycleRegistry;
   deps.lifecycleDeps.agentRegistry = deps.registry;
 
+  // ── SPEC-5a: operational runtime (async/bg + scheduling + worktree isolation) ──
+  const fleetDir = (cwd: string) => join(cwd, ".pi", "fleet");
+  const bgRuns = new BgRunsStore();
+  const resultsInbox = new ResultsInbox();
+  // 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) => {
+    const { runLifecycle } = await import("./lifecycle/run-lifecycle.ts");
+    const { spawnSubagent } = await import("./engine/spawnSubagent.ts");
+    const lifecycleFullDeps: LifecycleRunDeps = {
+      ...deps.lifecycleDeps,
+      genRunId: () => opts.runId,   // override: use the async runner's runId
+      // SPEC-5a (Q3=A): isolated run — worktree-diff artifact discovery instead of the prompt-baked block.
+      artifactDiscovery: ({ finalText, cwd, baseRef }) => (deps.asyncRunner as AsyncRunnerDeps).diff.diffPhase(cwd, baseRef, finalText),
+      spawn: async (o) => spawnSubagent({
+        agent: o.agent, task: o.task, lifecycleTodoId: o.lifecycleTodoId, model: o.model,
+        skillsOverride: o.skills, backendOverride: o.backend,
+        registry: deps.registry, todoSync: deps.todoSync, runRegistry: deps.runRegistry, lock: deps.lock,
+        backendRegistry: deps.backendRegistry, parentModel: deps.parentModel, parentCwd: opts.worktreePath,  // child runs in the worktree
+      }),
+    };
+    const res = await runLifecycle(task, lifecycleName, { deps: lifecycleFullDeps, mode: opts.mode, worktreePath: opts.worktreePath, baseRef: "HEAD", onCheckpoint: async (p) => p.status === "failed" ? { action: "abort" } : { action: "continue" } });
+    return res as unknown as import("./runtime/async-runner.ts").FakeLifecycleResult;
+  };
+  // asyncRunnerDeps + scheduler are built per-session (need the session cwd); wired on session_start.
+  // At init they're undefined — the subagent tool's `if (!deps.asyncRunner)` guard returns an
+  // actionable "not configured" error if called before session_start (can't happen in practice).
+  deps.bgRuns = bgRuns;
+
   const refresh = (ctx: { cwd: string; ui: { notify: (m: string, t?: "info" | "warning" | "error") => void } }): void => {
     const r = discoverAgents({
       projectDir: join(ctx.cwd, ".pi", "agents"),
@@ -184,6 +223,32 @@ export default async function (pi: ExtensionAPI): Promise<void> {
     const m = ctx.model;
     deps.parentModel = m ? { provider: m.provider, id: m.id } : { provider: "", id: "" };
     deps.parentCwd = ctx.cwd;
+    // SPEC-5a: build the per-session async runner + scheduler, start firing, scan for interrupted runs.
+    const dir = fleetDir(ctx.cwd);
+    deps.asyncRunner = {
+      worktree: new WorktreeService({ rootDir: ctx.cwd }),
+      diff: new DiffService(),
+      journal: new RunJournal(join(dir, "runs")),
+      pool: new ConcurrencyPool(3),
+      inbox: resultsInbox,
+      runLifecycle: asyncRunLifecycle,
+      notify: (m, lvl) => ctx.ui.notify(m, lvl),
+      genRunId: () => "fl-" + Date.now().toString(36) + "-" + Math.random().toString(36).slice(2, 8),
+      onProgress: (runId, status) => { bgRuns.set(runId, status); },
+    };
+    deps.scheduler = new Scheduler({
+      storePath: join(dir, "schedules.json"),
+      lockPath: join(dir, "schedules.lock"),
+      onFire: (spec) => {
+        if (!deps.asyncRunner) return;
+        runBackground(spec.task, { deps: deps.asyncRunner, lifecycle: spec.lifecycle ?? "default", mode: spec.auto ? "auto" : "checkpointed" });
+      },
+    });
+    deps.scheduler.start();
+    const cands = scanResumeCandidates(ctx.cwd, { runsDir: join(dir, "runs"), worktree: deps.asyncRunner.worktree });
+    if (cands.length > 0) {
+      ctx.ui.notify(`${cands.length} interrupted fleet run${cands.length > 1 ? "s" : ""} — open /fleet to resume`, "info");
+    }
   });
 
   pi.on("resources_discover", (event, ctx) => {
@@ -192,6 +257,8 @@ export default async function (pi: ExtensionAPI): Promise<void> {
   });
 
   pi.registerTool(createSubagentTool(deps) as never);
+  // SPEC-5a: fleet.results — the agent pulls completed bg-run results from the inbox (Q6=C).
+  pi.registerTool(createFleetResultsTool({ inbox: resultsInbox }) as never);
 
   pi.registerCommand("fleet", {
     description: "Open the armory-fleet panel (running + recent subagents + agent registry).",

package/src/lifecycle/run-lifecycle.ts

@@ -33,12 +33,20 @@ export interface LifecycleRunDeps {
   /** Resolve the backend for a phase: phase.backend → lifecycle.backend → "pi" (+ availability check). */
   resolveBackend: (phaseBackend: BackendId | undefined, lifecycleBackend: BackendId) => BackendId;
   genRunId: () => string;
+  /** SPEC-5a (Q3=A): when present, isolated runs use worktree-diff artifact discovery
+   *  instead of the prompt-baked `Artifacts:` block parser. Foreground runs leave this undefined. */
+  artifactDiscovery?: (o: { finalText: string; cwd: string; baseRef: string; terminal: boolean }) => { summary: string; paths: string[] } | { error: string };
 }
 
 export interface LifecycleRunOpts {
   deps: LifecycleRunDeps;
   mode: LifecycleMode;
   onCheckpoint: CheckpointFn;
+  /** SPEC-5a (Q3=A): the worktree path for isolated runs. When set + deps.artifactDiscovery is present,
+   *  artifact discovery uses worktree-diff instead of parseArtifacts. Foreground runs leave this undefined. */
+  worktreePath?: string;
+  /** SPEC-5a: the base ref to diff against (default "HEAD"). */
+  baseRef?: string;
 }
 
 export interface LifecycleRunResult {
@@ -143,6 +151,14 @@ export async function runLifecycle(task: string, lifecycleName: string, opts: Li
       let phaseRec: PhaseRecord;
       if (spawnRes.status === "failed") {
         phaseRec = { name: phaseDef.name, summary: spawnRes.error ?? spawnRes.finalText.slice(0, 120), paths: [], status: "failed", reviseCount };
+      } else if (deps.artifactDiscovery && opts.worktreePath) {
+        // SPEC-5a (Q3=A): isolated run — structural worktree-diff (robust to models that omit the Artifacts block).
+        const art = deps.artifactDiscovery({ finalText: spawnRes.finalText, cwd: opts.worktreePath, baseRef: opts.baseRef ?? "HEAD", terminal: isTerminal });
+        if ("error" in art) {
+          phaseRec = { name: phaseDef.name, summary: art.error, paths: [], status: "failed", reviseCount };
+        } else {
+          phaseRec = { name: phaseDef.name, summary: art.summary, paths: art.paths, status: "completed", reviseCount };
+        }
       } else {
         const art = parseArtifacts(spawnRes.finalText, { terminal: isTerminal });
         if ("error" in art) {

package/src/panel/bg-runs-store.ts

@@ -0,0 +1,36 @@
+// src/panel/bg-runs-store.ts
+// SPEC-5a proper-fix: a change-emitting store for live bg-run status rows.
+//
+// Replaces the bare `Map<string, BgRunStatus>` that `onProgress` used to mutate.
+// The async runner's `onProgress` callback writes here on every phase transition
+// and on completion; the /fleet panel subscribes so it re-renders the moment a
+// bg run's status changes — even while the parent is idle (no `turn_end` fires
+// for an async/fire-and-forget run). This is the SPEC-5b live-widget seam,
+// delivered early as the proper fix for the stale "running" row bug.
+import type { BgRunStatus } from "./rows.ts";
+
+export type BgRunsChangeListener = (runId: string) => void;
+
+export class BgRunsStore {
+  private readonly runs = new Map<string, BgRunStatus>();
+  private readonly listeners = new Set<BgRunsChangeListener>();
+
+  set(runId: string, status: BgRunStatus): void {
+    this.runs.set(runId, status);
+    for (const fn of this.listeners) fn(runId);
+  }
+
+  get(runId: string): BgRunStatus | undefined {
+    return this.runs.get(runId);
+  }
+
+  values(): IterableIterator<BgRunStatus> {
+    return this.runs.values();
+  }
+
+  /** Subscribe to status changes. Returns an unsubscribe function. */
+  subscribe(fn: BgRunsChangeListener): () => void {
+    this.listeners.add(fn);
+    return () => { this.listeners.delete(fn); };
+  }
+}

package/src/panel/fleet-items.ts

@@ -0,0 +1,36 @@
+// src/panel/fleet-items.ts
+// SPEC-5a proper-fix: pure builder for the /fleet fleet-tab list items.
+//
+// Extracted from FleetPanel.buildList so the merge + dedup of foreground
+// (RunRegistry) rows and live bg (BgRunsStore) rows is unit-testable without
+// a TUI harness. Foreground rows render via `fleetRow`; bg rows via
+// `renderBgRow` (the Q8=A live status icons + phase progress). The two stores
+// are disjoint by runId in practice (bg runs never enter RunRegistry under
+// their own runId; the lifecycle's child spawns use their own runIds), but we
+// dedup defensively in case a future change overlaps them.
+import type { RunRecord } from "../engine/run-registry.ts";
+import { fleetRow, renderBgRow, type BgRunStatus } from "./rows.ts";
+import type { SelectItem } from "@earendil-works/pi-tui";
+
+export interface FleetItemSources {
+  runRegistry: { list(): RunRecord[] };
+  bgRuns?: { values(): IterableIterator<BgRunStatus> };
+}
+
+export function buildFleetItems(src: FleetItemSources): SelectItem[] {
+  const items: SelectItem[] = [];
+  const seen = new Set<string>();
+  for (const r of src.runRegistry.list()) {
+    if (seen.has(r.runId)) continue;
+    seen.add(r.runId);
+    items.push({ value: r.runId, label: fleetRow(r) });
+  }
+  if (src.bgRuns) {
+    for (const b of src.bgRuns.values()) {
+      if (seen.has(b.runId)) continue;
+      seen.add(b.runId);
+      items.push({ value: b.runId, label: renderBgRow(b) });
+    }
+  }
+  return items;
+}

package/src/panel/fleet-panel.ts

@@ -10,8 +10,10 @@ 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, lifecycleRow, lifecyclePhaseTimeline } 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";
@@ -21,7 +23,7 @@ import type { LifecycleDef, LifecycleRunRecord, CheckpointDecision, PhaseRecord
 import type { LifecycleRunDeps, CheckpointFn } from "../lifecycle/run-lifecycle.ts";
 import { runLifecycle } from "../lifecycle/run-lifecycle.ts";
 
-type View = "fleet" | "lifecycle" | "agents" | "backends";
+type View = "fleet" | "lifecycle" | "agents" | "backends" | "scheduled";
 
 export interface FleetPanelDeps {
   registry: Map<string, AgentDef>;
@@ -35,6 +37,10 @@ export interface FleetPanelDeps {
   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 {
@@ -67,6 +73,17 @@ export class FleetPanel extends Container {
   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();
@@ -80,17 +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) }))
+        ? 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.deps.backendRegistry.list().map((b: Backend) => ({ value: b.id, label: backendsRow(b) }));
+            : 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),
@@ -99,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", "lifecycle", "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));
@@ -138,6 +183,24 @@ 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.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));
@@ -158,7 +221,7 @@ export class FleetPanel extends Container {
 
     this.addChild(new Spacer(1));
     const hint =
-      this.infoAgent || this.selectedBackend || this.selectedLifecycle
+      this.infoAgent || this.selectedBackend || this.selectedLifecycle || this.selectedSchedule
         ? "  esc:Back"
         : this.pendingCheckpoint
           ? "  c:Continue  v:Revise  a:Abort"
@@ -170,7 +233,9 @@ export class FleetPanel extends Container {
                 ? "  r:Run-lifecycle  i:Info  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.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));
@@ -238,9 +303,11 @@ export class FleetPanel extends Container {
   private switchView(): void {
     this.view = this.view === "fleet" ? "lifecycle"
       : this.view === "lifecycle" ? "agents"
-      : this.view === "agents" ? "backends" : "fleet";
+      : this.view === "agents" ? "backends"
+      : this.view === "backends" ? "scheduled" : "fleet";
     this.selectedBackend = null;
     this.selectedLifecycle = null;
+    this.selectedSchedule = null;
     this.list = this.buildList();
     this.renderShell();
   }
@@ -258,6 +325,16 @@ export class FleetPanel extends Container {
       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);
@@ -277,11 +354,11 @@ export class FleetPanel extends Container {
         this.pendingCheckpoint.resolve({ action: "abort" });
         this.pendingCheckpoint = null;
       }
-      this.onDone();
+      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);
@@ -312,6 +389,28 @@ export class FleetPanel extends Container {
       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; }
@@ -341,6 +440,59 @@ export class FleetPanel extends Container {
     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";

package/src/panel/rows.ts

@@ -85,6 +85,62 @@ export function backendInfo(b: Backend): string {
 
 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: "✗",
 };