pi-durable-subagents 1.0.16 → 1.0.17

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 1.0.17
+
+- A silent subagent shows one warning instead of separate activity and
+  progress warnings. The message now says that no new output or tool
+  progress has been received and that the model may still be processing;
+  the ten-minute thresholds are unchanged.
+- Warning cards update in place to `recovered` when activity resumes, or
+  `ended` when the execution ends. They refresh even when the status line
+  does not change or the dock is turned off.
+- Execution checkpoints and warnings record the latest received stream
+  update's time and type for diagnosis, without recording its content.
+
 ## 1.0.16
 
 - A used-up usage window is found while pi is still retrying: at the second

package/dist/agent/main/snapshots.js

@@ -107,11 +107,15 @@ const resolutions = new WeakMap();
 function resolvedIn(entries) {
     let done = resolutions.get(entries);
     if (!done) {
-        done = new Set(entries.filter(e => e.type === JT.attentionResolved).map(e => JSON.stringify([e.id, e.rev])));
+        done = new Map(entries.filter(e => e.type === JT.attentionResolved).map(e => [JSON.stringify([e.id, e.rev]), typeof e.resolution === "string" ? e.resolution : "resolved"]));
         resolutions.set(entries, done);
     }
     return done;
 }
+/** Preserve the reason so presentation distinguishes resumed output from a terminated execution. */
+export function attentionResolution(home, item) {
+    return resolvedIn(readJournalSnapshot(journalPath(home, item.wid))).get(JSON.stringify([item.id, item.rev]));
+}
 const asks = new Map(), ASK_SCANS = 64, MARK = 64;
 function ask(scan, line) {
     if (!line.includes('"ask"'))
@@ -189,7 +193,7 @@ function answeredAsks(path) {
 }
 /** P15: Refresh a question against durable workflow and child receipts at request time. */
 export function resolved(home, item) {
-    if (resolvedIn(readJournalSnapshot(journalPath(home, item.wid))).has(JSON.stringify([item.id, item.rev])))
+    if (attentionResolution(home, item) !== undefined)
         return true;
     if (item.kind !== "question" || !item.session || !item.qid)
         return false;

package/dist/orchestrator/executor/observe.js

@@ -23,6 +23,8 @@ 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;
+    // Diagnostic metadata only: checkpoint the latest received stream update, never its content.
+    let lastStream;
     const tools = new Set();
     // The tool calls running now, for the stall text: a silent long command and a stuck call read differently.
     const running = new Map();
@@ -38,7 +40,7 @@ export async function observeExecution(d) {
         const previous = t.journal.entries().findLast(e => e.type === "time" && e.exec === exec);
         if (!monotoneTime({ active: Number(previous?.active ?? 0) }, { active: clock.active }))
             throw new Error("Nonmonotone active time");
-        await t.journal.append("time", { exec, active: clock.active });
+        await t.journal.append("time", { exec, active: clock.active, ...(lastStream ? { lastStream } : {}) });
     });
     const limits = async () => {
         if (t.spec.timeoutMs !== undefined && prior + clock.active >= t.spec.timeoutMs) {
@@ -49,6 +51,11 @@ export async function observeExecution(d) {
         if (reached(totalUsage(t.journal.entries(), t.callId), t.spec.budget))
             signal();
     };
+    const openAlert = (id) => {
+        const last = attentionEntries(t.journal.entries(), id).at(-1)?.item;
+        return last && !t.journal.entries().some(e => e.type === JT.attentionResolved && e.id === id && e.rev === last.rev);
+    };
+    const progressDue = () => !clock.asking && !tools.size && performance.now() - progress >= (config.k?.progressMs ?? 600000);
     const stall = () => serial(async () => {
         const id = `stall:${t.callId}`;
         const items = attentionEntries(t.journal.entries(), id), last = items.at(-1)?.item;
@@ -56,8 +63,8 @@ export async function observeExecution(d) {
         const fresh = items.at(-1)?.exec === exec ? clock.last > Number(items.at(-1)?.horizon) : clock.last > started;
         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: `${t.wid}/${t.key}: no execution activity for ${Math.floor((performance.now() - clock.last) / 60000)}m` + runningText(), wid: t.wid, call: t.callId } });
+        else if (!open && !clock.asking && !progressDue() && !openAlert(`noprogress:${t.callId}`) && performance.now() - clock.last >= (config.k?.stallMs ?? 600000))
+            await t.journal.append(JT.attention, { exec, horizon: clock.last, ...(lastStream ? { lastStream } : {}), item: { id, rev: (last?.rev ?? 0) + 1, kind: "stall", text: `${t.wid}/${t.key}: no execution activity observed for ${Math.floor((performance.now() - clock.last) / 60000)}m` + runningText(), wid: t.wid, call: t.callId } });
     });
     /** "; running bash `make matrix` for 14m (no output or CPU use seen)": a silent long command, not a stuck model. */
     const runningText = () => {
@@ -73,10 +80,10 @@ export async function observeExecution(d) {
         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)` +
+        else if (!open && progressDue() && !openAlert(`stall:${t.callId}`)) {
+            const text = `${t.wid}/${t.key}: no new output or tool progress received for ${Math.floor((performance.now() - progress) / 60000)}m; the model may still be processing` +
                 (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 } });
+            await t.journal.append(JT.attention, { exec, horizon: progress, ...(lastStream ? { lastStream } : {}), item: { id, rev: (last?.rev ?? 0) + 1, kind: "stall", text, wid: t.wid, call: t.callId } });
         }
     });
     child.stdin.on("error", () => { });
@@ -105,6 +112,10 @@ 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());
+        if (event.type === "message_update") {
+            const type = event.assistantMessageEvent?.type;
+            lastStream = { type: typeof type === "string" && /^(thinking|text|toolcall)_(start|delta|end)$/.test(type) ? type : "message_update", receivedAt: Date.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;

package/dist/ui/cards.js

@@ -1,6 +1,6 @@
 import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { CT } from "../types.js";
-import { resolved } from "../agent/main/snapshots.js";
+import { attentionResolution, resolved } from "../agent/main/snapshots.js";
 const HEAD = {
     question: { icon: "?", title: "asks the main agent", tone: "accent" },
     finished: { icon: "✓", title: "finished", tone: "success" },
@@ -33,37 +33,48 @@ 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 pending = new Map();
+    const done = new Map(); // resolution is monotone: once resolved, never re-read
+    // pi renders every visible message on each frame; open cards re-read receipts 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 resolution = (item) => {
+        if (item.kind !== "question" && item.kind !== "stall")
+            return undefined;
+        const id = `${item.wid}:${item.id}@${item.rev}`;
+        if (done.has(id)) {
+            pending.delete(id);
+            return done.get(id);
+        }
         const now = Date.now();
         if (now - (checked.get(id) ?? -Infinity) < 1000)
-            return false;
+            return undefined;
         checked.set(id, now);
         try {
-            if (resolved(home, item)) {
-                done.add(id);
+            const reason = item.kind === "question" ? (resolved(home, item) ? "answered" : undefined) : attentionResolution(home, item);
+            if (reason) {
+                done.set(id, reason);
                 checked.delete(id);
-                return true;
+                pending.delete(id);
+                return reason;
             }
         }
         catch { /* display only */ }
-        return false;
+        return undefined;
     };
     pi.registerMessageRenderer(CT.attention, (message, options, theme) => {
         const items = message.details?.items;
         if (!items?.length)
             return undefined;
-        // The lines depend only on width, expansion, theme and which questions are answered: reuse them across frames.
+        for (const item of items)
+            if (item.kind === "stall" || item.kind === "question")
+                pending.set(`${item.wid}:${item.id}@${item.rev}`, item);
+        // Reuse lines until width, theme, expansion or an attention resolution changes.
         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}`;
+            const h = HEAD[item.kind] ?? HEAD.unknown, reason = resolution(item), closed = !!reason;
+            const title = item.kind === "stall" && item.id.startsWith("noprogress:") ? "awaiting progress" : h.title;
+            const status = item.kind === "question" ? "answered" : reason === "activity" || reason === "progress" ? "recovered" : reason === "ended" || reason === "retired" ? "ended" : "resolved";
+            const heading = `${closed ? "✓" : h.icon} ${item.kind === "finished" && !item.call ? "Workflow" : `Subagent ${keyOf(item)}`} ${closed ? `— ${status}` : 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
@@ -72,7 +83,7 @@ export function registerCards(pi, home) {
             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("")}`;
+                const key = `${width}|${items.map(item => resolution(item) ?? "").join("|")}`;
                 if (last?.key !== key)
                     last = { key, lines: draw(width) };
                 return last.lines;
@@ -87,4 +98,11 @@ export function registerCards(pi, home) {
                 return last.lines;
             } };
     });
+    // The existing UI refresh loop repaints receipts even when dock text did not change.
+    return () => {
+        const before = done.size;
+        for (const item of pending.values())
+            resolution(item);
+        return done.size !== before;
+    };
 }

package/dist/ui/index.js

@@ -7,8 +7,7 @@ import { registerCards } from "./cards.js";
 import { toolRenderers } from "./tool.js";
 /** UI §1–3, P16, P21: Register journal-backed list/watch surfaces only in interactive pi. */
 export function registerUi(pi, deps) {
-    if (typeof pi.registerMessageRenderer === "function")
-        registerCards(pi, deps.home); // P21: cards are optional
+    const refreshCards = typeof pi.registerMessageRenderer === "function" ? registerCards(pi, deps.home) : () => false; // P21: cards are optional
     // UI §5: compact tool calls and results (optional surface; without it pi shows the raw JSON).
     if (typeof pi.registerToolRenderer === "function")
         pi.registerToolRenderer((name, next) => {
@@ -38,7 +37,7 @@ export function registerUi(pi, deps) {
         const state = { folded: new Set(), done: new Map(), viewed: new Set(), finished: false };
         let screen, opening = false, stopped = false, closeScreen;
         let unsubscribe, timer;
-        let dockRows = () => [], dockAt = null, dockTui, lastDock = "";
+        let dockRows = () => [], dockAt = null, lastDock = "";
         // ↓ opens the list only from pi's own input editor. Another surface — /model's selector, a dialog, another
         // extension's overlay — has the focus instead, and its ↓ belongs to it. pi's editor (and any editor built on
         // CustomEditor) carries the app action map; the TUI comes from the dock widget, so without a dock the check
@@ -86,11 +85,9 @@ export function registerUi(pi, deps) {
                 const at = dock === "off" ? undefined : data.dockAt;
                 if (at !== dockAt) {
                     dockAt = at;
-                    dockTui = undefined;
                     // With the dock off, an empty widget below the editor still lends the TUI to the ↓ focus check; pi adds no
                     // spacer for it, so it takes no line.
                     ctx.ui.setWidget("durable-subagents", !at ? tui => { keysTui = tui; return { invalidate() { }, render: () => [] }; } : (tui, theme) => {
-                        dockTui = tui;
                         keysTui = tui;
                         return {
                             invalidate() { },
@@ -106,9 +103,10 @@ export function registerUi(pi, deps) {
                     }, { placement: at === "above" ? "aboveEditor" : "belowEditor" });
                 }
                 const shown = dockRows(200).join("\n");
-                if (shown !== lastDock) {
+                const cardsChanged = refreshCards();
+                if (shown !== lastDock || cardsChanged) {
                     lastDock = shown;
-                    dockTui?.requestRender();
+                    keysTui?.requestRender?.();
                 }
                 screen?.refresh();
             }

package/package.json

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