@fitchmultz/pi-subagents 0.50.0 → 0.52.0

package/dist/agent/usage.js

@@ -1,127 +1,12 @@
 import * as path from "node:path";
 import * as fs from "node:fs";
 import { journalStamp } from "../shared/native-journal.js";
-import { isDeepStrictEqual } from "node:util";
 import { nativeProjection } from "../shared/journal-projections.js";
 import { scanJournal } from "../shared/journal-frames.js";
 import { isRecord } from "../shared/unknown.js";
 import { Assert } from "./typebox.js";
 import { contributionsSchema, resultSchema, } from "./contracts.js";
 import { read, runDirectory, write } from "./storage.js";
-export function sumUsage(values) {
-    const total = {
-        input: 0,
-        output: 0,
-        cacheRead: 0,
-        cacheWrite: 0,
-        totalTokens: 0,
-        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-    };
-    for (const { usage } of values) {
-        for (const key of ["input", "output", "cacheRead", "cacheWrite", "totalTokens"]) {
-            total[key] += usage[key];
-        }
-        for (const key of ["input", "output", "cacheRead", "cacheWrite", "total"]) {
-            total.cost[key] += usage.cost[key];
-        }
-        for (const key of ["reasoning", "cacheWrite1h"]) {
-            if (usage[key] !== undefined) {
-                total[key] = (total[key] ?? 0) + usage[key];
-            }
-        }
-    }
-    return total;
-}
-function intents(details) {
-    if (!isRecord(details) || details.agentUsage === undefined) {
-        return;
-    }
-    const values = details.agentUsage;
-    Assert(contributionsSchema, values);
-    return values;
-}
-function publishedContributions(entry) {
-    if (!isRecord(entry) || entry.type !== "message" || !isRecord(entry.message)) {
-        return [];
-    }
-    const message = entry.message;
-    if (message.role !== "toolResult" ||
-        (message.toolName !== "delegate" && message.toolName !== "agent_runs")) {
-        return [];
-    }
-    const values = intents(message.details);
-    if (values === undefined || !isDeepStrictEqual(sumUsage(values), message.usage)) {
-        return [];
-    }
-    return values;
-}
-const receiptProjection = (keys) => {
-    if (keys.length === 0 || keys[0] === "type") {
-        return true;
-    }
-    if (keys[0] !== "message") {
-        return false;
-    }
-    if (keys.length === 1 || ["role", "toolName", "usage"].includes(String(keys[1]))) {
-        return true;
-    }
-    return keys[1] === "details" && (keys.length === 2 || keys[2] === "agentUsage");
-};
-function priorUsage(ctx) {
-    const values = new Map();
-    const file = ctx.sessionManager.getSessionFile();
-    if (file !== undefined) {
-        scanJournal(file, receiptProjection, ({ value: entry }) => {
-            for (const value of publishedContributions(entry)) {
-                values.set(value.id, value);
-            }
-        }, { policy: "live", requireNewline: true });
-    }
-    for (const entry of ctx.sessionManager.getEntries()) {
-        for (const value of publishedContributions(entry)) {
-            values.set(value.id, value);
-        }
-    }
-    return values;
-}
-function uncharged(values, prior) {
-    const pending = [];
-    for (const value of values) {
-        const earlier = prior.get(value.id);
-        if (earlier && !isDeepStrictEqual(earlier, value)) {
-            throw new Error(`Conflicting native usage contribution ${value.id}`);
-        }
-        if (!earlier) {
-            pending.push(value);
-            prior.set(value.id, value);
-        }
-    }
-    return pending;
-}
-export function registerUsage(pi) {
-    pi.on("message_end", (event, ctx) => {
-        const message = event.message;
-        if (message.role !== "toolResult" ||
-            (message.toolName !== "delegate" && message.toolName !== "agent_runs")) {
-            return;
-        }
-        const values = intents(message.details);
-        if (values === undefined || !isRecord(message.details)) {
-            return;
-        }
-        const pending = uncharged(values, priorUsage(ctx));
-        const { usage: _usage, ...rest } = message;
-        // Finalized native tool messages are serialized even for concurrent tools.
-        // Preparing or discarding a result cannot reserve a charge.
-        return {
-            message: {
-                ...rest,
-                details: { ...message.details, agentUsage: pending },
-                ...(pending.length > 0 ? { usage: sumUsage(pending) } : {}),
-            },
-        };
-    });
-}
 function billing(entry) {
     if (entry.checkpoint === true) {
         return;

package/dist/agent/view.js

@@ -1,23 +1,38 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { readOutputPage } from "../shared/output-page.js";
-import { actor, alive } from "./process.js";
+import { actor, alive, observeAlive } from "./process.js";
 import { admissionSchema, commandSchema, exitSchema, successorSchema, } from "./contracts.js";
 import { conversation, read, runDirectory } from "./storage.js";
 import { published } from "./notifications.js";
 import { readCanonicalResult, readResult } from "./usage.js";
 import { Type } from "./typebox.js";
 const commandMetadataSchema = Type.Pick(commandSchema, ["id", "runId", "action", "createdAt"]);
-export function toolResult(value, text = JSON.stringify(value, null, 2)) {
+function toolResult(value, text) {
     return { content: [{ type: "text", text }], details: value };
 }
-function processView(base, launch) {
+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,
+        };
+}
+/** `observed` holds batched liveness by actor token; any other actor gets a fresh check. */
+function processView(base, launch, observed) {
     const identity = actor(base, launch);
     const exit = identity
         ? read(path.join(conversation(base, launch), `exit-${identity.token}.json`), exitSchema)
         : undefined;
     return {
-        live: identity !== undefined && alive(identity),
+        live: identity !== undefined && (observed?.get(identity.token) ?? alive(identity)),
         exit: exit ?? null,
         exitKnown: exit !== undefined,
     };
@@ -60,7 +75,7 @@ function guidanceView(base, launches) {
 }
 function metadata(base, launch, result, options) {
     const directory = runDirectory(base, launch.id);
-    const process = processView(base, launch);
+    const process = processView(base, launch, options.observed);
     const outputFile = path.join(directory, "output.txt");
     const admission = read(path.join(conversation(base, launch), "admissions", `${launch.id}.json`), admissionSchema);
     const status = result?.status ??
@@ -89,12 +104,18 @@ function metadata(base, launch, result, options) {
         guidance: options.guidance,
     };
 }
-export function summaries(base, launches, ctx) {
+async function summaries(base, launches, ctx) {
     const guidance = guidanceView(base, launches);
+    const identities = [
+        ...new Map(launches.map((launch) => [launch.rootId, actor(base, launch)])).values(),
+    ].filter((identity) => identity !== undefined);
+    const verdicts = await observeAlive(identities);
+    const observed = new Map(identities.map((identity, index) => [identity.token, verdicts[index]]));
     return launches.map((launch) => {
         const view = metadata(base, launch, readCanonicalResult(base, launch), {
             ctx,
             guidance: guidance.get(launch.id) ?? [],
+            observed,
         });
         return {
             ...view,
@@ -109,7 +130,7 @@ export function summaries(base, launches, ctx) {
         };
     });
 }
-export function projection(base, launch, ctx, input = {}) {
+function projection(base, launch, ctx, input = {}) {
     const view = metadata(base, launch, readResult(base, launch), {
         ctx,
         guidance: guidanceView(base, [launch]).get(launch.id) ?? [],
@@ -119,6 +140,22 @@ export function projection(base, launch, ctx, input = {}) {
         output: outputView(view.outputFile, input),
     };
 }
+export function renderReceipt(base, launch, ctx, receipt) {
+    const details = { ...projection(base, launch, ctx), ...receipt };
+    const model = { ...details, result: receiptResult(details.result) };
+    return toolResult(details, JSON.stringify(model, null, 2));
+}
+export async function renderInventory(base, launches, ctx, input) {
+    const offset = input.offset ?? 0;
+    const runs = await summaries(base, launches.slice(offset, offset + 50), ctx);
+    const details = {
+        runs,
+        offset,
+        nextOffset: offset + runs.length < launches.length ? offset + runs.length : undefined,
+        total: launches.length,
+    };
+    return toolResult(details, JSON.stringify(details, null, 2));
+}
 function receiptText(details) {
     return details.nativeReceipt !== null
         ? `Native completion receipt: published (${details.nativeReceipt}); publication does not prove model consumption.`
@@ -148,15 +185,8 @@ function resultText(details) {
         `Native journal: ${details.sessionFile}`,
     ].join("\n");
 }
-export function render(base, launch, ctx, input = {}) {
-    const view = projection(base, launch, ctx, input);
-    const details = {
-        ...view,
-        receivedResult: input.receivedResult === true,
-        ...(input.receivedResult === true && view.result?.contributions !== undefined
-            ? { agentUsage: view.result.contributions }
-            : {}),
-    };
+export function renderInspection(base, launch, ctx, input = {}) {
+    const details = projection(base, launch, ctx, input);
     return {
         ...toolResult(details, resultText(details)),
         isError: details.result?.status === "failed",

package/dist/agent/wake.js

@@ -0,0 +1,99 @@
+import * as fs from "node:fs";
+import { journalStamp } from "../shared/native-journal.js";
+import { missing } from "./storage.js";
+/** Identity and change stamp of a path; "" when absent. */
+export function pathStamp(file) {
+    try {
+        const stat = fs.statSync(file, { bigint: true, throwIfNoEntry: false });
+        return stat === undefined ? "" : journalStamp(stat);
+    }
+    catch {
+        return "unreadable";
+    }
+}
+/** Native change hints for one directory identity; owners still reconcile canonical files. */
+export class DirectoryWatch {
+    watcher;
+    armed = "";
+    checked = "";
+    failed = false;
+    directory;
+    relevant;
+    wake;
+    constructor(directory, relevant, wake) {
+        this.directory = directory;
+        this.relevant = relevant;
+        this.wake = wake;
+    }
+    ensure() {
+        const stat = fs.statSync(this.directory, { bigint: true, throwIfNoEntry: false });
+        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) {
+            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);
+    }
+    arm(identity) {
+        try {
+            const watcher = fs.watch(this.directory, { persistent: false }, (_event, file) => {
+                if (watcher === this.watcher && this.relevant(file)) {
+                    this.wake();
+                }
+            });
+            watcher.on("error", () => {
+                if (watcher === this.watcher) {
+                    this.failed = true;
+                    this.close();
+                    this.wake();
+                }
+            });
+            this.watcher = watcher;
+            this.armed = identity;
+            return "armed";
+        }
+        catch (error) {
+            // Unsupported platforms and watch limits keep their owner's polling fallback.
+            this.failed = !missing(error);
+            return "unwatched";
+        }
+    }
+    close() {
+        this.watcher?.close();
+        this.watcher = undefined;
+        this.armed = "";
+    }
+}
+/** A coalesced wake for one owner loop; raised until that loop takes it. */
+export class Wake {
+    raised = true;
+    resolve;
+    raise = () => {
+        this.raised = true;
+        this.resolve?.();
+    };
+    take() {
+        const raised = this.raised;
+        this.raised = false;
+        return raised;
+    }
+    /** Returns at once for a wake raised since the last take. */
+    async sleep(ms) {
+        if (this.raised) {
+            return;
+        }
+        const { promise, resolve } = Promise.withResolvers();
+        const timer = setTimeout(() => {
+            resolve("elapsed");
+        }, ms);
+        this.resolve = () => {
+            resolve("woken");
+        };
+        await promise;
+        clearTimeout(timer);
+        this.resolve = undefined;
+    }
+}

package/dist/build-info.js

@@ -1 +1 @@
-export const EXTENSION_BUILD = Object.freeze({"version":"0.50.0","sha256":"030b516d81cb57e1faa44c99a09eb3eba9eca4a3b9d14e53836d7b54b900ced2"});
+export const EXTENSION_BUILD = Object.freeze({"version":"0.52.0","sha256":"a9faf29451051826907d9343b432c9232529ccaa68c75d681dbcb464702fc25f"});

package/dist/intercom-client.d.ts

@@ -0,0 +1,26 @@
+import { type IntercomClientOptions as BrokerOptions } from "./pi-intercom/broker/client.ts";
+import { type DeliveryGuard, type LastMessageQuery, type LastMessageResult, type ReceiptQuery, type ReceiptResult, type SendOptions, type SendResult, type SessionInfo } from "./pi-intercom/types.ts";
+export type { ContextTarget, DeliveryGuard, LastMessageQuery, LastMessageResult, MessageDelivery, NativeReceipt, PublicationReplyHint, ReceiptQuery, ReceiptResult, SendResult, SessionInfo, } from "./pi-intercom/types.ts";
+export type GuardedSendOptions = Omit<SendOptions, "messageId" | "guard" | "expectsReply" | "replyTo" | "human" | "topic" | "passive" | "delivery"> & {
+    readonly messageId: string;
+    readonly guard: DeliveryGuard;
+    readonly expectsReply: false;
+    readonly delivery: "queue" | "steer" | "passive";
+};
+export interface IntercomClientOptions extends BrokerOptions {
+    readonly spawn: false;
+    readonly session: Omit<SessionInfo, "id" | "guardedDelivery" | "applicationGuard" | "topics" | "subscriptions">;
+    readonly requestedId?: string;
+    readonly onError?: (error: Readonly<Error>) => void;
+}
+export interface IntercomClient {
+    readonly sessionId: string | null;
+    readonly isConnected: () => boolean;
+    readonly listSessions: () => Promise<readonly SessionInfo[]>;
+    readonly send: (to: string, options: GuardedSendOptions) => Promise<SendResult>;
+    readonly last: (to: string, query?: LastMessageQuery) => Promise<LastMessageResult>;
+    readonly receipt: (to: string, query: ReceiptQuery) => Promise<ReceiptResult>;
+    readonly disconnect: () => Promise<void>;
+}
+/** Connect to an existing native broker. No Pi runtime, broker spawn or automatic retry. */
+export declare function connectIntercom(options: IntercomClientOptions): Promise<IntercomClient>;

package/dist/intercom-client.js

@@ -0,0 +1,45 @@
+import { IntercomClient as BrokerClient, } from "./pi-intercom/broker/client.js";
+import { isDeliveryGuard, } from "./pi-intercom/types.js";
+import { isRecord } from "./shared/unknown.js";
+function requireNoSpawn(value) {
+    if (value !== false) {
+        throw new Error("The supported Intercom client requires spawn:false.");
+    }
+}
+function guardedSend(to, input) {
+    return (isRecord(input) &&
+        isDeliveryGuard(input.guard) &&
+        to === input.guard.peerId &&
+        typeof input.messageId === "string" &&
+        input.expectsReply === false &&
+        input.delivery !== undefined);
+}
+/** Connect to an existing native broker. No Pi runtime, broker spawn or automatic retry. */
+export async function connectIntercom(options) {
+    requireNoSpawn(options.spawn);
+    const client = new BrokerClient(options);
+    client.on("error", (error) => options.onError?.(error));
+    try {
+        await client.connect(options.session, options.requestedId);
+    }
+    catch (error) {
+        await client.disconnect();
+        throw error;
+    }
+    return Object.freeze({
+        get sessionId() {
+            return client.sessionId;
+        },
+        isConnected: () => client.isConnected(),
+        listSessions: () => client.listSessions(),
+        async send(to, input) {
+            if (!guardedSend(to, input)) {
+                throw new Error("An exact guarded nonblocking send with an original message ID is required.");
+            }
+            return await client.send(to, input);
+        },
+        last: (to, query) => client.last(to, query),
+        receipt: (to, query) => client.receipt(to, query),
+        disconnect: () => client.disconnect(),
+    });
+}

package/dist/pi-intercom/agent-dir.d.ts

@@ -0,0 +1 @@
+export declare function getPiAgentDir(): string;

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

@@ -4,6 +4,7 @@ import { IntercomClient } from "./broker/client.js";
 import { resolveSessionProjectId } from "./session-targets.js";
 import { Fault, cancelled, log, wait } from "./bridge-protocol.js";
 import { Mailbox } from "./bridge-mailbox.js";
+import { hasErrorCode } from "../shared/unknown.js";
 import { resolveBridgeTarget, bridgeSessionList } from "./bridge-target.js";
 const MAX_REQUESTS = 8;
 const IDLE_TIMEOUT = 5 * 60 * 1000;
@@ -222,7 +223,7 @@ export class Session {
         }
         catch (error) {
             cancelled(signal);
-            if (error instanceof Error && error.message === "List sessions timeout") {
+            if (hasErrorCode(error, "list_timeout")) {
                 throw new Fault(504, "list_timeout", "Broker session list deadline exceeded.");
             }
             throw new Fault(503, "broker_unavailable", "Broker session list failed.");

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

@@ -7,9 +7,11 @@ import { getBrokerRuntimeDir, prepareBrokerSocketPath } from "./paths.js";
 import { brokerPidRecord } from "./pid.js";
 import { assertBrokerCanStart } from "./spawn.js";
 import { LastMessageRelay } from "./last.js";
-import { assertMainParent, canSeeSession, findSessions } from "./targets.js";
-import { acceptBrokerConnection } from "./server-connection.js";
-import { compactTopicMessage, isSessionRegistration, normalizeMessage, normalizeSessionInfo, } from "../types.js";
+import { canSeeSession, findSessions } from "./targets.js";
+import { ParkedSessions, reachable } from "./parked.js";
+import { acceptBrokerConnection, registeredSessionInfo } from "./server-connection.js";
+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";
 const PID_PATH = join(getBrokerRuntimeDir(), "broker.pid");
@@ -17,6 +19,7 @@ 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();
     server;
     shutdownTimer = null;
@@ -55,7 +58,7 @@ class IntercomBroker {
         }
         this.shutdownTimer = setTimeout(() => {
             this.shutdownTimer = null;
-            if (this.sessions.size === 0) {
+            if (this.parking.exited) {
                 console.log("No sessions connected, shutting down");
                 this.shutdown();
             }
@@ -83,7 +86,7 @@ class IntercomBroker {
         }
         switch (msg.type) {
             case "unregister":
-                this.removeSession(currentId);
+                this.removeSession(currentId, socket);
                 setId(null);
                 break;
             case "list":
@@ -93,7 +96,8 @@ class IntercomBroker {
                 this.send(socket, msg, currentId);
                 break;
             case "last_request":
-                this.lastMessages.request(currentId, msg);
+                // Reads never spawn a parked child.
+                this.lastMessages.request(currentId, msg, (id) => this.parking.reader(id));
                 break;
             case "last_response":
                 this.lastMessages.respond(currentId, msg);
@@ -101,28 +105,29 @@ class IntercomBroker {
             case "presence":
                 this.presence(msg, currentId);
                 break;
+            case "park":
+            case "unpark":
+                this.parking.park(socket, currentId, msg.type === "park");
+                break;
             default:
                 throw new Error(`Unknown client message type: ${msg.type}`);
         }
     }
     register(socket, msg, setId) {
-        if (!isSessionRegistration(msg.session)) {
-            throw new Error("Invalid register message");
-        }
-        assertMainParent(msg.session, this.sessions);
-        const requestedId = typeof msg.requestedId === "string" && /^[a-zA-Z0-9_-]{8,80}$/.test(msg.requestedId)
-            ? msg.requestedId
-            : undefined;
-        const id = requestedId !== undefined && !this.sessions.has(requestedId) ? requestedId : randomUUID();
-        const info = { ...msg.session, id, lastSeen: msg.session.lastSeen ?? Date.now() };
+        const registered = registeredSessionInfo(msg, this.sessions);
+        const { id, resumed } = this.parking.claim(msg.requestedId, registered);
+        const info = { ...registered, id };
         snapshotFrames(randomUUID(), [info], true);
         const topicFrames = msg.topicFrames === true;
         this.sessions.set(id, {
             socket,
             info: messageSender(info),
-            topics: new TopicSnapshot(info),
+            // A woken generation registers no topics; the parked identity's owner keeps them.
+            topics: resumed?.topics ?? new TopicSnapshot(info),
             topicFrames,
             lastMessages: msg.lastMessages === true,
+            parking: msg.parking === true,
+            receiptReads: msg.receiptReads === 1,
         });
         setId(id);
         if (this.shutdownTimer) {
@@ -133,18 +138,24 @@ class IntercomBroker {
             type: "registered",
             sessionId: id,
             lastMessages: true,
+            parking: msg.parking === true,
+            receiptReads: 1,
+            ...(msg.guardedDelivery === 1 ? { guardedDelivery: 1 } : {}),
             ...(topicFrames ? { topicsSupported: true, topicFrames: true } : {}),
         });
+        this.parking.registered(id, resumed);
     }
-    removeSession(sessionId) {
+    removeSession(sessionId, socket) {
         const session = this.sessions.get(sessionId);
-        if (!session) {
+        if (session?.socket !== socket) {
             return;
         }
-        this.sessions.delete(sessionId);
         this.lastMessages.disconnected(sessionId);
-        this.clearPendingReplaceDeliveries(sessionId);
-        this.broadcast({ type: "session_left", sessionId }, session.info);
+        if (!this.parking.closed(session)) {
+            this.sessions.delete(sessionId);
+            this.clearPendingReplaceDeliveries(sessionId);
+            this.broadcast({ type: "session_left", sessionId }, session.info);
+        }
         this.scheduleShutdownCheck();
     }
     planPublications(fromId, from, publication) {
@@ -158,7 +169,7 @@ class IntercomBroker {
                 continue;
             }
             const message = publicationMessage(publication, subscription.awaitRelease === true);
-            const error = this.validateDeliveryPayload(from, message, target.topicFrames);
+            const error = this.validateDeliveryPayload(from, message, target);
             if (error !== null) {
                 throw new Error(error);
             }
@@ -240,6 +251,15 @@ class IntercomBroker {
         const targets = findSessions(this.sessions, msg.to, currentId);
         const target = targets[0];
         if (targets.length === 1) {
+            const guardError = guardedDeliveryError(this.sessions, msg.to, message);
+            if (guardError !== null) {
+                writeMessage(socket, {
+                    type: "delivery_failed",
+                    messageId: message.id,
+                    reason: guardError,
+                });
+                return;
+            }
             const fromSession = this.sessions.get(currentId);
             if (!fromSession) {
                 writeMessage(socket, {
@@ -280,11 +300,15 @@ class IntercomBroker {
             "lastIntercomActivity",
             "subscriptions",
             "topics",
+            "applicationGuard",
         ]) {
             if (msg[key] !== undefined) {
                 update[key] = msg[key];
             }
         }
+        if (msg.applicationGuard === null) {
+            delete update.applicationGuard;
+        }
         const nextInfo = normalizeSessionInfo(update);
         if (!nextInfo) {
             throw new Error("Invalid presence update");
@@ -297,22 +321,16 @@ class IntercomBroker {
     }
     sendToSession(fromId, toId, from, message) {
         const target = this.sessions.get(toId);
-        if (!target) {
-            return {
-                id: message.id,
-                accepted: false,
-                delivered: false,
-                reason: "Recipient disconnected before delivery",
-            };
-        }
-        if (shouldReplaceDelivery(message, target.info)) {
+        if (target && target.parked === undefined && shouldReplaceDelivery(message, target.info)) {
             return this.queueReplaceDelivery(fromId, toId, from, message);
         }
         const reason = this.deliverMessage(toId, from, message);
+        const queued = reason === null && target?.parked !== undefined;
         return {
             id: message.id,
             accepted: reason === null,
-            delivered: reason === null,
+            delivered: reason === null && !queued,
+            ...(queued ? { queued } : {}),
             ...(reason !== null ? { reason } : {}),
         };
     }
@@ -333,7 +351,7 @@ class IntercomBroker {
         return `${fromId}\0${toId}\0${threadId}`;
     }
     queueReplaceDelivery(fromId, toId, from, message) {
-        const validationError = this.validateDeliveryPayload(from, message, this.sessions.get(toId)?.topicFrames === true);
+        const validationError = this.validateDeliveryPayload(from, message, this.sessions.get(toId));
         if (validationError !== null) {
             return { id: message.id, accepted: false, delivered: false, reason: validationError };
         }
@@ -365,24 +383,25 @@ class IntercomBroker {
             }
         }
     }
-    validateDeliveryPayload(from, message, topicFrames) {
+    /** One admission rule; retained input is checked as the uncompacted envelope any later
+     * transport generation accepts. */
+    validateDeliveryPayload(from, message, target) {
+        const compact = target?.parked === undefined && target?.topicFrames === true;
         return (validateIntercomMessageSize({
             type: "message",
             from: messageSender(from),
-            message: topicFrames ? compactTopicMessage(message) : message,
+            message: compact ? compactTopicMessage(message) : message,
         })?.message ?? null);
     }
     deliverMessage(toId, from, message) {
         const target = this.sessions.get(toId);
-        if (!target ||
-            target.socket.destroyed ||
-            target.socket.writableEnded ||
-            !target.socket.writable) {
-            return "Recipient disconnected before delivery";
+        const refused = guardedDeliveryError(this.sessions, toId, message) ??
+            this.validateDeliveryPayload(from, message, target);
+        if (refused !== null || this.parking.retain(target, from, message)) {
+            return refused;
         }
-        const validationError = this.validateDeliveryPayload(from, message, target.topicFrames);
-        if (validationError !== null) {
-            return validationError;
+        if (!reachable(target)) {
+            return "Recipient disconnected before delivery";
         }
         this.touchActivity(toId, true);
         try {