pi-durable-subagents 1.0.5 → 1.0.6

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.0.6
+
+- A follow-up on a finished workflow shows as running work: in the dock, the
+  summary line, the list (no longer dimmed or hidden) and `status`. Quitting pi
+  pauses it, and `resume` continues it; before, a resume refused it as finished.
+- ↓ opens the subagent list only from pi's input editor. With `/model`'s
+  selector, a dialog or another overlay in focus, ↓ moves in that list again.
+
 ## 1.0.5
 
 - `status` without a wid is brief: what runs, what asks (with the address to

package/dist/agent/main.js

@@ -12,7 +12,7 @@ import { OsLock } from "../platform/lock.js";
 import { dsaHome, orchInbox, orchLedger, orchLock, outboxRoot } from "../paths.js";
 import { CT, JT } from "../types.js";
 import { attention, presentText, presented, resolved, unfinishedWorkflow } from "./main/snapshots.js";
-import { pausedElsewhere, statusBrief, statusCallDetail, statusCompactDetail, statusDetail, statusView, widOfRid } from "../orchestrator/snapshot.js";
+import { isLive, pausedElsewhere, statusBrief, statusCallDetail, statusCompactDetail, statusDetail, statusView, widOfRid } from "../orchestrator/snapshot.js";
 import { parameters, request } from "./main/tool.js";
 import { discoverAgents } from "../compat/agents.js";
 let noteSink;
@@ -165,7 +165,7 @@ export function registerMain(pi, ui) {
     pi.on("session_start", async (_event, context) => {
         await start(context);
         // Quit pause: say once, at the session's start, which of its workflows wait for a resume.
-        const paused = statusView(home, { origin: sender }).workflows.filter(w => w.origin === sender && w.status === "running" && w.paused);
+        const paused = statusView(home, { origin: sender }).workflows.filter(w => w.origin === sender && isLive(w) && w.paused);
         if (paused.length)
             pi.sendMessage({ customType: CT.note, display: true, content: `${paused.length} subagent workflow${paused.length > 1 ? "s were" : " was"} paused when pi quit (${paused.map(w => w.name ?? w.wid).join(", ")}). Ask to resume, or open /subagents (or ↓) and press r.` });
     });
@@ -176,7 +176,7 @@ export function registerMain(pi, ui) {
     pi.on("session_shutdown", async (event) => {
         if (event.reason === "quit" && quitPolicy(home) === "pause" && outbox && !stopped) {
             try {
-                const running = statusView(home, { origin: sender }).workflows.some(w => w.origin === sender && w.status === "running" && !w.paused);
+                const running = statusView(home, { origin: sender }).workflows.some(w => w.origin === sender && isLive(w) && !w.paused);
                 if (running)
                     await serial(async () => { await outbox?.send("orch", "drain", { fence: true, origin: sender }); });
             }

package/dist/cli/main.js

@@ -64,7 +64,7 @@ export function renderStatus(wf) {
 }
 /** P25, T10: Render the compact status projection shared with the `subagents` tool. */
 export function renderView(view) {
-    const lines = view.workflows.map(w => [`${w.wid}@${w.rev}${w.name ? ` ${w.name}` : ""}: ${w.status}${w.error ? ` (${clip(w.error, 200)})` : ""} · ${w.done}/${w.planned ?? w.calls.length}${w.planned === undefined && w.status === "running" ? "+" : ""} done${w.usage.input || w.usage.output || w.usage.costUsd ? ` · ${formatUsage(w.usage)}` : ""}`,
+    const lines = view.workflows.map(w => [`${w.wid}@${w.rev}${w.name ? ` ${w.name}` : ""}: ${w.status}${w.followUps ? " (follow-up running)" : ""}${w.error ? ` (${clip(w.error, 200)})` : ""} · ${w.done}/${w.planned ?? w.calls.length}${w.planned === undefined && w.status === "running" ? "+" : ""} done${w.usage.input || w.usage.output || w.usage.costUsd ? ` · ${formatUsage(w.usage)}` : ""}`,
         ...w.calls.map(c => `  ${c.key}@${c.gen} ${c.status ?? c.phase}${c.model ? ` ${c.model}` : ""}${c.tools ? ` tools:${c.tools}` : ""}${c.usage ? ` ${formatUsage(c.usage)}` : ""}${c.lastLine ? ` ${JSON.stringify(c.lastLine)}` : c.error ? ` (${c.error})` : ""}`),
         ...w.attention.map(a => `  ${a.kind}: ${JSON.stringify(a.text.split("\n")[0])}`)].join("\n"));
     if (view.paused)

package/dist/orchestrator/engine.js

@@ -97,6 +97,11 @@ export class Engine {
     held(wid) {
         return holdOf(this.ledgers.orch.entries(), wid, this.store.workflows.get(wid)?.origin) !== undefined;
     }
+    /** Follow-ups (generations) of the current revision that have not ended: on a finished workflow they are its only live work. */
+    openFollowUps(wf) {
+        const log = revisionEntries(wf), ended = new Set(log.filter(e => e.type === JT.sealed || e.type === 'retired').map(e => String(e.call)));
+        return log.some(e => e.type === 'generation' && !ended.has(`${wf.wid}@${wf.revision}/${e.key}@${e.gen}`));
+    }
     watcher;
     poll;
     constructor(ledgers, executor, options = {}) {
@@ -370,7 +375,8 @@ export class Engine {
             const inScope = (wf) => wid ? wf.wid === wid : origin ? wf.origin === origin : true;
             const took = (wf) => wf.journal.entries().some(e => e.type === 'resumed' && e.rid === req.rid);
             const replayed = this.ledgers.orch.entries().some(e => e.type === 'undrain' && e.rid === req.rid);
-            const holding = [...this.store.workflows.values()].filter(wf => inScope(wf) && this.held(wf.wid) && !this.terminal(wf));
+            // Held follow-ups of a finished workflow are released too; they run again through dispatchGeneration below.
+            const holding = [...this.store.workflows.values()].filter(wf => inScope(wf) && this.held(wf.wid) && (!this.terminal(wf) || this.openFollowUps(wf)));
             const releasing = replayed || holding.length > 0;
             const final = (wf) => { const done = this.terminal(wf); return done && done.status !== 'parked' ? String(done.status) : undefined; };
             const parked = (wf) => this.terminal(wf)?.status === 'parked';

package/dist/orchestrator/snapshot.js

@@ -6,6 +6,14 @@ import { compileFanout } from "../compat/fanout.js";
 import { readJournalSnapshot } from "../kernel/journal.js";
 import { journalPath, orchLedger, pinnedDir, workflowDir } from "../paths.js";
 import { JT } from "../types.js";
+/** A workflow has live work: it runs, or follow-ups opened on it after it finished have not ended yet. */
+export function isLive(wf) {
+    return wf.status === "running" || (wf.followUps ?? 0) > 0;
+}
+/** The calls of a workflow that are live work: every unfinished call of a running workflow, else open follow-ups. */
+export function liveCalls(wf) {
+    return wf.calls.filter(c => c.phase !== "sealed" && (wf.status === "running" || c.afterEnd === true));
+}
 /** v12 §4: done/total of one workflow: `done` counts keys whose latest generation is sealed; `total` is the planned
  *  count when known, else keys proposed so far (`plus` marks the `n+` script case while the workflow runs). */
 export function progressOf(wf) {
@@ -69,6 +77,7 @@ export function snapshotFromEntries(wid, entries) {
     const calls = new Map();
     const byExec = new Map();
     const resolved = new Set(entries.filter(e => e.type === JT.attentionResolved).map(e => `${e.id}@${e.rev}`));
+    const generations = new Set(), retired = new Set();
     const attention = [];
     // P31: usage per call id, deduplicated by message id; a seal carries the authoritative total.
     const live = new Map(), sealedUsage = new Map(), seen = new Set();
@@ -81,6 +90,8 @@ export function snapshotFromEntries(wid, entries) {
                 continue;
             const key = String(e.key), gen = Number(e.gen) || (e.type === "refused" ? 0 : 1);
             const callId = e.type === "reused" ? String(e.from) : `${wid}@${rev}/${key}@${gen}`;
+            if (e.type === "generation")
+                generations.add(callId);
             const result = e.type === "refused" ? refusedResult(key, e.reason) :
                 e.type === "reused" ? entries.find(s => s.type === JT.sealed && s.call === e.from)?.result : undefined;
             const wanted = e.spec?.model;
@@ -90,6 +101,9 @@ export function snapshotFromEntries(wid, entries) {
                 phase: result ? "sealed" : "queued", ...(result ? { result, endedAt: e.ts } : {}),
                 ...(e.type === "refused" ? { refused: String(e.reason) } : {}), ...(e.type === "reused" ? { reused: String(e.from) } : {}) });
         }
+        else if (e.type === "retired") {
+            retired.add(String(e.call));
+        }
         else if (e.type === JT.exec) {
             const call = calls.get(String(e.call));
             if (!call)
@@ -197,6 +211,10 @@ export function snapshotFromEntries(wid, entries) {
                 c.switching = switching;
         }
     }
+    const after = done ? list.filter(c => generations.has(c.callId) && c.phase !== "sealed" && !retired.has(c.callId)) : [];
+    for (const c of after)
+        c.afterEnd = true;
+    const followUps = after.length;
     const usage = zero();
     for (const id of new Set([...live.keys(), ...sealedUsage.keys()])) {
         const u = usageOf(id);
@@ -210,6 +228,7 @@ export function snapshotFromEntries(wid, entries) {
         status: done ? done.status : "running",
         ...(done?.error ? { error: String(done.error) } : {}), ...(done && "result" in done ? { result: done.result } : {}),
         ...(done ? { endedAt: done.ts } : {}),
+        ...(followUps ? { followUps } : {}),
         calls: list, counts, attention, usage,
     };
 }
@@ -262,7 +281,7 @@ export function heldWorkflows(home) {
 /** P25: Snapshot every workflow under DSA_HOME (newest first by wid, which is a ULID); `paused` marks work a drain holds. */
 export function allWorkflows(home) {
     const { held } = heldWorkflows(home);
-    return workflowIds(home).sort().reverse().map(wid => { const wf = workflowSnapshot(home, wid); return wf.status === "running" && held(wid) ? { ...wf, paused: true } : wf; });
+    return workflowIds(home).sort().reverse().map(wid => { const wf = workflowSnapshot(home, wid); return isLive(wf) && held(wid) ? { ...wf, paused: true } : wf; });
 }
 /** P10/P11: Per-workflow script console log written by the orchestrator (bounded, human-readable). */
 export function scriptLogPath(home, wid) { return join(workflowDir(home, wid), "script.log"); }
@@ -286,7 +305,7 @@ export function compactWorkflow(wf) {
                 ...(last ? { lastLine: clip(last, 200) } : {}), ...(r?.error ? { error: clip(r.error, 300) } : {}) };
         }),
         attention: wf.attention.map(a => ({ id: a.id, rev: a.rev, kind: a.kind, text: clip(a.text, 300), ...(a.call ? { call: a.call } : {}), ...(a.qid ? { qid: a.qid } : {}) })),
-        ...(wf.paused ? { paused: true } : {}),
+        ...(wf.paused ? { paused: true } : {}), ...(wf.followUps ? { followUps: wf.followUps } : {}),
     };
 }
 function origins(home) {
@@ -306,7 +325,7 @@ function snapshots(home, origin) {
     const { since, held } = heldWorkflows(home);
     const all = [...origins(home)].sort(([a], [b]) => a < b ? 1 : a > b ? -1 : 0).map(([wid, origin]) => {
         const wf = workflowSnapshot(home, wid), withOrigin = wf.origin === undefined && origin !== undefined ? { ...wf, origin } : wf;
-        return withOrigin.status === "running" && held(wid) ? { ...withOrigin, paused: true } : withOrigin;
+        return isLive(withOrigin) && held(wid) ? { ...withOrigin, paused: true } : withOrigin;
     }).sort((a, b) => own(b) - own(a));
     return { all, ...(since !== undefined ? { since } : {}) };
 }
@@ -315,13 +334,15 @@ export function statusView(home, options = {}) {
     const keep = options.keep ?? 10;
     const { all, since } = snapshots(home, options.origin);
     let finished = 0;
-    const shown = all.filter(w => !["done", "failed", "stopped"].includes(w.status) || ++finished <= keep);
+    const shown = all.filter(w => !settled(w) || ++finished <= keep);
     const hidden = all.length - shown.length;
     const paused = all.filter(w => w.paused).length;
     return { workflows: shown.map(compactWorkflow), ...(hidden ? { olderFinished: hidden, hint: "status wid=<wid> shows any workflow in detail" } : {}),
         ...(paused ? { paused: `${paused} workflow${paused > 1 ? "s" : ""} paused (stop-all, drain or a quit pi) since ${new Date(since).toISOString()}; resume continues them (new runs are not affected)` } : {}) };
 }
 const FINAL = ["done", "failed", "stopped"];
+/** Finished with nothing left running (a follow-up on a finished workflow is live work). */
+const settled = (w) => FINAL.includes(w.status) && !w.followUps;
 const age = (ms) => ms < 60_000 ? `${Math.max(0, Math.round(ms / 1000))}s` : ms < 3_600_000 ? `${Math.round(ms / 60_000)}m` : `${(ms / 3_600_000).toFixed(1)}h`;
 const tokens = (u) => { const n = u ? u.input + u.output : 0; return n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n); };
 /** The latest generation of every key, in first-call order. */
@@ -334,7 +355,7 @@ export function statusBrief(home, options = {}) {
     const mine = (w) => !origin || w.origin === origin;
     const line = (w) => {
         const p = progressOf(w), notOk = latestCalls(w).filter(c => c.result && !c.result.ok).length;
-        return [w.wid, w.name, `${w.paused ? "paused" : w.status}`, `${p.done}/${p.total}${p.plus ? "+" : ""} done`, notOk ? `${notOk} not ok` : "",
+        return [w.wid, w.name, `${w.paused ? "paused" : w.followUps ? `${w.status}, follow-up running` : w.status}`, `${p.done}/${p.total}${p.plus ? "+" : ""} done`, notOk ? `${notOk} not ok` : "",
             w.endedAt !== undefined ? `ended ${age(now - w.endedAt)} ago` : w.startedAt !== undefined ? `started ${age(now - w.startedAt)} ago` : ""].filter(Boolean).join(" · ");
     };
     const brief = (w) => {
@@ -349,12 +370,12 @@ export function statusBrief(home, options = {}) {
         });
         const asking = open.filter(a => a.kind === "question" && a.call).map(a => ({ to: `${w.wid}/${callKey(a.call)}`, ...(a.qid ? { qid: a.qid } : {}), question: clip(a.text, 300) }));
         const alerts = open.filter(a => a.kind !== "question").map(a => `${a.kind}${a.call ? ` ${w.wid}/${callKey(a.call)}` : ""}: ${clip(a.text, 200)}`);
-        return { wid: w.wid, ...(w.name ? { name: w.name } : {}), status: w.status, ...(w.paused ? { paused: true } : {}),
+        return { wid: w.wid, ...(w.name ? { name: w.name } : {}), status: w.status, ...(w.paused ? { paused: true } : {}), ...(w.followUps ? { followUps: w.followUps } : {}),
             progress: `${p.done}/${p.total}${p.plus ? "+" : ""}`, tokens: tokens(w.usage), calls,
             ...(asking.length ? { asking } : {}), ...(alerts.length ? { alerts } : {}) };
     };
-    const active = all.filter(w => !FINAL.includes(w.status));
-    const finished = all.filter(w => FINAL.includes(w.status) && mine(w));
+    const active = all.filter(w => !settled(w));
+    const finished = all.filter(w => settled(w) && mine(w));
     const others = active.filter(w => !mine(w));
     const heldMine = active.filter(w => mine(w) && w.paused).length, heldOthers = others.filter(w => w.paused);
     const paused = [heldMine ? `${heldMine} workflow${heldMine > 1 ? "s" : ""} of this session ${heldMine > 1 ? "are" : "is"} paused (stop-all, drain or a quit pi); resume continues ${heldMine > 1 ? "them" : "it"}` : "",
@@ -368,7 +389,7 @@ export function statusBrief(home, options = {}) {
 }
 /** Running workflows of other sessions that a pause holds, as "wid" or "wid (name)": a session's own resume skips them. */
 export function pausedElsewhere(home, origin) {
-    return snapshots(home, origin).all.filter(w => w.paused && w.origin !== origin && !FINAL.includes(w.status)).map(w => w.name ? `${w.wid} (${w.name})` : w.wid);
+    return snapshots(home, origin).all.filter(w => w.paused && w.origin !== origin && !settled(w)).map(w => w.name ? `${w.wid} (${w.name})` : w.wid);
 }
 /** "<rid>" or "<rid>/<rest>" of a run request that created a workflow → the same address with its wid; else unchanged.
  *  A run replies {submitted:{rid}} when its workflow is not created within 10 s, so the rid is all the caller has. */

package/dist/ui/index.js

@@ -38,7 +38,19 @@ export function registerUi(pi, deps) {
         const state = { folded: new Set(), done: new Map(), viewed: new Set(), finished: false };
         let screen, opening = false, stopped = false, closeScreen;
         let unsubscribe, timer;
-        let dockRows = () => [], dockAt, dockTui, lastDock = "";
+        let dockRows = () => [], dockAt = null, dockTui, lastDock = "";
+        // ↓ opens the list only from pi's own input editor. Another surface — /model's selector, a dialog, another
+        // extension's overlay — has the focus instead, and its ↓ belongs to it. pi's editor (and any editor built on
+        // CustomEditor) carries the app action map; the TUI comes from the dock widget, so without a dock the check
+        // falls back to the editor text alone.
+        let keysTui;
+        const editorFocused = () => {
+            const focus = keysTui?.getFocusedComponent;
+            if (typeof focus !== "function")
+                return true;
+            const focused = focus.call(keysTui);
+            return !!focused && typeof focused === "object" && focused.actionHandlers instanceof Map;
+        };
         const right = (text, width) => { const t = truncateToWidth(text, width); return " ".repeat(Math.max(0, width - visibleWidth(t))) + t; };
         const stop = () => {
             stopped = true;
@@ -75,8 +87,11 @@ export function registerUi(pi, deps) {
                 if (at !== dockAt) {
                     dockAt = at;
                     dockTui = undefined;
-                    ctx.ui.setWidget("durable-subagents", at ? (tui, theme) => {
+                    // With the dock off, an empty widget below the editor still lends the TUI to the ↓ focus check; pi adds no
+                    // spacer for it, so it takes no line.
+                    ctx.ui.setWidget("durable-subagents", !at ? tui => { keysTui = tui; return { invalidate() { }, render: () => [] }; } : (tui, theme) => {
                         dockTui = tui;
+                        keysTui = tui;
                         return {
                             invalidate() { },
                             render(width) {
@@ -88,7 +103,7 @@ export function registerUi(pi, deps) {
                                 return rows.map((row, i) => ` ${i === rows.length - 1 ? theme.fg("dim", right(row, inner)) : row.startsWith("? ") ? theme.fg("warning", row) : theme.fg("muted", row)}`);
                             },
                         };
-                    } : undefined, { placement: at === "above" ? "aboveEditor" : "belowEditor" });
+                    }, { placement: at === "above" ? "aboveEditor" : "belowEditor" });
                 }
                 const shown = dockRows(200).join("\n");
                 if (shown !== lastDock) {
@@ -118,7 +133,7 @@ export function registerUi(pi, deps) {
             };
             openList = open;
             unsubscribe = ctx.ui.onTerminalInput(key => {
-                if (stopped || opening || !matchesKey(key, "down") || ctx.ui.getEditorText() !== "" || !data.workflows.length)
+                if (stopped || opening || !matchesKey(key, "down") || ctx.ui.getEditorText() !== "" || !editorFocused() || !data.workflows.length)
                     return;
                 open();
                 return { consume: true };

package/dist/ui/tool.js

@@ -50,7 +50,7 @@ export function resultLines(details) {
     if (Array.isArray(d.active)) {
         const rows = d.active.map(w => {
             const failed = w.calls.filter(c => c.status && c.status !== "ok").length, asks = w.asking?.length ?? 0, alerts = w.alerts?.length ?? 0;
-            return `${w.name ?? short(w.wid)} · ${w.paused ? "paused" : w.status} · ${w.progress} done${failed ? ` · ${failed} not ok` : ""}${asks ? ` · ${asks} asking` : ""}${alerts ? ` · ${alerts} alert${alerts > 1 ? "s" : ""}` : ""}`;
+            return `${w.name ?? short(w.wid)} · ${w.paused ? "paused" : w.followUps ? `${w.status}, follow-up running` : w.status} · ${w.progress} done${failed ? ` · ${failed} not ok` : ""}${asks ? ` · ${asks} asking` : ""}${alerts ? ` · ${alerts} alert${alerts > 1 ? "s" : ""}` : ""}`;
         });
         const finished = Array.isArray(d.finished) ? d.finished.length + Number(d.olderFinished ?? 0) : 0;
         return [...(typeof d.paused === "string" ? [`⚠ ${d.paused}`] : []), ...(rows.length ? rows.slice(0, 6) : ["nothing running"]),

package/dist/ui/view.js

@@ -1,5 +1,5 @@
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { progressOf } from "../orchestrator/snapshot.js";
+import { isLive, liveCalls, progressOf } from "../orchestrator/snapshot.js";
 import { oneLine } from "./frame.js";
 /** UI §2: Render compact wall-clock durations; never present these as charged active time. */
 export function duration(ms) {
@@ -146,18 +146,18 @@ export const resultWord = (status) => WORDS[status] ?? "failed";
 const WORD_ORDER = ["done", "stopped", "failed", "timeout", "budget", "unknown", "skipped", "parked"];
 /** UI §1,4, v12 §4: One working sentence; done/total uses planned totals, `n+` while a script workflow keeps proposing. */
 export function summary(workflows) {
-    const running = workflows.filter(w => w.status === "running"), open = (w) => w.calls.filter(c => c.phase !== "sealed").length;
-    const asking = running.reduce((n, w) => n + w.calls.filter(c => c.phase !== "sealed" && w.attention.some(a => a.kind === "question" && a.call === c.callId)).length, 0);
+    const running = workflows.filter(isLive), open = (w) => liveCalls(w).length;
+    const asking = running.reduce((n, w) => n + liveCalls(w).filter(c => w.attention.some(a => a.kind === "question" && a.call === c.callId)).length, 0);
     const paused = running.filter(w => w.paused).reduce((n, w) => n + open(w), 0); // held work is not working: it burns nothing
     // Waiting for a slot is not working either: nothing is spent until it launches.
-    const queued = running.filter(w => !w.paused).reduce((n, w) => n + w.calls.filter(c => c.phase === "queued" && !w.attention.some(a => a.kind === "question" && a.call === c.callId)).length, 0);
+    const queued = running.filter(w => !w.paused).reduce((n, w) => n + liveCalls(w).filter(c => c.phase === "queued" && !w.attention.some(a => a.kind === "question" && a.call === c.callId)).length, 0);
     const progress = running.map(progressOf);
     return { working: running.reduce((n, w) => n + open(w), 0) - asking - paused - queued, asking, queued, paused,
         done: progress.reduce((n, p) => n + p.done, 0), total: progress.reduce((n, p) => n + p.total, 0), plus: progress.some(p => p.plus) };
 }
 /** UI §1, v12 §4: What needs you first, then what is running, then progress — e.g. "1 asking · 3 working · 12/40 done". */
 export function summaryText(workflows) {
-    const s = summary(workflows), finished = workflows.filter(w => w.status !== "running").length;
+    const s = summary(workflows), finished = workflows.filter(w => !isLive(w)).length;
     if (!s.total)
         return finished ? `${finished} finished` : "nothing running";
     return [s.asking ? `${s.asking} asking` : "", s.working ? `${s.working} working` : "", s.queued ? `${s.queued} queued` : "", s.paused ? `${s.paused} paused` : "", `${s.done}/${s.total}${s.plus ? "+" : ""} done`].filter(Boolean).join(" · ");
@@ -169,7 +169,7 @@ export function mainLine(workflows) {
     // The key that opens the list is spelled out: a bare arrow is easy to miss.
     if (s.working || s.asking || s.queued || s.paused)
         return `${summaryText(workflows)} · ↓ subagents`;
-    const w = workflows.filter(w => w.status !== "running").sort((a, b) => (b.endedAt ?? 0) - (a.endedAt ?? 0))[0];
+    const w = workflows.filter(w => !isLive(w)).sort((a, b) => (b.endedAt ?? 0) - (a.endedAt ?? 0))[0];
     if (!w)
         return undefined;
     const latest = [...new Map(w.calls.map(c => [c.key, c])).values()]; // the newest generation of each key (P37)
@@ -188,15 +188,16 @@ const SPIN = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "
  *  then one summary line; afterwards only the completion sentence for ten minutes; otherwise nothing. Activity spins
  *  only while there is fresh evidence, so a quiet agent visibly stops moving. */
 export function dockLines(workflows, facts, name, width, now = Date.now(), rows = 3) {
-    const live = workflows.filter(w => w.status === "running");
+    const live = workflows.filter(isLive);
     const active = live.flatMap(w => {
         const latest = new Map();
         for (const c of w.calls)
             latest.set(c.key, c);
-        return [...latest.values()].filter(c => c.phase !== "sealed").map(c => ({ w, c, asking: w.attention.some(a => a.kind === "question" && a.call === c.callId) }));
+        const open = new Set(liveCalls(w));
+        return [...latest.values()].filter(c => open.has(c)).map(c => ({ w, c, asking: w.attention.some(a => a.kind === "question" && a.call === c.callId) }));
     }).sort((a, b) => Number(b.asking) - Number(a.asking));
     if (!active.length) {
-        const ended = workflows.filter(w => w.status !== "running").sort((a, b) => (b.endedAt ?? 0) - (a.endedAt ?? 0))[0];
+        const ended = workflows.filter(w => !isLive(w)).sort((a, b) => (b.endedAt ?? 0) - (a.endedAt ?? 0))[0];
         const line = ended && now - (ended.endedAt ?? 0) < 10 * 60_000 ? mainLine(workflows) : undefined;
         return line ? [truncateToWidth(line, Math.max(1, width))] : [];
     }
@@ -217,7 +218,7 @@ export function dockLines(workflows, facts, name, width, now = Date.now(), rows
  *  keep unviewed failures visible, and page newest done rows eight at a time. */
 /** v12 §5: Whether a workflow shows its agents: running ones unless folded; finished ones once opened (Enter, or on completion). */
 export function isOpen(w, state) {
-    return !state.folded.has(w.wid) && (w.status === "running" || (state.done.get(w.wid) ?? 0) > 0);
+    return !state.folded.has(w.wid) && (isLive(w) || (state.done.get(w.wid) ?? 0) > 0);
 }
 /** v12 §5: Enter on a workflow row opens or closes it. */
 export function toggleOpen(w, state) {
@@ -225,7 +226,7 @@ export function toggleOpen(w, state) {
         state.folded.add(w.wid);
     else {
         state.folded.delete(w.wid);
-        if (w.status !== "running")
+        if (!isLive(w))
             state.done.set(w.wid, Math.max(8, state.done.get(w.wid) ?? 0));
     }
 }
@@ -267,13 +268,13 @@ export function listRows(workflows, state, facts, name, width, now = Date.now())
         for (const c of v.calls)
             latest.set(c.key, c);
         const w = latest.size === v.calls.length ? v : { ...v, calls: v.calls.filter(c => latest.get(c.key) === c) };
-        const dim = w.status !== "running"; // v12 §5: finished workflows are dimmed, not hidden
+        const dim = !isLive(w); // v12 §5: finished workflows are dimmed, not hidden; an open follow-up keeps one live
         if (w.calls.length === 1) {
             callRow(w, w.calls[0], "  ", "    ", dim);
             continue;
         }
         // Stable order (UI §2): active rows keep proposal (snapshot) order; done rows by immutable end time.
-        const done = doneOrder(w.calls), active = w.calls.filter(c => c.phase !== "sealed"), folded = !isOpen(w, state);
+        const done = doneOrder(w.calls), active = liveCalls(w), folded = !isOpen(w, state);
         const progress = progressOf(w); // v12 §4: done/planned, `n+` while a script workflow keeps proposing
         rows.push({ id: w.wid, kind: "workflow", workflow: w, dim, text: `${folded ? "▸" : "▾"} ${w.name ?? w.wid} · ${progress.done}/${progress.total}${progress.plus ? "+" : ""} · ${duration((w.endedAt ?? now) - (w.startedAt ?? now))}` });
         if (folded)
@@ -285,7 +286,7 @@ export function listRows(workflows, state, facts, name, width, now = Date.now())
         active.forEach((c, i) => { const last = i === active.length - 1 && !done.length; callRow(w, c, last ? "  └ " : "  ├ ", last ? "      " : "  │   ", dim); });
         if (!done.length)
             continue;
-        const count = state.done.get(w.wid) ?? (w.status === "running" && !active.length || unviewed(w) ? 8 : 0), shown = done.slice(0, count);
+        const count = state.done.get(w.wid) ?? (isLive(w) && !active.length || unviewed(w) ? 8 : 0), shown = done.slice(0, count);
         rows.push({ id: `${w.wid}:done`, kind: "done", workflow: w, dim, text: `  └ ${count ? "▾" : "▸"} ${progress.done} done` });
         const more = count && done.length > count;
         shown.forEach((c, i) => callRow(w, c, i === shown.length - 1 && !more ? "      └ " : "      ├ ", undefined, dim));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-durable-subagents",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Subagents for pi that never lose work and never do it twice. Crash-safe workflows, automatic recovery, and a live view just like the main agent.",
   "type": "module",
   "license": "MIT",