pi-durable-subagents 1.0.4 → 1.0.6

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # 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
+  answer) and what failed, with finished workflows one line each; it used to
+  return every call's usage and last line (tens of thousands of tokens on a
+  busy home). With a wid, outputs are clipped; `key` gives one call's full
+  result and `full: true` the previous complete detail.
+- A run's rid (from `{submitted: {rid}}`) works wherever a wid is expected.
+- With `tasks` or `chain`, top-level `model`, `timeoutMs`, `budget`,
+  `isolation`, `context`, `tools`, `skills` and `once` are defaults for every
+  step; other fields there, or any call field beside a workflow script, are
+  refused instead of silently ignored. Invalid fields report the value
+  received.
+- A call that keeps running without producing output tokens or tool results
+  (for example, retrying against an exhausted provider) raises a
+  "no progress" alert after 10 minutes (`k.progressMs`), with the last
+  provider error. A call that ends on an explicit quota or billing error fails
+  at once with `Provider error: …` instead of being relaunched; other lost
+  executions report their last error.
+- Attention reaches the main agent with the call's address; a question says
+  how to answer it.
+- `resume` without a wid names workflows that other sessions hold paused.
+
 ## 1.0.4
 
 - The TUI no longer stalls pi with a long subagent history. Its 500 ms refresh

package/README.md

@@ -72,6 +72,16 @@ subagents({ action: "send", to: "<wid>/<key>", kind: "steer", message: "Don't to
 subagents({ action: "status" })
 ```
 
+`status` without a wid is brief: what runs, what asks (with the address to
+answer) or failed, and one line per finished workflow. `status` with a wid
+shows one workflow with outputs clipped; add `key` for one call's full result,
+or `full: true` for everything. When a run replies `{submitted: {rid}}`
+(its workflow was not created within 10 s), the rid works wherever a wid does.
+With `tasks` or `chain`, top-level `model`, `timeoutMs`, `budget`, `isolation`,
+`context`, `tools`, `skills` and `once` apply to every step that does not set
+its own; other call fields there, and any of them beside a workflow script,
+are refused rather than ignored.
+
 Every run is asynchronous. The agent is woken once, when the workflow
 finishes (the notice carries each subagent's result) or when a subagent asks
 it something. Each verb means one thing, and a refusal says what would work:
@@ -79,7 +89,7 @@ it something. Each verb means one thing, and a refusal says what would work:
 | Verb | Applies to | Effect |
 |---|---|---|
 | `run` | — | Start one subagent, `tasks` in parallel, a `chain`, or a workflow script. An unknown agent name is refused before anything starts, with the list of agents. |
-| `send steer` | a running subagent | Reaches it at its next safe point. To a finished one: refused, use `follow-up`. |
+| `send steer` | a running subagent | Reaches it at its next safe point. To a finished one: refused, use `follow-up`; To one waiting on its question: it interrupts the question, and the subagent usually asks again; `answer` answers it. |
 | `send follow-up` | a finished subagent | Continues the same session as a new generation (`key@2`). |
 | `send answer` | an open question | Answers it once. |
 | `send model` | any subagent | Switches its model at the next request. |

package/dist/agent/main/snapshots.js

@@ -78,6 +78,14 @@ export function attention(home, sender, seen) {
     }
     return items;
 }
+/** What the main agent reads for an attention item: the text, addressed. A question's own text named neither the asking
+ *  call nor how to answer it, so answers went out as steers or to the wrong id. */
+export function presentText(item) {
+    const call = item.call ? item.call.replace(/@\d+\/([^@/]+)@\d+$/, "/$1") : undefined, where = call ?? item.wid;
+    if (item.kind === "question" && call)
+        return `Question from ${call}${item.qid ? ` (qid ${item.qid})` : ""}; reply with send kind:"answer" to:"${call}": ${item.text}`;
+    return item.text.includes(item.wid) ? item.text : `${where}: ${item.text}`;
+}
 /** P15: Refresh a question against durable workflow and child receipts at request time. */
 export function resolved(home, item) {
     if (readJournalSnapshot(journalPath(home, item.wid)).some(e => e.type === JT.attentionResolved && e.id === item.id && e.rev === item.rev))

package/dist/agent/main/tool.js

@@ -16,7 +16,13 @@ export const parameters = Type.Object({
     replaces: Type.Optional(Type.Array(Type.String())), target: Type.Optional(Type.String()), wid: Type.Optional(Type.String()),
     usageBudget: Type.Optional(Type.Object({ tokens: Type.Optional(Type.Number()), costUsd: Type.Optional(Type.Number()) })),
     maxCalls: Type.Optional(Type.Integer({ minimum: 1 })), inputs: Type.Optional(Type.Record(Type.String(), Type.String())),
+    name: Type.Optional(Type.String()),
+    timeoutMs: Type.Optional(Type.Number({ description: "Per-call limit on active time in milliseconds (a number). Omit unless a hard limit is needed; prefer budgets." })),
+    key: Type.Optional(Type.String({ description: "A single agent/task run: the call's key. status with wid: that call's full result." })),
+    full: Type.Optional(Type.Boolean({ description: "status: with wid, the complete workflow detail including every output." })),
 }, { additionalProperties: true });
+/** Call fields a tasks/chain run applies to every step that does not set its own. */
+export const stepDefaults = ["model", "timeoutMs", "budget", "isolation", "context", "tools", "skills", "once"];
 function string(args, name) {
     if (typeof args[name] !== "string" || !args[name])
         throw new Error(`${name} is required`);
@@ -49,6 +55,18 @@ export function request(args, cwd) {
         // inputs, per-call cwd) resolve against it and calls default to it. It used to be ignored, so a relative
         // workflow path was looked up in the session's directory instead.
         const runCwd = choices[4] === undefined && typeof spec.cwd === "string" && spec.cwd ? resolve(cwd, spec.cwd) : cwd;
+        // Call fields beside a tasks/chain list are defaults for its steps; anything else beside a list or a script was
+        // silently dropped before (a top-level model or timeoutMs did nothing), so it is an error now.
+        const extra = choices[4] === undefined ? Object.keys(spec).filter(k => k !== "cwd" && spec[k] !== undefined) : [];
+        const fields = (keys) => keys.map(k => `"${k}"`).join(", ");
+        if (tasks !== undefined || chain !== undefined) {
+            const bad = extra.filter(k => !stepDefaults.includes(k));
+            if (bad.length)
+                throw new Error(`${fields(bad)} cannot be set for a whole ${tasks !== undefined ? "tasks" : "chain"} run; set ${bad.length > 1 ? "them" : "it"} in each step (run-level step defaults: ${stepDefaults.join(", ")})`);
+        }
+        else if (extra.length)
+            throw new Error(`${fields(extra)} cannot be set for a ${workflow !== undefined ? "workflow" : "source"} run; set ${extra.length > 1 ? "them" : "it"} in the script's runs.run(key, spec) calls`);
+        const defaults = Object.fromEntries(extra.map(k => [k, spec[k]]));
         const body = { cwd: runCwd };
         if (workflow !== undefined)
             body.workflow = resolve(runCwd, string(args, "workflow"));
@@ -59,7 +77,7 @@ export function request(args, cwd) {
             if (!Array.isArray(list) || !list.length)
                 throw new Error("tasks/chain must be nonempty");
             const kind = tasks !== undefined ? "tasks" : "chain";
-            body[kind] = list.map((value, i) => call(value, runCwd, `${kind}[${i}]`));
+            body[kind] = list.map((value, i) => call(value && typeof value === "object" && !Array.isArray(value) ? { ...defaults, ...value } : value, runCwd, `${kind}[${i}]`));
             compileFanout(kind === "tasks" ? { tasks: body.tasks } : { chain: body.chain }); // duplicate keys fail here, not at admission
         }
         else

package/dist/agent/main.js

@@ -11,8 +11,8 @@ import { reduceLifecycle } from "../kernel/lifecycle.js";
 import { OsLock } from "../platform/lock.js";
 import { dsaHome, orchInbox, orchLedger, orchLock, outboxRoot } from "../paths.js";
 import { CT, JT } from "../types.js";
-import { attention, presented, resolved, unfinishedWorkflow } from "./main/snapshots.js";
-import { statusDetail, statusView } from "../orchestrator/snapshot.js";
+import { attention, presentText, presented, resolved, unfinishedWorkflow } from "./main/snapshots.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;
@@ -61,7 +61,8 @@ export function registerMain(pi, ui) {
             if (entry.type === JT.created)
                 await outbox?.markResolved(String(entry.rid));
     }
-    function pendingOutbox() {
+    function pendingOutbox() { return pendingRids().size > 0; }
+    function pendingRids() {
         const pending = new Set();
         for (const entry of readJournalSnapshot(join(outboxRoot(home), "outbox", `${sender}.jsonl`))) {
             if (entry.type === "sent")
@@ -69,7 +70,7 @@ export function registerMain(pi, ui) {
             else if (entry.type === "resolved")
                 pending.delete(String(entry.rid));
         }
-        return pending.size > 0;
+        return pending;
     }
     async function starter(submitting = false) {
         if (stopped)
@@ -90,7 +91,7 @@ export function registerMain(pi, ui) {
     }
     function collect() { return ctx ? attention(home, sender, [...presented(ctx), ...reserved]) : []; }
     function message(items) {
-        return { type: "custom_message", customType: CT.attention, content: items.map(i => i.text).join("\n"), display: true, details: { items } };
+        return { type: "custom_message", customType: CT.attention, content: items.map(presentText).join("\n"), display: true, details: { items } };
     }
     async function idle() {
         if (stopped || !ctx?.isIdle())
@@ -164,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.` });
     });
@@ -175,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 }); });
             }
@@ -193,7 +194,7 @@ export function registerMain(pi, ui) {
             const items = msg.details?.items;
             if (!items)
                 return msg;
-            return { ...msg, content: items.map(item => resolved(home, item) ? `(resolved: ${item.text})` : item.text).join("\n") };
+            return { ...msg, content: items.map(item => resolved(home, item) ? `(resolved: ${presentText(item)})` : presentText(item)).join("\n") };
         }) }));
     /** P25, P38, T6, T10: One durable submission path for the tool and the UI; replies say what happened when known within 10 s. */
     /** v12 §2, §6: An answer finds its open question (qid, rev and target) from whatever the caller gave; a send without a
@@ -218,9 +219,39 @@ export function registerMain(pi, ui) {
         }
         return args;
     }
+    /** "<rid>" or "<rid>/<key>" of a created run → the same address with its wid; anything else is unchanged. */
+    function ridToWid(value) { return widOfRid(ledger(), value); }
+    /** A run request without a workflow yet (still pending, or rejected), asked about by its rid. */
+    function pendingRun(rid) {
+        const decision = decisions().get(rid);
+        if (decision?.type === "rejected")
+            throw new Error(`${rid} is a run request that was rejected: ${decision.reason}`);
+        if (pendingRids().has(rid))
+            return { submitted: { rid }, state: "pending: no workflow yet; its wid arrives with the next notice" };
+        return undefined;
+    }
+    /** A session's resume found nothing of its own: name the workflows other sessions hold, which need resume wid=<wid>. */
+    function resumeElsewhere(reason) {
+        if (reason !== "nothing-to-resume")
+            return reason;
+        const others = pausedElsewhere(home, sender);
+        return others.length ? `nothing-to-resume: nothing of this session is paused; paused in other sessions: ${others.slice(0, 8).join(", ")} — resume wid=<wid> continues one` : reason;
+    }
     async function submit(args, cwd, signal, wait = true) {
-        if (args.action === "status")
-            return typeof args.wid === "string" && args.wid ? statusDetail(home, args.wid) : statusView(home, { origin: sender });
+        // A run answers {submitted:{rid}} when its workflow is not created within 10 s; that rid then stands for the wid.
+        for (const field of ["wid", "to", "target"])
+            if (typeof args[field] === "string")
+                args = { ...args, [field]: ridToWid(args[field]) };
+        if (args.action === "status") {
+            if (typeof args.wid !== "string" || !args.wid)
+                return statusBrief(home, { origin: sender });
+            const pending = pendingRun(args.wid);
+            if (pending)
+                return pending;
+            if (typeof args.key === "string" && args.key)
+                return statusCallDetail(home, args.wid, args.key);
+            return args.full === true ? statusDetail(home, args.wid) : statusCompactDetail(home, args.wid);
+        }
         if (args.action === "agents")
             return agentsAt(cwd).map(({ name, description, model, source }) => ({ name, description, ...(model === undefined ? {} : { model }), source }));
         // A send addressed like a stop (target:) means the same call; the field name is not worth a failed round trip.
@@ -271,7 +302,7 @@ export function registerMain(pi, ui) {
                     return { wid: receipt.wid };
                 // The rid is returned so a later send can supersede this one (replaces: [rid]).
                 if (decision.type === "rejected")
-                    return { applied: false, reason: decision.reason, rid: sent.rid };
+                    return { applied: false, reason: sent.kind === "resume" && args.wid === undefined ? resumeElsewhere(String(decision.reason)) : decision.reason, rid: sent.rid };
                 if (sent.kind !== "run")
                     return { applied: true, rid: sent.rid };
             }
@@ -291,10 +322,10 @@ export function registerMain(pi, ui) {
     pi.registerTool(defineTool({
         name: "subagents", label: "Subagents", description: [
             "Durable asynchronous subagents; run returns {wid} when created (or {submitted:{rid}} while pending). A finished workflow (its notice carries every agent's result) or a question wakes you, so after starting work end your turn: never poll with sleep or repeated status. Crash recovery resumes sessions, not external side effects. Background helper processes (orchestrator, evaluator) exit by themselves about 10 s after all work ends: never kill processes or delete files to 'clean up'. When the user quits pi, this session's running workflows pause (nothing is spent); resume continues them.",
-            "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, model, cwd, timeoutMs, usageBudget, maxCalls, inputs. Explicit unknown agents are rejected BEFORE creation, with available names; unknown script agents fail only their call.",
+            "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); 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 [wid] gives a digest. revise wid + workflow/source/args starts a revision.",
+            "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.",
             "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/chaos/scenario.js

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { callSession, orchInbox } from "../../paths.js";
 import { scanInbox } from "../../kernel/mailbox.js";
 import { CT, JT } from "../../types.js";
+import { presentText } from "../../agent/main/snapshots.js";
 import { rows, script, stack, until } from "./stack.js";
 const tailOf = (path) => { try {
     return readFileSync(path, "utf8").slice(-600);
@@ -164,7 +165,7 @@ export async function scenario(n, root, env) {
                 for (const item of message.details?.items ?? []) {
                     const resolved = entries.some(e => e.type === JT.attentionResolved && e.id === item.id && e.rev === item.rev && e.ts <= observation.at) ||
                         (item.session && rows(item.session).some(e => e.message?.toolName === "ask" && e.message.details?.qid === item.qid && e.message.details?.rev === item.rev && Date.parse(e.timestamp) <= observation.at));
-                    check(!resolved || String(message.content).includes(`(resolved: ${item.text})`), `AC4 stale reminder ${item.id}@${item.rev}`);
+                    check(!resolved || String(message.content).includes(`(resolved: ${presentText(item)})`), `AC4 stale reminder ${item.id}@${item.rev}`);
                 }
             }
         return { scenario: n, passed: true, duplicateRuns: 0, lostResults: 0, restartedFromScratch: 0, wakes, presentations: attention.length, questions, evidence: root };

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/compat/spec.js

@@ -3,6 +3,8 @@ const fields = new Set(["agent", "task", "model", "cwd", "timeoutMs", "output",
 const isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
 const positive = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
 const text = (v) => typeof v === "string" && v.trim() !== "";
+/** The received value, clipped, so a rejected field says what was sent (e.g. a number sent as a string). */
+const got = (v) => { const s = typeof v === "number" ? String(v) : JSON.stringify(v) ?? String(v); return ` (got ${s.length > 60 ? `${s.slice(0, 60)}…` : s})`; };
 const unknown = (value, known, prefix = "") => Object.keys(value).filter(k => value[k] !== undefined && !known.includes(k)).map(k => `unknown field "${prefix}${k}"`);
 function gate(value) {
     if (typeof value === "string")
@@ -17,7 +19,7 @@ function gate(value) {
     if (value.schema !== undefined)
         errors.push(...schemaProblems(value.schema, "gate.schema"));
     if (value.timeoutMs !== undefined && !positive(value.timeoutMs))
-        errors.push("gate.timeoutMs must be a positive number");
+        errors.push(`gate.timeoutMs must be a positive number${got(value.timeoutMs)}`);
     return errors;
 }
 function budget(value) {
@@ -28,7 +30,7 @@ function budget(value) {
         errors.push("budget needs tokens or costUsd");
     for (const k of ["tokens", "costUsd"])
         if (value[k] !== undefined && !positive(value[k]))
-            errors.push(`budget.${k} must be a positive number`);
+            errors.push(`budget.${k} must be a positive number${got(value[k])}`);
     return errors;
 }
 /** P34, P24, T2/T3/T4: Validate a call spec at submission; `key` is accepted only for tasks/chain steps. Empty = valid. */
@@ -45,29 +47,29 @@ export function validateCallSpec(spec, options = {}) {
             errors.push("key is only allowed in tasks/chain steps");
     }
     if (!text(s.agent))
-        errors.push("agent must be a non-empty string");
+        errors.push(`agent must be a non-empty string${has("agent") ? got(s.agent) : ""}`);
     if (!text(s.task))
         errors.push("task must be a non-empty string");
     for (const k of ["model", "cwd", "output"])
         if (has(k) && typeof s[k] !== "string")
-            errors.push(`${k} must be a string`);
+            errors.push(`${k} must be a string${got(s[k])}`);
     if (has("timeoutMs") && !positive(s.timeoutMs))
-        errors.push("timeoutMs must be a positive number");
+        errors.push(`timeoutMs must be a positive number (milliseconds)${got(s.timeoutMs)}`);
     if (has("schema"))
         errors.push(...schemaProblems(s.schema, "schema"));
     if (has("gate"))
         errors.push(...gate(s.gate));
     if (has("isolation") && s.isolation !== "none" && s.isolation !== "worktree")
-        errors.push('isolation must be "none" or "worktree"');
+        errors.push(`isolation must be "none" or "worktree"${got(s.isolation)}`);
     if (has("context") && s.context !== "fresh" && s.context !== "fork")
-        errors.push('context must be "fresh" or "fork"');
+        errors.push(`context must be "fresh" or "fork"${got(s.context)}`);
     if (has("budget"))
         errors.push(...budget(s.budget));
     if (has("once") && typeof s.once !== "boolean")
-        errors.push("once must be a boolean");
+        errors.push(`once must be a boolean${got(s.once)}`);
     for (const k of ["tools", "skills"])
         if (has(k) && (!Array.isArray(s[k]) || !s[k].every(v => typeof v === "string")))
-            errors.push(`${k} must be an array of strings`);
+            errors.push(`${k} must be an array of strings${got(s[k])}`);
     if (options.fanout && has("key") && !text(s.key))
         errors.push("key must be a non-empty string");
     return errors;

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

@@ -22,7 +22,7 @@ import { buildCallResult } from "../../compat/result.js";
 import createEffects from "./effects/index.js";
 import { continueSession } from "./generation.js";
 import { hibernation, openQuestion } from "./hibernate.js";
-import { evidence, forgetSession, readSessionState, receiptId, sessionModel } from "./session.js";
+import { evidence, fatalProviderError, forgetSession, readSessionState, receiptId, sessionModel } from "./session.js";
 import { activeTotal } from "./time.js";
 import { observeExecution } from "./observe.js";
 import { availableMemory } from "./memory.js";
@@ -572,6 +572,8 @@ export default function createExecutor(ledgers, options = {}) {
                         return finish(journal, t.callId, exec, { ...makeResult("ok", ev.text), usage: ev.usage });
                     if (t.spec.once && dangling.length)
                         return finish(journal, t.callId, exec, makeResult("unknown", "", `Unknown tool outcomes: ${dangling.join(", ")}`));
+                    if (has(journal, "settled", exec) && !ev.text && ev.error && fatalProviderError(ev.error))
+                        return finish(journal, t.callId, exec, makeResult("failed", "", `Provider error: ${ev.error}`));
                     await serial(async () => {
                         if (!has(journal, "loss", exec))
                             await journal.append("loss", { exec });
@@ -579,7 +581,7 @@ export default function createExecutor(ledgers, options = {}) {
                     });
                     const losses = journal.entries().filter(e => e.type === "loss" && String(e.exec).startsWith(`${t.callId}#`)).length;
                     if (losses >= (config.k?.lossBound ?? 5))
-                        return finish(journal, t.callId, exec, makeResult("failed", "", `lost ×${losses}`));
+                        return finish(journal, t.callId, exec, makeResult("failed", "", `lost ×${losses}${ev.error ? `; last error: ${ev.error.slice(0, 300)}` : ""}`));
                     await release(exec);
                 }
             }

package/dist/orchestrator/executor/observe.js

@@ -15,6 +15,8 @@ import { observation, reached, sessionUsage, totalUsage } from "./usage.js";
 export async function observeExecution(d) {
     const { home, config, ticket: t, exec, child, serial } = d;
     const session = callSession(home, t.wid, t.key, t.gen), clock = new ActiveTime(), started = clock.last;
+    let progress = started, providerError;
+    const tools = new Set();
     const prior = activeTotal(t.journal.entries(), t.callId);
     let size = (await fileStat(session).catch(() => ({ size: 0 }))).size, checkpoint = performance.now();
     let signal;
@@ -47,7 +49,21 @@ export async function observeExecution(d) {
         if (open && fresh)
             await t.journal.append(JT.attentionResolved, { id, rev: last.rev, resolution: "activity" });
         else if (!open && !clock.asking && performance.now() - clock.last >= (config.k?.stallMs ?? 600000))
-            await t.journal.append(JT.attention, { exec, horizon: clock.last, item: { id, rev: (last?.rev ?? 0) + 1, kind: "stall", text: "No execution activity", wid: t.wid, call: t.callId } });
+            await t.journal.append(JT.attention, { exec, horizon: clock.last, item: { id, rev: (last?.rev ?? 0) + 1, kind: "stall", text: `${t.wid}/${t.key}: no execution activity for ${Math.floor((performance.now() - clock.last) / 60000)}m`, wid: t.wid, call: t.callId } });
+    });
+    const noProgress = () => serial(async () => {
+        const id = `noprogress:${t.callId}`;
+        const items = t.journal.entries().filter(e => e.type === JT.attention && e.item.id === id);
+        const last = items.at(-1)?.item;
+        const open = last && !t.journal.entries().some(e => e.type === JT.attentionResolved && e.id === id && e.rev === last.rev);
+        const fresh = items.at(-1)?.exec === exec ? progress > Number(items.at(-1)?.horizon) : progress > started;
+        if (open && fresh)
+            await t.journal.append(JT.attentionResolved, { id, rev: last.rev, resolution: "progress" });
+        else if (!open && !clock.asking && !tools.size && performance.now() - progress >= (config.k?.progressMs ?? 600000)) {
+            const text = `${t.wid}/${t.key}: running but no progress for ${Math.floor((performance.now() - progress) / 60000)}m (no output tokens or tool results)` +
+                (providerError ? `; last provider error: ${providerError.slice(0, 200)}` : "");
+            await t.journal.append(JT.attention, { exec, horizon: progress, item: { id, rev: (last?.rev ?? 0) + 1, kind: "stall", text, wid: t.wid, call: t.callId } });
+        }
     });
     child.stdin.on("error", () => { });
     // Diagnostics only (never evidence for decisions): keep the first 256 KiB of the child's stderr per call.
@@ -75,6 +91,19 @@ export async function observeExecution(d) {
         // P18: Apply RPC boundaries at receipt, before any in-flight scan can resume.
         // Durable observations remain queued; clock transitions never wait on I/O.
         clock.event(event, performance.now());
+        const message = event.message;
+        const error = event.type === "auto_retry_start" ? event.errorMessage : event.type === "auto_retry_end" ? event.finalError :
+            event.type === "message_end" && message?.stopReason === "error" ? message.errorMessage : undefined;
+        if (typeof error === "string" && error)
+            providerError = error;
+        if (event.type === "tool_execution_start")
+            tools.add(String(event.toolCallId ?? ""));
+        if (event.type === "tool_execution_end")
+            tools.delete(String(event.toolCallId ?? ""));
+        // Receipt-time progress is independent of RPC chatter, CPU and session growth; open tools suppress alerts.
+        if (event.type === "message_update" || ["tool_execution_start", "tool_execution_update", "tool_execution_end"].includes(String(event.type)) ||
+            event.type === "message_end" && message?.stopReason !== "error" && (message?.usage?.output ?? 0) > 0)
+            progress = performance.now();
         enqueue(async () => {
             const slim = observation(event);
             if (slim) {
@@ -86,6 +115,7 @@ export async function observeExecution(d) {
             }
             await limits();
             await stall();
+            await noProgress();
             if (event.type === "agent_settled") {
                 await serial(async () => { if (!has("settled"))
                     await t.journal.append("settled", { exec }); });
@@ -121,6 +151,7 @@ export async function observeExecution(d) {
                 await d.recordUsage(sessionUsage(entries, t.callId));
                 await limits();
                 await stall();
+                await noProgress();
                 if (performance.now() - checkpoint >= (config.k?.checkpointMs ?? 10000)) {
                     await saveTime();
                     checkpoint = performance.now();

package/dist/orchestrator/executor/session.js

@@ -103,7 +103,13 @@ export function evidence(entries, exec) {
             tools.delete(m.toolCallId);
     }
     const budget = segment.some(e => e.type === "custom" && e.customType === CT.budget && e.data?.exec === exec);
-    return { report, budget, text, dangling: [...tools].map(([id, name]) => `${name} (${id})`), usage };
+    const last = segment.findLast(e => e.message?.role === "assistant")?.message;
+    const error = last?.stopReason === "error" ? last.errorMessage : undefined;
+    return { report, budget, text, error, dangling: [...tools].map(([id, name]) => `${name} (${id})`), usage };
+}
+/** Only explicit quota/payment failures are terminal; rate limits, overload and transport errors still retry. */
+export function fatalProviderError(text) {
+    return /\b402\b|insufficient[_ ]?(quota|balance|funds)|quota (exceeded|exhausted)|billing|credit balance|额度|余额|usage limit/i.test(text);
 }
 /** P13, C8: Restore the effective provider from the native session's model changes. */
 export function sessionModel(entries) {

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) {
@@ -300,21 +319,111 @@ function origins(home) {
             ids.set(wid, undefined);
     return ids;
 }
-/** P25, T10: Compact status of all workflows: own session first, then newest first; finished ones beyond the first `keep` collapse into a count. */
-export function statusView(home, options = {}) {
-    const keep = options.keep ?? 10, own = (w) => Number(!!options.origin && w.origin === options.origin);
+/** Every workflow with its origin and hold, own session first, then newest first. */
+function snapshots(home, origin) {
+    const own = (w) => Number(!!origin && w.origin === 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 } : {}) };
+}
+/** P25, T10: Compact status of all workflows: own session first, then newest first; finished ones beyond the first `keep` collapse into a count. */
+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. */
+const latestCalls = (wf) => [...new Map(wf.calls.map(c => [c.key, c])).values()];
+/** 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 = {}) {
+    const keep = options.keep ?? 5, now = options.now ?? Date.now(), origin = options.origin;
+    const { all } = snapshots(home, origin);
+    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.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) => {
+        const p = progressOf(w), open = w.attention.filter(a => a.kind !== "finished");
+        const calls = latestCalls(w).filter(c => c.phase !== "sealed" || (c.result && !c.result.ok)).map((c) => {
+            const live = c.phase !== "sealed", quiet = c.lastActivity !== undefined ? now - c.lastActivity : undefined;
+            return { key: c.key, agent: c.agent, phase: c.phase, ...(c.model ? { model: c.model } : {}),
+                ...(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) } : {}) } : {}) };
+        });
+        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 } : {}), ...(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 => !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"}` : "",
+        heldOthers.length ? `${heldOthers.length} workflow${heldOthers.length > 1 ? "s" : ""} of other sessions paused (${heldOthers.slice(0, 8).map(w => w.wid).join(", ")}); resume wid=<wid> continues one` : ""].filter(Boolean).join("; ");
+    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 } : {}),
+        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 && !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. */
+export function widOfRid(ledger, value) {
+    const cut = value.indexOf("/"), head = cut < 0 ? value : value.slice(0, cut);
+    const created = head ? ledger.find(e => e.type === JT.created && e.rid === head) : undefined;
+    return created ? `${String(created.wid)}${value.slice(head.length)}` : value;
+}
+const OUTPUT = 600;
+/** Tool status with a wid: one workflow with each call's output clipped (the full detail repeated every output twice and
+ *  reached ~100K characters); `key` gives one call in full. */
+export function statusCompactDetail(home, wid) {
+    const detail = statusDetail(home, wid), compact = compactWorkflow(detail);
+    const byId = new Map(detail.calls.map(c => [c.callId, c]));
+    const calls = compact.calls.map(({ lastLine: _l, ...c }) => {
+        const full = byId.get(c.callId), output = full.result?.output?.trim();
+        return { ...c, agent: full.agent, ...(output ? { output: output.length > OUTPUT ? `${output.slice(0, OUTPUT)}… [${output.length - OUTPUT} more chars: status wid key=${c.key}]` : output } : {}) };
+    });
+    let result;
+    if (detail.result !== undefined) {
+        const json = JSON.stringify(detail.result) ?? "";
+        result = json.length <= 2000 ? detail.result : `${json.slice(0, 2000)}… [${json.length - 2000} more chars: status wid full:true]`;
+    }
+    return { ...compact, ...(detail.cwd ? { cwd: detail.cwd } : {}), ...(detail.scriptLog ? { scriptLog: detail.scriptLog } : {}),
+        ...(result !== undefined ? { result } : {}), calls, hint: "key=<key> gives one call's full result; full:true gives everything" };
+}
+/** Tool status with a wid and key: that call's latest generation in full (result, usage, sends). */
+export function statusCallDetail(home, wid, key) {
+    const detail = statusDetail(home, wid);
+    const call = detail.calls.findLast(c => c.key === key || c.callId === key || `${c.key}@${c.gen}` === key);
+    if (!call)
+        throw new Error(`No call "${key}" in ${wid}; calls: ${[...new Set(detail.calls.map(c => c.key))].join(", ")}`);
+    return { wid, ...call };
+}
 /** P25, T10: One workflow in full detail (results, outputs, script log path) but without raw journal entries. */
 export function statusDetail(home, wid) {
     const origin = origins(home);

package/dist/ui/cards.js

@@ -61,7 +61,8 @@ export function registerCards(pi, home) {
         let last;
         const draw = (width) => items.flatMap(item => {
             const h = HEAD[item.kind] ?? HEAD.unknown, closed = item.kind === "question" && isResolved(item);
-            const heading = `${h.icon} ${item.kind === "finished" && !item.call ? "Workflow" : `Subagent ${keyOf(item)}`} ${closed ? "— answered" : h.title}`;
+            const title = item.kind === "stall" && item.id.startsWith("noprogress:") ? "no progress" : h.title;
+            const heading = `${h.icon} ${item.kind === "finished" && !item.call ? "Workflow" : `Subagent ${keyOf(item)}`} ${closed ? "— answered" : title}`;
             // v12 §3: a finished digest is first line + dim per-agent lines, clipped; old single-line items read exactly as before.
             const inner = Math.max(1, Math.max(3, Math.floor(width)) - 4);
             const body = item.kind === "finished" && !closed

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

@@ -30,6 +30,10 @@ export function callLine(args) {
 /** UI §5: The collapsed result: started / applied / rejected, or one line per workflow for status. */
 export function resultLines(details) {
     const d = (details ?? {});
+    if (typeof d.wid === "string" && typeof d.key === "string" && typeof d.phase === "string") {
+        const r = d.result;
+        return [`${d.key} · ${r?.status ?? d.phase}${typeof d.model === "string" ? ` · ${d.model}` : ""}`];
+    }
     if (typeof d.wid === "string" && !Array.isArray(d.calls))
         return [`started workflow ${d.wid}`, ...(typeof d.paused === "string" ? [`⚠ ${d.paused}`] : [])];
     if (d.applied === true)
@@ -43,6 +47,15 @@ export function resultLines(details) {
         const asks = (w.attention ?? []).filter(a => a.kind === "question").length;
         return `${w.name ?? short(w.wid)} · ${w.status} · ${done}/${w.calls.length} done${failed ? ` · ${failed} not ok` : ""}${asks ? ` · ${asks} asking` : ""}`;
     };
+    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.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"]),
+            ...(rows.length > 6 ? [`… ${rows.length - 6} more`] : []), ...(finished ? [`${finished} finished`] : [])];
+    }
     if (Array.isArray(d.workflows)) {
         const rows = d.workflows.map(row);
         return [...(typeof d.paused === "string" ? [`⚠ ${d.paused}`] : []), ...(rows.length ? rows.slice(0, 6) : ["no workflows"]), ...(rows.length > 6 ? [`… ${rows.length - 6} more`] : [])];

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) {
@@ -72,8 +72,8 @@ export function plainReason(reason) {
         return `that subagent already finished${detail}`;
     if (code === "finished")
         return `that subagent already finished${detail}; use f to follow up`;
-    if (r === "nothing-to-resume")
-        return "nothing is paused, so there is nothing to resume";
+    if (code === "nothing-to-resume")
+        return `nothing of this session is paused, so there is nothing to resume${r.includes("other sessions") ? `; ${r.slice(r.indexOf("paused in other sessions")).split(" — ")[0]}` : ""}`;
     if (code === "not-parked")
         return "it is already running";
     if (r === "already-answered" || r === "stale-question")
@@ -117,6 +117,10 @@ export function statusPhrase(call, workflow, facts, now) {
     const question = workflow.attention.find(a => a.kind === "question" && a.call === call.callId);
     if (question)
         return `asking main agent: ${question.text}`;
+    const noProgress = workflow.attention.find(a => a.kind === "stall" && a.call === call.callId && a.id.startsWith("noprogress:"));
+    // The alert's duration measures progress, whereas lastActivity also advances on provider retries.
+    if (noProgress)
+        return /no progress for [^(;]+/.exec(noProgress.text)?.[0].trim() ?? "no progress";
     if (workflow.attention.some(a => a.kind === "stall" && a.call === call.callId))
         return `no activity for ${duration(now - Math.max(call.lastActivity ?? call.startedAt ?? now, facts?.lastActivity ?? 0))}`;
     if (call.phase === "queued")
@@ -142,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(" · ");
@@ -165,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)
@@ -184,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))] : [];
     }
@@ -213,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) {
@@ -221,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));
     }
 }
@@ -263,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)
@@ -281,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.4",
+  "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",