@fitchmultz/pi-subagents 0.52.18 → 0.52.20

package/src/pi-intercom/bridge-wake.ts

@@ -15,6 +15,12 @@ interface Candidate {
   readonly entry: PendingNotification;
 }
 
+type DeliveryPhase =
+  | { readonly kind: "idle" }
+  | { readonly kind: "scheduled"; readonly timer: NodeJS.Timeout }
+  | { readonly kind: "running" | "running-dirty"; readonly task: Promise<void> }
+  | { readonly kind: "stopped"; readonly task: Promise<void> };
+
 function actionable(entry: PendingNotification): boolean {
   const message = entry.message;
   if (entry.acknowledged || message.passive === true || message.delivery === "passive") {
@@ -39,9 +45,7 @@ export class WakeDeliveries {
   private readonly allowed: (identity: Identity) => boolean;
   private readonly deliveries = new Map<string, Delivery>();
   private readonly controller = new AbortController();
-  private timer?: NodeJS.Timeout;
-  private running?: Promise<void> | undefined;
-  private dirty = false;
+  private phase: DeliveryPhase = { kind: "idle" };
   private storageBackoff = 15000;
 
   constructor(stateDir: string | undefined, allowed: (identity: Identity) => boolean) {
@@ -83,10 +87,17 @@ export class WakeDeliveries {
     } catch {
       // The scheduled storage recovery fails closed; never let an event bypass durable admission.
     }
-    if (this.running) {
-      this.dirty = true;
-    } else {
-      this.schedule(Date.now());
+    const phase = this.phase;
+    switch (phase.kind) {
+      case "running":
+        this.phase = { kind: "running-dirty", task: phase.task };
+        return;
+      case "running-dirty":
+      case "stopped":
+        return;
+      case "idle":
+      case "scheduled":
+        this.schedule(Date.now());
     }
   }
 
@@ -101,31 +112,40 @@ export class WakeDeliveries {
   }
 
   private schedule(deadline: number): void {
-    clearTimeout(this.timer);
-    this.timer = setTimeout(
-      () => {
-        this.dirty = false;
-        let next = Infinity;
-        this.running = this.deliver()
-          .then((due) => {
-            next = due;
-            this.storageBackoff = 15000;
-            return;
-          })
-          .catch(() => {
-            log("wake_delivery", { result: "storage_unavailable" });
-            next = Date.now() + this.storageBackoff;
-            this.storageBackoff = Math.min(this.storageBackoff * 2, 300000);
-          })
-          .finally(() => {
-            this.running = undefined;
-            if (!this.controller.signal.aborted && (this.dirty || Number.isFinite(next))) {
-              this.schedule(this.dirty ? Date.now() : next);
-            }
-          });
-      },
+    if (this.phase.kind === "scheduled") {
+      clearTimeout(this.phase.timer);
+    }
+    const timer = setTimeout(
+      () => this.startDelivery(),
       Math.max(0, Math.min(deadline - Date.now(), 0x7fffffff)),
     );
+    this.phase = { kind: "scheduled", timer };
+  }
+
+  private startDelivery(): void {
+    let next = Infinity;
+    const task = this.deliver()
+      .then((due) => {
+        next = due;
+        this.storageBackoff = 15000;
+        return;
+      })
+      .catch(() => {
+        log("wake_delivery", { result: "storage_unavailable" });
+        next = Date.now() + this.storageBackoff;
+        this.storageBackoff = Math.min(this.storageBackoff * 2, 300000);
+      })
+      .finally(() => {
+        if (this.phase.kind === "stopped") {
+          return;
+        }
+        const dirty = this.phase.kind === "running-dirty";
+        this.phase = { kind: "idle" };
+        if (dirty || Number.isFinite(next)) {
+          this.schedule(dirty ? Date.now() : next);
+        }
+      });
+    this.phase = { kind: "running", task };
   }
 
   private authorized(delivery: Delivery): boolean {
@@ -267,14 +287,26 @@ export class WakeDeliveries {
     this.changed(false);
   }
 
-  async stop(): Promise<void> {
-    this.controller.abort();
-    clearTimeout(this.timer);
-    await this.running;
-    for (const delivery of this.deliveries.values()) {
-      delivery.mailbox.close();
+  stop(): Promise<void> {
+    const phase = this.phase;
+    if (phase.kind === "stopped") {
+      return phase.task;
     }
-    this.deliveries.clear();
-    this.state?.close();
+    if (phase.kind === "scheduled") {
+      clearTimeout(phase.timer);
+    }
+    const running =
+      phase.kind === "running" || phase.kind === "running-dirty" ? phase.task : undefined;
+    const task = Promise.resolve(running).then(() => {
+      for (const delivery of this.deliveries.values()) {
+        delivery.mailbox.close();
+      }
+      this.deliveries.clear();
+      this.state?.close();
+      return;
+    });
+    this.phase = { kind: "stopped", task };
+    this.controller.abort();
+    return task;
   }
 }

package/src/pi-intercom/broker/broker.ts

@@ -29,6 +29,7 @@ import {
   snapshotFrames,
   TopicSnapshot,
   publicationMessage,
+  preparedPublication,
   deliveryAcknowledgement,
   shouldReplaceDelivery,
 } from "./snapshots.ts";
@@ -245,7 +246,7 @@ class IntercomBroker {
         ? session.info
         : session.topics.snapshot(session.info, prepared);
       const from = messageSender(nextInfo);
-      const deliveries = this.planPublications(currentId, from, prepared.publication);
+      const deliveries = this.planPublications(currentId, from, preparedPublication(prepared));
       // Validate every frame before committing state or delivering publications.
       if (prepared.restore) {
         session.topics.validateRestore(session.info, prepared, requestId);

package/src/pi-intercom/broker/client-last.ts

@@ -18,6 +18,7 @@ import {
   type SessionInfo,
 } from "../types.ts";
 import { writeMessage } from "./framing.ts";
+import { PendingRequests } from "./pending-requests.ts";
 
 /** A peer's read of this session or, for a main, of its exited `parked` child. */
 export function lastRequest(msg: UnknownRecord): {
@@ -46,35 +47,25 @@ export class LastMessageRequests {
   constructor(timeoutMs: number) {
     this.timeoutMs = timeoutMs;
   }
-  private readonly pending = new Map<
-    string,
-    {
-      readonly resolve: (result: NativeReadResult) => void;
-      readonly reject: (error: Readonly<Error>) => void;
-      readonly timer: NodeJS.Timeout;
-    }
-  >();
+  private readonly pending = new PendingRequests<{
+    readonly resolve: (result: NativeReadResult) => void;
+    readonly reject: (error: Readonly<Error>) => void;
+  }>();
 
   fail(error: Readonly<Error>): void {
     this.lastMessages = false;
     this.receiptReads = false;
-    for (const pending of this.pending.values()) {
-      clearTimeout(pending.timer);
-      pending.reject(error);
-    }
-    this.pending.clear();
+    this.pending.fail(error);
   }
 
   receive(message: UnknownRecord): void {
     if (typeof message.requestId !== "string" || !isNativeReadResult(message.result)) {
       throw new Error("Invalid last-message response");
     }
-    const pending = this.pending.get(message.requestId);
+    const pending = this.pending.take(message.requestId);
     if (!pending) {
       return;
     }
-    clearTimeout(pending.timer);
-    this.pending.delete(message.requestId);
     pending.resolve(message.result);
   }
 
@@ -100,18 +91,16 @@ export class LastMessageRequests {
     }
     return new Promise((resolve, reject) => {
       const requestId = randomUUID();
-      const timer = setTimeout(() => {
-        this.pending.delete(requestId);
-        reject(new Error("Last-message read timeout"));
-      }, this.timeoutMs);
-      timer.unref();
-      this.pending.set(requestId, { resolve, reject, timer });
+      this.pending.set(
+        requestId,
+        { resolve, reject },
+        this.timeoutMs,
+        () => new Error("Last-message read timeout"),
+      );
       try {
         writeMessage(socket, { type: "last_request", requestId, to, query });
       } catch (error) {
-        clearTimeout(timer);
-        this.pending.delete(requestId);
-        reject(new Error(errorMessage(error)));
+        this.pending.take(requestId)?.reject(new Error(errorMessage(error)));
       }
     });
   }

package/src/pi-intercom/broker/client.ts

@@ -4,6 +4,7 @@ import { randomUUID } from "crypto";
 import { writeMessage } from "./framing.ts";
 import { BrokerConnection, connectBrokerSocket } from "./connection.ts";
 import { SnapshotReader } from "./snapshot-reader.ts";
+import { PendingRequests } from "./pending-requests.ts";
 import { LastMessageRequests, lastRequest } from "./client-last.ts";
 import { ParkRequests } from "./client-park.ts";
 import { WakeMessages } from "./client-wake.ts";
@@ -70,18 +71,15 @@ export class IntercomClient extends EventEmitter {
   readonly wakes = new WakeMessages(this, () => this.requireActiveSocket());
   private guardedDeliverySupported = false;
   private readonly lastRequests: LastMessageRequests;
-  private readonly pendingSends = new Map<
-    string,
-    { readonly resolve: (r: SendResult) => void; readonly reject: (e: Readonly<Error>) => void }
-  >();
-  private readonly pendingLists = new Map<
-    string,
-    {
-      readonly resolve: (snapshot: SessionSnapshot) => void;
-      readonly reject: (e: Readonly<Error>) => void;
-      readonly reader: SnapshotReader;
-    }
-  >();
+  private readonly pendingSends = new PendingRequests<{
+    readonly resolve: (r: SendResult) => void;
+    readonly reject: (e: Readonly<Error>) => void;
+  }>();
+  private readonly pendingLists = new PendingRequests<{
+    readonly resolve: (snapshot: SessionSnapshot) => void;
+    readonly reject: (e: Readonly<Error>) => void;
+    readonly reader: SnapshotReader;
+  }>();
   private connecting = false;
   private disconnecting = false;
   private readonly sendTimeoutMs: number;
@@ -96,14 +94,8 @@ export class IntercomClient extends EventEmitter {
 
   private failPending(error: Readonly<Error>): void {
     this.lastRequests.fail(error);
-    for (const pending of this.pendingSends.values()) {
-      pending.reject(error);
-    }
-    this.pendingSends.clear();
-    for (const pending of this.pendingLists.values()) {
-      pending.reject(error);
-    }
-    this.pendingLists.clear();
+    this.pendingSends.fail(error);
+    this.pendingLists.fail(error);
   }
 
   get sessionId(): string | null {
@@ -301,12 +293,11 @@ export class IntercomClient extends EventEmitter {
     if (type !== "delivered" && typeof reason !== "string") {
       throw new Error(`Invalid ${errorMessage(type)} message`);
     }
-    const pending = this.pendingSends.get(messageId);
+    const pending = this.pendingSends.take(messageId);
     // Late responses are harmless after the caller has timed out.
     if (!pending) {
       return;
     }
-    this.pendingSends.delete(messageId);
     pending.resolve({
       id: messageId,
       accepted: type !== "delivery_failed",
@@ -330,14 +321,12 @@ export class IntercomClient extends EventEmitter {
       return;
     }
     if (typeof error === "string") {
-      this.pendingLists.delete(requestId);
-      pending.reject(new Error(error));
+      this.pendingLists.take(requestId)?.reject(new Error(error));
       return;
     }
     pending.reader.append(sessions, receipts);
     if (more !== true) {
-      this.pendingLists.delete(requestId);
-      pending.resolve(pending.reader.finish());
+      this.pendingLists.take(requestId)?.resolve(pending.reader.finish());
     }
   }
 
@@ -396,8 +385,8 @@ export class IntercomClient extends EventEmitter {
 
     return new Promise((resolve, reject) => {
       const requestId = randomUUID();
+      const reader = new SnapshotReader();
       const wrappedResolve = (snapshot: SessionSnapshot) => {
-        clearTimeout(timeout);
         try {
           // Commit confirmed subscriptions before handling a following message in the same read.
           onAccepted?.(snapshot);
@@ -407,23 +396,19 @@ export class IntercomClient extends EventEmitter {
         }
       };
       const wrappedReject = (error: Readonly<Error>) => {
-        clearTimeout(timeout);
+        reader.fail();
         reject(error);
       };
-      const timeout = setTimeout(() => {
-        if (this.pendingLists.has(requestId)) {
-          this.pendingLists.delete(requestId);
-          wrappedReject(
-            Object.assign(new Error("List sessions timeout"), { code: "list_timeout" }),
-          );
-        }
-      }, this.listTimeoutMs);
-      timeout.unref();
-      this.pendingLists.set(requestId, {
-        resolve: wrappedResolve,
-        reject: wrappedReject,
-        reader: new SnapshotReader(),
-      });
+      this.pendingLists.set(
+        requestId,
+        {
+          resolve: wrappedResolve,
+          reject: wrappedReject,
+          reader,
+        },
+        this.listTimeoutMs,
+        () => Object.assign(new Error("List sessions timeout"), { code: "list_timeout" }),
+      );
       try {
         writeMessage(socket, {
           type: "list",
@@ -432,9 +417,7 @@ export class IntercomClient extends EventEmitter {
           ...(change ? { change } : {}),
         });
       } catch (error) {
-        clearTimeout(timeout);
-        this.pendingLists.delete(requestId);
-        reject(toError(error));
+        this.pendingLists.take(requestId)?.reject(toError(error));
       }
     });
   }
@@ -456,7 +439,7 @@ export class IntercomClient extends EventEmitter {
     }
 
     const messageId = options.messageId ?? (options.guard ? "" : randomUUID());
-    if (this.pendingSends.has(messageId)) {
+    if (this.pendingSends.get(messageId)) {
       return Promise.reject(new Error("Message ID already has a pending send"));
     }
     const message: Message = {
@@ -482,22 +465,12 @@ export class IntercomClient extends EventEmitter {
       return Promise.reject(new Error("Invalid message format"));
     }
     return new Promise((resolve, reject) => {
-      const wrappedResolve = (result: SendResult) => {
-        clearTimeout(timeout);
-        resolve(result);
-      };
-      const wrappedReject = (error: Readonly<Error>) => {
-        clearTimeout(timeout);
-        reject(error);
-      };
-      const timeout = setTimeout(() => {
-        if (this.pendingSends.has(messageId)) {
-          this.pendingSends.delete(messageId);
-          wrappedReject(new Error("Send timeout"));
-        }
-      }, this.sendTimeoutMs);
-      timeout.unref();
-      this.pendingSends.set(messageId, { resolve: wrappedResolve, reject: wrappedReject });
+      this.pendingSends.set(
+        messageId,
+        { resolve, reject },
+        this.sendTimeoutMs,
+        () => new Error("Send timeout"),
+      );
 
       try {
         writeMessage(socket, {
@@ -506,9 +479,7 @@ export class IntercomClient extends EventEmitter {
           message: this._topicsSupported ? compactTopicMessage(message) : message,
         });
       } catch (error) {
-        clearTimeout(timeout);
-        this.pendingSends.delete(messageId);
-        reject(toError(error));
+        this.pendingSends.take(messageId)?.reject(toError(error));
       }
     });
   }

package/src/pi-intercom/broker/pending-requests.ts

@@ -0,0 +1,37 @@
+interface Request {
+  readonly reject: (error: Readonly<Error>) => void;
+}
+
+/** Map membership owns settlement; taking a request also releases its deadline. */
+export class PendingRequests<T extends Request> {
+  private readonly pending = new Map<
+    string,
+    { readonly value: T; readonly timer: NodeJS.Timeout }
+  >();
+
+  get(id: string): T | undefined {
+    return this.pending.get(id)?.value;
+  }
+
+  set(id: string, value: T, timeoutMs: number, timeoutError: () => Error): void {
+    const timer = setTimeout(() => this.take(id)?.reject(timeoutError()), timeoutMs);
+    timer.unref();
+    this.pending.set(id, { value, timer });
+  }
+
+  take(id: string): T | undefined {
+    const pending = this.pending.get(id);
+    if (pending === undefined) {
+      return;
+    }
+    this.pending.delete(id);
+    clearTimeout(pending.timer);
+    return pending.value;
+  }
+
+  fail(error: Readonly<Error>): void {
+    for (const id of this.pending.keys()) {
+      this.take(id)?.reject(error);
+    }
+  }
+}

package/src/pi-intercom/broker/snapshot-reader.ts

@@ -58,6 +58,14 @@ interface SessionParts {
   readonly subscriptions: TopicSubscription[] | undefined;
 }
 
+type SnapshotPhase =
+  | {
+      readonly kind: "open";
+      readonly sessions: Map<string, SessionParts>;
+      readonly receipts: Receipt[];
+    }
+  | { readonly kind: "finished" | "failed" };
+
 function appendRows<T>(
   previous: T[] | undefined,
   rows: readonly T[] | undefined,
@@ -75,16 +83,28 @@ function appendRows<T>(
 
 /** Multipart frames build a private cache; only a complete validated snapshot escapes. */
 export class SnapshotReader {
-  private readonly sessions = new Map<string, SessionParts>();
-  private readonly receipts: Receipt[] = [];
+  private phase: SnapshotPhase = { kind: "open", sessions: new Map(), receipts: [] };
+
+  private open(): Extract<SnapshotPhase, { readonly kind: "open" }> {
+    if (this.phase.kind !== "open") {
+      throw new Error(`Session snapshot is ${this.phase.kind}`);
+    }
+    return this.phase;
+  }
 
-  private addSession(row: unknown): void {
+  fail(): void {
+    if (this.phase.kind === "open") {
+      this.phase = { kind: "failed" };
+    }
+  }
+
+  private addSession(state: Extract<SnapshotPhase, { readonly kind: "open" }>, row: unknown): void {
     if (!isRecord(row) || typeof row.id !== "string") {
       throw new Error("Invalid session snapshot row");
     }
     const topics = optionalArray(row.topics);
     const subscriptions = optionalArray(row.subscriptions);
-    const previous = this.sessions.get(row.id);
+    const previous = state.sessions.get(row.id);
     const info = normalizeSessionInfo({
       ...previous?.info,
       ...row,
@@ -95,7 +115,7 @@ export class SnapshotReader {
       throw new Error("Invalid session snapshot");
     }
     const { topics: newTopics, subscriptions: newSubscriptions, ...identity } = info;
-    this.sessions.set(info.id, {
+    state.sessions.set(info.id, {
       info: identity,
       topics: appendRows(previous?.topics, newTopics, "topics" in row),
       subscriptions: appendRows(previous?.subscriptions, newSubscriptions, "subscriptions" in row),
@@ -103,27 +123,35 @@ export class SnapshotReader {
   }
 
   append(sessions: readonly unknown[], receipts: unknown): void {
-    for (const row of sessions) {
-      this.addSession(row);
-    }
-    if (receipts === undefined) {
-      return;
-    }
-    if (!isUnknownArray(receipts)) {
-      throw new Error("Invalid topic delivery receipts");
+    const state = this.open();
+    try {
+      for (const row of sessions) {
+        this.addSession(state, row);
+      }
+      if (receipts === undefined) {
+        return;
+      }
+      if (!isUnknownArray(receipts)) {
+        throw new Error("Invalid topic delivery receipts");
+      }
+      state.receipts.push(...receipts.map(receipt));
+    } catch (error) {
+      this.fail();
+      throw error;
     }
-    this.receipts.push(...receipts.map(receipt));
   }
 
   finish(): SessionSnapshot {
+    const state = this.open();
     const sessions: SessionInfo[] = [];
-    for (const { info, topics, subscriptions } of this.sessions.values()) {
+    for (const { info, topics, subscriptions } of state.sessions.values()) {
       sessions.push({
         ...info,
         ...(topics !== undefined ? { topics } : {}),
         ...(subscriptions !== undefined ? { subscriptions } : {}),
       });
     }
-    return { sessions, receipts: this.receipts };
+    this.phase = { kind: "finished" };
+    return { sessions, receipts: state.receipts };
   }
 }