@fitchmultz/pi-subagents 0.52.20 → 0.52.22

package/dist/agent/storage.js

@@ -118,13 +118,25 @@ export function latest(base, initial) {
 export function conversation(base, launch) {
     return runDirectory(base, launch.rootId);
 }
-export function enqueue(base, launch, action, options = {}) {
-    const id = action === "run" ? launch.id : randomUUID();
+/** Metadata only: replacing command bytes invalidates the actor's parsed-command cache. */
+export function commandIdentity(file) {
+    try {
+        const stat = fs.statSync(file, { bigint: true });
+        return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+    }
+    catch (error) {
+        if (missing(error)) {
+            return;
+        }
+        throw error;
+    }
+}
+export function enqueue(base, launch, input) {
+    const id = input.action === "run" ? launch.id : randomUUID();
     const command = {
         id,
         runId: launch.id,
-        action,
-        ...options,
+        ...input,
         createdAt: Date.now(),
     };
     write(path.join(conversation(base, launch), "commands", `${id}.json`), command, true);

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.22","sha256":"fc7e48d1fb96f143f56be9757d30a98bb138b94edd1f5388438ddeb3eed54638"});

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

@@ -28,7 +28,7 @@ export class WakeState {
     inode;
     device;
     owner;
-    finishing = false;
+    phase = { kind: "idle" };
     constructor(stateDir) {
         this.stateDir = stateDir;
         this.path = join(stateDir, FILE);
@@ -194,13 +194,37 @@ export class WakeState {
         this.validate();
         this.db.prepare("DELETE FROM wake_batches WHERE bucket=?").run(bucket);
     }
-    /** Persist quota and uncertainty BEFORE dispatch. Returning a deadline means no attempt admitted. */
+    /** Persist quota and uncertainty before exposing a single-use POST reservation. */
     reserve(bucket) {
         this.retrySettlement();
-        return this.transaction(() => this.reservation(bucket));
+        if (this.phase.kind !== "idle") {
+            throw new Error("A wake reservation is already active or its owner is closed.");
+        }
+        const until = this.transaction(() => this.reservation(bucket));
+        if (until !== undefined) {
+            return { kind: "deferred", until };
+        }
+        const reservation = {
+            kind: "reserved",
+            post: async (action) => {
+                if (this.phase !== reservation) {
+                    throw new Error("This wake reservation is no longer available.");
+                }
+                this.phase = { kind: "posting" };
+                try {
+                    await action();
+                }
+                finally {
+                    // Completion, rejection and abort all start the durable expiry window here.
+                    this.settle();
+                }
+            },
+        };
+        this.phase = reservation;
+        return reservation;
     }
     retrySettlement() {
-        if (this.finishing) {
+        if (this.phase.kind === "settlementPending") {
             this.settle();
         }
     }
@@ -219,9 +243,9 @@ export class WakeState {
     }
     /** A failed settlement stays open and must be retried before this owner can dispatch again. */
     settle() {
-        this.finishing = true;
+        this.phase = { kind: "settlementPending" };
         this.transaction(() => this.finishOwner(this.owner.name));
-        this.finishing = false;
+        this.phase = { kind: "idle" };
     }
     finishOwner(owner) {
         const now = Math.max(Date.now(), integer(this.db.prepare("SELECT clock FROM wake_meta").get()?.clock));
@@ -286,6 +310,7 @@ export class WakeState {
             this.settle();
         }
         finally {
+            this.phase = { kind: "closed" };
             this.db.close();
             this.owner.close();
         }

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

@@ -171,20 +171,14 @@ export class WakeDeliveries {
                 next = Math.min(next, due);
                 continue;
             }
-            const deferred = state.reserve(key);
-            if (deferred !== undefined) {
-                next = Math.min(next, deferred);
+            const reservation = state.reserve(key);
+            if (reservation.kind === "deferred") {
+                next = Math.min(next, reservation.until);
                 continue;
             }
             // ponytail: two cold Macs can each admit one wake. Literal cross-Mac single admission
             // requires a neutral quota authority governing every writer, not a URL hash or HTTP 2xx.
-            try {
-                await this.post(candidate);
-            }
-            finally {
-                // Expiry starts after response/error/abort, never before COMMIT or connect/TLS.
-                state.settle();
-            }
+            await reservation.post(() => this.post(candidate));
             // Re-read ACKs and all groups after transport I/O; a snapshot must not wake already consumed mail.
             return Date.now();
         }

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;