@fitchmultz/pi-subagents 0.52.17 → 0.52.18

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## 0.52.18 - 2026-11-06
+
+<!-- npm-release:unreleased:start -->
+
+- Keep replied or retired asks out of reply attribution when their queued input reaches a later native turn.
+- Preserve unanswered queued asks through abort recovery without sending a premature recipient-failure reply.
+
+<!-- npm-release:unreleased:end -->
+
+- Keep retired asks out of native reply attribution (#341) ([27a93f9](https://github.com/fitchmultz/pi-subagents/commit/27a93f9bc52aaa9e454ffc593017b66b01461bc4))
+
+### What's Changed
+
+- Keep retired asks out of native reply attribution by @fitchmultz in https://github.com/fitchmultz/pi-subagents/pull/341
+
+**Full Changelog**: https://github.com/fitchmultz/pi-subagents/compare/v0.52.17...v0.52.18
+
 ## 0.52.17 - 2026-11-05
 
 <!-- npm-release:unreleased:start -->

package/dist/build-info.js

@@ -1 +1 @@
-export const EXTENSION_BUILD = Object.freeze({"version":"0.52.17","sha256":"b18d11c5a8e05e11577a3347c2d40808b644af0b5bd5248f4a3314d68c97a640"});
+export const EXTENSION_BUILD = Object.freeze({"version":"0.52.18","sha256":"83db07f9acbdd6ff5985c46e1f5f5411f68b6766697a2dfab019b3d00dbba1c1"});

package/dist/pi-intercom/inbound-delivery.js

@@ -131,7 +131,7 @@ export class InboundDeliveryOwner {
         const trigger = index === -1 ? undefined : rest.splice(index, 1)[0];
         const replyTarget = entries.find((entry) => entry.message.expectsReply === true) ?? trigger;
         if (replyTarget && this.journal.get(replyTarget.message.id) === replyTarget) {
-            this.hooks.replies.queueTurnContext({ ...replyTarget, receivedAt: Date.now() });
+            this.hooks.replies.queueTurnContext(replyTarget.message.id);
         }
         for (const entry of rest) {
             if (!this.live(generation)) {
@@ -218,11 +218,7 @@ export class InboundDeliveryOwner {
             this.journal.markNative(entry.message.id);
         }
         if (delivery !== "passive") {
-            this.hooks.replies.queueTurnContext({
-                from: entry.from,
-                message: entry.message,
-                receivedAt: Date.now(),
-            });
+            this.hooks.replies.queueTurnContext(entry.message.id);
         }
     }
     nativeMessage(entry) {

package/dist/pi-intercom/reply-tracker.js

@@ -55,9 +55,9 @@ function replyBySender(contexts, to) {
 }
 export class ReplyTracker {
     pendingAsks = new Map();
-    pendingTurnContexts = [];
-    currentTurnContext = null;
-    activeAgentContext = null;
+    pendingTurnIds = [];
+    currentTurnId = null;
+    activeAgentId = null;
     askTimeoutMs;
     constructor(askTimeoutMs = 10 * 60 * 1000) {
         this.askTimeoutMs = askTimeoutMs;
@@ -70,61 +70,58 @@ export class ReplyTracker {
         }
         return context;
     }
-    queueTurnContext(context) {
-        if (context.message.expectsReply !== true) {
+    queueTurnContext(messageId) {
+        if (!this.pendingAsks.has(messageId) || this.hasTurnContext(messageId)) {
             return;
         }
-        if (this.hasTurnContext(context.message.id)) {
-            return;
-        }
-        this.pendingTurnContexts.push(context);
+        this.pendingTurnIds.push(messageId);
     }
     beginTurn(now = Date.now()) {
         this.pruneExpired(now);
-        this.currentTurnContext = this.pendingTurnContexts.shift() ?? null;
-        if (this.currentTurnContext) {
-            this.activeAgentContext = this.currentTurnContext;
+        this.currentTurnId = this.pendingTurnIds.shift() ?? null;
+        if (this.currentTurnId !== null) {
+            this.activeAgentId = this.currentTurnId;
         }
     }
     currentTurn() {
-        return this.currentTurnContext ?? this.activeAgentContext;
+        const id = this.currentTurnId ?? this.activeAgentId;
+        return id === null ? null : (this.pendingAsks.get(id) ?? null);
     }
     endTurn() {
-        this.currentTurnContext = null;
+        this.currentTurnId = null;
     }
     endAgent() {
-        this.currentTurnContext = null;
-        this.activeAgentContext = null;
+        this.currentTurnId = null;
+        this.activeAgentId = null;
     }
     reset() {
         this.pendingAsks.clear();
-        this.pendingTurnContexts.length = 0;
-        this.currentTurnContext = null;
-        this.activeAgentContext = null;
+        this.pendingTurnIds.length = 0;
+        this.endAgent();
     }
     expireSender(sessionId) {
-        const expires = (context) => context.from.id === sessionId;
+        const expiring = new Set([...this.pendingAsks.values()]
+            .filter((context) => context.from.id === sessionId)
+            .map((context) => context.message.id));
         let expired = 0;
-        for (const [messageId, context] of this.pendingAsks) {
-            if (expires(context)) {
-                this.pendingAsks.delete(messageId);
-                expired += 1;
-            }
+        for (const messageId of expiring) {
+            this.pendingAsks.delete(messageId);
+            expired += 1;
         }
-        const beforeQueued = this.pendingTurnContexts.length;
-        for (let index = this.pendingTurnContexts.length - 1; index >= 0; index -= 1) {
-            const context = this.pendingTurnContexts[index];
-            if (context !== undefined && expires(context)) {
-                this.pendingTurnContexts.splice(index, 1);
+        const beforeQueued = this.pendingTurnIds.length;
+        for (let index = this.pendingTurnIds.length - 1; index >= 0; index -= 1) {
+            const id = this.pendingTurnIds[index];
+            if (id !== undefined && expiring.has(id)) {
+                this.pendingTurnIds.splice(index, 1);
             }
         }
-        expired += beforeQueued - this.pendingTurnContexts.length;
-        if (this.currentTurnContext && expires(this.currentTurnContext)) {
-            this.currentTurnContext = null;
+        expired += beforeQueued - this.pendingTurnIds.length;
+        if (this.currentTurnId !== null && expiring.has(this.currentTurnId)) {
+            this.currentTurnId = null;
             expired += 1;
         }
-        if (this.activeAgentContext && expires(this.activeAgentContext)) {
-            this.activeAgentContext = null;
+        if (this.activeAgentId !== null && expiring.has(this.activeAgentId)) {
+            this.activeAgentId = null;
             expired += 1;
         }
         return expired;
@@ -132,26 +129,21 @@ export class ReplyTracker {
     resolveReplyTarget(options, now = Date.now()) {
         this.pruneExpired(now);
         const pending = Array.from(this.pendingAsks.values());
-        const contexts = this.currentTurnContext
-            ? [
-                this.currentTurnContext,
-                ...pending.filter((context) => context.message.id !== this.currentTurnContext?.message.id),
-            ]
-            : pending;
         const replyTo = options.replyTo ?? "";
         const to = options.to ?? "";
         if (replyTo !== "") {
-            return explicitReply(contexts, replyTo, to);
+            return explicitReply(pending, replyTo, to);
         }
         if (to !== "") {
-            return replyBySender(contexts, to);
+            return replyBySender(pending, to);
         }
         return this.implicitReplyTarget(pending);
     }
     /** Without an explicit target, the turn context wins, then a sole pending ask. */
     implicitReplyTarget(pending) {
-        if (this.currentTurnContext) {
-            return this.currentTurnContext;
+        const current = this.currentTurnId === null ? undefined : this.pendingAsks.get(this.currentTurnId);
+        if (current) {
+            return current;
         }
         const [solePending] = pending;
         if (pending.length === 1 && solePending !== undefined) {
@@ -170,22 +162,22 @@ export class ReplyTracker {
         return Array.from(this.pendingAsks.values()).sort((a, b) => a.receivedAt - b.receivedAt);
     }
     hasTurnContext(messageId) {
-        return (this.pendingTurnContexts.some((context) => context.message.id === messageId) ||
-            this.currentTurnContext?.message.id === messageId ||
-            this.activeAgentContext?.message.id === messageId);
+        return (this.pendingTurnIds.includes(messageId) ||
+            this.currentTurnId === messageId ||
+            this.activeAgentId === messageId);
     }
     removeContext(messageId) {
         this.pendingAsks.delete(messageId);
-        for (let index = this.pendingTurnContexts.length - 1; index >= 0; index -= 1) {
-            if (this.pendingTurnContexts[index]?.message.id === messageId) {
-                this.pendingTurnContexts.splice(index, 1);
+        for (let index = this.pendingTurnIds.length - 1; index >= 0; index -= 1) {
+            if (this.pendingTurnIds[index] === messageId) {
+                this.pendingTurnIds.splice(index, 1);
             }
         }
-        if (this.currentTurnContext?.message.id === messageId) {
-            this.currentTurnContext = null;
+        if (this.currentTurnId === messageId) {
+            this.currentTurnId = null;
         }
-        if (this.activeAgentContext?.message.id === messageId) {
-            this.activeAgentContext = null;
+        if (this.activeAgentId === messageId) {
+            this.activeAgentId = null;
         }
     }
     pruneExpired(now) {

package/dist/pi-intercom/session-events.js

@@ -46,6 +46,8 @@ export class IntercomSessionEvents {
         if (client?.isConnected() !== true ||
             !context ||
             context.message.expectsReply !== true ||
+            // A native turn can start without consuming its queued input after an abort.
+            journal.get(context.message.id) !== undefined ||
             error === null ||
             error === "") {
             return;

package/docs/intercom.md

@@ -330,8 +330,12 @@ not an end-to-end exactly-once guarantee for arbitrary tool side effects.
 
 Idle recovery preserves admission order within the non-passive backlog and wakes
 once on its last item; passive breadcrumbs are appended before that waking work.
-The first eligible ask remains the implicit reply target, independently of which
-message triggers the turn. A busy recipient's steer is handed to Pi's native
+The first unresolved eligible ask remains the implicit reply target, independently
+of which message triggers the turn. Reply attribution refers to the unresolved
+ask by ID. Placing delayed input does not revive an already replied, expired, or
+retired reply obligation. A failed turn can retire only an ask whose input Pi has
+consumed; queued input remains answerable after abort recovery.
+A busy recipient's steer is handed to Pi's native
 queue and consumed at its next tool boundary; no extension probe asks another
 tool to give up the turn.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fitchmultz/pi-subagents",
-  "version": "0.52.17",
+  "version": "0.52.18",
   "description": "Pi extension for subagent orchestration and local session coordination",
   "license": "MIT",
   "type": "module",

package/src/pi-intercom/inbound-delivery.ts

@@ -185,7 +185,7 @@ export class InboundDeliveryOwner {
     const trigger = index === -1 ? undefined : rest.splice(index, 1)[0];
     const replyTarget = entries.find((entry) => entry.message.expectsReply === true) ?? trigger;
     if (replyTarget && this.journal.get(replyTarget.message.id) === replyTarget) {
-      this.hooks.replies.queueTurnContext({ ...replyTarget, receivedAt: Date.now() });
+      this.hooks.replies.queueTurnContext(replyTarget.message.id);
     }
     for (const entry of rest) {
       if (!this.live(generation)) {
@@ -295,11 +295,7 @@ export class InboundDeliveryOwner {
       this.journal.markNative(entry.message.id);
     }
     if (delivery !== "passive") {
-      this.hooks.replies.queueTurnContext({
-        from: entry.from,
-        message: entry.message,
-        receivedAt: Date.now(),
-      });
+      this.hooks.replies.queueTurnContext(entry.message.id);
     }
   }
   private nativeMessage(entry: InboundMessageEntry): Parameters<ExtensionAPI["sendMessage"]>[0] {

package/src/pi-intercom/reply-tracker.ts

@@ -93,9 +93,9 @@ function replyBySender(contexts: readonly IntercomContext[], to: string): Interc
 }
 export class ReplyTracker {
   private readonly pendingAsks = new Map<string, IntercomContext>();
-  private readonly pendingTurnContexts: IntercomContext[] = [];
-  private currentTurnContext: IntercomContext | null = null;
-  private activeAgentContext: IntercomContext | null = null;
+  private readonly pendingTurnIds: string[] = [];
+  private currentTurnId: string | null = null;
+  private activeAgentId: string | null = null;
   private readonly askTimeoutMs: number;
 
   constructor(askTimeoutMs = 10 * 60 * 1000) {
@@ -115,67 +115,66 @@ export class ReplyTracker {
     return context;
   }
 
-  queueTurnContext(context: IntercomContext): void {
-    if (context.message.expectsReply !== true) {
+  queueTurnContext(messageId: string): void {
+    if (!this.pendingAsks.has(messageId) || this.hasTurnContext(messageId)) {
       return;
     }
-    if (this.hasTurnContext(context.message.id)) {
-      return;
-    }
-    this.pendingTurnContexts.push(context);
+    this.pendingTurnIds.push(messageId);
   }
 
   beginTurn(now = Date.now()): void {
     this.pruneExpired(now);
-    this.currentTurnContext = this.pendingTurnContexts.shift() ?? null;
-    if (this.currentTurnContext) {
-      this.activeAgentContext = this.currentTurnContext;
+    this.currentTurnId = this.pendingTurnIds.shift() ?? null;
+    if (this.currentTurnId !== null) {
+      this.activeAgentId = this.currentTurnId;
     }
   }
 
   currentTurn(): IntercomContext | null {
-    return this.currentTurnContext ?? this.activeAgentContext;
+    const id = this.currentTurnId ?? this.activeAgentId;
+    return id === null ? null : (this.pendingAsks.get(id) ?? null);
   }
 
   endTurn(): void {
-    this.currentTurnContext = null;
+    this.currentTurnId = null;
   }
 
   endAgent(): void {
-    this.currentTurnContext = null;
-    this.activeAgentContext = null;
+    this.currentTurnId = null;
+    this.activeAgentId = null;
   }
 
   reset(): void {
     this.pendingAsks.clear();
-    this.pendingTurnContexts.length = 0;
-    this.currentTurnContext = null;
-    this.activeAgentContext = null;
+    this.pendingTurnIds.length = 0;
+    this.endAgent();
   }
 
   expireSender(sessionId: string): number {
-    const expires = (context: IntercomContext) => context.from.id === sessionId;
+    const expiring = new Set(
+      [...this.pendingAsks.values()]
+        .filter((context) => context.from.id === sessionId)
+        .map((context) => context.message.id),
+    );
     let expired = 0;
-    for (const [messageId, context] of this.pendingAsks) {
-      if (expires(context)) {
-        this.pendingAsks.delete(messageId);
-        expired += 1;
-      }
+    for (const messageId of expiring) {
+      this.pendingAsks.delete(messageId);
+      expired += 1;
     }
-    const beforeQueued = this.pendingTurnContexts.length;
-    for (let index = this.pendingTurnContexts.length - 1; index >= 0; index -= 1) {
-      const context = this.pendingTurnContexts[index];
-      if (context !== undefined && expires(context)) {
-        this.pendingTurnContexts.splice(index, 1);
+    const beforeQueued = this.pendingTurnIds.length;
+    for (let index = this.pendingTurnIds.length - 1; index >= 0; index -= 1) {
+      const id = this.pendingTurnIds[index];
+      if (id !== undefined && expiring.has(id)) {
+        this.pendingTurnIds.splice(index, 1);
       }
     }
-    expired += beforeQueued - this.pendingTurnContexts.length;
-    if (this.currentTurnContext && expires(this.currentTurnContext)) {
-      this.currentTurnContext = null;
+    expired += beforeQueued - this.pendingTurnIds.length;
+    if (this.currentTurnId !== null && expiring.has(this.currentTurnId)) {
+      this.currentTurnId = null;
       expired += 1;
     }
-    if (this.activeAgentContext && expires(this.activeAgentContext)) {
-      this.activeAgentContext = null;
+    if (this.activeAgentId !== null && expiring.has(this.activeAgentId)) {
+      this.activeAgentId = null;
       expired += 1;
     }
     return expired;
@@ -188,30 +187,23 @@ export class ReplyTracker {
     this.pruneExpired(now);
 
     const pending = Array.from(this.pendingAsks.values());
-    const contexts = this.currentTurnContext
-      ? [
-          this.currentTurnContext,
-          ...pending.filter(
-            (context) => context.message.id !== this.currentTurnContext?.message.id,
-          ),
-        ]
-      : pending;
-
     const replyTo = options.replyTo ?? "";
     const to = options.to ?? "";
     if (replyTo !== "") {
-      return explicitReply(contexts, replyTo, to);
+      return explicitReply(pending, replyTo, to);
     }
     if (to !== "") {
-      return replyBySender(contexts, to);
+      return replyBySender(pending, to);
     }
     return this.implicitReplyTarget(pending);
   }
 
   /** Without an explicit target, the turn context wins, then a sole pending ask. */
   private implicitReplyTarget(pending: readonly IntercomContext[]): IntercomContext {
-    if (this.currentTurnContext) {
-      return this.currentTurnContext;
+    const current =
+      this.currentTurnId === null ? undefined : this.pendingAsks.get(this.currentTurnId);
+    if (current) {
+      return current;
     }
     const [solePending] = pending;
     if (pending.length === 1 && solePending !== undefined) {
@@ -234,24 +226,24 @@ export class ReplyTracker {
 
   private hasTurnContext(messageId: string): boolean {
     return (
-      this.pendingTurnContexts.some((context) => context.message.id === messageId) ||
-      this.currentTurnContext?.message.id === messageId ||
-      this.activeAgentContext?.message.id === messageId
+      this.pendingTurnIds.includes(messageId) ||
+      this.currentTurnId === messageId ||
+      this.activeAgentId === messageId
     );
   }
 
   private removeContext(messageId: string): void {
     this.pendingAsks.delete(messageId);
-    for (let index = this.pendingTurnContexts.length - 1; index >= 0; index -= 1) {
-      if (this.pendingTurnContexts[index]?.message.id === messageId) {
-        this.pendingTurnContexts.splice(index, 1);
+    for (let index = this.pendingTurnIds.length - 1; index >= 0; index -= 1) {
+      if (this.pendingTurnIds[index] === messageId) {
+        this.pendingTurnIds.splice(index, 1);
       }
     }
-    if (this.currentTurnContext?.message.id === messageId) {
-      this.currentTurnContext = null;
+    if (this.currentTurnId === messageId) {
+      this.currentTurnId = null;
     }
-    if (this.activeAgentContext?.message.id === messageId) {
-      this.activeAgentContext = null;
+    if (this.activeAgentId === messageId) {
+      this.activeAgentId = null;
     }
   }
 

package/src/pi-intercom/session-events.ts

@@ -33,7 +33,7 @@ type Connection = Readonly<
   >
 >;
 type Journal = Readonly<
-  Pick<InboundJournal, "clearNative" | "consume" | "reconcileConsumed" | "reset" | "retire">
+  Pick<InboundJournal, "clearNative" | "consume" | "get" | "reconcileConsumed" | "reset" | "retire">
 >;
 type ReplyWaitHandle = Readonly<Pick<ReplyWait, "reject">>;
 type InboundDeliveryHandle = Readonly<
@@ -101,6 +101,8 @@ export class IntercomSessionEvents {
       client?.isConnected() !== true ||
       !context ||
       context.message.expectsReply !== true ||
+      // A native turn can start without consuming its queued input after an abort.
+      journal.get(context.message.id) !== undefined ||
       error === null ||
       error === ""
     ) {