@clanker-code/pi-subagents 0.10.7 → 0.10.8

package/CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.10.8] - 2026-06-23
+
+### Changed
+- **`get_subagent_result` wait:true now detects queued user messages** — when the parent session has user messages waiting (e.g. the user typed while waiting), the tool returns early with a `pending_message` outcome instead of blocking for the full wait timeout. The queued message is delivered to the parent LLM immediately. Uses `ctx.hasPendingMessages()` polling during the wait. The subagent continues running undisturbed.
+
 ## [0.10.7] - 2026-06-23
 
 ### Fixed

package/dist/index.js

@@ -42,7 +42,7 @@ import { AgentWidget, buildInvocationTags, describeActivity, formatContextWindow
 import { menuSelect } from "./ui/menu-select.js";
 import { showSchedulesMenu } from "./ui/schedule-menu.js";
 import { addUsage, getLifetimeTotal, getSessionContextPercent } from "./usage.js";
-import { formatWaitTimeout, raceWait, waitTimeoutMessage } from "./wait.js";
+import { formatWaitTimeout, pollPendingMessages, raceWait, waitTimeoutMessage } from "./wait.js";
 // ---- Shared helpers ----
 /** Tool execute return value for a text response. */
 function textResult(msg, details) {
@@ -928,7 +928,7 @@ export default function (pi) {
                 description: "Return a lightweight tail/filter view of the agent's result or live output file, with line numbers. Ignored when verbose is true.",
             })),
         }),
-        execute: async (_toolCallId, params, signal, _onUpdate, _ctx) => {
+        execute: async (_toolCallId, params, signal, _onUpdate, ctx) => {
             const record = manager.getRecord(params.agent_id);
             if (!record) {
                 return textResult(`Agent not found: "${params.agent_id}". It may have been cleaned up.`);
@@ -946,7 +946,18 @@ export default function (pi) {
             let waitOutcome = "completed";
             if (params.wait && record.status === "running" && record.promise) {
                 cancelNudge(params.agent_id);
-                waitOutcome = await raceWait(record.promise, signal, getWaitTimeoutSeconds());
+                // Poll for queued user messages so we can return early and let the
+                // parent LLM process them immediately instead of blocking for the
+                // full wait timeout.
+                const pending = typeof ctx?.hasPendingMessages === "function"
+                    ? pollPendingMessages(() => ctx.hasPendingMessages())
+                    : undefined;
+                try {
+                    waitOutcome = await raceWait(record.promise, signal, getWaitTimeoutSeconds(), pending?.promise);
+                }
+                finally {
+                    pending?.cancel();
+                }
                 if (waitOutcome === "completed") {
                     record.resultConsumed = true;
                 }

package/dist/wait.d.ts

@@ -1,10 +1,24 @@
-export type WaitOutcome = "completed" | "timeout" | "aborted";
+export type WaitOutcome = "completed" | "timeout" | "aborted" | "pending_message";
 /** Human-readable "Xm Ys" for a duration in seconds. */
 export declare function formatWaitTimeout(seconds: number): string;
 /**
- * Race an agent completion promise against the configured wait timeout and the
- * parent abort signal. The subagent is never aborted here.
+ * Race an agent completion promise against the configured wait timeout, the
+ * parent abort signal, and an optional pending-message check. The subagent is
+ * never aborted here.
+ *
+ * @param pendingCheck - Optional promise that resolves when the parent session
+ *   has queued user messages waiting to be delivered. When it resolves, the
+ *   wait ends early so the parent turn can process the incoming message.
  */
-export declare function raceWait(promise: Promise<string>, signal: AbortSignal | undefined, timeoutSeconds: number): Promise<WaitOutcome>;
+export declare function raceWait(promise: Promise<string>, signal: AbortSignal | undefined, timeoutSeconds: number, pendingCheck?: Promise<void>): Promise<WaitOutcome>;
 /** Message returned when a wait ends with the agent still running. */
 export declare function waitTimeoutMessage(outcome: WaitOutcome, timeoutSeconds: number): string;
+/**
+ * Create a promise that resolves when the parent session has queued user
+ * messages. Polls at the given interval until `hasPendingMessages()` returns
+ * true. The caller should race this against the agent completion / timeout.
+ */
+export declare function pollPendingMessages(hasPendingMessages: () => boolean, intervalMs?: number): {
+    promise: Promise<void>;
+    cancel: () => void;
+};

package/dist/wait.js

@@ -5,10 +5,15 @@ export function formatWaitTimeout(seconds) {
     return m > 0 ? `${m}m${s > 0 ? ` ${s}s` : ""}` : `${s}s`;
 }
 /**
- * Race an agent completion promise against the configured wait timeout and the
- * parent abort signal. The subagent is never aborted here.
+ * Race an agent completion promise against the configured wait timeout, the
+ * parent abort signal, and an optional pending-message check. The subagent is
+ * never aborted here.
+ *
+ * @param pendingCheck - Optional promise that resolves when the parent session
+ *   has queued user messages waiting to be delivered. When it resolves, the
+ *   wait ends early so the parent turn can process the incoming message.
  */
-export function raceWait(promise, signal, timeoutSeconds) {
+export function raceWait(promise, signal, timeoutSeconds, pendingCheck) {
     return new Promise((resolve) => {
         let settled = false;
         const finish = (outcome) => {
@@ -23,6 +28,7 @@ export function raceWait(promise, signal, timeoutSeconds) {
         const onAbort = () => finish("aborted");
         signal?.addEventListener("abort", onAbort, { once: true });
         promise.then(() => finish("completed"));
+        pendingCheck?.then(() => finish("pending_message"));
     });
 }
 /** Message returned when a wait ends with the agent still running. */
@@ -33,5 +39,44 @@ export function waitTimeoutMessage(outcome, timeoutSeconds) {
     if (outcome === "aborted") {
         return `Agent is still running. The wait was cancelled by the user (parent turn aborted). The subagent was NOT stopped — it continues in the background.\nCall get_subagent_result with wait: true again to keep waiting, use peek to check progress, or omit wait to check status.`;
     }
+    if (outcome === "pending_message") {
+        return `Agent is still running. The wait was interrupted by an incoming user message. The subagent was NOT stopped — it continues in the background.\nThe queued message will be delivered after this tool returns.\nCall get_subagent_result with wait: true again to keep waiting, use peek to check progress, or omit wait to check status.`;
+    }
     return "Agent is still running. Use peek to check recent progress, wait: true to block until it finishes, or check back later.";
 }
+/**
+ * Create a promise that resolves when the parent session has queued user
+ * messages. Polls at the given interval until `hasPendingMessages()` returns
+ * true. The caller should race this against the agent completion / timeout.
+ */
+export function pollPendingMessages(hasPendingMessages, intervalMs = 1000) {
+    let settled = false;
+    let resolve;
+    const promise = new Promise((r) => { resolve = r; });
+    // Check immediately in case a message arrived between the tool call
+    // start and this poll setup.
+    if (hasPendingMessages()) {
+        settled = true;
+        resolve();
+        return { promise, cancel: () => { } };
+    }
+    const timer = setInterval(() => {
+        if (settled)
+            return;
+        if (hasPendingMessages()) {
+            settled = true;
+            clearInterval(timer);
+            resolve();
+        }
+    }, intervalMs);
+    return {
+        promise,
+        cancel: () => {
+            if (!settled) {
+                settled = true;
+                clearInterval(timer);
+                resolve();
+            }
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clanker-code/pi-subagents",
-  "version": "0.10.7",
+  "version": "0.10.8",
   "description": "A pi extension extension that brings smart Claude Code-style autonomous sub-agents to pi.",
   "author": "clankercode",
   "license": "MIT",

package/src/index.ts

@@ -55,7 +55,7 @@ import type { WidgetAgentSnapshot, WidgetDisplayMode } from "./ui/agent-widget-t
 import { menuSelect } from "./ui/menu-select.js";
 import { showSchedulesMenu } from "./ui/schedule-menu.js";
 import { addUsage, getLifetimeTotal, getSessionContextPercent } from "./usage.js";
-import { formatWaitTimeout, raceWait, type WaitOutcome, waitTimeoutMessage } from "./wait.js";
+import { formatWaitTimeout, pollPendingMessages, raceWait, type WaitOutcome, waitTimeoutMessage } from "./wait.js";
 
 // ---- Shared helpers ----
 
@@ -1077,7 +1077,7 @@ export default function (pi: ExtensionAPI) {
         }),
       ),
     }),
-    execute: async (_toolCallId, params, signal, _onUpdate, _ctx) => {
+    execute: async (_toolCallId, params, signal, _onUpdate, ctx) => {
       const record = manager.getRecord(params.agent_id);
       if (!record) {
         return textResult(`Agent not found: "${params.agent_id}". It may have been cleaned up.`);
@@ -1099,7 +1099,17 @@ export default function (pi: ExtensionAPI) {
       let waitOutcome: WaitOutcome = "completed";
       if (params.wait && record.status === "running" && record.promise) {
         cancelNudge(params.agent_id);
-        waitOutcome = await raceWait(record.promise, signal, getWaitTimeoutSeconds());
+        // Poll for queued user messages so we can return early and let the
+        // parent LLM process them immediately instead of blocking for the
+        // full wait timeout.
+        const pending = typeof ctx?.hasPendingMessages === "function"
+          ? pollPendingMessages(() => ctx.hasPendingMessages())
+          : undefined;
+        try {
+          waitOutcome = await raceWait(record.promise, signal, getWaitTimeoutSeconds(), pending?.promise);
+        } finally {
+          pending?.cancel();
+        }
         if (waitOutcome === "completed") {
           record.resultConsumed = true;
         }

package/src/wait.ts

@@ -1,4 +1,4 @@
-export type WaitOutcome = "completed" | "timeout" | "aborted";
+export type WaitOutcome = "completed" | "timeout" | "aborted" | "pending_message";
 
 /** Human-readable "Xm Ys" for a duration in seconds. */
 export function formatWaitTimeout(seconds: number): string {
@@ -8,13 +8,19 @@ export function formatWaitTimeout(seconds: number): string {
 }
 
 /**
- * Race an agent completion promise against the configured wait timeout and the
- * parent abort signal. The subagent is never aborted here.
+ * Race an agent completion promise against the configured wait timeout, the
+ * parent abort signal, and an optional pending-message check. The subagent is
+ * never aborted here.
+ *
+ * @param pendingCheck - Optional promise that resolves when the parent session
+ *   has queued user messages waiting to be delivered. When it resolves, the
+ *   wait ends early so the parent turn can process the incoming message.
  */
 export function raceWait(
   promise: Promise<string>,
   signal: AbortSignal | undefined,
   timeoutSeconds: number,
+  pendingCheck?: Promise<void>,
 ): Promise<WaitOutcome> {
   return new Promise((resolve) => {
     let settled = false;
@@ -29,6 +35,7 @@ export function raceWait(
     const onAbort = () => finish("aborted");
     signal?.addEventListener("abort", onAbort, { once: true });
     promise.then(() => finish("completed"));
+    pendingCheck?.then(() => finish("pending_message"));
   });
 }
 
@@ -40,5 +47,50 @@ export function waitTimeoutMessage(outcome: WaitOutcome, timeoutSeconds: number)
   if (outcome === "aborted") {
     return `Agent is still running. The wait was cancelled by the user (parent turn aborted). The subagent was NOT stopped — it continues in the background.\nCall get_subagent_result with wait: true again to keep waiting, use peek to check progress, or omit wait to check status.`;
   }
+  if (outcome === "pending_message") {
+    return `Agent is still running. The wait was interrupted by an incoming user message. The subagent was NOT stopped — it continues in the background.\nThe queued message will be delivered after this tool returns.\nCall get_subagent_result with wait: true again to keep waiting, use peek to check progress, or omit wait to check status.`;
+  }
   return "Agent is still running. Use peek to check recent progress, wait: true to block until it finishes, or check back later.";
 }
+
+/**
+ * Create a promise that resolves when the parent session has queued user
+ * messages. Polls at the given interval until `hasPendingMessages()` returns
+ * true. The caller should race this against the agent completion / timeout.
+ */
+export function pollPendingMessages(
+  hasPendingMessages: () => boolean,
+  intervalMs = 1000,
+): { promise: Promise<void>; cancel: () => void } {
+  let settled = false;
+  let resolve!: () => void;
+  const promise = new Promise<void>((r) => { resolve = r; });
+
+  // Check immediately in case a message arrived between the tool call
+  // start and this poll setup.
+  if (hasPendingMessages()) {
+    settled = true;
+    resolve();
+    return { promise, cancel: () => {} };
+  }
+
+  const timer = setInterval(() => {
+    if (settled) return;
+    if (hasPendingMessages()) {
+      settled = true;
+      clearInterval(timer);
+      resolve();
+    }
+  }, intervalMs);
+
+  return {
+    promise,
+    cancel: () => {
+      if (!settled) {
+        settled = true;
+        clearInterval(timer);
+        resolve();
+      }
+    },
+  };
+}