pi-durable-subagents 1.0.12 → 1.0.13

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 1.0.13
+
+- A subagent resumed after its execution was interrupted (the orchestrator
+  restarted, the process died, a failover) is told that the processes its
+  tools had started, background ones included, were stopped with it, and not
+  to wait for them; an asker that hibernated while waiting is told the same
+  with the answer. Before, it was told only to continue, and one slept on a
+  test loop that no longer ran.
+- The "no execution activity" alert names the tool command running and how
+  long it has run (for example "running bash `make fault-matrix` for 14m"), so
+  a long silent command reads differently from a stuck call.
+
 ## 1.0.12
 
 - Slot, memory and model decisions read the orchestrator settings recorded in

package/README.md

@@ -51,7 +51,7 @@ the npx cache, so `install-service` refuses to run from there.
 | A step runs past its `timeoutMs` (even inside a silent tool) | Stops it cleanly as `timeout`. Only time spent working counts; waiting for you does not. |
 | You quit pi (Ctrl+D, `/quit`, closing the terminal) while subagents run | That session's workflows pause: nothing more is spent, nothing is lost. When you come back, pi says so; `resume` (or `r` in the list) continues them in the same sessions. Set `"onQuit": "continue"` to let them run on instead. |
 | pi crashes or is killed (`kill -9`) while subagents run | The work keeps running. When you come back, the session that started the work is told what needs you. |
-| The machine or the orchestrator dies mid-run | The next pi you open resumes the work. Finished results are kept and nothing runs twice. |
+| The machine or the orchestrator dies mid-run | The next pi you open resumes the work. Finished results are kept and nothing runs twice. The resumed subagent is told that processes its tools had started (background ones included) were stopped, so it checks them instead of waiting for them. |
 | You steer a subagent while it is asking you a question | Your message reaches it, in order. Nothing is rejected or lost. |
 | Two steers arrive out of order and the second replaces the first | Only the second one applies. |
 | A step is refused, or a dependency fails | The workflow stops that branch cleanly. Nothing is retried in vain. |
@@ -174,7 +174,7 @@ The main agent is interrupted only when there is something to decide:
 
 - a question;
 - a finished workflow;
-- a stalled subagent;
+- a stalled subagent (the alert names the command it is running and for how long, so a long silent command reads differently from a stuck call);
 - an unknown outcome;
 - a reached budget.
 

package/dist/orchestrator/executor/index.js

@@ -88,6 +88,16 @@ async function defaultModel() {
     return settings.defaultModel ? `${settings.defaultProvider ? `${settings.defaultProvider}/` : ""}${settings.defaultModel}` : undefined;
 }
 /** P2, P9, P22: Construct the journal-owned execution authority under the engine's OS lock. */
+/** Restart feedback: a resumed child believed the test loop it had started was still running and slept on it. Its
+ *  previous execution was stopped (fenced), and with it every process its tools started, background ones included. */
+export function continueMessage(dangling) {
+    return "Your previous execution was interrupted and this one continues the task. Processes your tools started " +
+        "(background ones included) were stopped with it: do not wait for them or their output; check what they left " +
+        "and start again what is still needed. Tool calls whose outcomes are unknown: " + (dangling.join(", ") || "none") + ".";
+}
+/** An asker hibernates while it waits (its execution is stopped to free the provider slot), so the answer says so. */
+export const HIBERNATED_NOTE = "While you waited for the answer below your execution was stopped; processes your tools had " +
+    "started (background ones included) were stopped with it. Check them before relying on them.";
 export default function createExecutor(ledgers, options = {}) {
     const { home, config, orch } = ledgers;
     const containment = options.containment ?? serialContainment(), effects = options.effects ?? createEffects(ledgers);
@@ -742,7 +752,7 @@ export default function createExecutor(ledgers, options = {}) {
             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"]) });
+                await sender.send(t.callId, "continue", { message: continueMessage(dangling) }, undefined, { rid: contentHash([exec, "dispatch"]) });
             else
                 await sender.send(t.callId, "task", { message: t.opening?.message ?? t.spec.task }, undefined, { rid: contentHash([exec, "dispatch"]) });
             if (interrupted(a)) {
@@ -858,7 +868,7 @@ export default function createExecutor(ledgers, options = {}) {
                             return { action: "reject", reason: "stale-rev" };
                         const rid2 = forwardRid(req.rid, ctx.widRev, ctx.key, hash);
                         const item = attentionEntries(ctx.journal.entries()).find(e => e.item.call === dest && e.item.qid === sleeping.qid && e.item.rev === sleeping.rev)?.item;
-                        await ctx.journal.append("answer-bound", { call: dest, qid: sleeping.qid, rev: sleeping.rev, rid: req.rid, rid2, hash, message: `Question: ${item?.text ?? sleeping.qid}\nAnswer: ${req.body.message ?? ""}` });
+                        await ctx.journal.append("answer-bound", { call: dest, qid: sleeping.qid, rev: sleeping.rev, rid: req.rid, rid2, hash, message: `${HIBERNATED_NOTE}\n\nQuestion: ${item?.text ?? sleeping.qid}\nAnswer: ${req.body.message ?? ""}` });
                         active.get(dest)?.wake();
                         wake();
                         return { action: "apply" };

package/dist/orchestrator/executor/observe.js

@@ -11,12 +11,21 @@ import { monotoneTime } from "../../kernel/guards.js";
 import { readSession } from "./session.js";
 import { ActiveTime, activeTotal } from "./time.js";
 import { observation, reached, sessionUsage, totalUsage } from "./usage.js";
+/** A tool call's command for a status line: bash's command, else its arguments, on one line and clipped. */
+export function toolCommand(args) {
+    const a = args && typeof args === "object" ? args : {};
+    const text = typeof a.command === "string" ? a.command : Object.keys(a).length ? JSON.stringify(a) : "";
+    const line = text.replace(/\s+/g, " ").trim();
+    return line.length > 120 ? `${line.slice(0, 119)}…` : line;
+}
 /** P18, P31, P9: Observe slim evidence, decide limits and fence before returning to settlement. */
 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;
     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();
     const prior = activeTotal(t.journal.entries(), t.callId);
     let size = (await fileStat(session).catch(() => ({ size: 0 }))).size, checkpoint = performance.now();
     let signal;
@@ -48,8 +57,15 @@ export async function observeExecution(d) {
         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`, wid: t.wid, call: t.callId } });
+            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 } });
     });
+    /** "; running bash `make matrix` for 14m (no output or CPU use seen)": a silent long command, not a stuck model. */
+    const runningText = () => {
+        const now = performance.now(), open = [...running.values()].filter(r => r.name !== "ask");
+        if (!open.length)
+            return "";
+        return "; running " + open.map(r => `${r.name}${r.command ? ` \`${r.command}\`` : ""} for ${Math.floor((now - r.since) / 60000)}m`).join(", ") + " (no output or CPU use seen)";
+    };
     const noProgress = () => serial(async () => {
         const id = `noprogress:${t.callId}`;
         const items = attentionEntries(t.journal.entries(), id), last = items.at(-1)?.item;
@@ -94,10 +110,14 @@ export async function observeExecution(d) {
             event.type === "message_end" && message?.stopReason === "error" ? message.errorMessage : undefined;
         if (typeof error === "string" && error)
             providerError = error;
-        if (event.type === "tool_execution_start")
+        if (event.type === "tool_execution_start") {
             tools.add(String(event.toolCallId ?? ""));
-        if (event.type === "tool_execution_end")
+            running.set(String(event.toolCallId ?? ""), { name: String(event.toolName ?? "tool"), command: toolCommand(event.args), since: performance.now() });
+        }
+        if (event.type === "tool_execution_end") {
             tools.delete(String(event.toolCallId ?? ""));
+            running.delete(String(event.toolCallId ?? ""));
+        }
         // Receipt-time progress is independent of RPC chatter, CPU and session growth; open tools suppress alerts.
         if (event.type === "message_update" || ["tool_execution_start", "tool_execution_update", "tool_execution_end"].includes(String(event.type)) ||
             event.type === "message_end" && message?.stopReason !== "error" && (message?.usage?.output ?? 0) > 0)

package/package.json

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