@ryan_nookpi/pi-extension-subagent 0.5.12 → 0.5.13

package/README.md

@@ -41,7 +41,7 @@ Equivalent AI tool call:
 { "command": "subagent run worker --isolated -- implement the requested change and run tests" }
 ```
 
-Tool launches are asynchronous. Wait for the automatic completion or failure follow-up instead of polling immediately.
+Tool launches are asynchronous. Wait for the automatic completion or failure follow-up instead of polling immediately. Pi drops queued messages when you press Escape; if a completion was still queued when the run stops, it is added to the session without starting a new turn, and the agent sees it with your next message.
 
 ## Agent definitions
 

package/delivery-guard.ts

@@ -0,0 +1,103 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+type SendMessage = ExtensionAPI["sendMessage"];
+type Message = Parameters<SendMessage>[0];
+
+const GUARD_ID_KEY = "deliveryGuardId";
+
+function guardId(message: unknown): string | undefined {
+	const details = (message as { details?: unknown } | undefined)?.details;
+	if (!details || typeof details !== "object") return undefined;
+	const id = (details as Record<string, unknown>)[GUARD_ID_KEY];
+	return typeof id === "string" ? id : undefined;
+}
+
+/**
+ * Pi keeps steer and follow-up messages in an in-memory queue until the agent loop picks them up, and
+ * Escape clears that queue without restoring custom messages. A completion queued while the agent was
+ * busy would vanish. This tracks every turn-triggering message queued during a run, and when the run
+ * settles without the message reaching the model, appends it to the session without starting a turn:
+ * the user sees it now, and the model sees it on the next prompt.
+ *
+ * Extensions cannot tell Escape from other aborts: Pi's pending count covers only typed messages, not
+ * extension messages. An abort while the model streams keeps the original queued, and Pi delivers it on
+ * the next run after the restored copy. Both carry the same guard id, so the model input keeps only the first.
+ */
+export function guardQueuedDeliveries(pi: ExtensionAPI): ExtensionAPI {
+	let context: ExtensionContext | undefined;
+	let nextId = 0;
+	const queued = new Map<string, Message>();
+
+	const busy = () => {
+		try {
+			return context ? !context.isIdle() : false;
+		} catch {
+			return false;
+		}
+	};
+
+	const restored = new Set<string>();
+
+	pi.on("agent_start", (_event, ctx) => {
+		context = ctx;
+	});
+	pi.on("message_end", (event) => {
+		const id = guardId(event.message);
+		if (id) queued.delete(id);
+	});
+	pi.on("agent_settled", (_event, ctx) => {
+		context = ctx;
+		if (queued.size === 0) return;
+		const lost = [...queued.entries()];
+		queued.clear();
+		for (const [id, message] of lost) {
+			restored.add(id);
+			pi.sendMessage(message, { triggerTurn: false });
+		}
+	});
+	pi.on("context", (event) => {
+		if (restored.size === 0) return;
+		const seen = new Set<string>();
+		let dropped = false;
+		const messages = event.messages.filter((message) => {
+			const id = guardId(message);
+			if (!id || !restored.has(id)) return true;
+			if (!seen.has(id)) {
+				seen.add(id);
+				return true;
+			}
+			dropped = true;
+			return false;
+		});
+		return dropped ? { messages } : undefined;
+	});
+	pi.on("session_shutdown", () => {
+		queued.clear();
+		restored.clear();
+		context = undefined;
+	});
+
+	return new Proxy(pi, {
+		get(target, property, receiver) {
+			if (property !== "sendMessage") return Reflect.get(target, property, receiver);
+			const send: SendMessage = (message, options) => {
+				// An idle send starts its own run with the message as the prompt, so nothing can drop it.
+				if (options?.triggerTurn !== true || options.deliverAs === "nextTurn" || !busy()) {
+					target.sendMessage(message, options);
+					return;
+				}
+				const id = String(++nextId);
+				const details = message.details && typeof message.details === "object" ? message.details : {};
+				const tagged = { ...message, details: { ...details, [GUARD_ID_KEY]: id } } as Message;
+				queued.set(id, tagged);
+				try {
+					target.sendMessage(tagged, options);
+				} catch (error) {
+					queued.delete(id);
+					throw error;
+				}
+			};
+			return send;
+		},
+	});
+}

package/index.ts

@@ -30,6 +30,7 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { SubagentAsyncTasks } from "./async-task-lifecycle.js";
 import { HANG_CHECK_INTERVAL_MS } from "./constants.js";
+import { guardQueuedDeliveries } from "./delivery-guard.js";
 import { SUBAGENT_COMMANDS, SUBAGENT_SHORTCUTS, type SubagentCommandName } from "./registration-manifest.js";
 import { handleRunningReminderContext, ReminderAnchors } from "./running-reminder.js";
 
@@ -41,7 +42,9 @@ interface SubagentCore {
 	lifecycle: typeof import("./lifecycle.js");
 }
 
-export default function (pi: ExtensionAPI) {
+export default function (host: ExtensionAPI) {
+	// Completions are queued while the agent is busy; the guard restores any the queue drops on Escape.
+	const pi = guardQueuedDeliveries(host);
 	const asyncTasks = new SubagentAsyncTasks(pi);
 	let core: SubagentCore | null = null;
 	let corePromise: Promise<SubagentCore> | null = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryan_nookpi/pi-extension-subagent",
-  "version": "0.5.12",
+  "version": "0.5.13",
   "description": "Asynchronous subagent delegation for pi with run, batch, chain, and continuation workflows.",
   "license": "MIT",
   "repository": {
@@ -32,6 +32,7 @@
     "config.ts",
     "constants.ts",
     "context-limits.ts",
+    "delivery-guard.ts",
     "diagnostics.ts",
     "display-task.ts",
     "escalation.ts",