pi-durable-subagents 1.0.5 → 1.0.7

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 1.0.7
+
+- Changes to `config.json` (`defaultModel`, `pools`, `providers`, `memory`,
+  `k`) apply without restarting the orchestrator: it checks the file about
+  once a second and applies a valid change between slot admissions, so a call
+  still waiting for a slot follows the new model, pool or limit. Slots already
+  held are kept when a limit drops. An invalid change is refused and the
+  settings in effect stay; `status` names the error until the file is valid
+  again.
+- `status` marks an asker whose execution hibernated with `hibernated: true`
+  (CLI: "hibernated, no slot"): it holds no provider slot until it is
+  answered. Both `status` forms list provider slots in use against their
+  limits, and the config in effect.
+
+## 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/README.md

@@ -273,6 +273,11 @@ State lives in `~/.pi/durable-subagents`; set `DSA_HOME` to move it.
   never stopped for memory.
 - **onQuit:** `"pause"` (default) pauses a session's running workflows when
   you quit that pi; `"continue"` lets them run on in the background.
+- **Changes apply without a restart:** the orchestrator re-reads the file
+  when it changes. A new slot limit, pool or default model applies to the next
+  slot acquisition; slots already held are kept when a limit drops. An
+  invalid change is not applied, and `status` reports it next to the settings
+  still in effect (`config: <hash> since …`) and the slots held per provider.
 
 ## Switching back
 

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 }); });
             }
@@ -325,7 +325,7 @@ export function registerMain(pi, ui) {
             "run (action optional for exactly one launch form): agent+task; tasks:[call specs] parallel; chain:[call specs] sequential ({previous}); workflow:'./script.js' or source (runs.run(key,spec), runs.all([...]), emit(value), args, runs.input(name)). Optional name, cwd, usageBudget, maxCalls, inputs. With tasks/chain, top-level model, timeoutMs, budget, isolation, context, tools, skills, once are defaults for every step (a step's own value wins); a workflow/source script sets them per runs.run call. timeoutMs is milliseconds of active time (a number); omit it unless a hard limit is needed. Explicit unknown agents are rejected BEFORE creation, with available names; unknown script agents fail only their call.",
             "agents: list names, descriptions, default models and source for this cwd; use these names for run.",
             "send to:'<wid>/<key>' (bare '<wid>' only for a single-call workflow): steer on a running call delivers at the next safe point (receipt in status/UI); a steer to a call waiting on its question interrupts the question and the subagent usually asks again — use answer to answer it; sealed → finished:<status> — use kind 'follow-up'. follow-up continues a sealed call as generation g+1 or queues after a running turn. answer: give the qid (or just the call, or nothing when one question is open); to and rev are filled in. A question that needs the user's decision goes to the user; if you answer one yourself, tell the user what you chose. model switches at next provider request. Unknown targets list valid addresses. replaces:[rid] supersedes an earlier send.",
-            "stop target:<wid|<wid>/<key>> is terminal stopped (usage and partial edits kept); a sealed call → already-sealed:<status>, a finished workflow → terminal:<status>. drain holds existing workflows reversibly (new runs unaffected); resume [wid] releases held workflows. status: without wid, what runs, asks (with its answer address) or failed, finished workflows one line each; wid: one workflow, outputs clipped; wid+key: one call's full result; full:true: everything. A run's rid from {submitted:{rid}} works wherever a wid is expected. revise wid + workflow/source/args starts a revision.",
+            "stop target:<wid|<wid>/<key>> is terminal stopped (usage and partial edits kept); a sealed call → already-sealed:<status>, a finished workflow → terminal:<status>. drain holds existing workflows reversibly (new runs unaffected); resume [wid] releases held workflows. status: without wid, what runs, asks (with its answer address; hibernated:true holds no slot) or failed, finished workflows one line each, provider slots held/limit and the config in effect; wid: one workflow, outputs clipped; wid+key: one call's full result; full:true: everything. A run's rid from {submitted:{rid}} works wherever a wid is expected. revise wid + workflow/source/args starts a revision.",
             "Control replies are {applied:true,rid} or {applied:false,reason,rid} when decided; otherwise {submitted:{rid}} after 10s.",
             ...(agents ? [`Available agents: ${agents}.`] : []),
             "User sees a summary line above the editor; ↓ on an empty editor (or /subagents) opens the list, Enter watches live OR finished calls (finished transcripts remain on disk) and expands finished workflows. List keys: s steer (paste-capable input), x stop (confirm y), m model, a answer when asked, f follow-up on finished calls; action feedback appears in footer.",

package/dist/cli/main.js

@@ -64,14 +64,17 @@ 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)}` : ""}`,
-        ...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})` : ""}`),
+    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.hibernated ? " (hibernated, no slot)" : ""}${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)
         lines.unshift(`${view.paused} (pi-durable-subagents resume)`);
     if (view.olderFinished)
         lines.push(`(+${view.olderFinished} older finished workflows; status <wid> shows one in detail)`);
-    return lines.join("\n") || "No workflows";
+    const footer = [view.slots?.length ? `slots: ${view.slots.join(", ")}` : "", view.config ? `config: ${view.config}` : "", view.configRejected ? `config.json rejected: ${view.configRejected}` : ""].filter(Boolean);
+    if (!lines.length)
+        lines.push("No workflows");
+    return [...lines, ...footer].join("\n");
 }
 function snapshots(home, wid) {
     if (!wid)

package/dist/orchestrator/config.js

@@ -0,0 +1,147 @@
+// $DSA_HOME/config.json for the orchestrator: read at start and again whenever the file changes, so a new slot limit,
+// pool order or K-parameter needs no orchestrator restart (a restart at the wrong moment used to cost a dispatch).
+// Orchestrator ledger entries: config{hash,config} — the settings in effect from then on (at start, or after a change);
+// config-rejected{hash,error} — a changed file that was not applied; the settings before it stay in effect.
+// A reload changes the shared config object in place: every later read sees it (the next slot acquisition, model
+// resolution or check). Slots already held are kept when a limit drops; timers of running executions keep their period.
+import { readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { contentHash } from "../kernel/ids.js";
+/** The keys the orchestrator reads; config.json also holds pi-side settings (ui, onQuit) that it ignores. */
+const KEYS = ["defaultModel", "pools", "providers", "memory", "k"];
+const K = ["lossBound", "checkpointMs", "stallMs", "progressMs", "switchTimeoutMs", "idleExitMs", "trackerMs", "hibernateMs", "spawnBudget"];
+export const configPath = (home) => join(home, "config.json");
+/** The orchestrator's part of a parsed config.json. */
+export function orchestratorSettings(raw) {
+    const value = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+    return Object.fromEntries(KEYS.filter(k => value[k] !== undefined).map(k => [k, value[k]]));
+}
+export const configHash = (config) => contentHash(orchestratorSettings(config)).slice(0, 12);
+const record = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+const count = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0;
+/** What is wrong with a parsed config.json for the orchestrator, or undefined. Unknown keys are allowed. */
+export function configProblem(raw) {
+    if (!record(raw))
+        return "config.json must be a JSON object";
+    const { defaultModel, pools, providers, memory, k } = raw;
+    if (defaultModel !== undefined && typeof defaultModel !== "string")
+        return "defaultModel must be a string";
+    if (pools !== undefined) {
+        if (!record(pools))
+            return "pools must map names to model lists";
+        for (const [name, list] of Object.entries(pools))
+            if (!Array.isArray(list) || !list.length || !list.every(m => typeof m === "string" && m))
+                return `pools.${name} must be a nonempty list of "provider/id[:thinking]"`;
+    }
+    if (providers !== undefined) {
+        if (!record(providers))
+            return "providers must map provider names to { slots }";
+        for (const [name, p] of Object.entries(providers))
+            if (!record(p) || !Number.isSafeInteger(p.slots) || Number(p.slots) < 0)
+                return `providers.${name}.slots must be a nonnegative integer`;
+    }
+    if (memory !== undefined) {
+        if (!record(memory))
+            return "memory must be { reserveMb?, perChildMb? }";
+        for (const key of ["reserveMb", "perChildMb"])
+            if (memory[key] !== undefined && !count(memory[key]))
+                return `memory.${key} must be a nonnegative number`;
+    }
+    if (k !== undefined) {
+        if (!record(k))
+            return "k must map K-parameters to numbers";
+        for (const [key, v] of Object.entries(k)) {
+            if (!K.includes(key))
+                return `k.${key} is not a K-parameter (${K.join(", ")})`;
+            if (!count(v) || (key !== "lossBound" && key !== "spawnBudget" && v === 0))
+                return `k.${key} must be a positive number`;
+        }
+    }
+}
+/** Parse config.json; a missing file is the empty config. A JSON error throws. */
+export async function readConfig(path) {
+    try {
+        return JSON.parse(await readFile(path, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return {};
+        throw error;
+    }
+}
+/** Record the settings in effect unless the ledger already ends on the same ones (a restart with an unchanged file).
+ *  After a rejection they are recorded again: that confirms the file is back to settings in effect. */
+export async function recordConfig(orch, config) {
+    const hash = configHash(config), last = orch.entries().findLast(e => e.type === "config" || e.type === "config-rejected");
+    if (last?.type !== "config" || last.hash !== hash)
+        await orch.append("config", { hash, config: orchestratorSettings(config) });
+    return hash;
+}
+/** Replace the contents of the shared config object; readers hold the object, not a copy. */
+function applyInPlace(target, next) {
+    const t = target;
+    for (const key of KEYS)
+        delete t[key];
+    Object.assign(t, orchestratorSettings(next));
+}
+/** Identity of the file's current version (taken before a read, so a change during the read is seen next time). */
+export async function configStamp(path) {
+    try {
+        const s = await stat(path);
+        return `${s.ino}:${s.size}:${s.mtimeMs}`;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return "missing";
+        throw error;
+    }
+}
+/** Watch config.json from the version `stamp` (read at start) and apply each valid change in place. */
+/** `apply` runs the change where readers cannot observe half of it (the executor's admission section). */
+export function watchConfig(options) {
+    const { path, config, orch } = options;
+    let stamp = options.stamp, running, rejected, stopped = false;
+    const once = async () => {
+        const now = await configStamp(path);
+        if (now === stamp || stopped)
+            return;
+        let raw;
+        try {
+            raw = await readConfig(path);
+        }
+        catch (error) {
+            // A half-written file reads as invalid JSON: retry on the next change of the file, report it once per version.
+            stamp = now;
+            const hash = `invalid:${now}`;
+            if (rejected !== hash) {
+                rejected = hash;
+                await orch.append("config-rejected", { error: `config.json is not valid JSON: ${error.message}` });
+            }
+            return;
+        }
+        stamp = now;
+        // Validate the content first: `[]` or `null` project to no settings and must not pass as "unchanged".
+        const problem = configProblem(raw), next = orchestratorSettings(raw), hash = configHash(next);
+        if (problem) {
+            if (rejected !== hash) {
+                rejected = hash;
+                await orch.append("config-rejected", { hash, error: problem });
+            }
+            return;
+        }
+        rejected = undefined;
+        let changed = false;
+        await (options.apply ?? (change => change()))(async () => {
+            changed = hash !== configHash(config);
+            if (changed)
+                applyInPlace(config, next);
+            await recordConfig(orch, config); // also confirms a return to the settings in effect after a rejection
+        });
+        if (changed)
+            options.onApplied?.();
+    };
+    const check = () => running ??= once().catch(error => console.error(`durable-subagents: config.json check failed: ${String(error)}`)).finally(() => { running = undefined; });
+    const timer = setInterval(check, options.intervalMs ?? 1000);
+    timer.unref();
+    return { stop: async () => { stopped = true; clearInterval(timer); await running; }, check };
+}

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/executor/index.js

@@ -389,13 +389,18 @@ export default function createExecutor(ledgers, options = {}) {
     }
     const stopped = (a) => a.stopped || entriesFor(a.ticket.journal, a.ticket.callId).some(e => e.type === "stop-intent");
     const interrupted = (a) => closed || a.suspended || a.retired || stopped(a);
-    async function acquire(a, exec, models, pool, continuation = false) {
+    /** Wait for a slot. The candidates are decided again on every attempt, inside the serial section that also applies
+     *  config.json changes: a queued call follows a reloaded defaultModel, pool or limit, never a mix of two versions. */
+    async function acquire(a, exec, decide) {
+        let continuation = false;
         for (;;) {
             let signal;
             const changed = new Promise(resolve => { signal = resolve; waiters.add(resolve); });
             const chosen = await serial(async () => {
                 if (interrupted(a) || await workflowReached(a.ticket))
                     return;
+                const decision = await decide(), models = decision.candidates, pool = decision.pool;
+                continuation = decision.continuation;
                 for (const model of models) {
                     if (!continuation && pool && skipped(pool, model))
                         continue;
@@ -434,7 +439,7 @@ export default function createExecutor(ledgers, options = {}) {
             });
             if (chosen || interrupted(a) || reached(totalUsage(a.ticket.journal.entries()), a.ticket.workflowBudget)) {
                 waiters.delete(signal);
-                return chosen;
+                return { model: chosen, continuation };
             }
             const timer = setTimeout(signal, config.k?.trackerMs ?? 1000);
             try {
@@ -599,13 +604,13 @@ export default function createExecutor(ledgers, options = {}) {
             }
             let decision;
             try {
-                decision = await launchModel(t, entries, previous);
+                decision = await acquire(a, exec, () => launchModel(t, entries, previous));
             }
             catch (error) {
                 await fence(journal, exec, { park: a });
                 return finish(journal, t.callId, exec, makeResult("failed", "", String(error)));
             }
-            const model = await acquire(a, exec, decision.candidates, decision.pool, decision.continuation);
+            const model = decision.model;
             if (!model || interrupted(a)) {
                 await fence(journal, exec, { park: a });
                 return finish(journal, t.callId, exec, !interrupted(a) ? makeResult("failed", "", "workflow budget reached") : makeResult("stopped"));
@@ -687,6 +692,7 @@ export default function createExecutor(ledgers, options = {}) {
         await (await outbox).send(envelope.to, envelope.kind, envelope.body, envelope.cond, { rid: String(e.rid2) });
     }
     return {
+        async reconfigure(apply) { await serial(apply); wake(); },
         run(ticket) {
             const existing = completed.get(ticket.callId);
             if (existing)

package/dist/orchestrator/executor/observe.js

@@ -123,7 +123,7 @@ export async function observeExecution(d) {
             }
         });
     });
-    let scanning = false, scanFailures = 0;
+    let scanning = false, failingSince;
     const scan = () => {
         if (scanning)
             return;
@@ -133,12 +133,14 @@ export async function observeExecution(d) {
                 // One failed process-table scan is no evidence, not a reason to fence a live child: on macOS `ps` can miss its
                 // 2 s deadline right after the orchestrator was stopped or the machine slept (seen on CI as a spurious loss and
                 // a rerun). Only a scan that keeps failing for a minute ends the observation.
+                // Measured in elapsed time: the scan period is fixed at start while k.trackerMs can be reloaded.
                 try {
                     clock.scan(await d.track());
-                    scanFailures = 0;
+                    failingSince = undefined;
                 }
                 catch (error) {
-                    if (++scanFailures * (config.k?.trackerMs ?? 1000) >= 60_000)
+                    failingSince ??= performance.now();
+                    if (performance.now() - failingSince >= 60_000)
                         throw error;
                 }
                 const nextSize = (await fileStat(session).catch(() => ({ size: 0 }))).size;

package/dist/orchestrator/main.js

@@ -6,7 +6,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { mkdir, readFile } from 'node:fs/promises';
+import { mkdir } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import { realpathSync } from 'node:fs';
 import { join, resolve } from 'node:path';
@@ -14,6 +14,7 @@ import { dsaHome, orchLedger, orchLock } from "../paths.js";
 import { openJournal } from "../kernel/journal.js";
 import { OsLock } from "../platform/lock.js";
 import { Engine } from "./engine.js";
+import { configPath, configProblem, configStamp, readConfig, recordConfig, watchConfig } from "./config.js";
 /** P2, C4, K6: Acquire the single authority before opening ledgers, recover, and idle-exit. */
 export async function main(options = {}) {
     const home = options.home ?? dsaHome();
@@ -21,27 +22,34 @@ export async function main(options = {}) {
     const lock = await new OsLock().tryAcquire(orchLock(home));
     if (!lock)
         return;
-    let engine, ledgers;
+    let engine, ledgers, watcher;
     try {
-        let config = options.config;
+        let config = options.config, stamp;
         if (!config) {
-            try {
-                config = JSON.parse(await readFile(join(home, 'config.json'), 'utf8'));
-            }
-            catch (error) {
-                if (error.code !== 'ENOENT')
-                    throw error;
-                config = {};
-            }
+            // The stamp is taken before the read: a change made while reading is applied by the first check.
+            stamp = await configStamp(configPath(home));
+            const raw = await readConfig(configPath(home));
+            const problem = configProblem(raw);
+            if (problem)
+                console.error(`durable-subagents: config.json: ${problem}`);
+            config = raw;
         }
         ledgers = { home, config, orch: await openJournal(orchLedger(home)) };
         const factory = options.executor ?? (await import(__rewriteRelativeImportExtension(new URL(import.meta.url.endsWith('.ts') ? './executor/index.ts' : './executor/index.js', import.meta.url).href))).default;
-        engine = new Engine(ledgers, factory(ledgers), options);
+        const executor = factory(ledgers);
+        engine = new Engine(ledgers, executor, options);
+        if (stamp !== undefined) {
+            await recordConfig(ledgers.orch, config);
+            // A change applies between slot admissions, so one admission never mixes two versions of the limits.
+            watcher = watchConfig({ path: configPath(home), stamp, config, orch: ledgers.orch, intervalMs: Math.min(1000, config.k?.trackerMs ?? 1000),
+                apply: change => executor.reconfigure ? executor.reconfigure(change) : change() });
+        }
         await engine.recover();
         await engine.loop(options.signal);
     }
     finally {
         try {
+            await watcher?.stop();
             await engine?.close();
         }
         finally {

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) {
@@ -68,7 +76,9 @@ export function snapshotFromEntries(wid, entries) {
     const done = terminal?.type === JT.done ? terminal : undefined;
     const calls = new Map();
     const byExec = new Map();
+    const hibernating = new Map(); // callId → exec that decided to hibernate and is not fenced yet
     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 +91,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 +102,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)
@@ -101,12 +116,29 @@ export function snapshotFromEntries(wid, entries) {
             call.startedAt ??= e.ts;
             call.lastActivity = e.ts;
             byExec.set(call.exec, call);
+            delete call.hibernated;
+            hibernating.delete(call.callId);
+        }
+        else if (e.type === "hibernated") {
+            // The decision to hibernate precedes the fence; the slot is released only once the execution is fenced.
+            const call = calls.get(String(e.call));
+            if (call?.exec && call.exec === e.exec)
+                hibernating.set(call.callId, call.exec);
+        }
+        else if (e.type === "answer-bound" || (e.type === "resumed" && e.call)) {
+            const call = calls.get(String(e.call));
+            if (call) {
+                delete call.hibernated;
+                hibernating.delete(call.callId);
+            }
         }
         else if (e.type === JT.fenced) {
             // A fenced execution without a seal (stop-all, a quit pi, a loss before its continuation) waits to run again.
             const call = byExec.get(String(e.exec));
             if (call && call.phase === "running")
                 call.phase = "queued";
+            if (call && hibernating.get(call.callId) === e.exec)
+                call.hibernated = true;
         }
         else if (e.type === "selected") {
             const call = byExec.get(String(e.exec)), m = e.model;
@@ -144,6 +176,8 @@ export function snapshotFromEntries(wid, entries) {
             call.phase = "sealed";
             call.result = e.result;
             call.endedAt = e.ts;
+            delete call.hibernated;
+            hibernating.delete(call.callId);
         }
         else if (e.type === JT.attention) {
             const item = e.item;
@@ -175,6 +209,9 @@ export function snapshotFromEntries(wid, entries) {
         if (call && (call.phase === "running" || call.phase === "queued"))
             call.phase = "asking"; // a hibernated asker is fenced
     }
+    for (const c of calls.values())
+        if (c.hibernated && c.phase !== "asking")
+            delete c.hibernated;
     const usageOf = (callId) => sealedUsage.get(callId) ?? live.get(callId);
     const list = [...calls.values()];
     const counts = { queued: 0, running: 0, asking: 0, sealed: 0 };
@@ -197,6 +234,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 +251,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 +304,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"); }
@@ -283,10 +325,10 @@ export function compactWorkflow(wf) {
             const r = c.result, last = r?.output?.split("\n").map(l => l.trim()).filter(Boolean).at(-1);
             return { key: c.key, gen: c.gen, callId: c.callId, phase: c.phase, ...(r ? { status: r.status, ok: r.ok } : {}),
                 ...(c.model ? { model: c.model } : {}), ...(c.tools ? { tools: c.tools } : {}), ...(c.pending ? { pending: c.pending } : {}), ...(c.switching ? { switching: c.switching } : {}), ...(nonzero(c.usage) ? { usage: c.usage } : {}),
-                ...(last ? { lastLine: clip(last, 200) } : {}), ...(r?.error ? { error: clip(r.error, 300) } : {}) };
+                ...(last ? { lastLine: clip(last, 200) } : {}), ...(r?.error ? { error: clip(r.error, 300) } : {}), ...(c.hibernated ? { hibernated: true } : {}) };
         }),
         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 +348,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,17 +357,47 @@ 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)` } : {}) };
+        ...(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)` } : {}),
+        ...slotsView(home) };
 }
 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. */
 const latestCalls = (wf) => [...new Map(wf.calls.map(c => [c.key, c])).values()];
+/** Provider slots from the orchestrator ledger: holders per provider (hold/release{pool,slot,exec}) and the limits of
+ *  the settings in effect (the latest config{hash,config}); config-rejected after it is reported too. */
+export function slotsView(home, now = Date.now()) {
+    const held = new Map();
+    let config, rejected;
+    for (const e of readJournalSnapshot(orchLedger(home))) {
+        if (e.type === "hold")
+            held.set(`${e.pool}:${e.slot}`, e);
+        else if (e.type === "release" && held.get(`${e.pool}:${e.slot}`)?.exec === e.exec)
+            held.delete(`${e.pool}:${e.slot}`);
+        else if (e.type === "config") {
+            config = e;
+            rejected = undefined;
+        }
+        else if (e.type === "config-rejected")
+            rejected = e;
+    }
+    const limits = (config?.config?.providers) ?? {};
+    const holders = new Map();
+    for (const e of held.values())
+        if (e.pool !== "memory")
+            holders.set(String(e.pool), (holders.get(String(e.pool)) ?? 0) + 1);
+    const names = [...new Set([...Object.keys(limits), ...holders.keys()])].sort();
+    const slots = names.map(p => { const n = holders.get(p) ?? 0, limit = limits[p]?.slots; return typeof limit === "number" ? `${p} ${n}/${limit}` : `${p} ${n} (no limit)`; });
+    return { ...(slots.length ? { slots } : {}), ...(config ? { config: `${String(config.hash)} since ${age(now - config.ts)} ago` } : {}),
+        ...(rejected ? { configRejected: `${clip(String(rejected.error), 200)} (${age(now - rejected.ts)} ago); ${config ? String(config.hash) : "the start settings"} stay in effect` } : {}) };
+}
 /** Tool status without a wid: what runs, what waits for an answer and what failed, with finished workflows one line each.
  *  The full view (every call's last line and usage) ran to tens of thousands of tokens on a busy home. */
 export function statusBrief(home, options = {}) {
@@ -334,7 +406,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) => {
@@ -345,16 +417,18 @@ export function statusBrief(home, options = {}) {
                 ...(live && c.startedAt !== undefined ? { for: age(now - c.startedAt) } : {}),
                 ...(live && c.phase !== "asking" && quiet !== undefined && quiet >= 60_000 ? { quiet: age(quiet) } : {}),
                 ...(live && c.startedAt !== undefined ? { tokens: tokens(c.usage) } : {}),
-                ...(c.result ? { status: c.result.status, ...(c.result.error ? { error: clip(c.result.error, 200) } : {}) } : {}) };
+                ...(c.result ? { status: c.result.status, ...(c.result.error ? { error: clip(c.result.error, 200) } : {}) } : {}),
+                ...(c.hibernated ? { hibernated: true } : {}) };
         });
-        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 asking = open.filter(a => a.kind === "question" && a.call).map(a => ({ to: `${w.wid}/${callKey(a.call)}`, ...(a.qid ? { qid: a.qid } : {}),
+            ...(w.calls.some(c => c.callId === a.call && c.hibernated) ? { hibernated: true } : {}), 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"}` : "",
@@ -362,13 +436,13 @@ export function statusBrief(home, options = {}) {
     return {
         active: active.filter(mine).map(brief), ...(others.length ? { otherSessions: others.slice(0, 10).map(line) } : {}),
         finished: finished.slice(0, keep).map(line), ...(finished.length > keep ? { olderFinished: finished.length - keep } : {}),
-        ...(paused ? { paused } : {}),
+        ...(paused ? { paused } : {}), ...slotsView(home, now),
         hint: "status wid=<wid> shows one workflow (outputs clipped); add key=<key> for one call's full result, or full:true for everything",
     };
 }
 /** 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.7",
   "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",