pi-durable-subagents 1.0.7 → 1.0.9

package/dist/orchestrator/snapshot.js

@@ -67,17 +67,16 @@ function callKey(call) {
 export function refusedResult(key, reason) {
     return { key, gen: 0, status: "failed", ok: false, error: reason === "spawn-budget" ? "spawn budget exceeded" : String(reason), output: "" };
 }
-export function snapshotFromEntries(wid, entries) {
+function snapshotReducer(wid, entries) {
     const created = entries.find(e => e.type === "wf-created");
     const rev = Math.max(1, ...entries.filter(e => e.type === "wf-created" || e.type === "revised").map(e => Number(e.revision) || 1));
     const boundary = entries.findLastIndex(e => e.type === "revised");
     const current = entries.slice(Math.max(0, boundary));
-    const terminal = current.findLast(e => e.type === JT.done || (e.type === "resumed" && !e.call));
-    const done = terminal?.type === JT.done ? terminal : undefined;
+    let terminal = current.findLast(e => e.type === JT.done || (e.type === "resumed" && !e.call));
     const calls = new Map();
     const byExec = new Map();
     const hibernating = new Map(); // callId → exec that decided to hibernate and is not fenced yet
-    const resolved = new Set(entries.filter(e => e.type === JT.attentionResolved).map(e => `${e.id}@${e.rev}`));
+    const resolved = new Set();
     const generations = new Set(), retired = new Set();
     const attention = [];
     // P31: usage per call id, deduplicated by message id; a seal carries the authoritative total.
@@ -85,191 +84,285 @@ export function snapshotFromEntries(wid, entries) {
     const tools = new Map();
     // P7, P27: forward / forward-delivered / forward-retired, by destination call; retirements carry only rid2.
     const sends = new Map(), byRid2 = new Map();
-    for (const e of entries) {
-        if (["call", "generation", "refused", "reused"].includes(e.type)) {
-            if (boundary >= 0 && e.seq < entries[boundary].seq)
-                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;
-            calls.set(callId, { key, gen, callId, pos: Number(e.pos), agent: String(e.spec?.agent ?? ""),
-                // Until a slot is acquired (`selected`), show the model the call asked for, not nothing.
-                ...(typeof wanted === "string" && wanted ? { model: wanted } : {}),
-                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)
-                continue;
-            // An execution waits for a provider slot and memory before it launches; it is running once `selected` says so
-            // (otherwise a call still waiting for a slot reads "thinking · 2m").
-            call.exec = String(e.exec);
-            call.phase = "queued";
-            call.startedAt ??= e.ts;
-            call.lastActivity = e.ts;
-            byExec.set(call.exec, call);
-            delete call.hibernated;
-            hibernating.delete(call.callId);
-        }
-        else if (e.type === "hibernated") {
-            // The decision to hibernate precedes the fence; the slot is released only once the execution is fenced.
-            const call = calls.get(String(e.call));
-            if (call?.exec && call.exec === e.exec)
-                hibernating.set(call.callId, call.exec);
-        }
-        else if (e.type === "answer-bound" || (e.type === "resumed" && e.call)) {
-            const call = calls.get(String(e.call));
-            if (call) {
-                delete call.hibernated;
-                hibernating.delete(call.callId);
+    function apply(batch, from = 0) {
+        for (let i = from; i < batch.length; i++) {
+            const e = batch[i];
+            if (i >= boundary && (e.type === JT.done || (e.type === "resumed" && !e.call)))
+                terminal = e;
+            if (e.type === JT.attentionResolved)
+                resolved.add(`${e.id}@${e.rev}`);
+            if (["call", "generation", "refused", "reused"].includes(e.type)) {
+                if (boundary >= 0 && e.seq < entries[boundary].seq)
+                    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;
+                calls.set(callId, { key, gen, callId, pos: Number(e.pos), agent: String(e.spec?.agent ?? ""),
+                    // Until a slot is acquired (`selected`), show the model the call asked for, not nothing.
+                    ...(typeof wanted === "string" && wanted ? { model: wanted } : {}),
+                    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 === JT.fenced) {
-            // A fenced execution without a seal (stop-all, a quit pi, a loss before its continuation) waits to run again.
-            const call = byExec.get(String(e.exec));
-            if (call && call.phase === "running")
+            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)
+                    continue;
+                // An execution waits for a provider slot and memory before it launches; it is running once `selected` says so
+                // (otherwise a call still waiting for a slot reads "thinking · 2m").
+                call.exec = String(e.exec);
                 call.phase = "queued";
-            if (call && hibernating.get(call.callId) === e.exec)
-                call.hibernated = true;
-        }
-        else if (e.type === "selected") {
-            const call = byExec.get(String(e.exec)), m = e.model;
-            if (call && m)
-                call.model = m.provider ? `${m.provider}/${m.id}` : m.id;
-            if (call && call.phase === "queued")
-                call.phase = "running";
-        }
-        else if (e.type === "observation") {
-            // Only what the agent did counts as activity; tracker scans and time checkpoints are bookkeeping.
-            const call = byExec.get(String(e.exec));
-            if (call)
+                call.startedAt ??= e.ts;
                 call.lastActivity = e.ts;
-            if (call && e.type === "observation" && e.event?.type === "tool_execution_start")
-                tools.set(call.callId, (tools.get(call.callId) ?? 0) + 1);
-        }
-        else if (e.type === "usage") {
-            const id = `${e.call}:${e.id}`, u = e.usage;
-            if (seen.has(id) || !u)
-                continue;
-            seen.add(id);
-            const total = live.get(String(e.call)) ?? zero();
-            total.input += u.input;
-            total.output += u.output;
-            total.costUsd += u.costUsd;
-            live.set(String(e.call), total);
-        }
-        else if (e.type === JT.sealed) {
-            const usage = e.result?.usage;
-            if (usage)
-                sealedUsage.set(String(e.call), usage);
-            const call = calls.get(String(e.call));
-            if (!call)
-                continue;
-            call.phase = "sealed";
-            call.result = e.result;
-            call.endedAt = e.ts;
-            delete call.hibernated;
-            hibernating.delete(call.callId);
-        }
-        else if (e.type === JT.attention) {
-            const item = e.item;
-            if (!resolved.has(`${item.id}@${item.rev}`))
+                byExec.set(call.exec, call);
+                delete call.hibernated;
+                hibernating.delete(call.callId);
+            }
+            else if (e.type === "hibernated") {
+                // The decision to hibernate precedes the fence; the slot is released only once the execution is fenced.
+                const call = calls.get(String(e.call));
+                if (call?.exec && call.exec === e.exec)
+                    hibernating.set(call.callId, call.exec);
+            }
+            else if (e.type === "answer-bound" || (e.type === "resumed" && e.call)) {
+                const call = calls.get(String(e.call));
+                if (call) {
+                    delete call.hibernated;
+                    hibernating.delete(call.callId);
+                }
+            }
+            else if (e.type === JT.fenced) {
+                // A fenced execution without a seal (stop-all, a quit pi, a loss before its continuation) waits to run again.
+                const call = byExec.get(String(e.exec));
+                if (call && call.phase === "running")
+                    call.phase = "queued";
+                if (call && hibernating.get(call.callId) === e.exec)
+                    call.hibernated = true;
+            }
+            else if (e.type === "selected") {
+                const call = byExec.get(String(e.exec)), m = e.model;
+                if (call && m)
+                    call.model = m.provider ? `${m.provider}/${m.id}` : m.id;
+                if (call && call.phase === "queued")
+                    call.phase = "running";
+            }
+            else if (e.type === "model-used") {
+                // Evidence of a switch: the execution answered with another model than it launched with.
+                const call = byExec.get(String(e.exec)), m = e.model;
+                if (call && m)
+                    call.model = m.provider ? `${m.provider}/${m.id}` : m.id;
+            }
+            else if (e.type === "observation") {
+                // Only what the agent did counts as activity; tracker scans and time checkpoints are bookkeeping.
+                const call = byExec.get(String(e.exec));
+                if (call)
+                    call.lastActivity = e.ts;
+                if (call && e.type === "observation" && e.event?.type === "tool_execution_start")
+                    tools.set(call.callId, (tools.get(call.callId) ?? 0) + 1);
+            }
+            else if (e.type === "usage") {
+                const id = `${e.call}:${e.id}`, u = e.usage;
+                if (seen.has(id) || !u)
+                    continue;
+                seen.add(id);
+                const total = live.get(String(e.call)) ?? zero();
+                total.input += u.input;
+                total.output += u.output;
+                total.costUsd += u.costUsd;
+                live.set(String(e.call), total);
+            }
+            else if (e.type === JT.sealed) {
+                const usage = e.result?.usage;
+                if (usage)
+                    sealedUsage.set(String(e.call), usage);
+                const call = calls.get(String(e.call));
+                if (!call)
+                    continue;
+                call.phase = "sealed";
+                call.result = e.result;
+                call.endedAt = e.ts;
+                delete call.hibernated;
+                hibernating.delete(call.callId);
+            }
+            else if (e.type === JT.attention) {
+                const item = e.item;
                 attention.push(item);
+            }
+            else if (e.type === "forward") {
+                const envelope = e.envelope;
+                const send = { rid: String(e.rid), kind: String(envelope?.kind ?? ""), state: "pending", at: e.ts,
+                    ...(envelope?.kind === "model" && envelope.body?.provider ? { model: `${envelope.body.provider}/${envelope.body.model}` } : {}) };
+                const list = sends.get(String(e.dest)) ?? [];
+                list.push(send);
+                sends.set(String(e.dest), list);
+                // A withdrawn model request no longer stands (the executor ignores it for the next launch as well).
+                if (envelope?.kind === "withdraw")
+                    for (const rid2 of envelope.body?.rids ?? []) {
+                        const target = byRid2.get(`${e.dest}\n${rid2}`);
+                        if (target?.kind === "model" && target.state === "pending")
+                            target.reason = "withdrawn";
+                    }
+                byRid2.set(`${e.dest}\n${e.rid2}`, send);
+                byRid2.set(String(e.rid2), send);
+            }
+            else if (e.type === "forward-delivered" || e.type === "forward-retired") {
+                const send = byRid2.get(e.type === "forward-delivered" ? `${e.call}\n${e.rid2}` : String(e.rid2));
+                if (!send || send.state !== "pending")
+                    continue;
+                send.state = e.type === "forward-delivered" ? "delivered" : "retired";
+                send.at = e.ts;
+                if (e.type === "forward-delivered" && e.reason !== undefined)
+                    send.reason = String(e.reason);
+            }
         }
-        else if (e.type === "forward") {
-            const envelope = e.envelope;
-            const send = { rid: String(e.rid), kind: String(envelope?.kind ?? ""), state: "pending", at: e.ts,
-                ...(envelope?.kind === "model" && envelope.body?.provider ? { model: `${envelope.body.provider}/${envelope.body.model}` } : {}) };
-            const list = sends.get(String(e.dest)) ?? [];
-            list.push(send);
-            sends.set(String(e.dest), list);
-            byRid2.set(`${e.dest}\n${e.rid2}`, send);
-            byRid2.set(String(e.rid2), send);
+    }
+    apply(entries);
+    function finish() {
+        const done = terminal?.type === JT.done ? terminal : undefined;
+        // Finish owns every exposed object; UI decoration and consumers cannot alter reducer history.
+        const list = structuredClone([...calls.values()]);
+        const openAttention = structuredClone(attention.filter(item => !resolved.has(`${item.id}@${item.rev}`)));
+        for (const item of openAttention) {
+            const call = item.kind === "question" ? list.find(c => item.id.startsWith(`q:${c.callId}:`)) : undefined;
+            if (call && (call.phase === "running" || call.phase === "queued"))
+                call.phase = "asking"; // a hibernated asker is fenced
         }
-        else if (e.type === "forward-delivered" || e.type === "forward-retired") {
-            const send = byRid2.get(e.type === "forward-delivered" ? `${e.call}\n${e.rid2}` : String(e.rid2));
-            if (!send || send.state !== "pending")
-                continue;
-            send.state = e.type === "forward-delivered" ? "delivered" : "retired";
-            send.at = e.ts;
-            if (e.type === "forward-delivered" && e.reason !== undefined)
-                send.reason = String(e.reason);
+        for (const c of list)
+            if (c.hibernated && c.phase !== "asking")
+                delete c.hibernated;
+        const usageOf = (callId) => sealedUsage.get(callId) ?? live.get(callId);
+        const counts = { queued: 0, running: 0, asking: 0, sealed: 0 };
+        for (const c of list) {
+            counts[c.phase]++;
+            const usage = usageOf(c.callId);
+            if (usage)
+                c.usage = { ...usage };
+            const n = tools.get(c.callId);
+            if (n)
+                c.tools = n;
+            const forwarded = sends.get(c.callId);
+            if (forwarded) {
+                c.sends = structuredClone(forwarded);
+                const pending = forwarded.filter(pendingMessage).length;
+                if (pending)
+                    c.pending = pending;
+                const last = c.phase !== "sealed" && !retired.has(c.callId) ? forwarded.findLast(s => s.kind === "model" && s.reason !== "withdrawn") : undefined;
+                if (last?.reason !== undefined)
+                    c.switchFailed = `${last.model} (${last.reason})`;
+                else if (last && last.state !== "retired" && last.model !== c.model?.replace(/:(off|minimal|low|medium|high|xhigh|max)$/, ""))
+                    c.switching = last.model;
+            }
         }
-    }
-    for (const item of attention) {
-        const call = item.kind === "question" ? [...calls.values()].find(c => item.id.startsWith(`q:${c.callId}:`)) : undefined;
-        if (call && (call.phase === "running" || call.phase === "queued"))
-            call.phase = "asking"; // a hibernated asker is fenced
-    }
-    for (const c of calls.values())
-        if (c.hibernated && c.phase !== "asking")
-            delete c.hibernated;
-    const usageOf = (callId) => sealedUsage.get(callId) ?? live.get(callId);
-    const list = [...calls.values()];
-    const counts = { queued: 0, running: 0, asking: 0, sealed: 0 };
-    for (const c of list) {
-        counts[c.phase]++;
-        const usage = usageOf(c.callId);
-        if (usage)
-            c.usage = { ...usage };
-        const n = tools.get(c.callId);
-        if (n)
-            c.tools = n;
-        const forwarded = sends.get(c.callId);
-        if (forwarded) {
-            c.sends = forwarded;
-            const pending = forwarded.filter(pendingMessage).length;
-            if (pending)
-                c.pending = pending;
-            const switching = c.phase !== "sealed" ? forwarded.findLast(s => s.kind === "model" && s.state === "pending")?.model : undefined;
-            if (switching && switching !== c.model?.replace(/:(off|minimal|low|medium|high|xhigh|max)$/, ""))
-                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);
+            usage.input += u.input;
+            usage.output += u.output;
+            usage.costUsd += u.costUsd;
         }
+        return {
+            wid, rev, ...(typeof created?.name === "string" ? { name: created.name } : {}),
+            ...(created ? { origin: String(created.origin), cwd: String(created.cwd), startedAt: created.ts } : {}),
+            status: done ? done.status : "running",
+            ...(done?.error ? { error: String(done.error) } : {}), ...(done && "result" in done ? { result: structuredClone(done.result) } : {}),
+            ...(done ? { endedAt: done.ts } : {}),
+            ...(followUps ? { followUps } : {}),
+            calls: list, counts, attention: openAttention, usage,
+        };
     }
-    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);
-        usage.input += u.input;
-        usage.output += u.output;
-        usage.costUsd += u.costUsd;
-    }
-    return {
-        wid, rev, ...(typeof created?.name === "string" ? { name: created.name } : {}),
-        ...(created ? { origin: String(created.origin), cwd: String(created.cwd), startedAt: created.ts } : {}),
-        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,
-    };
+    // Only the current revision's reuse looks ahead for a seal (entries before the boundary are skipped).
+    return { apply, finish, hasReuse: current.some(e => e.type === "reused") };
+}
+export function snapshotFromEntries(wid, entries) {
+    return snapshotReducer(wid, entries).finish();
 }
 /** 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 FOLDS = 256; // workflows whose fold state is kept; pruned and long-idle ones fall out
+const folds = new Map();
 const derived = new WeakMap();
 export function workflowSnapshot(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 path = journalPath(home, wid), entries = readJournalSnapshot(path), hit = derived.get(entries);
+    let wf;
+    if (hit?.wid === wid)
+        wf = hit.snapshot;
+    else {
+        const prior = folds.get(path);
+        // The journal reader preserves entry identity only when extending the same committed prefix.
+        const prefix = prior?.wid === wid && entries.length >= prior.length &&
+            (prior.length === 0 || entries[prior.length - 1] === prior.last);
+        let reusable = prefix;
+        if (reusable)
+            for (let i = prior.length; i < entries.length; i++) {
+                const e = entries[i];
+                // Revisions change earlier call identities/boundaries. Reuse looks ahead for the first seal.
+                if (e.type === "revised" || e.type === "wf-created" || e.type === "reused" ||
+                    (prior.reducer.hasReuse && e.type === JT.sealed)) {
+                    reusable = false;
+                    break;
+                }
+            }
+        const reducer = reusable ? prior.reducer : snapshotReducer(wid, entries);
+        if (reusable)
+            reducer.apply(entries, prior.length);
+        wf = reducer.finish();
+        if (entries.length) {
+            folds.delete(path);
+            folds.set(path, { wid, length: entries.length, last: entries.at(-1), reducer }); // least recently folded first
+            if (folds.size > FOLDS)
+                folds.delete(folds.keys().next().value);
+            derived.set(entries, { wid, snapshot: wf });
+        }
+        else
+            folds.delete(path);
+    }
     const planned = plannedTotal(home, wid, wf.rev);
     return planned === undefined ? wf : { ...wf, planned };
 }
 /** Ops: wids archived by `prune` (orchestrator ledger `pruned{wid}`); they no longer exist for any reader. */
 function prunedIds(home) {
-    return new Set(readJournalSnapshot(orchLedger(home)).filter(e => e.type === "pruned").map(e => String(e.wid)));
+    return ledgerIndex(readJournalSnapshot(orchLedger(home))).pruned;
+}
+const ledgerIndexes = new WeakMap();
+export function ledgerIndex(ledger) {
+    let ix = ledgerIndexes.get(ledger);
+    if (!ix || ix.length > ledger.length || (ix.length && ledger[ix.length - 1] !== ix.last)) {
+        ix = { length: 0, created: new Map(), pruned: new Set(), byWid: new Map(), byOrigin: new Map() };
+        ledgerIndexes.set(ledger, ix);
+    }
+    for (let i = ix.length; i < ledger.length; i++) {
+        const e = ledger[i];
+        if (e.type === JT.created) {
+            if (!ix.created.has(e.wid))
+                ix.created.set(e.wid, e);
+        }
+        else if (e.type === "pruned")
+            ix.pruned.add(String(e.wid));
+        else if (e.type === "drain" || e.type === "undrain") {
+            if (e.type === "drain")
+                ix.lastDrain = i;
+            if (e.wid === undefined && e.origin === undefined)
+                ix.global = i;
+            if (e.wid !== undefined)
+                ix.byWid.set(e.wid, i);
+            if (e.origin !== undefined)
+                ix.byOrigin.set(e.origin, i);
+        }
+    }
+    ix.length = ledger.length;
+    ix.last = ledger[ledger.length - 1];
+    return ix;
 }
 function workflowIds(home) {
     let wids = [];
@@ -286,19 +379,21 @@ function workflowIds(home) {
 /** Drain: the one hold rule. drain/undrain entries apply to every workflow (no scope), one session's (`origin`) or one
  *  workflow (`wid`). A workflow is held when the newest entry that applies to it is a drain recorded after it was created. */
 export function holdOf(ledger, wid, origin) {
-    const applies = (e) => (e.wid === undefined && e.origin === undefined) || e.wid === wid || (origin !== undefined && e.origin === origin);
-    const last = ledger.findLast(e => (e.type === "drain" || e.type === "undrain") && applies(e));
+    // The newest applicable entry is the newest of the newest unscoped, the newest for this wid and the newest for its origin.
+    const ix = ledgerIndex(ledger);
+    const at = Math.max(ix.global ?? -1, ix.byWid.get(wid) ?? -1, origin !== undefined ? ix.byOrigin.get(origin) ?? -1 : -1);
+    const last = at >= 0 ? ledger[at] : undefined;
     if (last?.type !== "drain")
         return undefined;
-    const created = ledger.find(e => e.type === JT.created && e.wid === wid);
+    const created = ix.created.get(wid);
     return !created || created.seq < last.seq ? last : undefined;
 }
 /** Drain: the workflows a drain (stop-all, a quit pi) holds until resume, and since when. */
 export function heldWorkflows(home) {
-    const ledger = readJournalSnapshot(orchLedger(home));
-    const origin = (wid) => ledger.find(e => e.type === JT.created && e.wid === wid)?.origin;
+    const ledger = readJournalSnapshot(orchLedger(home)), ix = ledgerIndex(ledger);
+    const origin = (wid) => ix.created.get(wid)?.origin;
     const hold = (wid) => holdOf(ledger, wid, origin(wid));
-    const since = ledger.filter(e => e.type === "drain").at(-1)?.ts;
+    const since = ix.lastDrain !== undefined ? ledger[ix.lastDrain].ts : undefined;
     return { ...(since !== undefined ? { since } : {}), held: wid => hold(wid) !== undefined };
 }
 /** P25: Snapshot every workflow under DSA_HOME (newest first by wid, which is a ULID); `paused` marks work a drain holds. */
@@ -324,7 +419,7 @@ export function compactWorkflow(wf) {
         calls: wf.calls.map(c => {
             const r = c.result, last = r?.output?.split("\n").map(l => l.trim()).filter(Boolean).at(-1);
             return { key: c.key, gen: c.gen, callId: c.callId, phase: c.phase, ...(r ? { status: r.status, ok: r.ok } : {}),
-                ...(c.model ? { model: c.model } : {}), ...(c.tools ? { tools: c.tools } : {}), ...(c.pending ? { pending: c.pending } : {}), ...(c.switching ? { switching: c.switching } : {}), ...(nonzero(c.usage) ? { usage: c.usage } : {}),
+                ...(c.model ? { model: c.model } : {}), ...(c.tools ? { tools: c.tools } : {}), ...(c.pending ? { pending: c.pending } : {}), ...(c.switching ? { switching: c.switching } : {}), ...(c.switchFailed ? { switchFailed: c.switchFailed } : {}), ...(nonzero(c.usage) ? { usage: c.usage } : {}),
                 ...(last ? { lastLine: clip(last, 200) } : {}), ...(r?.error ? { error: clip(r.error, 300) } : {}), ...(c.hibernated ? { hibernated: true } : {}) };
         }),
         attention: wf.attention.map(a => ({ id: a.id, rev: a.rev, kind: a.kind, text: clip(a.text, 300), ...(a.call ? { call: a.call } : {}), ...(a.qid ? { qid: a.qid } : {}) })),
@@ -418,7 +513,8 @@ export function statusBrief(home, options = {}) {
                 ...(live && c.phase !== "asking" && quiet !== undefined && quiet >= 60_000 ? { quiet: age(quiet) } : {}),
                 ...(live && c.startedAt !== undefined ? { tokens: tokens(c.usage) } : {}),
                 ...(c.result ? { status: c.result.status, ...(c.result.error ? { error: clip(c.result.error, 200) } : {}) } : {}),
-                ...(c.hibernated ? { hibernated: true } : {}) };
+                ...(c.hibernated ? { hibernated: true } : {}),
+                ...(live && c.switching ? { switching: c.switching } : {}), ...(live && c.switchFailed ? { switchFailed: c.switchFailed } : {}) };
         });
         const asking = open.filter(a => a.kind === "question" && a.call).map(a => ({ to: `${w.wid}/${callKey(a.call)}`, ...(a.qid ? { qid: a.qid } : {}),
             ...(w.calls.some(c => c.callId === a.call && c.hibernated) ? { hibernated: true } : {}), question: clip(a.text, 300) }));

package/dist/ui/data.js

@@ -44,6 +44,10 @@ export class LazyMap extends Map {
         this.produce(key); return super.get(key); }
     has(key) { return this.get(key) !== undefined; }
 }
+/** How long after its seal a call's session is still followed. A sealed execution has been fenced, so its session is
+ *  final: a follow-up or a revision runs as a new generation with its own session. A session changed after that (by
+ *  hand) shows in a new pi session only. */
+const FINAL_MS = 10_000;
 /** A1, P25: Read the UI's data from durable workflow snapshots and native session tails only. */
 export class UiData {
     workflows = [];
@@ -56,8 +60,21 @@ export class UiData {
     /** 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;
+    warmMs = 8;
     tails = new Map();
+    /** Facts of calls sealed more than FINAL_MS ago, read once after their seal; their transcript is read when shown. */
+    final = new Map();
+    /** The transcript of one final call last asked for (the open call view asks on every frame). Keeping every
+     *  historical transcript parsed held hundreds of MB and made pi's garbage collection pause typing. */
+    opened;
+    transcript(callId, sessions) {
+        const final = this.final.get(callId);
+        if (!final)
+            return;
+        if (this.opened?.callId !== callId || this.opened.endedAt !== final.endedAt)
+            this.opened = { callId, endedAt: final.endedAt, entries: sessionBranch(new SessionTail().read(final.path)) };
+        sessions.put(callId, this.opened.entries);
+    }
     /** 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();
@@ -65,11 +82,20 @@ export class UiData {
     constructor(home) { this.home = home; }
     refresh() {
         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)?.());
+        const facts = new LazyMap(key => deferred.get(key)?.());
+        const sessions = new LazyMap(key => deferred.has(key) ? deferred.get(key)() : this.transcript(key, sessions));
         for (const w of workflows) {
-            const index = journalIndex(readJournalSnapshot(journalPath(this.home, w.wid)));
+            let index; // only calls still followed need it
+            const journal = () => index ??= journalIndex(readJournalSnapshot(journalPath(this.home, w.wid)));
             for (const c of w.calls) {
                 known.add(c.callId);
+                const final = this.final.get(c.callId);
+                if (final && c.phase === "sealed" && c.endedAt === final.endedAt) {
+                    facts.put(c.callId, final.facts);
+                    continue;
+                }
+                if (final)
+                    this.final.delete(c.callId);
                 const load = () => {
                     deferred.delete(c.callId);
                     let tail = this.tails.get(c.callId);
@@ -85,16 +111,23 @@ export class UiData {
                         this.derived.set(c.callId, cached);
                     }
                     const value = { ...cached.facts, live: undefined };
-                    const proposal = index.calls.get(`${c.key}\0${c.gen}`);
+                    const proposal = journal().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;
+                    const loss = journal().losses.get(String(c.exec)) ?? -1;
+                    const launch = journal().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 call sealed a while ago writes nothing more (a follow-up opens a new generation and session), so its
+                    // session is not stat'ed again: polling every historical session twice a second kept pi's main thread busy.
+                    if (c.phase === "sealed" && c.endedAt !== undefined && Date.now() - c.endedAt > FINAL_MS) {
+                        this.final.set(c.callId, { endedAt: c.endedAt, path: callSession(this.home, w.wid, c.key, c.gen), facts: value });
+                        this.tails.delete(c.callId);
+                        this.derived.delete(c.callId);
+                    }
                 };
                 // 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.
@@ -109,6 +142,9 @@ export class UiData {
                 this.tails.delete(key);
                 this.derived.delete(key);
             }
+        for (const key of this.final.keys())
+            if (!known.has(key))
+                this.final.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()]) {

package/dist/ui/screen.js

@@ -565,7 +565,7 @@ export class SubagentScreen {
         const facts = this.data.facts.get(c.callId), active = w.calls.filter(c => c.phase !== "sealed"), done = w.calls.length - active.length;
         const tabs = size.width < 60 ? `${c.key} ${w.calls.indexOf(c) + 1}/${w.calls.length}` : `${[...active.map(c => c.key), ...(done ? [`${done} done`] : [])].join(" · ")}    ← → switch`;
         const tools = toolCount(facts?.tools), pending = pendingText(c.pending), rule = this.theme.fg("borderMuted", "─".repeat(size.width));
-        const switching = c.switching ? ` → ${this.name(c.switching)} (at the end of this step)` : "";
+        const switching = c.switching ? ` → ${this.name(c.switching)} (requested)` : "";
         const head = [tabs, `${label(c)} · ${this.name(facts?.model ?? c.model)} ▾${switching} · ${facts?.thinking ?? "off"} ▾${tools ? ` · ${tools}` : ""}${pending ? ` · ${pending}` : ""}`,
             this.theme.fg("dim", this.spend(c, facts)), rule];
         const asking = w.attention.some(a => a.kind === "question" && a.call === c.callId);