pi-durable-subagents 1.0.3 → 1.0.5

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## 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
+  re-read and re-derived every historical call's session and scanned journals
+  once per call, taking over a second per refresh with a few hundred finished
+  calls; it now reuses per-call facts and a journal index (about 5 ms).
+- Main-session polling, attention cards and transcript cards reuse derived
+  state per journal and per width instead of rescanning the session every
+  200 ms, so typing stays responsive in long sessions.
+- Faster startup: thinking summaries no longer use a regex that went
+  quadratic on long unpunctuated thoughts (200 KB took 43 s), and finished
+  calls' sessions are read when first shown or in small idle slices rather
+  than all at startup.
+
 ## 1.0.3
 
 - Recovery delivers a call's task when an earlier execution ended before its

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

@@ -1,7 +1,6 @@
 import { readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { readJournalSnapshot } from "../../kernel/journal.js";
-import { singlePresentation } from "../../kernel/guards.js";
 import { journalPath, orchLedger } from "../../paths.js";
 import { CT, JT } from "../../types.js";
 import { holdOf } from "../../orchestrator/snapshot.js";
@@ -20,9 +19,13 @@ export function workflows(home) {
     }
     const pruned = new Set(ledger.filter(e => e.type === "pruned").map(e => String(e.wid)));
     const ids = new Set([...ledger.filter(e => e.type === JT.created).map(e => String(e.wid)), ...names].filter(wid => !pruned.has(wid)));
+    const createdBy = new Map();
+    for (const e of ledger)
+        if (e.type === JT.created && !createdBy.has(e.wid))
+            createdBy.set(e.wid, e);
     return [...ids].sort().map(wid => {
         const entries = readJournalSnapshot(journalPath(home, wid));
-        const created = ledger.find(e => e.type === JT.created && e.wid === wid) ?? entries.find(e => e.type === JT.created);
+        const created = createdBy.get(wid) ?? entries.find(e => e.type === JT.created);
         return { wid, origin: created?.origin, entries };
     });
 }
@@ -36,29 +39,53 @@ export function unfinishedWorkflow(home) {
     const ledger = readJournalSnapshot(orchLedger(home));
     return workflows(home).some(w => (!w.entries.some(e => e.type === JT.done) || openGeneration(w.entries)) && !holdOf(ledger, w.wid, w.origin));
 }
-/** P15, V7: Rebuild session-wide receipts, including entries hidden by compaction. */
+const receipts = new WeakMap();
+const receiptsOf = (entry) => entry.type === "custom_message" && entry.customType === CT.attention
+    ? entry.details?.items ?? [] : [];
 export function presented(ctx) {
-    return ctx.sessionManager.getEntries().flatMap(entry => entry.type === "custom_message" && entry.customType === CT.attention
-        ? entry.details?.items ?? [] : []);
+    // The main session is append-only between session switches: scan only the entries added since the last poll.
+    const entries = ctx.sessionManager.getEntries();
+    const owner = ctx.sessionManager, prior = receipts.get(owner);
+    const appended = prior && prior.length <= entries.length && prior.first === entries[0] && prior.last === entries[prior.length - 1];
+    const items = appended ? prior.items.concat(entries.slice(prior.length).flatMap(receiptsOf)) : entries.flatMap(receiptsOf);
+    receipts.set(owner, { first: entries[0], last: entries.at(-1), length: entries.length, items });
+    return items;
+}
+const open = new WeakMap();
+/** The unresolved attention items of one immutable journal snapshot, computed once per snapshot. */
+function unresolved(entries) {
+    let items = open.get(entries);
+    if (items)
+        return items;
+    const done = new Set(entries.filter(e => e.type === JT.attentionResolved).map(e => `${e.id}\0${e.rev}`));
+    items = entries.filter(e => e.type === JT.attention).map(e => e.item).filter(item => !done.has(`${item.id}\0${item.rev}`));
+    open.set(entries, items);
+    return items;
 }
 /** P15, V7: Select only unresolved, unpresented items owned by this session. */
 export function attention(home, sender, seen) {
-    const items = [];
+    const items = [], shown = new Set(seen.map(s => `${s.id}\0${s.rev}`));
     for (const workflow of workflows(home)) {
         if (workflow.origin !== sender)
             continue;
-        for (const entry of workflow.entries) {
-            if (entry.type !== JT.attention)
-                continue;
-            const item = entry.item;
-            if (workflow.entries.some(e => e.type === JT.attentionResolved && e.id === item.id && e.rev === item.rev))
-                continue;
-            if (singlePresentation({ presented: [...seen, ...items] }, item))
-                items.push(item);
+        for (const item of unresolved(workflow.entries)) {
+            const key = `${item.id}\0${item.rev}`;
+            if (shown.has(key))
+                continue; // singlePresentation: one presentation per id/rev
+            shown.add(key);
+            items.push(item);
         }
     }
     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 { 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())
@@ -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/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/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

@@ -214,8 +214,14 @@ export function snapshotFromEntries(wid, entries) {
     };
 }
 /** P25: Snapshot one workflow from its durable journal (v12 §4: plus the planned total of its pinned run body). */
+// A journal snapshot is immutable and replaced on every append, so its derived workflow snapshot is reused until then:
+// re-deriving every historical workflow on each UI refresh dominated pi's main thread.
+const derived = new WeakMap();
 export function workflowSnapshot(home, wid) {
-    const wf = snapshotFromEntries(wid, readJournalSnapshot(journalPath(home, wid)));
+    const entries = readJournalSnapshot(journalPath(home, wid)), hit = derived.get(entries);
+    const wf = hit?.wid === wid ? hit.snapshot : snapshotFromEntries(wid, entries);
+    if (hit?.wid !== wid && entries.length)
+        derived.set(entries, { wid, snapshot: wf });
     const planned = plannedTotal(home, wid, wf.rev);
     return planned === undefined ? wf : { ...wf, planned };
 }
@@ -294,14 +300,20 @@ 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;
     }).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 hidden = all.length - shown.length;
@@ -309,6 +321,88 @@ export function statusView(home, options = {}) {
     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"];
+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.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 } : {}),
+            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 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 && !FINAL.includes(w.status)).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

@@ -33,13 +33,20 @@ export function card(theme, tone, heading, body, width, expanded = false) {
 /** P15, P16: Register renderers for attention presentations and watch-view notes in the main session. */
 export function registerCards(pi, home) {
     const done = new Set(); // resolution is monotone: once resolved, never re-read
+    // pi renders every visible message on each frame; an open question re-reads its child session at most once a second.
+    const checked = new Map();
     const isResolved = (item) => {
         const id = `${item.id}@${item.rev}`;
         if (done.has(id))
             return true;
+        const now = Date.now();
+        if (now - (checked.get(id) ?? -Infinity) < 1000)
+            return false;
+        checked.set(id, now);
         try {
             if (resolved(home, item)) {
                 done.add(id);
+                checked.delete(id);
                 return true;
             }
         }
@@ -50,19 +57,33 @@ export function registerCards(pi, home) {
         const items = message.details?.items;
         if (!items?.length)
             return undefined;
-        return { invalidate() { }, render: (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}`;
-                // 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
-                    ? digestLines(item.text, line => theme.fg("dim", line), inner)
-                    : [closed ? theme.fg("dim", item.text) : item.text];
-                return card(theme, closed ? "muted" : h.tone, heading, body, width, options.expanded);
-            }) };
+        // The lines depend only on width, expansion, theme and which questions are answered: reuse them across frames.
+        let last;
+        const draw = (width) => items.flatMap(item => {
+            const h = HEAD[item.kind] ?? HEAD.unknown, closed = item.kind === "question" && isResolved(item);
+            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
+                ? digestLines(item.text, line => theme.fg("dim", line), inner)
+                : [closed ? theme.fg("dim", item.text) : item.text];
+            return card(theme, closed ? "muted" : h.tone, heading, body, width, options.expanded);
+        });
+        return { invalidate() { last = undefined; }, render: (width) => {
+                const key = `${width}|${items.map(item => item.kind === "question" && isResolved(item) ? 1 : 0).join("")}`;
+                if (last?.key !== key)
+                    last = { key, lines: draw(width) };
+                return last.lines;
+            } };
     });
     pi.registerMessageRenderer(CT.note, (message, options, theme) => {
         const text = typeof message.content === "string" ? message.content : "";
-        return { invalidate() { }, render: (width) => card(theme, "muted", "you, in the subagent view", text.split("\n"), width, options.expanded) };
+        let last;
+        return { invalidate() { last = undefined; }, render: (width) => {
+                if (last?.width !== width)
+                    last = { width, lines: card(theme, "muted", "you, in the subagent view", text.split("\n"), width, options.expanded) };
+                return last.lines;
+            } };
     });
 }

package/dist/ui/data.js

@@ -16,9 +16,38 @@ function readLive(path) {
         return undefined;
     }
 }
+const indexes = new WeakMap();
+/** The last call proposal per key/gen and the last loss and launch per execution, built once per journal snapshot
+ *  instead of scanning the whole journal for every call on every refresh. */
+function journalIndex(journal) {
+    const hit = indexes.get(journal);
+    if (hit && hit.length === journal.length)
+        return hit;
+    const index = { length: journal.length, calls: new Map(), losses: new Map(), execs: new Map() };
+    journal.forEach((e, i) => {
+        if (e.type === "call")
+            index.calls.set(`${e.key}\0${e.gen}`, e);
+        else if (e.type === "loss")
+            index.losses.set(String(e.exec), i);
+        else if (e.type === JT.exec)
+            index.execs.set(String(e.exec), i);
+    });
+    indexes.set(journal, index);
+    return index;
+}
+/** A map whose missing entries are produced on first `get`/`has`; iteration and `size` cover only produced entries. */
+export class LazyMap extends Map {
+    produce;
+    constructor(produce) { super(); this.produce = produce; }
+    put(key, value) { super.set(key, value); }
+    get(key) { if (!super.has(key))
+        this.produce(key); return super.get(key); }
+    has(key) { return this.get(key) !== undefined; }
+}
 /** A1, P25: Read the UI's data from durable workflow snapshots and native session tails only. */
 export class UiData {
     workflows = [];
+    /** Facts and session branch per call id; a finished call's are read on first `get` (see refresh). */
     facts = new Map();
     sessions = new Map();
     aliases = {};
@@ -26,36 +55,67 @@ export class UiData {
     dock = "auto";
     /** Where the dock sits: below the editor (default; never splits an editor header such as a powerline bar) or above. */
     dockAt = "above";
+    /** Per-refresh budget (ms) for reading not yet read finished sessions (history) in the background. */
+    warmMs = 15;
     tails = new Map();
+    /** Branch and facts per call, reused while its session tail is unchanged: a finished call's session never grows, and
+     *  re-deriving every historical call on each refresh blocked pi's main thread for over a second. */
+    derived = new Map();
     home;
     constructor(home) { this.home = home; }
     refresh() {
-        const workflows = allWorkflows(this.home), facts = new Map(), sessions = new Map();
+        const workflows = allWorkflows(this.home), known = new Set(), deferred = new Map();
+        const facts = new LazyMap(key => deferred.get(key)?.()), sessions = new LazyMap(key => deferred.get(key)?.());
         for (const w of workflows) {
-            const journal = readJournalSnapshot(journalPath(this.home, w.wid));
+            const index = journalIndex(readJournalSnapshot(journalPath(this.home, w.wid)));
             for (const c of w.calls) {
-                let tail = this.tails.get(c.callId);
-                if (!tail) {
-                    tail = new SessionTail();
-                    this.tails.set(c.callId, tail);
-                }
-                const entries = sessionBranch(tail.read(callSession(this.home, w.wid, c.key, c.gen)));
-                const value = sessionFacts(entries, c.callId);
-                const proposal = journal.findLast(e => e.type === "call" && e.key === c.key && e.gen === c.gen);
-                value.task ||= String(proposal?.spec?.task ?? "");
-                const loss = journal.findLastIndex(e => e.type === "loss" && e.exec === c.exec);
-                const launch = journal.findLastIndex(e => e.type === JT.exec && e.exec === c.exec);
-                if (c.phase !== "sealed" && loss > launch)
-                    value.activity = "connection dropped, retrying";
-                if (c.phase !== "sealed")
-                    value.live = readLive(join(callDir(this.home, w.wid, c.key, c.gen), LIVE_FILE));
-                sessions.set(c.callId, entries);
-                facts.set(c.callId, value);
+                known.add(c.callId);
+                const load = () => {
+                    deferred.delete(c.callId);
+                    let tail = this.tails.get(c.callId);
+                    if (!tail) {
+                        tail = new SessionTail();
+                        this.tails.set(c.callId, tail);
+                    }
+                    const source = tail.read(callSession(this.home, w.wid, c.key, c.gen));
+                    let cached = this.derived.get(c.callId);
+                    if (!cached || cached.source !== source || cached.length !== source.length) {
+                        const entries = sessionBranch(source);
+                        cached = { source, length: source.length, entries, facts: sessionFacts(entries, c.callId) };
+                        this.derived.set(c.callId, cached);
+                    }
+                    const value = { ...cached.facts, live: undefined };
+                    const proposal = index.calls.get(`${c.key}\0${c.gen}`);
+                    value.task ||= String(proposal?.spec?.task ?? "");
+                    const loss = index.losses.get(String(c.exec)) ?? -1;
+                    const launch = index.execs.get(String(c.exec)) ?? -1;
+                    if (c.phase !== "sealed" && loss > launch)
+                        value.activity = "connection dropped, retrying";
+                    if (c.phase !== "sealed")
+                        value.live = readLive(join(callDir(this.home, w.wid, c.key, c.gen), LIVE_FILE));
+                    sessions.put(c.callId, cached.entries);
+                    facts.put(c.callId, value);
+                };
+                // A finished call never read before (history at startup) is read when first shown or by the idle warm-up below;
+                // reading every historical session up front blocked pi's startup for seconds.
+                if (c.phase === "sealed" && !this.tails.has(c.callId))
+                    deferred.set(c.callId, load);
+                else
+                    load();
             }
         }
         for (const key of this.tails.keys())
-            if (!sessions.has(key))
+            if (!known.has(key)) {
                 this.tails.delete(key);
+                this.derived.delete(key);
+            }
+        // Warm the history a slice at a time, so opening the list later finds it read without one long stall now.
+        const until = performance.now() + this.warmMs;
+        for (const load of [...deferred.values()]) {
+            if (performance.now() >= until)
+                break;
+            load();
+        }
         this.workflows = workflows;
         this.facts = facts;
         this.sessions = sessions;

package/dist/ui/session.js

@@ -84,7 +84,22 @@ export function thoughtSummary(text) {
     const headings = [...text.matchAll(/\*\*([^*\n]+)\*\*|^#{1,6}\s+(.+)$/gm)];
     if (headings.length)
         return (headings.at(-1)[1] ?? headings.at(-1)[2]).trim();
-    return text.match(/[^.!?。！？]+[.!?。！？](?=\s|$)/gu)?.at(-1)?.trim() ?? "";
+    return lastSentence(text);
+}
+const STOPS = new Set([...".!?。！？"]);
+/** The last match of /[^.!?。！？]+[.!?。！？](?=\s|$)/gu without the regex: a long thought with no sentence end made
+ *  that regex retry from every position (quadratic), which stalled pi's startup on long histories. Such a match is a
+ *  whole run of non-stop characters followed by one stop that ends the text or precedes whitespace. */
+function lastSentence(text) {
+    for (let end = text.length - 1; end > 0; end--) {
+        if (!STOPS.has(text[end]) || STOPS.has(text[end - 1]) || (end + 1 < text.length && !/\s/u.test(String.fromCodePoint(text.codePointAt(end + 1)))))
+            continue;
+        let start = end - 1;
+        while (start > 0 && !STOPS.has(text[start - 1]))
+            start--;
+        return text.slice(start, end + 1).trim();
+    }
+    return "";
 }
 /** UI §2–3, P31: Derive model, thinking, tool activity and the call's own tool-call count solely from committed session entries. */
 export function sessionFacts(entries, call) {

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.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

@@ -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")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-durable-subagents",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "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",