@getpipher/armory-fleet 0.5.1 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpipher/armory-fleet",
-  "version": "0.5.1",
+  "version": "0.6.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",
@@ -60,6 +60,6 @@
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
-    "test:run": "node --import tsx --test test/*.test.mts"
+    "test:run": "node --import tsx --test --test-timeout=30000 test/*.test.mts"
   }
 }

package/src/engine/run-registry.ts

@@ -16,6 +16,10 @@ export interface RunRecord {
   backendSessionId?: string | null;
   /** The sessionKey whose resume this run belongs to (SPEC-3). */
   sessionKey?: string | null;
+  /** SPEC-5b-1: runId this run resumed from (rehydrated the prior sessionKey + a follow-up). */
+  resumedFrom?: string;
+  /** SPEC-5b-1: runId this run forked from (fresh re-run with same agent+task). */
+  forkedFrom?: string;
 }
 
 /** runId format: fl-<base36 ms>-<6 random> (SPEC-1 §5.1). */

package/src/engine/spawnSubagent.ts

@@ -7,6 +7,8 @@ import type { BackendRegistry } from "../backend/port.ts";
 import { genRunId, RunRegistry } from "./run-registry.ts";
 import { createTurnBudget, DEFAULT_MAX_TURNS } from "./turn-budget.ts";
 import type { SingleSlotLock } from "./concurrency-lock.ts";
+import type { RunLog } from "../runtime/run-log.ts";
+import { buildToolEvent } from "../runtime/run-log.ts";
 
 const PI_DEFAULT_TOOLS = ["read", "bash", "edit", "write"];
 
@@ -81,6 +83,13 @@ export interface SpawnOptions {
    *  (Q4=C) instead of the agent's `backend`. */
   skillsOverride?: string[];
   backendOverride?: "pi" | "claude";
+  /** SPEC-5b-1: per-run conversation journal. When set, spawnSubagent writes run:meta →
+   *  message/tool → run:ended events. Absent = no journal (unit tests stay clean). */
+  runLog?: RunLog;
+  /** SPEC-5b-1: when set, the new run is a resume of this prior runId (written to run:ended + RunRecord.resumedFrom). */
+  resumeLink?: string;
+  /** SPEC-5b-1: when set, the new run is a fork of this prior runId (written to run:ended + RunRecord.forkedFrom). */
+  forkLink?: string;
 }
 
 export interface SpawnResult {
@@ -145,6 +154,9 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
       runId, agent: agentDef.name, model, task: opts.task, track,
       todoId: null, status: "running", startedAt,
     });
+    try {
+      opts.runLog?.append(runId, { type: "run:meta", runId, agent: agentDef.name, model, task: opts.task, startedAt, track, todoId: null });
+    } catch { /* best-effort: journal is the index, not the product */ }
 
     // todo-sync (before) — only when both caller tracks AND agent allows todoSync
     let priorStatus: string | undefined;
@@ -179,6 +191,7 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
     let finalText = "";
     let tokenTotal = 0;
     let aborted = false;
+    let turnIdx = -1;
 
     const onSignalAbort = (): void => { aborted = true; void session.abort(); };
     opts.signal?.addEventListener("abort", onSignalAbort);
@@ -186,6 +199,11 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
     const unsub = session.subscribe((e) => {
       if (e.type === "session_init" && e.backendSessionId) {
         opts.runRegistry.update(runId, { backendSessionId: e.backendSessionId, sessionKey: agentDef.sessionKey });
+        try {
+          opts.runLog?.append(runId, { type: "run:meta", runId, agent: agentDef.name, model, task: opts.task, startedAt, track, todoId, backendSessionId: e.backendSessionId, sessionKey: agentDef.sessionKey });
+        } catch { /* best-effort */ }
+      } else if (e.type === "turn_start") {
+        turnIdx++;
       } else if (e.type === "turn_end") {
         if (budget.consume()) void session.abort();
       } else if (e.type === "message_end" && e.message?.role === "assistant") {
@@ -193,6 +211,13 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
         if (text) finalText = text;
         const total = e.message.usage?.cost?.total;
         if (typeof total === "number") tokenTotal += total;
+        try {
+          opts.runLog?.append(runId, { type: "message", role: "assistant", text, usage: { total }, turnIndex: turnIdx });
+        } catch { /* best-effort */ }
+      } else if (e.type === "tool_execution_end") {
+        try {
+          opts.runLog?.append(runId, buildToolEvent((e as any).toolName, (e as any).args, (e as any).result, (e as any).isError ?? false, turnIdx));
+        } catch { /* best-effort */ }
       }
       opts.onEvent?.(e);
     });
@@ -242,7 +267,17 @@ async function finishRun(
   error: string | undefined, agentName: string, model: string, tokenTotal = 0,
 ): Promise<SpawnResult> {
   const endedAt = Date.now();
-  opts.runRegistry.update(runId, { status, endedAt, resultSummary: finalText.slice(0, 120) });
+  opts.runRegistry.update(runId, {
+    status, endedAt, resultSummary: finalText.slice(0, 120),
+    resumedFrom: opts.resumeLink, forkedFrom: opts.forkLink,
+  });
+  try {
+    opts.runLog?.append(runId, {
+      type: "run:ended", runId, status, endedAt,
+      resultSummary: finalText.slice(0, 120), tokenTotal,
+      resumedFrom: opts.resumeLink, forkedFrom: opts.forkLink,
+    });
+  } catch { /* best-effort: journal is the index, not the product */ }
   // SPEC-4: lifecycle phase children skip the per-run todo reconciliation — the lifecycle
   // engine owns the lifecycle todo's status + progress block (Q7=C).
   if (!opts.lifecycleTodoId) {

package/src/index.ts

@@ -37,6 +37,8 @@ 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 { RunLog } from "./runtime/run-log.ts";
+import { reconcileRuns } from "./runtime/reconcile.ts";
 import { Scheduler } from "./scheduling/scheduler.ts";
 import { createFleetResultsTool } from "./tools/fleet-results.ts";
 import { BgRunsStore } from "./panel/bg-runs-store.ts";
@@ -170,6 +172,13 @@ export default async function (pi: ExtensionAPI): Promise<void> {
   const asyncRunLifecycle: AsyncRunnerDeps["runLifecycle"] = async (task, lifecycleName, opts) => {
     const { runLifecycle } = await import("./lifecycle/run-lifecycle.ts");
     const { spawnSubagent } = await import("./engine/spawnSubagent.ts");
+    // SPEC-5a §8.1 (Q4=A): bg runs must NOT compete with the foreground single-slot lock.
+    // The ConcurrencyPool gates bg-RUN concurrency (N-slot); within a run the lifecycle loop
+    // serializes phases, so a fresh per-run lock just satisfies spawnSubagent's tryAcquire API
+    // without ever contending (foreground holds deps.lock; bg holds its own). Without this, a
+    // foreground subagent holding deps.lock made every bg run's first-phase spawn fail fast
+    // (tryAcquire → "concurrency lock unexpectedly unavailable" → 6ms run:aborted).
+    const bgLock = createSingleSlotLock();
     const lifecycleFullDeps: LifecycleRunDeps = {
       ...deps.lifecycleDeps,
       genRunId: () => opts.runId,   // override: use the async runner's runId
@@ -178,8 +187,8 @@ export default async function (pi: ExtensionAPI): Promise<void> {
       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
+        registry: deps.registry, todoSync: deps.todoSync, runRegistry: deps.runRegistry, lock: bgLock,
+        backendRegistry: deps.backendRegistry, parentModel: deps.parentModel, parentCwd: opts.worktreePath, runLog: deps.runLog,  // 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" } });
@@ -189,6 +198,9 @@ export default async function (pi: ExtensionAPI): Promise<void> {
   // 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;
+  // SPEC-5b-1: RunLog is constructed per-session (needs the cwd) in session_start; the
+  // shared `deps` reference is mutated there so the subagent tool + panel pick it up live.
+  deps.runLog = undefined as RunLog | undefined;
 
   const refresh = (ctx: { cwd: string; ui: { notify: (m: string, t?: "info" | "warning" | "error") => void } }): void => {
     const r = discoverAgents({
@@ -225,6 +237,13 @@ export default async function (pi: ExtensionAPI): Promise<void> {
     deps.parentCwd = ctx.cwd;
     // SPEC-5a: build the per-session async runner + scheduler, start firing, scan for interrupted runs.
     const dir = fleetDir(ctx.cwd);
+    // SPEC-5b-1: per-session RunLog at .pi/fleet/conversations/ (separate from the
+    // SPEC-5a phase journal at .pi/fleet/runs/ — different granularity, no filename collision).
+    deps.runLog = new RunLog(join(dir, "conversations"));
+    const reconciled = reconcileRuns(deps.runLog);
+    if (reconciled.length > 0) {
+      ctx.ui.notify(`reconciled ${reconciled.length} interrupted fleet run${reconciled.length > 1 ? "s" : ""} (marked aborted)`, "info");
+    }
     deps.asyncRunner = {
       worktree: new WorktreeService({ rootDir: ctx.cwd }),
       diff: new DiffService(),

package/src/lifecycle/run-lifecycle.ts

@@ -203,7 +203,13 @@ export async function runLifecycle(task: string, lifecycleName: string, opts: Li
         // A failed phase that's aborted = lifecycle failed (the work failed); a healthy phase
         // aborted at a checkpoint = user-aborted (§12).
         const status: LifecycleStatus = phaseRec.status === "failed" ? "failed" : "aborted";
-        return doneResult(runId, startedAt, status, lifecycleName, task, lifecycleBackend, opts.mode, phaseRecords, todoId);
+        // SPEC-5a fix: surface the failed phase's summary as the lifecycle error so the async
+        // runner's run:aborted journal event + notify show the real cause (spawnRes.error etc.),
+        // not just the bare status. Guard on non-empty summary so an empty summary still falls
+        // back to the status in the async runner (res.error ?? res.status). A healthy phase
+        // aborted at a checkpoint has no error.
+        const error = phaseRec.status === "failed" && phaseRec.summary ? phaseRec.summary : undefined;
+        return doneResult(runId, startedAt, status, lifecycleName, task, lifecycleBackend, opts.mode, phaseRecords, todoId, error);
       }
       // decision.action === "revise"
       reviseCount++;

package/src/panel/fleet-panel.ts

@@ -12,6 +12,9 @@ import {
 import type { AgentDef } from "../registry/frontmatter.ts";
 import { agentsRow, agentInfo, backendsRow, backendInfo, lifecycleRow, lifecyclePhaseTimeline, scheduleRow } from "./rows.ts";
 import { buildFleetItems } from "./fleet-items.ts";
+import { runsRow, runTimelineRow } from "./runs-rows.ts";
+import { buildRunsIndex } from "./runs-index.ts";
+import type { RunLog, RunMeta, RunLogEvent } from "../runtime/run-log.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";
@@ -23,7 +26,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" | "scheduled";
+type View = "fleet" | "lifecycle" | "runs" | "agents" | "backends" | "scheduled";
 
 export interface FleetPanelDeps {
   registry: Map<string, AgentDef>;
@@ -41,6 +44,8 @@ export interface FleetPanelDeps {
   scheduler?: Scheduler;
   /** SPEC-5a: live bg run status rows for the fleet tab. Optional. */
   bgRuns?: BgRunsStore;
+  /** SPEC-5b-1: durable per-run conversation log. Optional — Runs tab degrades to empty when absent. */
+  runLog?: RunLog;
 }
 
 export interface FleetPanelOpts {
@@ -80,6 +85,11 @@ export class FleetPanel extends Container {
   private schedNameInput: Input | null = null;
   private schedPhase: "task" | "expr" | "name" = "task";
   private selectedSchedule: Schedule | null = null;
+  // SPEC-5b-1: Runs tab — replay overlay state + resume/fork input state
+  private selectedRun: RunMeta | null = null;
+  private runTimeline: RunLogEvent[] | null = null;
+  private resumeInput: Input | null = null;
+  private resumeMode = false;
   /** 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)[] = [];
@@ -111,8 +121,10 @@ export class FleetPanel extends Container {
         ? 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 === "runs"
+            ? buildRunsIndex(this.deps.runLog?.dir ?? "").map((r: RunMeta) => ({ value: r.runId, label: runsRow(r) }))
+            : 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) }));
@@ -153,7 +165,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", "agents", "backends", "scheduled"] as View[])
+    const tabs = (["fleet", "lifecycle", "runs", "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));
@@ -196,6 +208,33 @@ export class FleetPanel extends Container {
         `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.selectedRun) {
+      // SPEC-5b-1: Runs tab — per-turn timeline replay (read-only); enter reserved for 5b-3 overlay.
+      this.addChild(new Text(this.theme.fg("dim", `  ── run ${this.selectedRun.runId} — timeline ──`), 0, 0));
+      const events = (this.runTimeline ?? []).filter((e) => e.type === "message" || e.type === "tool") as Array<RunLogEvent>;
+      if (events.length === 0) {
+        this.addChild(new Text(this.theme.fg("dim", "  (no conversation events)"), 0, 0));
+      } else {
+        const tl = new SelectList(
+          events.map((e) => ({ value: "", label: runTimelineRow(e as never) })),
+          Math.min(events.length, 12),
+          {
+            selectedPrefix: (s: string) => this.theme.fg("accent", s),
+            selectedText: (s: string) => this.theme.fg("accent", s),
+            description: (s: string) => this.theme.fg("muted", s),
+            scrollInfo: (s: string) => this.theme.fg("dim", s),
+            noMatch: (s: string) => this.theme.fg("warning", s),
+          },
+        );
+        tl.onCancel = () => { this.selectedRun = null; this.runTimeline = null; this.renderShell(); };
+        this.addChild(tl);
+      }
+      this.addChild(new Text(this.theme.fg("dim", "  enter: (5b-3 full message)  esc:Back"), 0, 0));
+    } else if (this.resumeMode && this.resumeInput) {
+      // SPEC-5b-1: Runs tab — resume follow-up input.
+      this.addChild(new Text(this.theme.fg("accent", "  follow-up> "), 0, 0));
+      this.addChild(this.resumeInput);
+      this.addChild(new Text(this.theme.fg("dim", "  enter submit • esc cancel"), 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));
@@ -221,8 +260,8 @@ export class FleetPanel extends Container {
 
     this.addChild(new Spacer(1));
     const hint =
-      this.infoAgent || this.selectedBackend || this.selectedLifecycle || this.selectedSchedule
-        ? "  esc:Back"
+      this.infoAgent || this.selectedBackend || this.selectedLifecycle || this.selectedSchedule || this.selectedRun
+        ? (this.selectedRun ? "  enter:(5b-3)  esc:Back" : "  esc:Back")
         : this.pendingCheckpoint
           ? "  c:Continue  v:Revise  a:Abort"
           : this.lcRevising
@@ -230,8 +269,10 @@ export class FleetPanel extends Container {
             : 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-lifecycle  i:Info  tab:Runs  q:Quit"
+                : this.view === "runs"
+                  ? "  enter:Replay  r:Resume  f:Fork  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"
@@ -277,6 +318,7 @@ export class FleetPanel extends Container {
       runRegistry: this.deps.runRegistry, lock: this.deps.lock,
       backendRegistry: this.deps.backendRegistry,
       parentModel: this.deps.parentModel, parentCwd: this.deps.parentCwd,
+      runLog: this.deps.runLog,
       // live Fleet row during the run (SPEC-1 §4c) — re-render on each turn_end
       onEvent: (e) => {
         if (e.type === "turn_end") {
@@ -302,12 +344,15 @@ export class FleetPanel extends Container {
 
   private switchView(): void {
     this.view = this.view === "fleet" ? "lifecycle"
-      : this.view === "lifecycle" ? "agents"
+      : this.view === "lifecycle" ? "runs"
+      : this.view === "runs" ? "agents"
       : this.view === "agents" ? "backends"
       : this.view === "backends" ? "scheduled" : "fleet";
     this.selectedBackend = null;
     this.selectedLifecycle = null;
     this.selectedSchedule = null;
+    this.selectedRun = null;
+    this.runTimeline = null;
     this.list = this.buildList();
     this.renderShell();
   }
@@ -329,6 +374,17 @@ export class FleetPanel extends Container {
       if (matchesKey(data, "escape")) { this.selectedSchedule = null; this.renderShell(); }
       return;
     }
+    if (this.selectedRun) {
+      // SPEC-5b-1: Runs timeline replay overlay — esc back; enter is a 5b-3 placeholder.
+      if (matchesKey(data, "escape")) { this.selectedRun = null; this.runTimeline = null; this.renderShell(); }
+      return;
+    }
+    if (this.resumeMode && this.resumeInput) {
+      if (matchesKey(data, "escape")) { this.cancelResume(); return; }
+      this.resumeInput.handleInput(data);
+      this.invalidate();
+      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);
@@ -379,6 +435,20 @@ export class FleetPanel extends Container {
       this.renderShell();
       return;
     }
+    // SPEC-5b-1: Runs view — enter/i:Replay  R:Resume  F:Fork
+    if (this.view === "runs" && this.deps.runLog) {
+      if (matchesKey(data, "enter") || matchesKey(data, "i")) {
+        const sel = this.list.getSelectedItem();
+        if (sel) {
+          this.selectedRun = buildRunsIndex(this.deps.runLog.dir).find((r) => r.runId === sel.value) ?? null;
+          this.runTimeline = this.deps.runLog.replay(sel.value);
+          this.renderShell();
+        }
+        return;
+      }
+      if (matchesKey(data, "r")) { this.startResume(); return; }
+      if (matchesKey(data, "f")) { this.startFork(); return; }
+    }
     // SPEC-4: Lifecycle view — i:Info + r:Run-lifecycle
     if (matchesKey(data, "i") && this.view === "lifecycle") {
       const sel = this.list.getSelectedItem();
@@ -493,6 +563,87 @@ export class FleetPanel extends Container {
     this.renderShell();
   }
 
+  /** SPEC-5b-1: Resume — rehydrate the prior session (same agent sessionKey) + a follow-up. */
+  private startResume(): void {
+    const sel = this.list.getSelectedItem();
+    if (!sel) return;
+    const run = buildRunsIndex(this.deps.runLog!.dir).find((r) => r.runId === sel.value);
+    if (!run) return;
+    if (!run.backendSessionId) { this.onNotify("no resumable session for this run", "warning"); return; }
+    if (run.status === "running") { this.onNotify("run still running; stop it first", "warning"); return; }
+    this.resumeInput = new Input();
+    this.resumeInput.onSubmit = (followUp: string) => {
+      if (!followUp.trim()) { this.cancelResume(); return; }
+      void this.executeResume(run, followUp.trim());
+    };
+    this.resumeInput.onEscape = () => this.cancelResume();
+    this.resumeMode = true;
+    this.renderShell();
+  }
+
+  private cancelResume(): void {
+    this.resumeMode = false;
+    this.resumeInput = null;
+    this.renderShell();
+  }
+
+  private async executeResume(prior: RunMeta, followUp: string): Promise<void> {
+    this.resumeMode = false;
+    this.resumeInput = null;
+    this.renderShell();
+    const res: SpawnResult = await spawnSubagent({
+      agent: prior.agent, task: followUp, track: true, resumeLink: prior.runId, runLog: this.deps.runLog,
+      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,
+      onEvent: (e) => { if (e.type === "turn_end") { this.list = this.buildList(); this.renderShell(); } },
+    });
+    this.list = this.buildList();
+    this.renderShell();
+    this.onNotify(`resume ${res.status}: ${res.runId}${res.error ? " — " + res.error : ""}`, res.status === "completed" ? "info" : "warning");
+  }
+
+  /** SPEC-5b-1: Fork — fresh re-run with the same agent + task (no session rehydration). */
+  private startFork(): void {
+    const sel = this.list.getSelectedItem();
+    if (!sel) return;
+    const run = buildRunsIndex(this.deps.runLog!.dir).find((r) => r.runId === sel.value);
+    if (!run) return;
+    if (run.status === "running") { this.onNotify("run still running; stop it first", "warning"); return; }
+    this.linkPhase = "task";
+    this.taskInput = new Input();
+    this.taskInput.onSubmit = (task: string) => {
+      const finalTask = task.trim() || run.task;
+      this.linkPhase = "link";
+      this.linkInput = new Input();
+      this.linkInput.onSubmit = (todoIdRaw: string) => {
+        void this.executeFork(run.agent, finalTask, todoIdRaw.trim() || undefined, run.runId);
+      };
+      this.linkInput.onEscape = () => { void this.executeFork(run.agent, finalTask, undefined, run.runId); };
+      this.renderShell();
+    };
+    this.taskInput.onEscape = () => this.cancelRun();
+    this.runMode = true;
+    this.renderShell();
+  }
+
+  private async executeFork(agent: string, task: string, todoId: string | undefined, priorRunId: string): Promise<void> {
+    this.runMode = false;
+    this.taskInput = null;
+    this.linkInput = null;
+    this.renderShell();
+    const res: SpawnResult = await spawnSubagent({
+      agent, task, todoId, track: true, forkLink: priorRunId, runLog: this.deps.runLog,
+      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,
+      onEvent: (e) => { if (e.type === "turn_end") { this.list = this.buildList(); this.renderShell(); } },
+    });
+    this.list = this.buildList();
+    this.renderShell();
+    this.onNotify(`fork ${res.status}: ${res.runId}${res.error ? " — " + res.error : ""}`, res.status === "completed" ? "info" : "warning");
+  }
+
   /** SPEC-4: open the Run-lifecycle inline inputs (task → lifecycle name → start runLifecycle). */
   private startLifecycleRun(): void {
     this.lcPhase = "task";
@@ -542,6 +693,7 @@ export class FleetPanel extends Container {
             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,
+          runLog: this.deps.runLog,
         });
       },
     };

package/src/panel/runs-index.ts

@@ -0,0 +1,8 @@
+// src/panel/runs-index.ts
+// SPEC-5b-1 — pure scan of the conversations dir → newest-first run list. Pure so the
+// Runs tab + unit tests share one path (mirrors buildFleetItems from v0.5.0).
+import { RunLog, type RunMeta } from "../runtime/run-log.ts";
+
+export function buildRunsIndex(logDir: string): RunMeta[] {
+  return new RunLog(logDir).scanMeta().sort((a, b) => b.startedAt - a.startedAt);
+}

package/src/panel/runs-rows.ts

@@ -0,0 +1,29 @@
+// src/panel/runs-rows.ts
+// SPEC-5b-1 — pure renderers for the Runs tab + per-turn timeline. Reuses the glyph
+// language (▶ ✓ ✗) so the Runs tab is visually consistent with Fleet/Lifecycle.
+import { fmtDuration } from "./rows.ts";
+import type { RunMeta, MessageEvent, ToolEvent } from "../runtime/run-log.ts";
+
+const STATUS_GLYPH: Record<RunMeta["status"], string> = {
+  running: "▶", completed: "✓", failed: "✗", aborted: "✗",
+};
+
+export function runsRow(r: RunMeta): string {
+  const dur = r.endedAt ? fmtDuration(r.endedAt - r.startedAt) : "—";
+  const tok = r.tokenTotal > 0 ? `  ${r.tokenTotal} tok` : "";
+  const summary = r.resultSummary ? `  "${r.resultSummary}"` : "";
+  const prov = r.resumedFrom ? `  ← resumed:${r.resumedFrom}` : r.forkedFrom ? `  ← forked:${r.forkedFrom}` : "";
+  return `${STATUS_GLYPH[r.status]} ${r.runId}  ${r.agent}  ${r.status}  ${dur}${tok}${summary}${prov}`;
+}
+
+export function runTimelineRow(e: MessageEvent | ToolEvent): string {
+  const turn = Math.max(0, e.turnIndex);
+  if (e.type === "message") {
+    const text = e.text.length > 80 ? e.text.slice(0, 79) + "…" : e.text;
+    const tok = e.usage?.total != null ? `  ${e.usage.total} tok` : "";
+    return `[a] "${text}"${tok}  ·t${turn}`;
+  }
+  const glyph = e.isError ? "✗" : "✓";
+  const err = e.isError ? `  "${e.result}"` : "";
+  return `[t] ${e.toolName}  ${e.args}  ${glyph}${err}  ·t${turn}`;
+}

package/src/runtime/reconcile.ts

@@ -0,0 +1,29 @@
+// 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).
+import type { RunLog } from "./run-log.ts";
+
+export interface ReconcileOpts {
+  /** Orphans whose startedAt is older than (now - graceMs) are marked aborted. Default 60000. */
+  graceMs?: number;
+  /** Test injection. Default Date.now(). */
+  now?: number;
+}
+
+/** Returns the runIds it marked aborted. Idempotent: a run already ended is skipped. */
+export function reconcileRuns(log: RunLog, opts: ReconcileOpts = {}): string[] {
+  const grace = opts.graceMs ?? 60_000;
+  const now = opts.now ?? Date.now();
+  const aborted: string[] = [];
+  for (const meta of log.scanMeta()) {
+    if (meta.status !== "running") continue;
+    if (now - meta.startedAt <= grace) continue;
+    log.append(meta.runId, {
+      type: "run:ended", runId: meta.runId, status: "aborted",
+      endedAt: now, resultSummary: "process-gone", tokenTotal: meta.tokenTotal,
+    });
+    aborted.push(meta.runId);
+  }
+  return aborted;
+}

package/src/runtime/run-log.ts

@@ -0,0 +1,124 @@
+// src/runtime/run-log.ts
+// SPEC-5b-1 — self-describing per-run conversation log. Append-only JSONL (crash-safe:
+// partial last line discarded). One file per run in .pi/fleet/conversations/<runId>.jsonl.
+// The Runs tab rebuilds the run list across restarts via scanMeta().
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
+export type FleetRunStatus = "running" | "completed" | "failed" | "aborted";
+
+export interface RunMetaEvent {
+  type: "run:meta"; runId: string; agent: string; model: string; task: string;
+  startedAt: number; track: boolean; todoId: string | null;
+  backendSessionId?: string; sessionKey?: string;
+}
+export interface MessageEvent {
+  type: "message"; role: string; text: string;
+  usage?: { total?: number }; turnIndex: number;
+}
+export interface ToolEvent {
+  type: "tool"; toolName: string; args: string; result: string; isError: boolean; turnIndex: number;
+}
+export interface RunEndedEvent {
+  type: "run:ended"; runId: string; status: FleetRunStatus; endedAt: number;
+  resultSummary?: string; tokenTotal: number; resumedFrom?: string; forkedFrom?: string;
+}
+export type RunLogEvent = RunMetaEvent | MessageEvent | ToolEvent | RunEndedEvent;
+
+/** Resolved view of a run for the Runs tab (scanMeta result). */
+export interface RunMeta {
+  runId: string; agent: string; model: string; task: string;
+  startedAt: number; track: boolean; todoId: string | null;
+  backendSessionId?: string; sessionKey?: string;
+  status: FleetRunStatus; endedAt?: number; resultSummary?: string; tokenTotal: number;
+  resumedFrom?: string; forkedFrom?: string;
+}
+
+const ARGS_LIMIT = 200;
+const RESULT_LIMIT = 500;
+
+/** Truncate to `n` chars with a single `…` ellipsis. Non-string → "". */
+export function excerpt(str: string, n: number): string {
+  if (typeof str !== "string" || str.length === 0) return "";
+  if (str.length <= n) return str;
+  return str.slice(0, Math.max(0, n - 1)) + "…";
+}
+
+export class RunLog {
+  /** Public so buildRunsIndex + FleetPanel can read `runLog.dir` for the scan. */
+  constructor(readonly dir: string) {}
+
+  private file(runId: string): string { return join(this.dir, `${runId}.jsonl`); }
+
+  append(runId: string, event: RunLogEvent): void {
+    try {
+      mkdirSync(this.dir, { recursive: true });
+      appendFileSync(this.file(runId), JSON.stringify(event) + "\n", "utf8");
+    } catch {
+      // best-effort: the run is the product; the journal is the index. Never fail the run.
+    }
+  }
+
+  replay(runId: string): RunLogEvent[] {
+    const f = this.file(runId);
+    if (!existsSync(f)) return [];
+    const events: RunLogEvent[] = [];
+    for (const line of readFileSync(f, "utf8").split("\n")) {
+      if (!line) continue;
+      try { events.push(JSON.parse(line) as RunLogEvent); } catch { /* partial last line */ }
+    }
+    return events;
+  }
+
+  /** Rebuild the durable run list across restarts. Reads each file's run:meta events
+   * (latest binding wins for backendSessionId/sessionKey; first wins for startedAt) + the
+   * last run:ended (if present). */
+  scanMeta(): RunMeta[] {
+    if (!existsSync(this.dir)) return [];
+    const out: RunMeta[] = [];
+    for (const f of readdirSync(this.dir)) {
+      if (!f.endsWith(".jsonl")) continue;
+      const runId = f.slice(0, -".jsonl".length);
+      const events = this.replay(runId);
+      let meta: RunMeta | null = null;
+      let ended: RunEndedEvent | null = null;
+      for (const e of events) {
+        if (e.type === "run:meta") {
+          if (!meta) {
+            meta = { runId: e.runId, agent: e.agent, model: e.model, task: e.task, startedAt: e.startedAt,
+              track: e.track, todoId: e.todoId, backendSessionId: e.backendSessionId, sessionKey: e.sessionKey,
+              status: "running", tokenTotal: 0 };
+          } else {
+            // latest binding wins
+            if (e.backendSessionId) meta.backendSessionId = e.backendSessionId;
+            if (e.sessionKey) meta.sessionKey = e.sessionKey;
+          }
+        } else if (e.type === "run:ended") {
+          ended = e; // keep the last one
+        }
+      }
+      if (!meta) continue;
+      if (ended) {
+        meta.status = ended.status; meta.endedAt = ended.endedAt;
+        meta.resultSummary = ended.resultSummary; meta.tokenTotal = ended.tokenTotal;
+        meta.resumedFrom = ended.resumedFrom; meta.forkedFrom = ended.forkedFrom;
+      }
+      out.push(meta);
+    }
+    return out;
+  }
+}
+
+/** Build a tool event with the excerpt policy: errors-in-full, non-errors excerpted. */
+export function buildToolEvent(
+  toolName: string, args: unknown, result: unknown, isError: boolean, turnIndex: number,
+): ToolEvent {
+  const argsStr = typeof args === "string" ? args : JSON.stringify(args);
+  const resultStr = typeof result === "string" ? result : JSON.stringify(result);
+  return {
+    type: "tool", toolName,
+    args: excerpt(argsStr, ARGS_LIMIT),
+    result: isError ? resultStr : excerpt(resultStr, RESULT_LIMIT),
+    isError, turnIndex,
+  };
+}

package/src/tools/subagent.ts

@@ -45,6 +45,8 @@ export interface SubagentToolDeps {
   scheduler?: Scheduler;
   /** SPEC-5a: live bg run status rows for the /fleet panel. Optional. */
   bgRuns?: import("../panel/bg-runs-store.ts").BgRunsStore;
+  /** SPEC-5b-1: durable per-run conversation log. Optional — Runs tab + journaling disabled when absent. */
+  runLog?: import("../runtime/run-log.ts").RunLog;
 }
 
 /** Build the pi.registerTool definition. Thin wrapper over spawnSubagent. */
@@ -84,7 +86,7 @@ export function createSubagentTool(deps: SubagentToolDeps) {
             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: deps.parentCwd, signal,
+            backendRegistry: deps.backendRegistry, parentModel: deps.parentModel, parentCwd: deps.parentCwd, runLog: deps.runLog, signal,
           }),
         };
         const res = await runLifecycle(params.task, params.lifecycle, {
@@ -113,6 +115,7 @@ export function createSubagentTool(deps: SubagentToolDeps) {
         backendRegistry: deps.backendRegistry,
         parentModel: deps.parentModel,
         parentCwd: deps.parentCwd,
+        runLog: deps.runLog,
         signal,
         onEvent: (e) => {
           if (ctx?.ui?.setWidget && e.type === "turn_end") {

package/src/worktree/diff-service.ts

@@ -8,6 +8,13 @@ export interface PhaseArtifacts {
   summary: string;
 }
 
+/** SPEC-5a robustness: the error variant when the worktree git state is corrupted (e.g. child
+ *  ran rm -rf .git). runLifecycle treats this as a failed phase (clean abort) instead of an
+ *  unhandled throw. Matches the artifactDiscovery union in run-lifecycle.ts. */
+export interface PhaseArtifactsError {
+  error: string;
+}
+
 function sh(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).toString();
 }
@@ -22,11 +29,19 @@ export class DiffService {
    *
    * @param childFinalText  the child's final text, truncated to MAX_SUMMARY chars as the prose summary.
    */
-  diffPhase(worktreePath: string, baseRef: string, childFinalText = ""): PhaseArtifacts {
-    const tracked = sh(`git diff --name-only ${baseRef} --`, worktreePath)
-      .split("\n")
-      .filter(Boolean);
-    const status = sh("git status --porcelain", worktreePath);
+  diffPhase(worktreePath: string, baseRef: string, childFinalText = ""): PhaseArtifacts | PhaseArtifactsError {
+    // SPEC-5a robustness: a child can corrupt its worktree's git state (e.g. rm -rf .git,
+    // git init over the worktree link). Catch git failures + return {error} so runLifecycle
+    // treats it as a failed phase (clean abort with surfaced cause) instead of an unhandled
+    // throw crashing the async runner. Empty diff (no changes) is NOT an error — returns paths: [].
+    let tracked: string[] = [];
+    let status = "";
+    try {
+      tracked = sh(`git diff --name-only ${baseRef} --`, worktreePath).split("\n").filter(Boolean);
+      status = sh("git status --porcelain", worktreePath);
+    } catch (e) {
+      return { error: `worktree diff failed: ${(e as Error).message.split("\n").filter(Boolean).pop() ?? (e as Error).message}` };
+    }
     const untracked = status
       .split("\n")
       .filter((l) => l.startsWith("?? "))