@fitchmultz/pi-subagents 0.52.18 → 0.52.20

package/dist/agent/usage.js

@@ -7,6 +7,37 @@ import { isRecord } from "../shared/unknown.js";
 import { Assert } from "./typebox.js";
 import { contributionsSchema, resultSchema, } from "./contracts.js";
 import { read, runDirectory, write } from "./storage.js";
+/** Pending repair remains authoritative until its native terminal is published and validated. */
+export function accountingState(result) {
+    if (result?.accountingPending !== undefined) {
+        return { kind: "pending", pending: result.accountingPending, error: result.accountingError };
+    }
+    const terminalEntryId = result?.terminalEntryId;
+    if (result?.contributions !== undefined) {
+        return { kind: "verified", contributions: result.contributions, terminalEntryId };
+    }
+    return result?.accountingError === undefined
+        ? { kind: "unrecorded", terminalEntryId }
+        : { kind: "unavailable", error: result.accountingError, terminalEntryId };
+}
+export function accountingFields(state) {
+    const terminal = state.kind !== "pending" && state.terminalEntryId !== undefined
+        ? { terminalEntryId: state.terminalEntryId }
+        : {};
+    switch (state.kind) {
+        case "unrecorded":
+            return terminal;
+        case "verified":
+            return { contributions: state.contributions, ...terminal };
+        case "pending":
+            return {
+                accountingPending: state.pending,
+                ...(state.error === undefined ? {} : { accountingError: state.error }),
+            };
+        case "unavailable":
+            return { accountingError: state.error, ...terminal };
+    }
+}
 /** Billing evidence of one native entry. Missing required usage is an error only outside a baseline. */
 function billing(entry) {
     if (entry.checkpoint === true) {
@@ -143,10 +174,11 @@ export function readResult(base, launch) {
     if (!result) {
         return;
     }
-    const pending = result.accountingPending;
-    if (pending === undefined) {
+    const accounting = accountingState(result);
+    if (accounting.kind !== "pending") {
         return result;
     }
+    const { pending } = accounting;
     let contributions;
     try {
         contributions = childUsage(launch, new Set(pending.baseline), pending.terminalCandidate);
@@ -156,7 +188,14 @@ export function readResult(base, launch) {
         return result;
     }
     const { accountingPending: _pending, accountingError: _error, ...execution } = result;
-    const repaired = { ...execution, terminalEntryId: pending.terminalCandidate, contributions };
+    const repaired = {
+        ...execution,
+        ...accountingFields({
+            kind: "verified",
+            terminalEntryId: pending.terminalCandidate,
+            contributions,
+        }),
+    };
     write(path.join(runDirectory(base, launch.id), "result.json"), repaired);
     return repaired;
 }

package/dist/agent/view.js

@@ -5,25 +5,25 @@ import { actor, alive, observeAlive } from "./process.js";
 import { admissionSchema, commandSchema, exitSchema, successorSchema, wakeFailureSchema, } from "./contracts.js";
 import { conversation, read, runDirectory } from "./storage.js";
 import { published } from "./notifications.js";
-import { readCanonicalResult, readResult } from "./usage.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 };
 }
 function receiptResult(result) {
-    return result === undefined
-        ? undefined
-        : {
-            id: result.id,
-            owner: result.owner,
-            status: result.status,
-            endedAt: result.endedAt,
-            terminalEntryId: result.terminalEntryId,
-            error: result.error,
-            accountingError: result.accountingError,
-            accountingPending: result.accountingPending,
-        };
+    if (result === undefined) {
+        return;
+    }
+    const { contributions: _contributions, ...accounting } = accountingFields(accountingState(result));
+    return {
+        id: result.id,
+        owner: result.owner,
+        status: result.status,
+        endedAt: result.endedAt,
+        error: result.error,
+        ...accounting,
+    };
 }
 /** `observed` holds batched liveness by actor token; any other actor gets a fresh check. */
 function processView(base, launch, observed) {

package/dist/agent/wake.js

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import assert from "node:assert/strict";
 import { journalStamp } from "../shared/native-journal.js";
 import { missing } from "./storage.js";
 /** Identity and change stamp of a path; "" when absent. */
@@ -13,10 +14,10 @@ export function pathStamp(file) {
 }
 /** Native change hints for one directory identity; owners still reconcile canonical files. */
 export class DirectoryWatch {
-    watcher;
-    armed = "";
+    state = {
+        kind: "unarmed",
+    };
     checked = "";
-    failed = false;
     directory;
     relevant;
     wake;
@@ -30,41 +31,41 @@ export class DirectoryWatch {
         const identity = stat?.isDirectory() === true ? `${stat.dev}:${stat.ino}` : "";
         const checked = this.checked;
         this.checked = stat === undefined ? "" : `${identity}:${stat.mtimeNs}:${stat.ctimeNs}`;
-        if (this.watcher !== undefined && identity === this.armed) {
+        if (this.state.kind === "armed" && identity === this.state.identity) {
             return checked === this.checked ? "watching" : "changed";
         }
         // A replaced directory leaves an inode watch silent on Linux.
         this.close();
-        return identity === "" || this.failed ? "unwatched" : this.arm(identity);
+        return identity === "" || this.state.kind === "polling" ? "unwatched" : this.arm(identity);
     }
     arm(identity) {
         try {
             const watcher = fs.watch(this.directory, { persistent: false }, (_event, file) => {
-                if (watcher === this.watcher && this.relevant(file)) {
+                if (this.state.kind === "armed" && watcher === this.state.watcher && this.relevant(file)) {
                     this.wake();
                 }
             });
             watcher.on("error", () => {
-                if (watcher === this.watcher) {
-                    this.failed = true;
-                    this.close();
+                if (this.state.kind === "armed" && watcher === this.state.watcher) {
+                    watcher.close();
+                    this.state = { kind: "polling" };
                     this.wake();
                 }
             });
-            this.watcher = watcher;
-            this.armed = identity;
+            this.state = { kind: "armed", watcher, identity };
             return "armed";
         }
         catch (error) {
             // Unsupported platforms and watch limits keep their owner's polling fallback.
-            this.failed = !missing(error);
+            this.state = { kind: missing(error) ? "unarmed" : "polling" };
             return "unwatched";
         }
     }
     close() {
-        this.watcher?.close();
-        this.watcher = undefined;
-        this.armed = "";
+        if (this.state.kind === "armed") {
+            this.state.watcher.close();
+            this.state = { kind: "unarmed" };
+        }
     }
 }
 /** A coalesced wake for one owner loop; raised until that loop takes it. */
@@ -82,6 +83,7 @@ export class Wake {
     }
     /** Returns at once for a wake raised since the last take. */
     async sleep(ms) {
+        assert.equal(this.resolve, undefined, "A Wake belongs to one waiting owner loop.");
         if (this.raised) {
             return;
         }

package/dist/build-info.js

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

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

@@ -13,7 +13,7 @@ import { acceptBrokerConnection, registeredSessionInfo } from "./server-connecti
 import { guardedDeliveryError } from "./guard.js";
 import { compactTopicMessage, normalizeMessage, normalizeSessionInfo, } from "../types.js";
 import { errorMessage, isRecord } from "../../shared/unknown.js";
-import { messageSender, snapshotFrames, TopicSnapshot, publicationMessage, deliveryAcknowledgement, shouldReplaceDelivery, } from "./snapshots.js";
+import { messageSender, snapshotFrames, TopicSnapshot, publicationMessage, preparedPublication, deliveryAcknowledgement, shouldReplaceDelivery, } from "./snapshots.js";
 const PID_PATH = join(getBrokerRuntimeDir(), "broker.pid");
 const REPLACE_DELIVERY_DELAY_MS = 1500;
 class IntercomBroker {
@@ -192,7 +192,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/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.js

@@ -3,6 +3,7 @@ import { randomUUID } from "crypto";
 import { writeMessage } from "./framing.js";
 import { BrokerConnection, connectBrokerSocket } from "./connection.js";
 import { SnapshotReader } from "./snapshot-reader.js";
+import { PendingRequests } from "./pending-requests.js";
 import { LastMessageRequests, lastRequest } from "./client-last.js";
 import { ParkRequests } from "./client-park.js";
 import { WakeMessages } from "./client-wake.js";
@@ -36,8 +37,8 @@ export class IntercomClient extends EventEmitter {
     wakes = new WakeMessages(this, () => this.requireActiveSocket());
     guardedDeliverySupported = false;
     lastRequests;
-    pendingSends = new Map();
-    pendingLists = new Map();
+    pendingSends = new PendingRequests();
+    pendingLists = new PendingRequests();
     connecting = false;
     disconnecting = false;
     sendTimeoutMs;
@@ -50,14 +51,8 @@ export class IntercomClient extends EventEmitter {
     }
     failPending(error) {
         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() {
         return this._sessionId;
@@ -240,12 +235,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",
@@ -266,14 +260,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());
         }
     }
     park(on = true) {
@@ -319,8 +311,8 @@ export class IntercomClient extends EventEmitter {
         }
         return new Promise((resolve, reject) => {
             const requestId = randomUUID();
+            const reader = new SnapshotReader();
             const wrappedResolve = (snapshot) => {
-                clearTimeout(timeout);
                 try {
                     // Commit confirmed subscriptions before handling a following message in the same read.
                     onAccepted?.(snapshot);
@@ -331,21 +323,14 @@ export class IntercomClient extends EventEmitter {
                 }
             };
             const wrappedReject = (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(),
-            });
+                reader,
+            }, this.listTimeoutMs, () => Object.assign(new Error("List sessions timeout"), { code: "list_timeout" }));
             try {
                 writeMessage(socket, {
                     type: "list",
@@ -355,9 +340,7 @@ export class IntercomClient extends EventEmitter {
                 });
             }
             catch (error) {
-                clearTimeout(timeout);
-                this.pendingLists.delete(requestId);
-                reject(toError(error));
+                this.pendingLists.take(requestId)?.reject(toError(error));
             }
         });
     }
@@ -377,7 +360,7 @@ export class IntercomClient extends EventEmitter {
             return Promise.reject(toError(error));
         }
         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 = {
@@ -402,22 +385,7 @@ export class IntercomClient extends EventEmitter {
             return Promise.reject(new Error("Invalid message format"));
         }
         return new Promise((resolve, reject) => {
-            const wrappedResolve = (result) => {
-                clearTimeout(timeout);
-                resolve(result);
-            };
-            const wrappedReject = (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, {
                     type: "send",
@@ -426,9 +394,7 @@ export class IntercomClient extends EventEmitter {
                 });
             }
             catch (error) {
-                clearTimeout(timeout);
-                this.pendingSends.delete(messageId);
-                reject(toError(error));
+                this.pendingSends.take(messageId)?.reject(toError(error));
             }
         });
     }

package/dist/pi-intercom/broker/pending-requests.d.ts

@@ -0,0 +1,12 @@
+interface Request {
+    readonly reject: (error: Readonly<Error>) => void;
+}
+/** Map membership owns settlement; taking a request also releases its deadline. */
+export declare class PendingRequests<T extends Request> {
+    private readonly pending;
+    get(id: string): T | undefined;
+    set(id: string, value: T, timeoutMs: number, timeoutError: () => Error): void;
+    take(id: string): T | undefined;
+    fail(error: Readonly<Error>): void;
+}
+export {};

package/dist/pi-intercom/broker/pending-requests.js

@@ -0,0 +1,26 @@
+/** Map membership owns settlement; taking a request also releases its deadline. */
+export class PendingRequests {
+    pending = new Map();
+    get(id) {
+        return this.pending.get(id)?.value;
+    }
+    set(id, value, timeoutMs, timeoutError) {
+        const timer = setTimeout(() => this.take(id)?.reject(timeoutError()), timeoutMs);
+        timer.unref();
+        this.pending.set(id, { value, timer });
+    }
+    take(id) {
+        const pending = this.pending.get(id);
+        if (pending === undefined) {
+            return;
+        }
+        this.pending.delete(id);
+        clearTimeout(pending.timer);
+        return pending.value;
+    }
+    fail(error) {
+        for (const id of this.pending.keys()) {
+            this.take(id)?.reject(error);
+        }
+    }
+}