@fitchmultz/pi-subagents 0.52.19 → 0.52.21

package/dist/agent/view.js

@@ -2,12 +2,10 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { readOutputPage } from "../shared/output-page.js";
 import { actor, alive, observeAlive } from "./process.js";
-import { admissionSchema, commandSchema, exitSchema, successorSchema, wakeFailureSchema, } from "./contracts.js";
+import { admissionSchema, commandMetadataSchema, exitSchema, successorSchema, wakeFailureSchema, } from "./contracts.js";
 import { conversation, read, runDirectory } from "./storage.js";
 import { published } from "./notifications.js";
 import { accountingFields, accountingState, readCanonicalResult, readResult } from "./usage.js";
-import { Type } from "./typebox.js";
-const commandMetadataSchema = Type.Pick(commandSchema, ["id", "runId", "action", "createdAt"]);
 function toolResult(value, text) {
     return { content: [{ type: "text", text }], details: value };
 }

package/dist/build-info.js

@@ -1 +1 @@
-export const EXTENSION_BUILD = Object.freeze({"version":"0.52.19","sha256":"a5cb823f7d9194659bb3c3e53c68e90032ef520a962758d896dccee78a3bd2c5"});
+export const EXTENSION_BUILD = Object.freeze({"version":"0.52.21","sha256":"d0c9a96a0eca06a58dc73d77b64300d7e41a9eb5c75b1deee8751ae3af4b87ce"});

package/dist/pi-intercom/bridge-presence.js

@@ -4,9 +4,7 @@ import { readBridgeFile, writeBridgeJson } from "./bridge-files.js";
 import { log } from "./bridge-protocol.js";
 export class PersistentPresence {
     registrations = new Map();
-    stopped = false;
-    timer;
-    running;
+    phase = { kind: "idle" };
     owner;
     constructor(owner) {
         this.owner = owner;
@@ -61,21 +59,28 @@ export class PersistentPresence {
         this.start();
     }
     start() {
-        if (!this.stopped && !this.running) {
-            clearTimeout(this.timer);
-            this.timer = setTimeout(() => {
-                this.running = this.maintain().finally(() => {
-                    this.running = undefined;
-                    if (!this.stopped) {
-                        this.timer = setTimeout(() => this.start(), 15000);
-                    }
-                });
-            }, 0);
+        if (this.phase.kind === "running" || this.phase.kind === "stopped") {
+            return;
+        }
+        this.schedule(0);
+    }
+    schedule(delay) {
+        if (this.phase.kind === "scheduled") {
+            clearTimeout(this.phase.timer);
         }
+        const timer = setTimeout(() => {
+            const task = this.maintain().finally(() => {
+                if (this.phase.kind !== "stopped") {
+                    this.schedule(15000);
+                }
+            });
+            this.phase = { kind: "running", task };
+        }, delay);
+        this.phase = { kind: "scheduled", timer };
     }
     async maintain() {
         for (const registration of this.registrations.values()) {
-            if (this.stopped) {
+            if (this.phase.kind === "stopped") {
                 return;
             }
             const identity = this.owner.clients().get(registration.fingerprint);
@@ -95,9 +100,16 @@ export class PersistentPresence {
             }
         }
     }
-    async stop() {
-        this.stopped = true;
-        clearTimeout(this.timer);
-        await this.running;
+    stop() {
+        const phase = this.phase;
+        if (phase.kind === "stopped") {
+            return phase.task;
+        }
+        if (phase.kind === "scheduled") {
+            clearTimeout(phase.timer);
+        }
+        const task = phase.kind === "running" ? phase.task : Promise.resolve();
+        this.phase = { kind: "stopped", task };
+        return task;
     }
 }

package/dist/pi-intercom/bridge-wake.js

@@ -22,9 +22,7 @@ export class WakeDeliveries {
     allowed;
     deliveries = new Map();
     controller = new AbortController();
-    timer;
-    running;
-    dirty = false;
+    phase = { kind: "idle" };
     storageBackoff = 15000;
     constructor(stateDir, allowed) {
         this.stateDir = stateDir;
@@ -62,11 +60,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());
         }
     }
     reconcile() {
@@ -80,28 +84,36 @@ export class WakeDeliveries {
         }
     }
     schedule(deadline) {
-        clearTimeout(this.timer);
-        this.timer = setTimeout(() => {
-            this.dirty = false;
-            let next = Infinity;
-            this.running = this.deliver()
-                .then((due) => {
-                next = due;
-                this.storageBackoff = 15000;
+        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 };
+    }
+    startDelivery() {
+        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;
-            })
-                .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);
-                }
-            });
-        }, Math.max(0, Math.min(deadline - Date.now(), 0x7fffffff)));
+            }
+            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 };
     }
     authorized(delivery) {
         return (!this.controller.signal.aborted &&
@@ -233,14 +245,25 @@ export class WakeDeliveries {
         }
         this.changed(false);
     }
-    async stop() {
-        this.controller.abort();
-        clearTimeout(this.timer);
-        await this.running;
-        for (const delivery of this.deliveries.values()) {
-            delivery.mailbox.close();
+    stop() {
+        const phase = this.phase;
+        if (phase.kind === "stopped") {
+            return phase.task;
+        }
+        if (phase.kind === "scheduled") {
+            clearTimeout(phase.timer);
         }
-        this.deliveries.clear();
-        this.state?.close();
+        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/dist/pi-intercom/broker/broker.js

@@ -14,13 +14,13 @@ import { guardedDeliveryError } from "./guard.js";
 import { compactTopicMessage, normalizeMessage, normalizeSessionInfo, } from "../types.js";
 import { errorMessage, isRecord } from "../../shared/unknown.js";
 import { messageSender, snapshotFrames, TopicSnapshot, publicationMessage, preparedPublication, deliveryAcknowledgement, shouldReplaceDelivery, } from "./snapshots.js";
+import { ReplaceDeliveries } from "./replace-deliveries.js";
 const PID_PATH = join(getBrokerRuntimeDir(), "broker.pid");
-const REPLACE_DELIVERY_DELAY_MS = 1500;
 class IntercomBroker {
     sessions = new Map();
     lastMessages = new LastMessageRelay(this.sessions);
     parking = new ParkedSessions(this.sessions, this.deliverMessage.bind(this));
-    pendingReplaceDeliveries = new Map();
+    replacements = new ReplaceDeliveries(this.deliverMessage.bind(this));
     server;
     shutdownTimer = null;
     socketPath;
@@ -153,7 +153,7 @@ class IntercomBroker {
         this.lastMessages.disconnected(sessionId);
         if (!this.parking.closed(session)) {
             this.sessions.delete(sessionId);
-            this.clearPendingReplaceDeliveries(sessionId);
+            this.replacements.disconnected(sessionId);
             this.broadcast({ type: "session_left", sessionId }, session.info);
         }
         this.scheduleShutdownCheck();
@@ -348,25 +348,12 @@ class IntercomBroker {
             ...(comms ? { lastIntercomActivity: now } : {}),
         };
     }
-    replaceKey(fromId, toId, threadId) {
-        return `${fromId}\0${toId}\0${threadId}`;
-    }
     queueReplaceDelivery(fromId, toId, from, message) {
         const validationError = this.validateDeliveryPayload(from, message, this.sessions.get(toId));
         if (validationError !== null) {
             return { id: message.id, accepted: false, delivered: false, reason: validationError };
         }
-        const key = this.replaceKey(fromId, toId, message.threadId ?? "");
-        const existing = this.pendingReplaceDeliveries.get(key);
-        if (existing) {
-            clearTimeout(existing.timer);
-        }
-        const timer = setTimeout(() => {
-            this.pendingReplaceDeliveries.delete(key);
-            this.deliverMessage(toId, from, message);
-        }, REPLACE_DELIVERY_DELAY_MS);
-        timer.unref();
-        this.pendingReplaceDeliveries.set(key, { fromId, toId, message, timer });
+        this.replacements.stage(fromId, toId, from, message);
         return {
             id: message.id,
             accepted: true,
@@ -375,15 +362,6 @@ class IntercomBroker {
             reason: "Queued for replace-mode delivery",
         };
     }
-    clearPendingReplaceDeliveries(sessionId) {
-        for (const [key, pending] of this.pendingReplaceDeliveries) {
-            if (pending.toId === sessionId ||
-                (pending.fromId === sessionId && pending.message.expectsReply === true)) {
-                clearTimeout(pending.timer);
-                this.pendingReplaceDeliveries.delete(key);
-            }
-        }
-    }
     /** One admission rule; retained input is checked as the uncompacted envelope any later
      * transport generation accepts. */
     validateDeliveryPayload(from, message, target) {

package/dist/pi-intercom/broker/client-last.js

@@ -3,6 +3,7 @@ import { errorMessage } from "../../shared/unknown.js";
 import { isNativeReadQuery, isNativeReadResult, isLastMessageResult, isReceiptResult, } from "./last.js";
 import { normalizeSessionInfo, } from "../types.js";
 import { writeMessage } from "./framing.js";
+import { PendingRequests } from "./pending-requests.js";
 /** A peer's read of this session or, for a main, of its exited `parked` child. */
 export function lastRequest(msg) {
     const from = normalizeSessionInfo(msg.from);
@@ -24,26 +25,20 @@ export class LastMessageRequests {
     constructor(timeoutMs) {
         this.timeoutMs = timeoutMs;
     }
-    pending = new Map();
+    pending = new PendingRequests();
     fail(error) {
         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) {
         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);
     }
     async last(socket, to, query) {
@@ -66,19 +61,12 @@ 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/dist/pi-intercom/broker/client-park.d.ts

@@ -2,7 +2,7 @@ import type net from "node:net";
 /** Parking negotiation and its single outstanding broker acknowledgement. */
 export declare class ParkRequests {
     supported: boolean;
-    private acknowledged?;
+    private state;
     settle(parked: boolean): void;
     /** True once the broker retains later input; false when it cannot or the socket closed. */
     request(socket: () => net.Socket, on: boolean): Promise<boolean>;

package/dist/pi-intercom/broker/client-park.js

@@ -2,20 +2,36 @@ import { writeMessage } from "./framing.js";
 /** Parking negotiation and its single outstanding broker acknowledgement. */
 export class ParkRequests {
     supported = false;
-    acknowledged;
+    state = { kind: "idle" };
     settle(parked) {
-        this.acknowledged?.(parked);
+        const state = this.state;
+        this.state = { kind: "idle" };
+        if (state.kind === "pending") {
+            state.resolve(parked);
+        }
     }
     /** True once the broker retains later input; false when it cannot or the socket closed. */
     request(socket, on) {
-        return new Promise((resolve) => {
-            this.acknowledged = on && this.supported ? resolve : undefined;
+        if (on && this.state.kind === "pending") {
+            return this.state.promise;
+        }
+        const { promise, resolve, reject } = Promise.withResolvers();
+        this.settle(false);
+        if (on && this.supported) {
+            this.state = { kind: "pending", promise, resolve };
+        }
+        try {
             if (this.supported) {
                 writeMessage(socket(), { type: on ? "park" : "unpark" });
             }
-            if (this.acknowledged === undefined) {
+            if (this.state.kind === "idle") {
                 resolve(false);
             }
-        });
+        }
+        catch (error) {
+            this.state = { kind: "idle" };
+            reject(error);
+        }
+        return promise;
     }
 }

package/dist/pi-intercom/broker/client.d.ts

@@ -18,8 +18,7 @@ export declare class IntercomClient extends EventEmitter {
     private readonly lastRequests;
     private readonly pendingSends;
     private readonly pendingLists;
-    private connecting;
-    private disconnecting;
+    private phase;
     private readonly sendTimeoutMs;
     private readonly listTimeoutMs;
     constructor(options?: IntercomClientOptions);
@@ -30,6 +29,7 @@ export declare class IntercomClient extends EventEmitter {
     isConnected(): boolean;
     private requireActiveSocket;
     connect(session: Omit<SessionInfo, "id">, requestedId?: string): Promise<void>;
+    private establish;
     private restoreTopics;
     private handleBrokerMessage;
     private receiveRegistration;
@@ -39,6 +39,7 @@ export declare class IntercomClient extends EventEmitter {
     private receiveSessions;
     park(on?: boolean): Promise<boolean>;
     disconnect(): Promise<void>;
+    private close;
     listSessions(): Promise<SessionInfo[]>;
     last(to: string, query?: LastMessageQuery): Promise<LastMessageResult>;
     receipt(to: string, query: ReceiptQuery): Promise<ReceiptResult>;