@getpipher/armory-fleet 0.11.1 → 0.12.1

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) => {
@@ -279,10 +294,15 @@ export default async function (pi: ExtensionAPI): Promise<void> {
     deps.runLog = new RunLog(join(dir, "conversations"));
     // v0.10.2: pass the in-memory RunRegistry so reconcile syncs it too — otherwise orphaned
     // (process-gone) runs keep status:"running" in memory and the live widget shows a stale ▶ forever.
-    const reconciled = reconcileRuns(deps.runLog, { runRegistry: deps.runRegistry });
-    if (reconciled.length > 0) {
-      ctx.ui.notify(`reconciled ${reconciled.length} interrupted fleet run${reconciled.length > 1 ? "s" : ""} (marked aborted)`, "info");
-    }
+    // #22 bg-watchdog: pass todoSync so a process-gone run's linked TODO is reverted to open
+    // (retryable) with a WORKER_EXITED_WITHOUT_RESULT note, not stuck in_progress forever.
+    // Fire-and-forget (async) so the asyncRunner setup below isn't blocked.
+    void reconcileRuns(deps.runLog, { runRegistry: deps.runRegistry, todoSync: deps.todoSync })
+      .then((reconciled) => {
+        if (reconciled.length > 0) {
+          ctx.ui.notify(`reconciled ${reconciled.length} interrupted fleet run${reconciled.length > 1 ? "s" : ""} (marked aborted; linked TODOs reverted to open)`, "info");
+        }
+      });
     deps.asyncRunner = {
       worktree: new WorktreeService({ rootDir: ctx.cwd }),
       diff: new DiffService(),
@@ -325,6 +345,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
       getModelContextWindow,
       cwd: ctx.cwd,
       runLog: deps.runLog,
+      todoSync: deps.todoSync,  // #22 bg-watchdog: periodic probe reverts process-gone runs' TODOs
     });
     fleetWidget.start();
 
@@ -342,10 +363,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 +461,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 +530,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,107 @@ export class FleetPanel extends Container {
         return;
       }
     }
+    // SPEC-6-3: Workflows view — direct p/u/x controls + host-only intent completion
+    if (this.view === "workflows") {
+      // #27: classify the key FIRST. Non-action keys (Down/Up/PageUp/PageDown) are forwarded
+      // to the list BEFORE the sel check, so nav still works when no row is selected (empty-list
+      // edge case the reviewer flagged — the prior `if (!sel) return` at the top swallowed nav
+      // keys the same way the original `if (!action) return` did).
+      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) {
+        // Not a workflow action key — forward to the list so Down/Up/PageUp/PageDown move the
+        // selection cursor (#27). Without this, every non-action key was swallowed here and the
+        // bottom-of-handleInput `this.list.handleInput(data)` was never reached for Workflows,
+        // so the → cursor could never move off the first row (blocking all run-row actions).
+        this.list.handleInput(data)
+        this.invalidate()
+        return
+      }
+      const sel = this.list.getSelectedItem()
+      if (!sel) return  // an action key was pressed but there's no row to act on
+      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)
+
+      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 +973,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 +1197,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/panel/fleet-widget.ts

@@ -46,6 +46,9 @@ export interface FleetWidgetDeps {
   cwd?: string;
   /** SPEC-6-2: RunLog for the periodic liveness probe (reconcileRuns). Optional — absent → no periodic probe. */
   runLog?: import("../runtime/run-log.ts").RunLog;
+  /** #22 bg-watchdog: when wired, the periodic probe reverts a process-gone run's linked TODO to
+   *  open (retryable) with a WORKER_EXITED_WITHOUT_RESULT note. Optional — absent → no TODO transition. */
+  todoSync?: import("../todo-sync/port.ts").TodoSyncPort;
 }
 
 export class FleetWidgetController {
@@ -69,9 +72,10 @@ export class FleetWidgetController {
     this.unsubs.push(this.deps.runRegistry.subscribe(() => this.render()));
     if (this.deps.bgRuns) this.unsubs.push(this.deps.bgRuns.subscribe(() => this.render()));
     // SPEC-6-2: periodic liveness probe — reconciles dead orphans every 60s.
+    // #22 bg-watchdog: pass todoSync so a process-gone run's TODO is reverted (not stuck in_progress).
     if (this.deps.runLog) {
       this.livenessTimerId = this.setIntervalFn(() => {
-        reconcileRuns(this.deps.runLog!, { runRegistry: this.deps.runRegistry });
+        void reconcileRuns(this.deps.runLog!, { runRegistry: this.deps.runRegistry, todoSync: this.deps.todoSync }).catch(() => {});
       }, 60_000);
       (this.livenessTimerId as { unref?: () => void }).unref?.();
     }

package/src/runtime/reconcile.ts

@@ -1,14 +1,10 @@
 // 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";
+import type { TodoSyncPort } from "../todo-sync/port.ts";
 
 export type Liveness = "alive" | "dead";
 
@@ -30,13 +26,20 @@ export interface ReconcileOpts {
   graceMs?: number;
   now?: number;
   runRegistry?: RunRegistry;
+  /** #22 bg-watchdog: when wired, a process-gone run's linked TODO is reverted to open
+   *  (retryable) with a WORKER_EXITED_WITHOUT_RESULT note, so it doesn't stay in_progress
+   *  forever after a worker exits without a terminal record. Best-effort (the run is already
+   *  marked aborted in the log + registry). */
+  todoSync?: TodoSyncPort;
 }
 
-/** Returns the runIds it marked aborted. Probe-driven (SPEC-6-2); idempotent. */
-export function reconcileRuns(log: RunLog, opts: ReconcileOpts = {}): string[] {
+/** Returns the runIds it marked aborted. Probe-driven (SPEC-6-2); idempotent.
+ *  #22: async — awaits the best-effort TODO transition for each aborted run with a todoId. */
+export async function reconcileRuns(log: RunLog, opts: ReconcileOpts = {}): Promise<string[]> {
   const grace = opts.graceMs ?? 60_000;
   const now = opts.now ?? Date.now();
   const reg = opts.runRegistry;
+  const todoSync = opts.todoSync;
   const aborted: string[] = [];
   for (const meta of log.scanMeta()) {
     if (meta.status !== "running") continue;
@@ -49,7 +52,25 @@ export function reconcileRuns(log: RunLog, opts: ReconcileOpts = {}): string[] {
       endedAt: now, resultSummary: "process-gone (probe)", tokenTotal: meta.tokenTotal,
     });
     reg?.update(meta.runId, { status: "aborted", endedAt: now });
+    // #22 bg-watchdog: transition the linked TODO so a worker that exited without a terminal
+    // record doesn't leave its fleet TODO stuck in_progress forever. markRunTodoReverted with
+    // priorStatus=undefined reverts a fleet-created TODO to open (retryable) + appends the
+    // reason note. (The link path only accepts open/in_progress TODOs, so reverting to open is
+    // the correct recovery for a linked one too — its prior was open/in_progress.)
+    if (meta.todoId && todoSync) {
+      try {
+        await todoSync.markRunTodoReverted(meta.todoId, undefined, "WORKER_EXITED_WITHOUT_RESULT: process gone (probe)");
+      } catch { /* best-effort: the run is already marked aborted in the log + registry */ }
+    }
     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();
+}

package/src/todo-sync/adapter.ts

@@ -12,11 +12,30 @@ const FLEET_SOURCE = "armory-fleet";
 const FLEET_TAG = "fleet-run";
 const OPEN_STATES: Status[] = ["open", "in_progress"];
 
+/** #34: cap the task excerpt written into the TODO notes well below armory-todo's maxNotesBytes
+ *  (8192). The full task already lives in the run-log + the fleet run record; the TODO is a
+ *  tracking stub, not a transcript. 1024 leaves ~7KB headroom for the fleet-run header + the
+ *  progress/done/reverted appends during the run. */
+const TASK_EXCERPT_CAP = 1024;
+/** Cap appended note lines (done-result / reverted-reason). The #25 turn-budget partial can be
+ *  ~4000 chars; appending it verbatim would accumulate toward the cap on retries. */
+const NOTE_LINE_CAP = 500;
+
 function titleFor(run: RunMeta): string {
   const raw = `[${run.agent}] ${run.task}`.trim();
   return raw.length > 120 ? raw.slice(0, 117) + "…" : raw;
 }
 
+function taskExcerptFor(task: string): string {
+  return task.length > TASK_EXCERPT_CAP
+    ? task.slice(0, TASK_EXCERPT_CAP) + "…[truncated; full task in run-log]"
+    : task;
+}
+
+function capNoteLine(s: string): string {
+  return s.length > NOTE_LINE_CAP ? s.slice(0, NOTE_LINE_CAP) + "…" : s;
+}
+
 /** Append a note line to a todo (read-then-write; updateTodo replaces notes). */
 function appendNote(id: string, line: string): void {
   const t = getTodo(id);
@@ -54,7 +73,7 @@ export class ArmoryTodoAdapter implements TodoSyncPort {
       source: FLEET_SOURCE,
       priority: "med",
       tags: [FLEET_TAG],
-      notes: `fleet-run:${run.runId}\n\nTask: ${run.task}`,
+      notes: `fleet-run:${run.runId}\n\nTask: ${taskExcerptFor(run.task)}`,
     });
     updateTodo(created.id, { status: "in_progress" });
     return { todoId: created.id }; // priorStatus undefined -> created
@@ -69,7 +88,7 @@ export class ArmoryTodoAdapter implements TodoSyncPort {
       // linked -> restore prior (user owns the close)
       updateTodo(todoId, { status: priorStatus as Status });
     }
-    appendNote(todoId, `fleet-run done: ${result}`);
+    appendNote(todoId, `fleet-run done: ${capNoteLine(result)}`);
   }
 
   async markRunTodoReverted(todoId: string | null, priorStatus: string | undefined, reason: string): Promise<void> {
@@ -79,7 +98,7 @@ export class ArmoryTodoAdapter implements TodoSyncPort {
     } else {
       updateTodo(todoId, { status: priorStatus as Status });
     }
-    appendNote(todoId, `fleet-run reverted: ${reason}`);
+    appendNote(todoId, `fleet-run reverted: ${capNoteLine(reason)}`);
   }
 
   async updateLifecycleProgress(todoId: string, progressBlock: string): Promise<void> {