pi-durable-subagents 1.0.2 → 1.0.4

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 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
+  subagent received it (for example, an orchestrator restart while the call
+  waited for a provider slot). It used to send only "Continue the task", and
+  the fresh subagent had to guess what the task was.
+
 ## 1.0.2
 
 The first published release (1.0.0 and 1.0.1 were prepared but never

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,25 +39,41 @@ 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;

package/dist/orchestrator/executor/index.js

@@ -625,12 +625,21 @@ export default function createExecutor(ledgers, options = {}) {
             const receipt = unresolved && entries.some(e => receiptId(e) === unresolved.rid2);
             const openingRid = t.opening && contentHash([t.opening.rid, "dispatch"]);
             const openingReceived = openingRid && entries.some(e => receiptId(e) === openingRid);
+            // The task has one identity: the dispatch of the call's first execution. A later execution continues only once
+            // the session holds that task; an execution interrupted before its child received it (still waiting for a
+            // provider slot, say) leaves a session without a task, and "continue" would ask a fresh model to guess.
+            const taskRid = contentHash([`${t.callId}#1.1`, "dispatch"]);
+            const taskReceived = !openingRid && entries.some(e => receiptId(e) === taskRid);
             if (openingRid && !openingReceived)
                 await sender.send(t.callId, "task", { message: t.opening.message }, undefined, { rid: openingRid });
+            else if (!openingRid && !taskReceived)
+                await sender.send(t.callId, "task", { message: t.spec.task }, undefined, { rid: taskRid });
             else if (unresolved && !receipt)
                 await sender.send(t.callId, "continue", { message: String(unresolved.message) }, { qid: String(unresolved.qid), rev: Number(unresolved.rev) }, { rid: String(unresolved.rid2) });
+            else if (previous)
+                await sender.send(t.callId, "continue", { message: `Continue the task. Tool calls whose outcomes are unknown: ${dangling.join(", ") || "none"}.` }, undefined, { rid: contentHash([exec, "dispatch"]) });
             else
-                await sender.send(t.callId, previous ? "continue" : "task", { message: previous ? `Continue the task. Tool calls whose outcomes are unknown: ${dangling.join(", ") || "none"}.` : t.opening?.message ?? t.spec.task }, undefined, { rid: contentHash([exec, "dispatch"]) });
+                await sender.send(t.callId, "task", { message: t.opening?.message ?? t.spec.task }, undefined, { rid: contentHash([exec, "dispatch"]) });
             if (interrupted(a)) {
                 await fence(journal, exec, { park: a });
                 return finish(journal, t.callId, exec, makeResult("stopped"));

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 };
 }

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,32 @@ 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 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);
+        });
+        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/package.json

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