@getpipher/armory-fleet 0.11.1 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpipher/armory-fleet",
-  "version": "0.11.1",
+  "version": "0.12.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/concurrency-lock.ts

@@ -6,19 +6,24 @@ export interface SingleSlotLock {
   current(): string | null;
 }
 
+export class SingleSlotLockImpl implements SingleSlotLock {
+  private holding: string | null = null;
+  tryAcquire(id: string): boolean {
+    if (this.holding !== null) return false;
+    this.holding = id;
+    return true;
+  }
+  release(): void {
+    this.holding = null;
+  }
+  current(): string | null {
+    return this.holding;
+  }
+}
+
+/** Alias so tests can `new SingleSlotLock()`. */
+export const SingleSlotLock = SingleSlotLockImpl;
+
 export function createSingleSlotLock(): SingleSlotLock {
-  let holding: string | null = null;
-  return {
-    tryAcquire(id): boolean {
-      if (holding !== null) return false;
-      holding = id;
-      return true;
-    },
-    release(): void {
-      holding = null;
-    },
-    current(): string | null {
-      return holding;
-    },
-  };
-}
+  return new SingleSlotLock();
+}

package/src/engine/spawnSubagent.ts

@@ -140,6 +140,8 @@ export interface SpawnOptions {
   tierRegistry?: TierRegistry;
   /** SPEC-6-1: model catalog for contextFloor filtering. Optional — absent means no catalog filtering. */
   modelRegistry?: ModelRegistryLike;
+  /** SPEC-6-3: workflow adapter tier override — replaces agent.tier before model resolution. */
+  tierOverride?: string;
 }
 
 export interface SpawnResult {
@@ -195,8 +197,12 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
     const childAgent = opts.skillsOverride ? { ...agentDef, skills: opts.skillsOverride } : agentDef;
 
     // SPEC-6-1: resolve model via tier registry (Q4 precedence + Q5 contextFloor/catalog filter).
+    // SPEC-6-3: workflow tierOverride replaces agent.tier before resolution.
+    const effectiveAgent = opts.tierOverride
+      ? { ...agentDef, tier: opts.tierOverride }
+      : agentDef;
     const resolved = resolveAgentModel(
-      agentDef, opts.model, opts.parentModel,
+      effectiveAgent, opts.model, opts.parentModel,
       opts.tierRegistry ?? new TierRegistry({ tiers: [], agents: new Map() }),
       opts.modelRegistry ?? { find: () => undefined },
     );
@@ -410,4 +416,4 @@ async function finishRun(
     status, finalText, runId, todoId, agent: agentName, model,
     durationMs: endedAt - startedAt, tokenTotal, costTotal, contextTokens, error,
   };
-}
+}

package/src/index.ts

@@ -9,7 +9,7 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import type { Model } from "@earendil-works/pi-ai";
 import { createSubagentTool, type SubagentToolDeps } from "./tools/subagent.ts";
-import { openFleetPanel } from "./panel/fleet-panel.ts";
+// SPEC-6-3: /fleet uses openWorkflowPanelLoop (Task 12) instead of the raw openFleetPanel factory.
 import { discoverAgents } from "./registry/discovery.ts";
 import { RunRegistry } from "./engine/run-registry.ts";
 import { createSingleSlotLock } from "./engine/concurrency-lock.ts";
@@ -49,6 +49,16 @@ import { TierRegistry, mergeTiers } from "./tiers/tier-registry.ts";
 import { BUILTIN_TIERS } from "./tiers/builtin.ts";
 import { TierStore } from "./tiers/tier-store.ts";
 import { splitModel } from "./tiers/resolve.ts";
+import { WorkflowJournal } from "./workflows/journal.ts";
+import { discoverWorkflows, WorkflowRegistry, type WorkflowDef } from "./workflows/registry.ts";
+import { runWorkflow, type WorkflowRunDeps, type WorkflowRunResult } from "./workflows/runner.ts";
+import { scanWorkflowResumeCandidates } from "./runtime/reconcile.ts";
+import { WorkflowController } from "./workflows/runtime/controller.ts";
+import { WorkflowRunStore } from "./workflows/runtime/run-store.ts";
+import { createWorkflowAdapters } from "./workflows/runtime/adapters.ts";
+import { openWorkflowPanelLoop } from "./workflows/panel-host.ts";
+import { workflowKeywordHint } from "./workflows/keyword.ts";
+import { createFleetTool } from "./tools/fleet.ts";
 
 /** The package builtin agents/ dir, resolved relative to this module. */
 function builtinAgentsDir(): string {
@@ -200,6 +210,11 @@ export default async function (pi: ExtensionAPI): Promise<void> {
   // SPEC-5b-2: the live widget (above editor) controller.
   // Display-only, independent of the /fleet panel; constructed per-session in session_start.
   let fleetWidget: FleetWidgetController | null = null;
+  // SPEC-6-3: hoisted so /fleet command handler + session_shutdown can reach them.
+  let wfController: WorkflowController | null = null;
+  let wfStore: WorkflowRunStore | null = null;
+  let wfRegistry: WorkflowRegistry | null = null;
+  let wfSessionAbort: AbortController | null = null;
   // 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) => {
@@ -342,10 +357,86 @@ export default async function (pi: ExtensionAPI): Promise<void> {
     };
     deps.reloadTiers = reloadTiers;
     reloadTiers();  // build the real merged registry (replaces the builtin-only placeholder)
+
+    // SPEC-6-3: workflow journal + registry + runner + fleet tool wiring.
+    const workflowJournal = new WorkflowJournal(join(dir, "workflows"));
+    wfRegistry = new WorkflowRegistry(discoverWorkflows({
+      projectDir: join(ctx.cwd, ".pi", "fleet", "workflows"),
+      globalDir: join(process.env.HOME ?? "", ".pi", "agent", "fleet", "workflows"),
+      builtinDir: join(new URL(".", import.meta.url).pathname, "workflows", "builtin"),
+    }).workflows);
+    const workflowRegistry = wfRegistry;
+    // SPEC-6-3: production workflow child/lifecycle adapters (Task 5). Replace the inline spawn stub
+    // with the adapter factory so workflow-internal parallel calls use the per-workflow ConcurrencyPool
+    // + fresh per-child locks (not the foreground singleton), and lifecycle phase spawns share the pool.
+    wfSessionAbort = new AbortController();
+    const adapters = createWorkflowAdapters({
+      registry: deps.registry as unknown as Map<string, unknown>,
+      todoSync: deps.todoSync,
+      runRegistry: deps.runRegistry,
+      backendRegistry: deps.backendRegistry,
+      parentModel: deps.parentModel,
+      parentCwd: ctx.cwd,
+      runLog: deps.runLog,
+      tierRegistry: deps.tierRegistry,
+      modelRegistry: deps.modelRegistry,
+      lifecycleDeps: deps.lifecycleDeps,
+      spawnSubagentFn: async (opts) => { const { spawnSubagent } = await import("./engine/spawnSubagent.ts"); return spawnSubagent(opts); },
+      runLifecycleFn: async (task, name, lcOpts) => { const { runLifecycle } = await import("./lifecycle/run-lifecycle.ts"); return runLifecycle(task, name, lcOpts); },
+    }, { concurrency: 3, signal: wfSessionAbort.signal });
+    const wfRunnerDeps: WorkflowRunDeps = {
+      spawn: adapters.spawn,
+      runLifecycle: adapters.runLifecycle,
+      worktree: deps.asyncRunner.worktree,
+      tierRegistry: deps.tierRegistry ?? new TierRegistry({ tiers: BUILTIN_TIERS, agents: deps.registry }),
+      journal: workflowJournal,
+      runRegistry: deps.runRegistry,
+      getModelContextWindow: (m: string) => deps.getModelContextWindow?.(m),
+      genRunId: () => "wf-" + Date.now().toString(36) + "-" + Math.random().toString(36).slice(2, 8),
+      notify: (m: string, l?: "info" | "warning" | "error") => ctx.ui.notify(m, l ?? "info"),
+      onCheckpoint: async () => undefined,
+      resolveWorkflow: (name: string) => workflowRegistry.get(name) as { sourceText: string; executable: string } | undefined,
+    };
+    wfStore = new WorkflowRunStore();
+    wfController = new WorkflowController({
+      registry: workflowRegistry,
+      projectDir: join(ctx.cwd, ".pi", "fleet", "workflows"),
+      store: wfStore,
+      journal: workflowJournal,
+      runWorkflow,
+      runDepsFactory: () => wfRunnerDeps,
+      inbox: resultsInbox,
+      genRunId: wfRunnerDeps.genRunId,
+      notify: (m: string, l?: "info" | "warning" | "error") => ctx.ui.notify(m, l ?? "info"),
+    });
+    wfController.hydrate();
+    const wfCands = scanWorkflowResumeCandidates(join(dir, "workflows"));
+    if (wfCands.length > 0) {
+      ctx.ui.notify(`${wfCands.length} interrupted workflow${wfCands.length > 1 ? "s" : ""} — open /fleet Workflows to resume`, "info");
+    }
+    pi.registerTool(createFleetTool({
+      getController: () => {
+        if (!wfController) throw new Error("workflow runtime not initialized for this session");
+        return wfController;
+      },
+    }) as never);
   });
 
   pi.on("session_shutdown", () => {
     if (fleetWidget) { fleetWidget.dispose(); fleetWidget = null; }
+    // SPEC-6-3: abort in-flight workflow children via the session-wide adapter signal.
+    // Terminal runs are not re-journaled — only non-terminal spawns observe the abort.
+    wfSessionAbort?.abort();
+  });
+
+  // SPEC-6-3: inject bounded ResultsInbox + workflow-keyword hints into the system prompt without
+  // consuming the inbox. renderHint() is read-only; pull() consumes (left to the model's fleet.results).
+  pi.on("before_agent_start", async (event) => {
+    const hint = resultsInbox.renderHint();
+    const kw = workflowKeywordHint(event.prompt) ?? "";
+    if (!hint && !kw) return undefined;
+    const block = [hint, kw].filter(Boolean).join("\n");
+    return { systemPrompt: event.systemPrompt + "\n\n" + block };
   });
 
   pi.on("resources_discover", (event, ctx) => {
@@ -364,7 +455,17 @@ export default async function (pi: ExtensionAPI): Promise<void> {
         ctx.ui.notify("fleet panel is TUI-only; use the subagent tool in non-interactive modes.", "info");
         return;
       }
-      openFleetPanel(deps, ctx as never);
+      await openWorkflowPanelLoop(
+        { ...deps, workflowController: wfController!, workflowStore: wfStore!, workflowRegistry: wfRegistry! },
+        {
+          custom: (factory) => { ctx.ui.custom(factory as never); },
+          editor: (initial) => ctx.ui.editor("Edit workflow source", initial) as Promise<string>,
+          input: (prompt) => ctx.ui.input(prompt) as Promise<string>,
+          confirm: (prompt) => ctx.ui.confirm(prompt, "Proceed?") as Promise<boolean>,
+          notify: (m, t) => ctx.ui.notify(m, t ?? "info"),
+          sendUserMessage: (text) => { void pi.sendUserMessage(text); },
+        },
+      );
     },
   });
 
@@ -423,4 +524,4 @@ export default async function (pi: ExtensionAPI): Promise<void> {
       ctx.ui.notify("fleet-register-gate: custom gates must be registered via the GateRegistry module export (see src/lifecycle/gates/registry.ts).", "info");
     },
   });
-}
+}

package/src/panel/fleet-panel.ts

@@ -29,8 +29,13 @@ import { runLifecycle } from "../lifecycle/run-lifecycle.ts";
 import type { TierRegistry } from "../tiers/tier-registry.ts";
 import type { TierStore } from "../tiers/tier-store.ts";
 import { buildTiersItems, setTierCostCap, setTierModels, setTierContextFloor, addTier, deleteTier } from "./tiers-items.ts";
+import { buildWorkflowPanelItems, actionsForWorkflowItem, parseWorkflowPanelKey, type WorkflowPanelItem, type WorkflowPanelAction } from "../workflows/panel/workflows-rows.ts";
+import type { WorkflowController } from "../workflows/runtime/controller.ts";
+import type { WorkflowRunStore } from "../workflows/runtime/run-store.ts";
+import type { WorkflowRegistry } from "../workflows/registry.ts";
+import type { WorkflowPanelIntent } from "../workflows/panel-host.ts";
 
-type View = "fleet" | "lifecycle" | "runs" | "agents" | "backends" | "scheduled" | "tiers";
+type View = "fleet" | "lifecycle" | "runs" | "agents" | "backends" | "scheduled" | "tiers" | "workflows";
 
 export interface FleetPanelDeps {
   registry: Map<string, AgentDef>;
@@ -58,19 +63,25 @@ export interface FleetPanelDeps {
   reloadTiers?: () => void;
   /** SPEC-6-1: model contextWindow resolver for Runs-tab ctx% (Surface C). Optional — ctx% hidden when absent. */
   getModelContextWindow?: (model: string) => number | undefined;
+  /** SPEC-6-3: live workflow controller + store + registry for the Workflows view. */
+  workflowController: WorkflowController;
+  workflowStore: WorkflowRunStore;
+  workflowRegistry: WorkflowRegistry;
+  /** SPEC-6-3: panel intent callback for host-only actions (Task 12 wires). */
+  onWorkflowIntent?: (intent: { action: string; runId?: string; definitionName?: string }) => void;
 }
 
 export interface FleetPanelOpts {
   theme: Theme;
   deps: FleetPanelDeps;
-  onDone: () => void;
+  onDone: (intent?: WorkflowPanelIntent | null) => void;
   onNotify: (msg: string, type?: "info" | "warning" | "error") => void;
 }
 
 export class FleetPanel extends Container {
   private readonly theme: Theme;
   private readonly deps: FleetPanelDeps;
-  private readonly onDone: () => void;
+  private readonly onDone: (intent?: WorkflowPanelIntent | null) => void;
   private readonly onNotify: (msg: string, type?: "info" | "warning" | "error") => void;
   private view: View = "fleet";
   private list: SelectList;
@@ -120,6 +131,10 @@ export class FleetPanel extends Container {
    * 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
+  // SPEC-6-3: Workflows view — inline Run prompt input state
+  private wfRunMode = false;
+  private wfPromptInput: Input | null = null;
+  private wfRunDefinitionName = "";
 
   constructor(opts: FleetPanelOpts) {
     super();
@@ -139,6 +154,8 @@ export class FleetPanel extends Container {
     // 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()));
+    // SPEC-6-3: subscribe to workflow store mutations → live Workflows view refresh.
+    this.unsubs.push(this.deps.workflowStore.subscribe(() => this.refresh()));
   }
 
   private buildList(): SelectList {
@@ -155,7 +172,9 @@ export class FleetPanel extends Container {
               ? (this.deps.scheduler?.list() ?? []).map((s: Schedule) => ({ value: s.id, label: scheduleRow(s) }))
             : this.view === "tiers"
               ? (this.deps.tierRegistry ? buildTiersItems({ tierRegistry: this.deps.tierRegistry, runRegistry: this.deps.runRegistry }) : [])
-              : this.deps.backendRegistry.list().map((b: Backend) => ({ value: b.id, label: backendsRow(b) }));
+            : this.view === "workflows"
+              ? buildWorkflowPanelItems({ definitions: this.deps.workflowRegistry.list(), runs: this.deps.workflowStore.values() })
+            : 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),
@@ -180,12 +199,12 @@ export class FleetPanel extends Container {
   /** 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 {
+  private close(intent?: WorkflowPanelIntent | null): void {
     if (this.closed) return;
     this.closed = true;
     for (const u of this.unsubs) u();
     this.unsubs.length = 0;
-    this.onDone();
+    this.onDone(intent ?? null);
   }
 
   private renderShell(): void {
@@ -193,7 +212,7 @@ export class FleetPanel extends Container {
     this.children.length = 0;
     this.children.push(...keep);
     const accent = (s: string): string => this.theme.fg("accent", s);
-    const tabs = (["fleet", "lifecycle", "runs", "agents", "backends", "scheduled", "tiers"] as View[])
+        const tabs = (["fleet", "lifecycle", "runs", "agents", "backends", "scheduled", "tiers", "workflows"] 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));
@@ -309,6 +328,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.wfRunMode && this.wfPromptInput) {
+      // SPEC-6-3: Workflows tab — inline Run prompt input.
+      this.addChild(new Text(this.theme.fg("accent", `  run ${this.wfRunDefinitionName}> `), 0, 0));
+      this.addChild(this.wfPromptInput);
+      this.addChild(new Text(this.theme.fg("dim", "  enter submit (blank=direct run) • esc cancel"), 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));
@@ -374,8 +398,10 @@ export class FleetPanel extends Container {
                   : this.view === "scheduled"
                     ? "  a:Add  p:Pause/resume  d:Delete  i:Info  tab:Tiers  q:Quit"
                   : this.view === "tiers"
-                    ? "  m:Models  c:costCap  f:contextFloor  a:Add  d:Delete  g:scope  tab:Fleet  q:Quit"
-                    : "  r:Refresh  i:Info  tab:Fleet  q:Quit";
+                    ? "  m:Models  c:costCap  f:contextFloor  a:Add  d:Delete  g:scope  tab:Workflows  q:Quit"
+                  : this.view === "workflows"
+                    ? "  r:Run  e:Edit-and-resume  o:Open  p:Pause  u:Resume  x:Stop  s:Save-as  v:View-result  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));
@@ -446,7 +472,7 @@ export class FleetPanel extends Container {
       : this.view === "lifecycle" ? "runs"
       : this.view === "runs" ? "agents"
       : this.view === "agents" ? "backends"
-      : this.view === "backends" ? "scheduled" : this.view === "scheduled" ? "tiers" : "fleet";
+      : this.view === "backends" ? "scheduled" : this.view === "scheduled" ? "tiers" : this.view === "tiers" ? "workflows" : "fleet";
     this.selectedBackend = null;
     this.selectedLifecycle = null;
     this.selectedSchedule = null;
@@ -530,6 +556,12 @@ export class FleetPanel extends Container {
       this.invalidate();
       return;
     }
+    if (this.wfRunMode && this.wfPromptInput) {
+      if (matchesKey(data, "escape")) { this.cancelWorkflowRun(); return; }
+      this.wfPromptInput.handleInput(data);
+      this.invalidate();
+      return;
+    }
     if (this.steerMode && this.steerInput) {
       if (matchesKey(data, "escape")) { this.cancelSteer(); return; }
       this.steerInput.handleInput(data);
@@ -663,6 +695,95 @@ export class FleetPanel extends Container {
         return;
       }
     }
+    // SPEC-6-3: Workflows view — direct p/u/x controls + host-only intent completion
+    if (this.view === "workflows") {
+      const sel = this.list.getSelectedItem()
+      if (!sel) return
+      const parsed = parseWorkflowPanelKey(sel.value)
+      const item: WorkflowPanelItem = parsed.kind === "definition"
+        ? { kind: "definition", definition: this.deps.workflowRegistry.get(parsed.name) ?? { name: parsed.name, description: "", phases: [], sourceText: "", body: "", executable: "", source: "builtin", filePath: "" } }
+        : { kind: "run", run: this.deps.workflowStore.get(parsed.runId) ?? { runId: parsed.runId, name: parsed.runId, script: "", mode: "auto", status: "completed", startedAt: 0, currentPhase: "default", phases: [], childRunIds: [], logs: [], tokenTotal: 0, costTotal: 0 } }
+      const available = actionsForWorkflowItem(item)
+
+      const keyAction: Record<string, WorkflowPanelAction> = {
+        r: "run", e: "edit-resume", o: "open", p: "pause", u: "resume", x: "stop", s: "save", v: "view-result", c: "respond",
+      }
+      const action = keyAction[data]
+      if (!action) return
+      if (!available.includes(action)) {
+        this.onNotify(`action '${action}' not available for this item`, "warning")
+        return
+      }
+
+      // Direct controls (no panel close)
+      if (action === "pause") {
+        if (parsed.kind === "run") this.deps.workflowController.pause(parsed.runId)
+        return
+      }
+      if (action === "resume") {
+        if (parsed.kind === "run") {
+          void this.deps.workflowController.resume(parsed.runId).then(() => {
+            this.refresh()
+          }).catch((e: unknown) => {
+            this.onNotify(`resume failed: ${(e as Error).message}`, "error")
+          })
+        }
+        return
+      }
+      if (action === "stop") {
+        if (parsed.kind === "run") {
+          void this.deps.workflowController.stop(parsed.runId).then(() => {
+            this.refresh()
+          }).catch((e: unknown) => {
+            this.onNotify(`stop failed: ${(e as Error).message}`, "error")
+          })
+        }
+        return
+      }
+
+      // Run action: inline prompt input for definitions
+      if (action === "run" && parsed.kind === "definition") {
+        this.startWorkflowRun(parsed.name)
+        return
+      }
+
+      // Host-only actions: close panel with intent (Task 12 host loop handles them)
+      if (action === "run" && parsed.kind === "run") {
+        this.close({ action: "run", definitionName: parsed.runId, prompt: "" })
+        return
+      }
+      if (action === "edit-resume") {
+        if (parsed.kind === "run") this.close({ action: "edit-resume", runId: parsed.runId })
+        return
+      }
+      if (action === "open") {
+        if (parsed.kind === "definition") {
+          this.close({ action: "open-definition", name: parsed.name })
+        } else {
+          const run = this.deps.workflowStore.get(parsed.runId)
+          const childId = run?.childRunIds[0]
+          if (childId) {
+            this.close({ action: "open-child", runId: parsed.runId, childRunId: childId })
+          } else {
+            this.onNotify(`run '${parsed.runId}' has no child runs to open`, "info")
+          }
+        }
+        return
+      }
+      if (action === "save") {
+        if (parsed.kind === "run") this.close({ action: "save", runId: parsed.runId })
+        return
+      }
+      if (action === "view-result") {
+        if (parsed.kind === "run") this.close({ action: "view-result", runId: parsed.runId })
+        return
+      }
+      if (action === "respond") {
+        if (parsed.kind === "run") this.close({ action: "respond", runId: parsed.runId })
+        return
+      }
+      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; }
@@ -840,6 +961,39 @@ export class FleetPanel extends Container {
     this.renderShell();
   }
 
+  // ───────────────────────────────── SPEC-6-3: Workflows Run prompt ─────────────────────────────────
+
+  private startWorkflowRun(definitionName: string): void {
+    this.wfRunDefinitionName = definitionName;
+    this.wfPromptInput = new Input();
+    this.wfPromptInput.onSubmit = (prompt: string) => {
+      if (prompt.trim()) {
+        this.close({ action: "run", definitionName: this.wfRunDefinitionName, prompt: prompt.trim() });
+      } else {
+        // Blank prompt → execute the definition directly
+        void this.deps.workflowController.start({
+          workflowName: this.wfRunDefinitionName,
+          mode: "checkpointed",
+        }).then(() => {
+          this.refresh();
+        }).catch((e: unknown) => {
+          this.onNotify(`start failed: ${(e as Error).message}`, "error");
+        });
+      }
+      this.cancelWorkflowRun();
+    };
+    this.wfPromptInput.onEscape = () => this.cancelWorkflowRun();
+    this.wfRunMode = true;
+    this.renderShell();
+  }
+
+  private cancelWorkflowRun(): void {
+    this.wfRunMode = false;
+    this.wfPromptInput = null;
+    this.wfRunDefinitionName = "";
+    this.renderShell();
+  }
+
   private cancelTiersEdit(): void {
     this.tiersEditPhase = null;
     this.tiersInput = null;
@@ -1031,4 +1185,4 @@ export function openFleetPanel(
   ctx.ui.custom((_tui, theme, _kb, done) => {
     return new FleetPanel({ theme, deps, onDone: done, onNotify: (m, t) => ctx.ui.notify(m, t) });
   });
-}
+}

package/src/runtime/reconcile.ts

@@ -1,12 +1,7 @@
 // src/runtime/reconcile.ts
-// SPEC-5b-1 — on pi boot, mark orphan RunLog runs (run:meta with no run:ended whose process
-// is gone) as aborted so the Runs tab doesn't show stale "running" rows across restarts.
-// Foreground orphans; bg/lifecycle orphans are already handled by scanResumeCandidates (SPEC-5a).
-//
-// SPEC-6-2: rewritten to be probe-driven — uses `probeRun` (handle/pid/age-fallback) instead of
-// age+grace alone. This catches orphans whose process died but whose startedAt is within grace
-// (e.g. a crash seconds after start), and avoids aborting runs whose process is alive but old
-// (e.g. a long-running build).
+// SPEC-6-3 — restart-recovery: scan workflow journals for non-terminal runs
+// (interrupted workflows become resume candidates in the Workflows view).
+import { WorkflowJournal } from "../workflows/journal.ts";
 import type { RunLog } from "./run-log.ts";
 import type { RunRegistry, RunRecord } from "../engine/run-registry.ts";
 
@@ -52,4 +47,12 @@ export function reconcileRuns(log: RunLog, opts: ReconcileOpts = {}): string[] {
     aborted.push(meta.runId);
   }
   return aborted;
-}
+}
+
+/** SPEC-6-3 — on pi start, scan .pi/fleet/workflows/ for non-terminal workflow journals.
+ *  Returns runIds whose journal has no wf:completed/wf:aborted event — these are
+ *  interrupted workflows that the Workflows view surfaces as resume candidates. */
+export function scanWorkflowResumeCandidates(workflowsDir: string): string[] {
+  const journal = new WorkflowJournal(workflowsDir);
+  return journal.scanNonTerminal();
+}