pi-durable-subagents 1.0.22 → 1.0.23

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 1.0.23
+
+- An asker cut off by a restart (also `restart --force`) now hibernates and
+  resumes with the answer, as documented. A graceful shutdown let its `ask`
+  end with its own "Session shut down" (or "Ask aborted") error before the
+  process exited; recovery took that for an answered ask, recorded a loss and
+  ran the call again, so the model asked a second time, `describe` showed a
+  `lastFence` and the stale question stayed listed. Only a killed process (no
+  result at all) was recognised before.
+
 ## 1.0.22
 
 - The installed CLI runs `run`, `send` and `stop` again: 1.0.21 loaded the

package/dist/agent/child.js

@@ -1,7 +1,7 @@
 import { watch } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { Type } from '@earendil-works/pi-ai';
-import { CT, ENV, JT } from "../types.js";
+import { ASK_CUT, CT, ENV, JT } from "../types.js";
 import { readJournalSnapshot } from "../kernel/journal.js";
 import { scanInbox } from "../kernel/mailbox.js";
 import { contentHash } from "../kernel/ids.js";
@@ -250,7 +250,7 @@ export function registerChild(pi) {
     pi.on('session_shutdown', async () => {
         active = false;
         watcher?.close();
-        blocked?.reject(new Error('Session shut down'));
+        blocked?.reject(new Error(ASK_CUT.shutdown));
         blocked = undefined;
         await queue;
     });
@@ -263,12 +263,12 @@ export function registerChild(pi) {
             // Attach immediately so abort during the queued intake never produces an unhandled rejection.
             void result.catch(() => { });
             const abort = () => { void serial(async () => { if (blocked?.resolve === resolve)
-                blocked = undefined; reject(new Error('Ask aborted')); }); };
+                blocked = undefined; reject(new Error(ASK_CUT.aborted)); }); };
             signal?.addEventListener('abort', abort, { once: true });
             try {
                 await serial(async () => {
                     if (!active || signal?.aborted)
-                        throw new Error('Ask aborted');
+                        throw new Error(ASK_CUT.aborted);
                     if (blocked)
                         throw new Error('Another question is already blocked');
                     const qid = contentHash({ exec, question }), rev = (state.questions.get(qid)?.rev ?? 0) + 1;

package/dist/orchestrator/executor/hibernate.js

@@ -1,10 +1,10 @@
 // Private workflow entries (P28): hibernated{call,qid,rev,exec};
 // answer-bound{call,qid,rev,rid,rid2,message,hash}; resumed{call,rid,exec}.
 import { CT } from "../../types.js";
-import { receiptId } from "./session.js";
+import { askOf, cutAskResult, receiptId } from "./session.js";
 /** P28, V4: Find an unanswered question whose native ask tool remains blocked. */
 export function openQuestion(entries) {
-    const q = entries.findLast(e => e.type === "custom" && e.customType === CT.question)?.data;
+    const at = entries.findLastIndex(e => e.type === "custom" && e.customType === CT.question), q = entries[at]?.data;
     if (!q || typeof q.qid !== "string" || typeof q.rev !== "number")
         return;
     if (entries.some(e => {
@@ -12,17 +12,12 @@ export function openQuestion(entries) {
         return !!details && details.qid === q.qid && details.rev === q.rev && receiptId(e) !== undefined;
     }))
         return;
-    const pending = new Set();
-    for (const e of entries) {
-        const m = e.message;
-        if (m?.role === "assistant" && Array.isArray(m.content))
-            for (const b of m.content)
-                if (b.type === "toolCall" && b.name === "ask" && b.id)
-                    pending.add(b.id);
-        if (m?.role === "toolResult" && m.toolCallId)
-            pending.delete(m.toolCallId);
-    }
-    if (!pending.size)
+    // Only the ask that wrote this question counts: it is still blocked when it has no result, or only the error it ended
+    // with when its session shut down or its run was aborted. An earlier ask cut off that way does not keep a later
+    // question (ended by a steer, say) open.
+    const ask = askOf(entries, at);
+    const result = ask === undefined ? undefined : entries.find(e => e.message?.role === "toolResult" && e.message.toolCallId === ask);
+    if (ask === undefined || result && !cutAskResult(result.message))
         return;
     return { qid: q.qid, rev: q.rev, question: String(q.question) };
 }

package/dist/orchestrator/executor/session.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { open } from "node:fs/promises";
-import { CT } from "../../types.js";
+import { ASK_CUT, CT } from "../../types.js";
 // A child session is append-only while observed (pi appends whole lines), so a cached state is extended by parsing only
 // the bytes appended since the last read. A different inode, a shorter file or a changed first 4 KiB (pi rewrites a
 // session in place when it migrates or initializes it) is read from scratch.
@@ -75,12 +75,37 @@ export function receiptId(entry) {
         (entry.type === "custom" && [CT.rejected, CT.withdrawn, CT.model].includes(entry.customType) ? entry.data?.rid : undefined);
     return typeof rid === "string" ? rid : undefined;
 }
+/** P28: an `ask` result the child wrote because its session shut down or its run was aborted, which is no answer. */
+export function cutAskResult(m) {
+    if (m?.role !== "toolResult" || !m.isError)
+        return false;
+    const text = typeof m.content === "string" ? m.content : (m.content ?? []).map(b => b.text ?? "").join("");
+    return text === ASK_CUT.shutdown || text === ASK_CUT.aborted;
+}
+/** P28: the `ask` tool call that wrote the question at `index`. The child appends a question while that ask runs, after
+ *  the assistant message that called it; a message with an ask runs its tools in order, so it is that message's first
+ *  ask with no result before the question. */
+export function askOf(entries, index) {
+    for (let i = index - 1; i >= 0; i--) {
+        const m = entries[i].message;
+        if (m?.role !== "assistant" || !Array.isArray(m.content))
+            continue;
+        const asks = m.content.filter(b => b.type === "toolCall" && b.name === "ask" && b.id);
+        if (!asks.length)
+            continue;
+        const done = new Set(entries.slice(i + 1, index).map(e => e.message?.role === "toolResult" ? e.message.toolCallId : undefined));
+        return (asks.find(b => !done.has(b.id)) ?? asks.at(-1)).id;
+    }
+    return undefined;
+}
 /** P9: Derive evidence only after this execution's own launch receipt. */
 export function evidence(entries, exec) {
     const start = entries.findLastIndex(e => e.type === "custom" && e.customType === CT.exec && e.data?.exec === exec);
     const segment = start < 0 ? [] : entries.slice(start + 1);
     const report = segment.findLast(e => e.type === "custom" && e.customType === CT.report && e.data?.exec === exec && ["ok", "failed"].includes(String(e.data.outcome)))?.data;
     const tools = new Map();
+    // P28: only an ask that wrote a question can be cut off while waiting; one aborted before that is an ordinary result.
+    const asked = new Set(segment.flatMap((e, i) => e.type === "custom" && e.customType === CT.question ? [askOf(segment, i)] : []));
     let text = "";
     const usage = { input: 0, output: 0, costUsd: 0 };
     for (const e of segment) {
@@ -99,7 +124,8 @@ export function evidence(entries, exec) {
             usage.output += m.usage?.output ?? 0;
             usage.costUsd += m.usage?.cost?.total ?? 0;
         }
-        if (m?.role === "toolResult" && m.toolCallId)
+        // P28: an ask cut off by shutdown or abort while its question waited keeps an unknown outcome, like one with no result.
+        if (m?.role === "toolResult" && m.toolCallId && !(asked.has(m.toolCallId) && cutAskResult(m)))
             tools.delete(m.toolCallId);
     }
     const budget = segment.some(e => e.type === "custom" && e.customType === CT.budget && e.data?.exec === exec);

package/dist/types.js

@@ -11,6 +11,9 @@ export function attentionEntries(entries, id) {
 // Child session entries (pi session file is the child's log; P4, P8, P23, P24)
 // customType values written by the session agent. All carry details/data as below.
 // ---------------------------------------------------------------------------
+/** P28: the errors the child's own `ask` ends with when its session shuts down or its run is aborted. Such a result is
+ *  no answer: recovery treats the ask as cut off while waiting, like one with no result. */
+export const ASK_CUT = { shutdown: "Session shut down", aborted: "Ask aborted" };
 export const CT = {
     admitted: "dsa-admitted", // custom: { rid, from, sseq, hash, kind } — lifecycle admission record (kernel DecisionRecord)
     exec: "dsa-exec", // custom: { exec } — start of an execution segment

package/package.json

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