@fitchmultz/pi-subagents 0.52.20 → 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.20","sha256":"6698668f485ef551faf914031fee7ad7165c9062a38c31b2827077d8e93e94b9"});
+export const EXTENSION_BUILD = Object.freeze({"version":"0.52.21","sha256":"d0c9a96a0eca06a58dc73d77b64300d7e41a9eb5c75b1deee8751ae3af4b87ce"});

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-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>;

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

@@ -39,8 +39,7 @@ export class IntercomClient extends EventEmitter {
     lastRequests;
     pendingSends = new PendingRequests();
     pendingLists = new PendingRequests();
-    connecting = false;
-    disconnecting = false;
+    phase = { kind: "idle" };
     sendTimeoutMs;
     listTimeoutMs;
     constructor(options = {}) {
@@ -65,11 +64,11 @@ export class IntercomClient extends EventEmitter {
     }
     isConnected() {
         return ((this._sessionId ?? "").length > 0 &&
-            !this.disconnecting &&
+            this.phase.kind !== "closing" &&
             this.connection?.isActive() === true);
     }
     requireActiveSocket() {
-        if (this.disconnecting) {
+        if (this.phase.kind === "closing") {
             throw new Error("Client disconnecting");
         }
         const connection = this.connection;
@@ -82,62 +81,72 @@ export class IntercomClient extends EventEmitter {
         return connection.socket;
     }
     async connect(session, requestedId) {
-        if (this.connection || this.connecting) {
+        if (this.connection || this.phase.kind !== "idle") {
             throw new Error("Already connected");
         }
-        this.connecting = true;
+        const task = this.establish(session, requestedId);
+        this.phase = { kind: "connecting", task };
         try {
-            const socket = await connectBrokerSocket();
-            const connection = new BrokerConnection(socket, {
-                message: (message) => this.handleBrokerMessage(message),
-                error: (error) => {
-                    this.emit("error", error);
-                },
-                closed: (error, expected) => {
-                    if (this.connection !== connection) {
-                        return;
-                    }
-                    const established = this._sessionId !== null;
-                    this.connection = null;
-                    this._sessionId = null;
-                    this._topicsSupported = false;
-                    this.parking.settle(false);
-                    this.guardedDeliverySupported = false;
-                    this.wakes.supported = false;
-                    this.disconnecting = false;
-                    this.failPending(error);
-                    if (established && !expected) {
-                        this.emit("disconnected", error);
-                    }
-                },
-            });
-            this.connection = connection;
-            const { topics, subscriptions, ...identity } = session;
-            try {
-                await connection.start({
-                    type: "register",
-                    session: identity,
-                    requestedId,
-                    topicFrames: true,
-                    lastMessages: true,
-                    parking: true,
-                    receiptReads: 1,
-                    guardedDelivery: 1,
-                    ...this.wakes.registration(),
-                });
+            await task;
+        }
+        finally {
+            if (this.phase.kind === "connecting" && this.phase.task === task) {
+                this.phase = { kind: this.isConnected() ? "connected" : "idle" };
             }
-            catch (error) {
-                if (this.connection === connection) {
-                    this.connection = null;
+        }
+    }
+    async establish(session, requestedId) {
+        const socket = await connectBrokerSocket();
+        const connection = new BrokerConnection(socket, {
+            message: (message) => this.handleBrokerMessage(message),
+            error: (error) => {
+                this.emit("error", error);
+            },
+            closed: (error, expected) => {
+                if (this.connection !== connection) {
+                    return;
                 }
-                throw error;
-            }
-            if (this.supportsTopics) {
-                await this.restoreTopics(topics, subscriptions);
-            }
+                const established = this._sessionId !== null;
+                this.connection = null;
+                this._sessionId = null;
+                this._topicsSupported = false;
+                this.parking.settle(false);
+                this.guardedDeliverySupported = false;
+                this.wakes.supported = false;
+                if (this.phase.kind === "connected") {
+                    this.phase = { kind: "idle" };
+                }
+                this.failPending(error);
+                if (established && !expected) {
+                    this.emit("disconnected", error);
+                }
+            },
+        });
+        this.connection = connection;
+        if (this.phase.kind === "closing") {
+            await connection.disconnect();
+            throw new Error("Client disconnecting");
         }
-        finally {
-            this.connecting = false;
+        const { topics, subscriptions, ...identity } = session;
+        try {
+            await connection.start({
+                type: "register",
+                session: identity,
+                requestedId,
+                topicFrames: true,
+                lastMessages: true,
+                parking: true,
+                receiptReads: 1,
+                guardedDelivery: 1,
+                ...this.wakes.registration(),
+            });
+        }
+        catch (error) {
+            await connection.disconnect();
+            throw error;
+        }
+        if (this.supportsTopics) {
+            await this.restoreTopics(topics, subscriptions);
         }
     }
     async restoreTopics(topics, subscriptions) {
@@ -271,14 +280,31 @@ export class IntercomClient extends EventEmitter {
     park(on = true) {
         return this.parking.request(() => this.requireActiveSocket(), on);
     }
-    async disconnect() {
-        const connection = this.connection;
-        if (!connection) {
-            return;
-        }
-        this.disconnecting = true;
+    disconnect() {
+        const phase = this.phase;
+        if (phase.kind === "closing") {
+            return phase.task;
+        }
+        const connecting = phase.kind === "connecting" ? phase.task : undefined;
+        const task = Promise.resolve().then(() => this.close(connecting));
+        this.phase = { kind: "closing", task };
+        return task;
+    }
+    async close(connecting) {
         this.failPending(new Error("Client disconnected"));
-        await connection.disconnect();
+        try {
+            await this.connection?.disconnect();
+            try {
+                await connecting;
+            }
+            catch {
+                // The connect caller owns acquisition failure; close still joins any acquired socket.
+            }
+            await this.connection?.disconnect();
+        }
+        finally {
+            this.phase = { kind: "idle" };
+        }
     }
     listSessions() {
         return this.requestSessions().then((snapshot) => [...snapshot.sessions]);
@@ -399,7 +425,7 @@ export class IntercomClient extends EventEmitter {
         });
     }
     updatePresence(updates) {
-        if (this.disconnecting) {
+        if (this.phase.kind === "closing") {
             return;
         }
         const socket = this.connection?.socket;

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

@@ -7,22 +7,20 @@ interface ConnectionHandlers {
 }
 /** One socket owns registration, read/error listeners, and graceful shutdown. */
 export declare class BrokerConnection {
-    private registered;
-    private closing;
+    private phase;
     private failure;
-    private registration;
-    private registrationTimer;
     private readonly reader;
     readonly socket: net.Socket;
     private readonly handlers;
     constructor(socket: net.Socket, handlers: ConnectionHandlers);
     start(registration: unknown): Promise<void>;
     confirmRegistration(): void;
-    private clearRegistration;
+    private takeRegistration;
     private failRegistration;
     private protocolError;
     private readonly onError;
     private readonly onClose;
+    private get registered();
     isActive(): boolean;
     disconnect(): Promise<void>;
 }

package/dist/pi-intercom/broker/connection.js

@@ -34,11 +34,8 @@ export async function connectBrokerSocket() {
 }
 /** One socket owns registration, read/error listeners, and graceful shutdown. */
 export class BrokerConnection {
-    registered = false;
-    closing = false;
+    phase = { kind: "acquired" };
     failure = null;
-    registration = null;
-    registrationTimer = null;
     reader;
     socket;
     handlers;
@@ -52,9 +49,9 @@ export class BrokerConnection {
     }
     start(registration) {
         return new Promise((resolve, reject) => {
-            this.registration = { resolve, reject };
-            this.registrationTimer = setTimeout(() => this.failRegistration(new Error("Connection timeout")), 10000);
-            this.registrationTimer.unref();
+            const timer = setTimeout(() => this.failRegistration(new Error("Connection timeout")), 10000);
+            timer.unref();
+            this.phase = { kind: "registering", resolve, reject, timer };
             try {
                 writeMessage(this.socket, registration);
             }
@@ -64,21 +61,26 @@ export class BrokerConnection {
         });
     }
     confirmRegistration() {
-        this.registered = true;
-        const pending = this.registration;
-        this.clearRegistration();
-        pending?.resolve();
+        const pending = this.takeRegistration();
+        if (pending !== undefined) {
+            this.phase = { kind: "active" };
+            pending.resolve();
+        }
     }
-    clearRegistration() {
-        if (this.registrationTimer) {
-            clearTimeout(this.registrationTimer);
+    takeRegistration() {
+        const pending = this.phase;
+        if (pending.kind !== "registering") {
+            return;
         }
-        this.registrationTimer = null;
-        this.registration = null;
+        clearTimeout(pending.timer);
+        this.phase = { kind: "acquired" };
+        return pending;
     }
     failRegistration(error) {
-        const pending = this.registration;
-        this.clearRegistration();
+        const pending = this.takeRegistration();
+        if (this.phase.kind !== "closing") {
+            this.phase = { kind: "failed" };
+        }
         this.failure = error;
         this.socket.destroy();
         pending?.reject(error);
@@ -102,31 +104,37 @@ export class BrokerConnection {
         this.handlers.error(error);
     };
     onClose = () => {
-        const pending = this.registration;
-        this.clearRegistration();
+        const closing = this.phase.kind === "closing";
+        const pending = this.takeRegistration();
+        this.phase = { kind: "closed" };
         this.socket.off("data", this.reader);
         this.socket.off("error", this.onError);
         this.socket.off("close", this.onClose);
         pending?.reject(new Error("Connection closed before registration"));
-        this.handlers.closed(this.failure ?? new Error("Client disconnected"), this.closing);
+        this.handlers.closed(this.failure ?? new Error("Client disconnected"), closing);
     };
+    get registered() {
+        return this.phase.kind === "active" || (this.phase.kind === "closing" && this.phase.registered);
+    }
     isActive() {
-        return (this.registered &&
-            !this.closing &&
+        return (this.phase.kind === "active" &&
             !this.socket.destroyed &&
             !this.socket.writableEnded &&
             this.socket.writable);
     }
     disconnect() {
-        this.closing = true;
+        const phase = this.phase;
+        if (phase.kind === "closing") {
+            return phase.task;
+        }
+        if (phase.kind === "closed") {
+            return Promise.resolve();
+        }
+        const pending = this.takeRegistration();
+        pending?.reject(new Error("Client disconnected before registration"));
         this.failure = null;
-        return new Promise((resolve) => {
-            let settled = false;
+        const task = new Promise((resolve) => {
             const finish = () => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
                 clearTimeout(timeout);
                 this.socket.off("close", finish);
                 this.socket.off("error", onError);
@@ -140,13 +148,20 @@ export class BrokerConnection {
             }, 2000);
             this.socket.once("close", finish);
             this.socket.once("error", onError);
-            try {
+        });
+        this.phase = { kind: "closing", task, registered: phase.kind === "active" };
+        try {
+            if (phase.kind === "active" || phase.kind === "registering") {
                 writeMessage(this.socket, { type: "unregister" });
                 this.socket.end();
             }
-            catch {
+            else {
                 this.socket.destroy();
             }
-        });
+        }
+        catch {
+            this.socket.destroy();
+        }
+        return task;
     }
 }

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

@@ -12,6 +12,6 @@ export declare function writeFrame(socket: Socket, json: string, limit?: number)
 /**
  * Create a message reader that handles partial reads.
  * Calls onMessage for each complete message received.
- * Protocol or handler errors are reported to onError so the caller can close the socket.
+ * Protocol or handler errors end reading and are reported so the caller can close the socket.
  */
 export declare function createMessageReader(onMessage: (msg: unknown) => void, onError: (error: Readonly<Error>) => void, limit?: number): (data: Buffer) => void;

package/dist/pi-intercom/broker/framing.js

@@ -84,33 +84,40 @@ class MessageBuffer {
 /**
  * Create a message reader that handles partial reads.
  * Calls onMessage for each complete message received.
- * Protocol or handler errors are reported to onError so the caller can close the socket.
+ * Protocol or handler errors end reading and are reported so the caller can close the socket.
  */
 export function createMessageReader(onMessage, onError, limit = MAX_FRAME_SIZE_BYTES) {
     const buffer = new MessageBuffer();
-    let length;
+    let state = { kind: "header" };
+    const fail = (error) => {
+        state = { kind: "failed" };
+        buffer.clear();
+        onError(error);
+    };
     return (data) => {
+        if (state.kind === "failed") {
+            return;
+        }
         buffer.append(data);
-        while (buffer.length >= (length ?? 4)) {
-            if (length === undefined) {
-                length = buffer.read(4).readUInt32BE(0);
+        while (buffer.length >= (state.kind === "payload" ? state.length : 4)) {
+            if (state.kind === "header") {
+                const length = buffer.read(4).readUInt32BE(0);
                 if (length > limit) {
-                    onError(new Error(`Intercom frame too large (${length} bytes; max ${limit})`));
-                    buffer.clear();
-                    length = undefined;
+                    fail(new Error(`Intercom frame too large (${length} bytes; max ${limit})`));
                     return;
                 }
+                state = { kind: "payload", length };
                 continue;
             }
-            const payload = buffer.read(length);
-            length = undefined;
+            const payload = buffer.read(state.length);
+            state = { kind: "header" };
             let msg;
             try {
                 msg = JSON.parse(payload.toString("utf-8"));
             }
             catch (error) {
                 const message = errorMessage(error);
-                onError(new Error(`Failed to parse intercom message: ${message}`, { cause: error }));
+                fail(new Error(`Failed to parse intercom message: ${message}`, { cause: error }));
                 return;
             }
             try {
@@ -118,7 +125,7 @@ export function createMessageReader(onMessage, onError, limit = MAX_FRAME_SIZE_B
             }
             catch (error) {
                 const message = errorMessage(error);
-                onError(new Error(`Failed to handle intercom message: ${message}`, { cause: error }));
+                fail(new Error(`Failed to handle intercom message: ${message}`, { cause: error }));
                 return;
             }
         }

package/dist/pi-intercom/broker/replace-deliveries.js

@@ -0,0 +1,38 @@
+const REPLACE_DELIVERY_DELAY_MS = 1500;
+/** Only broker-staged messages remain replaceable; forwarding ends this owner's authority. */
+export class ReplaceDeliveries {
+    pending = new Map();
+    deliver;
+    constructor(deliver) {
+        this.deliver = deliver;
+    }
+    stage(fromId, toId, from, message) {
+        const key = `${fromId}\0${toId}\0${message.threadId ?? ""}`;
+        this.take(key);
+        const timer = setTimeout(() => this.flush(key), REPLACE_DELIVERY_DELAY_MS);
+        timer.unref();
+        this.pending.set(key, { fromId, toId, from, message, timer });
+    }
+    take(key) {
+        const pending = this.pending.get(key);
+        if (pending !== undefined) {
+            this.pending.delete(key);
+            clearTimeout(pending.timer);
+        }
+        return pending;
+    }
+    flush(key) {
+        const pending = this.take(key);
+        if (pending !== undefined) {
+            this.deliver(pending.toId, pending.from, pending.message);
+        }
+    }
+    disconnected(sessionId) {
+        for (const [key, pending] of this.pending) {
+            if (pending.toId === sessionId ||
+                (pending.fromId === sessionId && pending.message.expectsReply === true)) {
+                this.take(key);
+            }
+        }
+    }
+}