pi-better-harness 0.44.0 → 0.45.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.45.0] - 2026-11-12
+
+### Changed
+
+- Bundle Subagents 0.32.0 for session-scoped historical wait warnings, original-session inspection, durable cancellation, and dismissal of unchanged notices. (#719)
+
 ## [0.44.0] - 2026-11-12
 
 ### Changed

package/node_modules/pi-better-subagents/docs/usage.md

@@ -1085,3 +1085,17 @@ Near-term:
   twice ([#2](https://github.com/1aboveio/pi-better-subagents/issues/2)) — **done**.
 - Named agent-definition files (per-agent system prompt + tool allowlist) and
   chain/parallel orchestration.
+# Historical Waits
+
+`/subagents history` lists retained waits from other sessions in this workspace.
+Each entry identifies its originating session and offers inspection or explicit
+cancellation. Inspection does not adopt the assignment, acknowledge its evidence,
+or start a continuation. Cancellation confirms the durable result; it does not
+claim that an uncertain writer has stopped. Failures leave the wait available
+for inspection and retry.
+
+`/subagents history dismiss` durably dismisses the current historical-attention
+notice without changing any wait or evidence. A changed wait generation, phase,
+publication or attention reason can produce a new notice. Ordinary task navigation
+remains scoped to the active session.
+

package/node_modules/pi-better-subagents/historical-attention.ts

@@ -0,0 +1,35 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { type RunCallbackOrigin } from "./registry.ts";
+import { durableSubagentRoot } from "./session-store.ts";
+import { parkedWaits, type ParkedWait } from "./worker-waits.ts";
+
+/** Discovery is not adoption: the captured owner and wait evidence stay untouched. */
+export function historicalWaits(origin: RunCallbackOrigin | undefined): ParkedWait[] {
+    if (!origin) return [];
+    return parkedWaits().filter(({ record }) => record.ownerWorkspace === origin.cwd
+        && record.ownerSessionId !== origin.sessionId);
+}
+
+export function attentionRevision(waits: ParkedWait[]): string {
+    return createHash("sha256").update(JSON.stringify(waits.map(({ runId, record }) => [
+        runId, record.waitId, record.generation, record.phase, record.heldReason,
+        record.cancelReason, record.resumedBy, record.resumeLaunchToken,
+    ]).sort((a, b) => String(a[0]).localeCompare(String(b[0]))))).digest("hex");
+}
+
+function receiptPath(workspace: string): string {
+    return join(durableSubagentRoot(), `historical-attention-${createHash("sha256").update(workspace).digest("hex")}.json`);
+}
+export function attentionDismissed(workspace: string, revision: string): boolean {
+    try { return JSON.parse(readFileSync(receiptPath(workspace), "utf8")).revision === revision; }
+    catch { return false; }
+}
+export function dismissAttention(workspace: string, revision: string): void {
+    mkdirSync(durableSubagentRoot(), { recursive: true });
+    const path = receiptPath(workspace);
+    const temp = `${path}.${randomUUID()}.tmp`;
+    writeFileSync(temp, JSON.stringify({ version: 1, revision }), { mode: 0o600 });
+    renameSync(temp, path);
+}

package/node_modules/pi-better-subagents/index.ts

@@ -12,6 +12,7 @@
  */
 
 import { assignmentFor } from "./assignment-projection.mjs";
+import { historicalWaits, attentionRevision, attentionDismissed, dismissAttention } from "./historical-attention.ts";
 import { registerAssignmentAttempt, commitAssignmentTerminal, readOutcome, receiptOutcome, outcomeTranscriptReceipt, inspectOutcome, createOutcomeHost, closeOutcomeHost, claimOutcome, type AssignmentBinding } from "./assignment-outcomes.ts";
 import { currentSandboxPermissions } from "./permission-policy.ts";
 import { requestResumeAdmission } from "./worker-waits.ts";
@@ -238,6 +239,8 @@ import { defaultUserRoot, type CatalogSnapshot } from "./catalog-store.ts";
 import { restrictContextFilesToWorktree } from "./shared-worktree-context.ts";
 
 const SUBAGENT_MODE_ACTIONS: readonly AutocompleteItem[] = [
+    { value: "history", label: "history", description: "Inspect or cancel waits from other sessions" },
+    { value: "history dismiss", label: "history dismiss", description: "Dismiss unchanged historical attention notices" },
     { value: "settings", label: "settings", description: "Open delegation, concurrency, and timing settings" },
     { value: "cap", label: "cap <number>", description: "Set a positive concurrent subagent limit for this session" },
     { value: "tool-wait", label: "tool-wait <minutes>", description: "Set the session tool-wait alert time; 0 turns it off" },
@@ -1438,20 +1441,22 @@ function navigatorDetail(id: string, now: number = Date.now()) {
  * Set by the active extension instance: cancel a parked assignment's pending
  * wait. Returns false when the run is not parked, so the ordinary stop path runs.
  */
-let cancelParkedForUi: ((id: string, reason: string) => boolean) | undefined;
+let cancelParkedForUi: ((id: string, reason: string) => Promise<boolean>) | undefined;
 
 /** Shared #44 stop+dismiss path used by navigator Close (#47). */
 function navigatorCloseRun(id: string) {
     // A parked attempt's child already exited cleanly, so "close" must cancel the
     // pending automatic resume instead of pretending to stop a live process.
-    if (cancelParkedForUi?.(id, "closed from the navigator; the automatic resume is cancelled")) {
-        try { dismissRun(id); } catch { /* dismissal is best effort */ }
-        spendCache.delete(id);
-        healthLogCache.delete(id);
-        resetChildEventLogCursor(id);
-        resetParseRunCursor(id);
-        syncHealthTicker();
-        return { action: "stopped", id };
+    if (parkedWaitForRun(id) && cancelParkedForUi) {
+        void cancelParkedForUi(id, "closed from the navigator; the automatic resume is cancelled")
+            .then((cancelled) => {
+                if (!cancelled) throw new Error("The pending wait changed; inspect it again.");
+                dismissRun(id);
+                uiCtx?.ui.notify(`Cancelled the pending wait of ${id}. Writer termination may remain unproven.`, "info");
+            })
+            .catch((error) => uiCtx?.ui.notify(`Cancellation failed for ${id}: ${String(error)}. The wait remains available for inspection and retry.`, "warning"));
+        // The synchronous navigator must retain the row until the durable operation settles.
+        return { action: "missing", id };
     }
     const outcome = executeNavigatorClose(id, {
         readMeta,
@@ -2300,18 +2305,21 @@ export default function (pi: ExtensionAPI) {
         childExtensionPath: childBridgeExtensionPath(selfDir()),
     });
     let resumeOrchestration: ResumeOrchestration | undefined;
+    const notifyOwnedWait = (message: string, level: "warning" | "info" = "warning") => {
+        try { uiCtx?.ui?.notify?.(message, level); } catch { /* no UI */ }
+    };
     /**
      * Stop a continuation attempt only when this parent owns it and the token
      * published with it matches. A pid is never signalled on a guess.
      */
     const stopPublishedAttempt = createOwnedAttemptStopper();
-    cancelParkedForUi = (id, reason) => {
+    cancelParkedForUi = async (id, reason) => {
         const parked = parkedWaitForRun(id);
         if (!parked) return false;
-        void cancelParkedWait(workerOperations.service, parked, reason, { stopAttempt: stopPublishedAttempt })
-            .then(() => { if (parked.meta.assignment) enqueueCompletionCallback(pi, id); })
-            .catch(() => { /* the durable record keeps the wait visible */ })
-            .finally(() => syncHealthTicker());
+        try {
+            await cancelParkedWait(workerOperations.service, parked, reason, { stopAttempt: stopPublishedAttempt });
+            if (parked.meta.assignment) enqueueCompletionCallback(pi, id);
+        } finally { syncHealthTicker(); }
         return true;
     };
     const effectiveSettings = () => {
@@ -3482,9 +3490,8 @@ export default function (pi: ExtensionAPI) {
             capacity: resumeCapacity(),
             launch: launchParkedResume,
             stopAttempt: stopPublishedAttempt,
-            notify: (message, level) => {
-                try { uiCtx?.ui?.notify?.(message, level); } catch { /* ignore UI failures */ }
-            },
+            notifyWhen: (meta) => Boolean(activeCallbackOrigin && belongsToOrigin(meta, activeCallbackOrigin)),
+            notify: notifyOwnedWait,
         });
         return resumeOrchestration;
     }
@@ -3509,10 +3516,13 @@ export default function (pi: ExtensionAPI) {
         try {
             await reconcileParkedWaits(service, {
                 resume: (park) => orchestration.resume(park),
-                notify: (message) => {
-                    try { uiCtx?.ui?.notify?.(message, "warning"); } catch { /* ignore UI failures */ }
-                },
+                notifyWhen: (meta) => Boolean(activeCallbackOrigin && belongsToOrigin(meta, activeCallbackOrigin)),
+                notify: notifyOwnedWait,
             });
+            const historical = historicalWaits(activeCallbackOrigin);
+            if (historical.length && activeCallbackOrigin && !attentionDismissed(activeCallbackOrigin.cwd, attentionRevision(historical))) {
+                uiCtx?.ui?.notify?.(`${historical.length} historical subagent waits remain. Inspect or cancel with /subagents history; dismiss this notice with /subagents history dismiss.`, "warning");
+            }
         } catch { /* reconciliation retries on the next session start */ }
     }
 
@@ -3990,23 +4000,25 @@ export default function (pi: ExtensionAPI) {
         enqueueCompletionCallback(pi, id);
     } });
     acceptanceStopToolRef = acceptanceStopTool;
-    // A parked assignment has no live child: `subagent_stop` is the explicit
-    // takeover that cancels its pending automatic resume, so the conversation can
-    // be continued manually. Without this, stop would report "not running" and
-    // leave the automatic resume armed for the same assignment.
+    // A parked attempt may have exited, but its automatic resume is still armed.
+    // Explicit stop must confirm durable cancellation, not just stop a process.
     const acceptanceStopToolWithParked = {
         ...acceptanceStopTool,
         async execute(toolCallId: string, params: unknown, signal?: AbortSignal, onUpdate?: unknown, ctx?: unknown) {
             const target = (params as { id?: unknown } | undefined)?.id;
-            if (typeof target === "string" && cancelParkedForUi?.(target, "cancelled by subagent_stop; the automatic resume is cancelled")) {
-                renderWidget();
-                syncHealthTicker();
-                return {
-                    content: [{
-                        type: "text",
-                        text: `Cancelled the pending wait of parked subagent ${target}. Its conversation can now be continued with subagent_spawn session_id.`,
-                    }],
-                };
+            try {
+                if (typeof target === "string" && await cancelParkedForUi?.(target, "cancelled by subagent_stop; the automatic resume is cancelled")) {
+                    renderWidget();
+                    syncHealthTicker();
+                    return {
+                        content: [{
+                            type: "text",
+                            text: `Durably cancelled the pending wait of parked subagent ${target}. Writer termination may remain unproven; ordinary continuation admission still applies.`,
+                        }],
+                    };
+                }
+            } catch (error) {
+                return { isError: true, content: [{ type: "text", text: `Cancellation failed for ${target}: ${String(error)}. The retained wait remains available for inspection and retry.` }] };
             }
             return (acceptanceStopTool.execute as (
                 id: string, p: unknown, s?: AbortSignal, u?: unknown, c?: unknown,
@@ -4100,10 +4112,36 @@ export default function (pi: ExtensionAPI) {
     if (typeof pi.registerCommand === "function") {
         agentOperations.registerCommands(pi);
         pi.registerCommand("subagents", {
-            description: "[settings|mode manual|adaptive|coordinator|cap <number>|tool-wait <minutes>|stuck <minutes>|save|reset] — Subagent settings",
+            description: "[history [dismiss]|settings|mode manual|adaptive|coordinator|cap <number>|tool-wait <minutes>|stuck <minutes>|save|reset] — Subagent management",
             getArgumentCompletions: subagentsArgumentCompletions,
             async handler(args, ctx) {
                 const tokens = args.trim().split(/\s+/).filter(Boolean);
+                if (tokens[0] === "history") {
+                    try {
+                        const origin = { cwd: ctx.cwd, sessionId: ctx.sessionManager.getSessionId() };
+                        const waits = historicalWaits(origin);
+                        if (tokens[1] === "dismiss") {
+                            dismissAttention(ctx.cwd, attentionRevision(waits));
+                            ctx.ui.notify("Historical attention notice dismissed. Waits and evidence are unchanged.", "info");
+                            return;
+                        }
+                        const labels = waits.map((p) => `${p.runId} · session ${p.record.ownerSessionId ?? "unknown"} · ${p.phase}`);
+                        const selected = await ctx.ui.select("Historical subagent waits", labels);
+                        const park = waits[labels.indexOf(selected ?? "")];
+                        if (!park) return;
+                        const action = await ctx.ui.select(`${park.runId} · session ${park.record.ownerSessionId ?? "unknown"}`, ["Inspect", "Cancel pending wait"]);
+                        if (action === "Inspect") {
+                            ctx.ui.notify(JSON.stringify({ runId: park.runId, originatingSession: park.record.ownerSessionId,
+                                workspace: park.record.ownerWorkspace, waitId: park.waitId, generation: park.generation,
+                                phase: park.phase, reason: park.record.heldReason, cancellation: park.record.cancelReason,
+                                resumedBy: park.record.resumedBy, log: park.meta.logPath }), "info");
+                        } else if (action === "Cancel pending wait" && await ctx.ui.confirm("Cancel pending wait?", `${park.runId} belongs to session ${park.record.ownerSessionId ?? "unknown"}. This does not prove its writer has stopped.`)) {
+                            if (!await cancelParkedForUi?.(park.runId, "explicit cancellation from historical management")) throw new Error("The pending wait changed; inspect it again.");
+                            ctx.ui.notify(`Durably cancelled the pending wait of ${park.runId}. Writer termination may remain unproven.`, "info");
+                        }
+                    } catch (error) { ctx.ui.notify(`Historical wait management failed: ${String(error)}. Inspect or retry with /subagents history.`, "warning"); }
+                    return;
+                }
                 if (tokens.length === 0 || (tokens.length === 1 && tokens[0] === "settings")) {
                     await openSettings(ctx);
                     return;
@@ -4153,7 +4191,7 @@ export default function (pi: ExtensionAPI) {
                     changeTiming(key, minutes);
                     ctx.ui.notify(`${tokens[0] === "tool-wait" ? "Tool-wait" : "No-progress"} alert: ${minutes} min (current session). Running subagents are unchanged.`, "info");
                 } else {
-                    ctx.ui.notify("Usage: /subagents [settings|mode manual|adaptive|coordinator|cap <number>|tool-wait <minutes>|stuck <minutes>|save|reset]", "warning");
+                    ctx.ui.notify("Usage: /subagents [history [dismiss]|settings|mode manual|adaptive|coordinator|cap <number>|tool-wait <minutes>|stuck <minutes>|save|reset]", "warning");
                 }
                 refreshBackgroundWorkNavigator(ctx);
             },

package/node_modules/pi-better-subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-subagents",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "description": "Pi extension for detached, sandboxed subagent runs that keep the foreground session free.",
   "license": "MIT",
   "type": "module",

package/node_modules/pi-better-subagents/worker-waits.ts

@@ -1670,6 +1670,7 @@ export interface ResumeOrchestrationOptions {
     /** Follow a cancelled generation to the attempt it already published. */
     stopAttempt?: StopPublishedAttempt;
     notify?(message: string, level: "info" | "warning"): void;
+    notifyWhen?(meta: RunMeta): boolean;
     now?: () => number;
 }
 
@@ -1872,7 +1873,7 @@ export function createResumeOrchestration(options: ResumeOrchestrationOptions):
         } catch { /* the park record still shows the hold */ }
         if (park.meta.assignment) commitAssignmentTerminal({ ...park.meta, status: "failed", failureReason: reason }, true);
         try {
-            options.notify?.(`Subagent ${park.runId} wait ${park.waitId} is held: ${reason}`, "warning");
+            if (!options.notifyWhen || options.notifyWhen(park.meta)) options.notify?.(`Subagent ${park.runId} wait ${park.waitId} is held: ${reason}`, "warning");
         } catch { /* ignore UI failures */ }
         return "held";
     };
@@ -2117,7 +2118,8 @@ export async function cancelParkedWait(
     const scope = backgroundScopeForMeta(park.meta, park.record);
     const at = (options.now ?? Date.now)();
     if (park.meta.assignment) {
-        commitAssignmentTerminal({ ...park.meta, status: "killed" });
+        const outcome = commitAssignmentTerminal({ ...park.meta, status: "killed" });
+        if (outcome?.outcome !== "cancelled") throw new Error("The assignment already has a non-cancelled terminal outcome; cancellation was not committed.");
         const cancellation = await stopPublishedAttempt(park, reason, options.stopAttempt, options.now);
         updateParkRecord(park.runId, { phase: "cancelled", cancelReason: cancellation === "foreign" ? `${reason} (published writer termination remains unproven)` : reason, cancelledAt: at });
         return;
@@ -2130,10 +2132,10 @@ export async function cancelParkedWait(
             updateParkRecord(park.runId, {
                 phase: "held",
                 cancelReason: `${reason} (the durable cancellation failed: ${reasonOf(error)})`,
-                cancelledAt: at,
             });
-            return;
+            throw new Error(`Durable cancellation failed: ${reasonOf(error)}`);
         }
+        if (view.phase !== "cancelled") throw new Error(`Durable cancellation was not confirmed (wait is ${view.phase}).`);
         const settled = readParkRecord(park.runId);
         if (settled?.phase === "cancelled" && settled.cancelReason) return;
         const cancellation = await stopPublishedAttempt(park, reason, options.stopAttempt, options.now);
@@ -2148,14 +2150,7 @@ export async function cancelParkedWait(
         });
         return;
     }
-    const cancellation = await stopPublishedAttempt(park, reason, options.stopAttempt, options.now);
-    updateParkRecord(park.runId, {
-        phase: "cancelled",
-        cancelReason: cancellation === "foreign"
-            ? `${reason} (the published continuation could not be attributed to this parent and was left running)`
-            : reason,
-        cancelledAt: at,
-    });
+    throw new Error("Durable cancellation unavailable: the original worker scope and observed-waits service are required.");
 }
 
 /**
@@ -2493,17 +2488,22 @@ export async function settleResumedAttemptExit(input: ResumedAttemptExitInput):
 
 export async function reconcileParkedWaits(
     service: WorkerOperationService | undefined,
-    options: {
+    outerOptions: {
         resume(park: ParkedWait): Promise<"resumed" | "held" | "skipped">;
         notify?(message: string, level: "warning"): void;
+        notifyWhen?(meta: RunMeta): boolean;
     },
 ): Promise<{ resumed: number; held: number; skipped: number }> {
     let resumed = 0;
     let held = 0;
     let skipped = 0;
+    const options = outerOptions;
+    const scopedOptions = (meta: RunMeta) => ({ ...outerOptions,
+        notify: outerOptions.notifyWhen && !outerOptions.notifyWhen(meta) ? undefined : outerOptions.notify });
     if (service?.outageReconciliation === 1) {
         try {
             for (const report of pendingObservations()) {
+                const options = scopedOptions(report.meta);
                 try {
                     const scope = backgroundScopeForMeta(report.meta, report.record);
                     if (!scope) continue;
@@ -2569,6 +2569,7 @@ export async function reconcileParkedWaits(
         }
     }
     for (const park of parkedWaits()) {
+        const options = scopedOptions(park.meta);
         try {
             if (park.record.phase === "resuming") {
                 const attemptId = park.record.resumedBy ?? "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-harness",
-  "version": "0.44.0",
+  "version": "0.45.0",
   "description": "Pi extension bundle for a write sandbox, subagents, background tasks, SSH, goals, model routing, and Outcome & Todo.",
   "license": "MIT",
   "type": "module",
@@ -64,7 +64,7 @@
     "pi-ollama-cloud": "0.13.1",
     "pi-better-sandbox": "0.14.1",
     "pi-better-ssh": "0.1.5",
-    "pi-better-subagents": "0.31.0",
+    "pi-better-subagents": "0.32.0",
     "proper-lockfile": "^4.1.2",
     "shell-quote": "1.12.0",
     "smol-toml": "1.9.0",