pi-durable-subagents 1.0.21 → 1.0.23

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # 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
+  optional pi peer package from the tool schema and failed with
+  `ERR_MODULE_NOT_FOUND` where it does not resolve (pi's own npm prefix,
+  `npm i -g`). The schema lives apart now; the import check rejects any pi
+  import reachable from the CLI, orchestrator or evaluator, and `pack:smoke`
+  drives a run by request id from a package directory that cannot see pi.
+- `describe` reports `lastFence` only for an execution that was cut off; an
+  execution that ended its turn, hibernated, or was stopped, timed out or
+  over budget, or hibernated on its question (also when recovery finds only its
+  `ask` was running) is not an interruption. A `once` call sealed `unknown` and a call
+  sealed after repeated losses still name their fence.
+- With `--json`, a `run`/`send`/`stop` refused before submission (unknown
+  agent, invalid spec, usage) answers `{request, applied: false, reason,
+  spec_digest?}` instead of plain text; exit code 1 as before. A failure after
+  submission, and a retry of a recorded run whose agent has since gone, are
+  pending (75), never a refusal; other content under a recorded id is a
+  `request-conflict` (3) before any agent check.
+- The import check parses with TypeScript, follows the executor, which the
+  orchestrator loads through `import(new URL(…))`, and treats only
+  `import type` as erased (`import { type X }` still loads the module).
+
 ## 1.0.21
 
 1.0.20 was not published; its changes ship in this release.

package/README.md

@@ -286,9 +286,9 @@ session and is rejected.
 | exit | meaning | `--json` reply |
 | --- | --- | --- |
 | 0 | decided and applied (a retry gets the same answer) | run: `{request, wid, created, spec_digest}`; send/stop: `{request, applied, generation?, call?, spec_digest}` |
-| 1 | decided and rejected (`reason`), or a usage error | `{request, applied: false, reason, spec_digest}` |
+| 1 | decided and rejected (`reason`), or refused before submission (usage error, invalid spec, unknown agent: this invocation submitted nothing) | `{request, applied: false, reason, spec_digest?}` (`spec_digest` once the content could be hashed) |
 | 3 | `request-conflict`: the id already names other content; nothing was sent | `{request, error, wid?, spec_digest, state}` (the original's digest and state) |
-| 75 | not decided yet: submitted but undecided in `--wait-ms` (default 60 s), submitted and then a later step failed (`reason` says which), or a lock was busy (`reason: "busy"`); retry with the same id | `{request, pending: true, reason?}` |
+| 75 | not decided yet: submitted but undecided in `--wait-ms` (default 60 s), submitted and then a later step failed (`reason` says which), or a lock was busy (`reason: "busy"`); an id already recorded is never refused again (the same content gets its first outcome, its agents are not rechecked; other content is a conflict); retry with the same id | `{request, pending: true, reason?}` |
 
 `created` is false when the id had already been decided before the command
 ran. A conflicting id stays conflicting forever, also after `prune`: the
@@ -311,9 +311,13 @@ full text, `qid`, `rev` and the `to` address to answer), `sealed` (finished:
 `pruned` (`pruned: {status, endedAt}`; workflows pruned before 1.0.21 have
 only `endedAt`), with `wid`, `request` and
 `spec_digest`. Live calls also show what they wait for (slot, writer lock,
-lease, exhausted provider) and the last fence of their execution
-(`lastFence: {at, exec, reason}`); the reason is a best-effort reading of the
-journals: `restart-force` when a forced restart listed the execution,
+lease, exhausted provider). `lastFence: {at, exec, reason}` appears only
+when an execution was cut off: it had not ended its turn when it was fenced,
+did not hibernate on a question (also when recovery finds it cut off while only
+its question's `ask` ran), and was not ended on purpose (stop, timeout,
+budget). Every execution ends with a fence, so an ordinary end is not
+reported; a `once` call sealed `unknown` or a call sealed after repeated losses
+is. The reason is a best-effort reading of the journals: `restart-force` when a forced restart listed the execution,
 `orchestrator-crash` when the orchestrator died uncleanly while it ran, else
 `process-died`.
 

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/agent/main/schema.js

@@ -0,0 +1,25 @@
+// The subagents tool's parameter schema. Kept apart from tool.ts because it needs the optional pi peer
+// package, which the CLI (sharing tool.ts) must not import: it runs from the package directory.
+import { Type } from "@earendil-works/pi-ai";
+const stepsDoc = "Call specs {agent, task, model?, cwd?, timeoutMs?, output?, schema?, gate?, isolation?, context?, budget?, once?, tools?, skills?, writer?, key?}; " +
+    "each call is addressed as '<wid>/<key>', where key is the step's own unique key or else 'tasks:<i>' / 'chain:<i>'.";
+export const parameters = Type.Object({
+    action: Type.Optional(Type.Union(["run", "agents", "send", "stop", "revise", "status", "resume", "drain", "restart"].map(v => Type.Literal(v)))),
+    workflow: Type.Optional(Type.String()), source: Type.Optional(Type.String()), args: Type.Optional(Type.Unknown()),
+    tasks: Type.Optional(Type.Array(Type.Any(), { description: `Parallel calls. ${stepsDoc}` })),
+    chain: Type.Optional(Type.Array(Type.Any(), { description: `Sequential calls ({previous} = previous output). ${stepsDoc}` })),
+    agent: Type.Optional(Type.String()), task: Type.Optional(Type.String()), model: Type.Optional(Type.String()),
+    cwd: Type.Optional(Type.String({ description: "Run directory (default: this session's). Relative workflow, inputs and call cwd paths resolve against it." })),
+    to: Type.Optional(Type.String()), kind: Type.Optional(Type.Union([Type.Literal("steer"), Type.Literal("follow-up"), Type.Literal("answer"), Type.Literal("model")])),
+    message: Type.Optional(Type.String()), qid: Type.Optional(Type.String()), rev: Type.Optional(Type.Integer({ minimum: 1 })),
+    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." })),
+    force: Type.Optional(Type.Union([Type.String(), Type.Boolean()], { description: "restart: the token shown by a refusal. Show the user the list and obtain explicit approval first; boolean true is refused. Subagents cannot force a restart." })),
+    reason: Type.Optional(Type.String({ description: "restart: non-empty reason, at most 500 characters; required with force." })),
+    request: Type.Optional(Type.String({ description: "run/send/stop: your own request id (1-124 chars [A-Za-z0-9][A-Za-z0-9._:-]*) making a retry safe: the same id with the same content gets the first outcome; other content is refused (request-conflict)." })),
+}, { additionalProperties: true });

package/dist/agent/main/tool.js

@@ -1,30 +1,7 @@
 import { restartInputError } from "../../orchestrator/restart.js";
 import { resolve } from "node:path";
-import { Type } from "@earendil-works/pi-ai";
 import { validateCallSpec } from "../../compat/spec.js";
 import { compileFanout } from "../../compat/fanout.js";
-const stepsDoc = "Call specs {agent, task, model?, cwd?, timeoutMs?, output?, schema?, gate?, isolation?, context?, budget?, once?, tools?, skills?, writer?, key?}; " +
-    "each call is addressed as '<wid>/<key>', where key is the step's own unique key or else 'tasks:<i>' / 'chain:<i>'.";
-export const parameters = Type.Object({
-    action: Type.Optional(Type.Union(["run", "agents", "send", "stop", "revise", "status", "resume", "drain", "restart"].map(v => Type.Literal(v)))),
-    workflow: Type.Optional(Type.String()), source: Type.Optional(Type.String()), args: Type.Optional(Type.Unknown()),
-    tasks: Type.Optional(Type.Array(Type.Any(), { description: `Parallel calls. ${stepsDoc}` })),
-    chain: Type.Optional(Type.Array(Type.Any(), { description: `Sequential calls ({previous} = previous output). ${stepsDoc}` })),
-    agent: Type.Optional(Type.String()), task: Type.Optional(Type.String()), model: Type.Optional(Type.String()),
-    cwd: Type.Optional(Type.String({ description: "Run directory (default: this session's). Relative workflow, inputs and call cwd paths resolve against it." })),
-    to: Type.Optional(Type.String()), kind: Type.Optional(Type.Union([Type.Literal("steer"), Type.Literal("follow-up"), Type.Literal("answer"), Type.Literal("model")])),
-    message: Type.Optional(Type.String()), qid: Type.Optional(Type.String()), rev: Type.Optional(Type.Integer({ minimum: 1 })),
-    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." })),
-    force: Type.Optional(Type.Union([Type.String(), Type.Boolean()], { description: "restart: the token shown by a refusal. Show the user the list and obtain explicit approval first; boolean true is refused. Subagents cannot force a restart." })),
-    reason: Type.Optional(Type.String({ description: "restart: non-empty reason, at most 500 characters; required with force." })),
-    request: Type.Optional(Type.String({ description: "run/send/stop: your own request id (1-124 chars [A-Za-z0-9][A-Za-z0-9._:-]*) making a retry safe: the same id with the same content gets the first outcome; other content is refused (request-conflict)." })),
-}, { 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", "writer"];
 function string(args, name) {

package/dist/agent/main.js

@@ -13,7 +13,8 @@ import { dsaHome, orchInbox, orchLedger, orchLock, outboxRoot } from "../paths.j
 import { CT, JT } from "../types.js";
 import { attention, presentText, presented, resolved, unfinishedWorkflow } from "./main/snapshots.js";
 import { isLive, pausedElsewhere, runningOrchestrator, statusBrief, statusCallDetail, statusCompactDetail, statusDetail, statusView, widOfRid } from "../orchestrator/snapshot.js";
-import { checkAgents, parameters, request, sendReceipt } from "./main/tool.js";
+import { checkAgents, request, sendReceipt } from "./main/tool.js";
+import { parameters } from "./main/schema.js";
 import { findRequest, requestRid, sendIdentified } from "../requests.js";
 import { discoverAgents } from "../compat/agents.js";
 import { restartInputError } from "../orchestrator/restart.js";

package/dist/cli/requests.js

@@ -103,11 +103,28 @@ function describeWorkflow(home, wid, entries, now) {
     return { state, wid, ...(id ? { request: id } : {}), ...(admitted ? { spec_digest: specDigest(admitted) } : {}), status: wf.status, ...(wf.error ? { error: wf.error } : {}),
         calls, ...(questions.length ? { questions } : {}), ...(attention.length ? { attention } : {}), ...(fence ? { lastFence: fence } : {}) };
 }
-/** R3, best effort: why the latest execution fence happened. restart-force: a forced restart listed the execution as live;
+/** R3, best effort: why the latest fence that interrupted work happened. Every execution ends with a fence; one interrupted
+ *  work only when the execution neither settled (its turn ended) before it nor hibernated (it waits for an answer), and
+ *  was not sealed on purpose: a seal ends an execution on purpose unless its outcome is `unknown` (a `once` call cut off
+ *  in a tool) or the execution was recorded as lost (the loss bound sealed it), which are interruptions themselves.
+ *  A seal for an execution that never ran (a launch failure) or that the call's stop, timeout or budget ended is on
+ *  purpose. restart-force: a forced restart listed the execution as live;
  *  orchestrator-crash: the execution was launched before an orchestrator start that is not preceded by a clean exit and
- *  fenced after it (startup recovery); otherwise process-died (the child or its host went away, or a drain/stop fenced it). */
+ *  fenced after it (startup recovery); otherwise process-died (the child or its host went away, or a drain fenced it). */
 export function lastFence(journal, orch) {
-    const fence = journal.findLast(e => e.type === JT.fenced);
+    const lost = new Set(journal.filter(e => e.type === "loss").map(e => String(e.exec)));
+    const fencedAt = new Map(journal.filter(e => e.type === JT.fenced).map(e => [String(e.exec), Number(e.seq)]));
+    const ended = new Set(journal.filter(e => {
+        const exec = String(e.exec);
+        // Recovery records `hibernated` after the fence for an execution cut off while only its question's ask ran (P28):
+        // it was waiting, not working, so that is no interruption either.
+        if (e.type === "hibernated")
+            return true;
+        if (e.type === "settled")
+            return Number(e.seq) < (fencedAt.get(exec) ?? Infinity);
+        return e.type === JT.sealed && e.result?.status !== "unknown" && !lost.has(exec);
+    }).map(e => String(e.exec)));
+    const fence = journal.findLast(e => e.type === JT.fenced && !ended.has(String(e.exec)));
     if (!fence)
         return undefined;
     const exec = String(fence.exec), at = Number(fence.ts);
@@ -183,13 +200,14 @@ function pending(ctx, id, json, why = "") {
     return EXIT.pending;
 }
 /** Submit, then wait; a decision whose admitted envelope has other content (another sender won the id) is a conflict. */
-async function submitAndWait(ctx, id, kind, body, cond, wait, json) {
+async function submitAndWait(ctx, seen, id, kind, body, cond, wait, json) {
     // R2: `created` is false only when the id was already decided before this invocation submitted (decisions are
     // monotonic); racing first attempts may all report created — the wid is what identifies the run.
     const rid = requestRid(id), earlier = Boolean(await outcome(ctx.home, rid, kind === "run", 0));
     let sent;
     try {
         sent = await submitIdentified(ctx.home, rid, kind, body, cond, ctx.env, ctx.starter);
+        seen.submitted = !("conflict" in sent);
     }
     catch (error) {
         // Exit 1 means decided (rejected) or a usage error. A busy lock submitted nothing, and a failure after the envelope
@@ -209,13 +227,37 @@ async function submitAndWait(ctx, id, kind, body, cond, wait, json) {
         return { code: await conflict(ctx, id, specDigest(admitted), json) };
     return { sent, outcome: result, earlier };
 }
+/** R2: a failure once this invocation submitted, or once the id is found recorded with this content, is "not decided
+ *  yet" (75), never a refusal. Otherwise, with --json, a request refused before submission (a usage error, an invalid
+ *  spec, an unknown agent, no open question) answers `{request, applied:false, reason, spec_digest?}` with exit 1;
+ *  spec_digest is present once the content was complete enough to hash. This invocation submitted nothing. */
+async function refusable(args, ctx, run) {
+    const seen = {};
+    try {
+        return await run(args, ctx, seen);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error), json = seen.json ?? args.includes("--json");
+        const recorded = !seen.submitted && seen.id && seen.digest && REQUEST_ID.test(seen.id) ? await findRequest(ctx.home, requestRid(seen.id)).catch(() => undefined) : undefined;
+        if (seen.id && (seen.submitted || recorded && specDigest(recorded.request) === seen.digest))
+            return pending(ctx, seen.id, json, `submitted, then: ${reason}`);
+        if (!json)
+            throw error;
+        const at = args.indexOf("--request"), id = seen.id ?? (at >= 0 && at + 1 < args.length ? args[at + 1] : undefined);
+        ctx.write(JSON.stringify({ request: id ?? null, applied: false, reason, ...(seen.digest ? { spec_digest: seen.digest } : {}) }));
+        return EXIT.rejected;
+    }
+}
 const forks = (spec) => [spec, ...["tasks", "chain"].flatMap(k => Array.isArray(spec[k]) ? spec[k] : [])]
     .some(s => s && typeof s === "object" && s.context === "fork");
 /** R2: `run --request <id> --spec <file|-> [--cwd <dir>] [--json] [--wait-ms <n>]`. The spec is the `subagents` run
  *  form ({agent,task,…} or {tasks|chain:[…],…}); it is validated by the tool's own normalizer and agent check. */
-export async function runCommand(args, ctx) {
+export const runCommand = (args, ctx) => refusable(args, ctx, runRequest);
+async function runRequest(args, ctx, seen) {
     const { values, positionals } = flags(args, { request: "value", spec: "value", cwd: "value", json: "flag", "wait-ms": "value" });
     const id = text(values, "request"), file = text(values, "spec"), json = values.json === true, wait = waitMs(values, ctx);
+    seen.id = id;
+    seen.json = json;
     if (!id || !file || positionals.length)
         throw new Error("usage: run --request <id> --spec <file|-> [--cwd <dir>] [--json] [--wait-ms <n>]");
     requestRid(id);
@@ -239,8 +281,13 @@ export async function runCommand(args, ctx) {
     const base = resolve(ctx.cwd ?? process.cwd(), text(values, "cwd") ?? "."), dir = typeof spec.cwd === "string" && spec.cwd ? resolve(base, spec.cwd) : base;
     const normalized = request({ ...spec, action: "run", ...(typeof spec.cwd === "string" && spec.cwd ? { cwd: dir } : {}) }, dir);
     const body = normalized.body;
-    checkAgents(body, () => discoverAgents(dir, { home: ctx.env.HOME || undefined, agentDir: ctx.env.PI_CODING_AGENT_DIR || undefined }).agents.map(a => a.name));
-    const done = await submitAndWait(ctx, id, "run", body, undefined, wait, json);
+    seen.digest = specDigest({ kind: "run", body });
+    // An id already recorded is decided by that record: the same content gets its first outcome (the agents it named may
+    // have changed since), other content is a request-conflict. Only a new id is checked here.
+    const prior = (await findRequest(ctx.home, requestRid(id)))?.request;
+    if (!prior)
+        checkAgents(body, () => discoverAgents(dir, { home: ctx.env.HOME || undefined, agentDir: ctx.env.PI_CODING_AGENT_DIR || undefined }).agents.map(a => a.name));
+    const done = await submitAndWait(ctx, seen, id, "run", body, undefined, wait, json);
     if ("code" in done)
         return done.code;
     if (done.outcome.type === "rejected") {
@@ -283,9 +330,12 @@ async function target(home, to, call, prior) {
     throw new Error(`${to} has ${keys.length ? `calls ${keys.join(", ")}` : "no calls yet"}; name one with --call <key> or --to <wid>/<key>`);
 }
 /** R2: `send --request <id> --to <…> --kind follow-up|answer|steer|model [--qid <qid> --rev <n>] --message <text|@file> [--model <m>]`. */
-export async function sendCommand(args, ctx) {
+export const sendCommand = (args, ctx) => refusable(args, ctx, sendRequest);
+async function sendRequest(args, ctx, seen) {
     const { values, positionals } = flags(args, { request: "value", to: "value", call: "value", kind: "value", qid: "value", rev: "value", message: "value", model: "value", json: "flag", "wait-ms": "value" });
     const id = text(values, "request"), to = text(values, "to"), kind = text(values, "kind"), json = values.json === true, wait = waitMs(values, ctx);
+    seen.id = id;
+    seen.json = json;
     if (!id || !to || !kind || positionals.length)
         throw new Error("usage: send --request <id> --to <run-id|wid/key> --kind follow-up|answer|steer|model [--qid <qid> --rev <n>] --message <text|@file> [--model <m>] [--json]");
     const rid = requestRid(id), prior = (await findRequest(ctx.home, rid))?.request;
@@ -310,15 +360,19 @@ export async function sendCommand(args, ctx) {
     }
     const normalized = request({ action: "send", to: where.to, kind, ...(message !== undefined ? { message } : {}), ...(text(values, "model") !== undefined ? { model: text(values, "model") } : {}),
         ...(qid !== undefined ? { qid } : {}), ...(revision !== undefined ? { rev: revision } : {}) }, ctx.cwd ?? process.cwd());
-    const done = await submitAndWait(ctx, id, "send", normalized.body, normalized.cond, wait, json);
+    seen.digest = specDigest({ kind: "send", body: normalized.body, cond: normalized.cond });
+    const done = await submitAndWait(ctx, seen, id, "send", normalized.body, normalized.cond, wait, json);
     if ("code" in done)
         return done.code;
     return decided(ctx, id, done, json);
 }
 /** R2: `stop --request <id> <run-id|wid|wid/key|callId>`. */
-export async function stopCommand(args, ctx) {
+export const stopCommand = (args, ctx) => refusable(args, ctx, stopRequest);
+async function stopRequest(args, ctx, seen) {
     const { values, positionals } = flags(args, { request: "value", json: "flag", "wait-ms": "value" });
     const id = text(values, "request"), json = values.json === true, wait = waitMs(values, ctx);
+    seen.id = id;
+    seen.json = json;
     if (!id || positionals.length !== 1)
         throw new Error("usage: stop --request <id> <run-id|wid|wid/key> [--json]");
     requestRid(id);
@@ -327,7 +381,8 @@ export async function stopCommand(args, ctx) {
     if ("pending" in resolved)
         return pending(ctx, id, json, `run ${head} has no workflow yet`);
     const normalized = request({ action: "stop", target: raw.includes("@") ? raw : `${resolved.wid}${raw.slice(head.length)}` }, ctx.cwd ?? process.cwd());
-    const done = await submitAndWait(ctx, id, "stop", normalized.body, undefined, wait, json);
+    seen.digest = specDigest({ kind: "stop", body: normalized.body });
+    const done = await submitAndWait(ctx, seen, id, "stop", normalized.body, undefined, wait, json);
     if ("code" in done)
         return done.code;
     return decided(ctx, id, done, json);

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.21",
+  "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",