@fitchmultz/pi-subagents 0.47.0 → 0.49.0

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

@@ -1,17 +1,30 @@
 import { isUnknownArray } from "../shared/unknown.js";
 import { ASK_TIMEOUT, Fault, INBOX_COUNT, label, object, text } from "./bridge-protocol.js";
 import { body } from "./bridge-http.js";
+import { groupDefinition } from "./bridge-groups.js";
+import { isControlVerb } from "./native-control-protocol.js";
+import { transcriptOptions } from "./transcript.js";
 const fields = {
     "GET /v1/list": [],
     "GET /v1/inbox": [],
     "POST /v1/register": [],
     "POST /v1/ack": ["ids"],
-    "POST /v1/send": ["to", "message"],
+    "POST /v1/send": ["to", "message", "passive", "messageId"],
     "POST /v1/ask": ["to", "message", "timeoutMs"],
     "POST /v1/reply": ["replyTo", "message"],
     "POST /v1/start": ["name"],
+    "POST /v1/spawn": ["name", "cwd", "task", "provider", "model"],
+    "POST /v1/resume": ["sessionId", "name", "target", "task"],
     "GET /v1/sessions": [],
-    "POST /v1/stop": ["sessionId"],
+    "POST /v1/stop": ["sessionId", "target", "to", "mode", "timeoutMs"],
+    "POST /v1/cancel": ["sessionId", "target", "to", "timeoutMs"],
+    "GET /v1/groups": [],
+    "POST /v1/groups": ["name", "members", "namePattern", "cwdPattern", "match"],
+    "POST /v1/broadcast": ["message", "group"],
+    "POST /v1/control": ["to", "verb", "options", "timeoutMs"],
+    "POST /v1/capabilities": ["to", "timeoutMs"],
+    "POST /v1/transcript": ["to", "limit", "maxBytes", "cursor", "timeoutMs"],
+    "GET /v1/transcript": ["target", "limit", "maxBytes", "cursor", "timeoutMs"],
 };
 function isRoute(route) {
     return Object.hasOwn(fields, route);
@@ -25,8 +38,9 @@ export function routeFor(req) {
     if (!isRoute(route)) {
         throw new Fault(404, "not_found", "Unknown method or path.");
     }
-    if (req.url?.includes("?") === true && route !== "GET /v1/inbox") {
-        throw new Fault(400, "invalid_input", "Only inbox accepts query parameters.");
+    if (req.url?.includes("?") === true &&
+        !["GET /v1/inbox", "GET /v1/sessions", "GET /v1/transcript"].includes(route)) {
+        throw new Fault(400, "invalid_input", "Query parameters are only supported for inbox, sessions and transcript.");
     }
     checkGetBody(req);
     return route;
@@ -38,51 +52,145 @@ function checkGetBody(req) {
         throw new Fault(400, "invalid_input", "GET requests must not have a body.");
     }
 }
-function inboxQuery(req) {
-    const url = req.url ?? "";
-    const separator = url.indexOf("?");
-    const query = new URLSearchParams(separator === -1 ? "" : url.slice(separator + 1));
-    if ([...query.keys()].some((key) => !["after", "limit"].includes(key) || query.getAll(key).length !== 1)) {
-        throw new Fault(400, "invalid_input", "Unknown or repeated inbox query parameter.");
+function queryFor(req, allowed) {
+    const query = new URL(req.url ?? "", "https://127.0.0.1").searchParams;
+    if ([...query.keys()].some((key) => !allowed.includes(key) || query.getAll(key).length !== 1)) {
+        throw new Fault(400, "invalid_input", "Unknown or repeated query parameter.");
     }
+    return query;
+}
+function inboxQuery(req) {
+    const query = queryFor(req, ["after", "limit", "waitMs"]);
     const after = query.get("after") ?? "0";
     const limit = query.get("limit") ?? String(INBOX_COUNT);
+    const waitMs = query.get("waitMs") ?? "0";
     if (!/^(0|[1-9]\d{0,15})$/.test(after) ||
         !Number.isSafeInteger(Number(after)) ||
         !/^[1-9]\d{0,2}$/.test(limit) ||
-        Number(limit) > INBOX_COUNT) {
-        throw new Fault(400, "invalid_input", "after must be a nonnegative safe integer cursor; limit must be 1..256.");
+        Number(limit) > INBOX_COUNT ||
+        !/^(0|[1-9]\d{0,3}|10000)$/.test(waitMs)) {
+        throw new Fault(400, "invalid_input", "after must be a nonnegative safe integer cursor; limit must be 1..256; waitMs must be 0..10000.");
+    }
+    return {
+        route: "GET /v1/inbox",
+        after: Number(after),
+        limit: Number(limit),
+        waitMs: Number(waitMs),
+    };
+}
+function pageNumber(value, fallback, min, max) {
+    const number = value === null ? fallback : Number(value);
+    if (value === "" || !Number.isSafeInteger(number) || number < min || number > max) {
+        throw new Fault(400, "invalid_input", "Invalid catalog pagination.");
+    }
+    return number;
+}
+function queryBoolean(value) {
+    if (value !== null && value !== "true" && value !== "false") {
+        throw new Fault(400, "invalid_input", "Catalog switches must be true or false.");
     }
-    return { route: "GET /v1/inbox", after: Number(after), limit: Number(limit) };
+    return value === "true";
 }
-function timeout(value) {
-    const ms = value === undefined ? ASK_TIMEOUT : value;
-    if (typeof ms !== "number" || !Number.isInteger(ms) || ms < 100 || ms > ASK_TIMEOUT) {
-        throw new Fault(400, "invalid_input", "timeoutMs must be an integer from 100 to 120000.");
+function catalogQuery(req) {
+    if (req.url?.includes("?") !== true) {
+        return undefined;
+    }
+    const params = queryFor(req, ["live", "saved", "q", "offset", "limit"]);
+    return {
+        live: queryBoolean(params.get("live")),
+        saved: queryBoolean(params.get("saved")),
+        q: params.has("q") ? label(params.get("q"), "catalog filter", 128) : undefined,
+        offset: pageNumber(params.get("offset"), 0, 0, Number.MAX_SAFE_INTEGER),
+        limit: pageNumber(params.get("limit"), 50, 1, 100),
+    };
+}
+function timeout(value, control = false) {
+    const defaultMs = control ? 3000 : ASK_TIMEOUT;
+    const ms = value === undefined ? defaultMs : value;
+    const max = control ? 10000 : ASK_TIMEOUT;
+    if (typeof ms !== "number" || !Number.isInteger(ms) || ms < 100 || ms > max) {
+        throw new Fault(400, "invalid_input", `timeoutMs must be an integer from 100 to ${max}.`);
     }
     return ms;
 }
-export async function operationFor(req, route, signal) {
-    const input = req.method === "POST" ? object(await body(req, signal), fields[route]) : {};
+function resume(input) {
+    if (["sessionId", "name", "target"].filter((key) => input[key] !== undefined).length !== 1) {
+        throw new Fault(400, "invalid_input", "Resume requires exactly one of sessionId, name or target.");
+    }
+    const sessionId = input.sessionId === undefined ? undefined : label(input.sessionId, "native session ID", 128);
+    if (sessionId !== undefined && !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(sessionId)) {
+        throw new Fault(400, "invalid_input", "Resume takes a native ID, never a journal path.");
+    }
+    return {
+        route: "POST /v1/resume",
+        sessionId,
+        target: input.target === undefined ? undefined : label(input.target, "resume target", 256).trim(),
+        name: input.name === undefined ? undefined : label(input.name, "saved session name", 256).trim(),
+        task: input.task === undefined ? undefined : text(input.task),
+    };
+}
+function stop(route, input) {
+    if (["sessionId", "target", "to"].filter((key) => input[key] !== undefined).length !== 1) {
+        throw new Fault(400, "invalid_input", "Control requires exactly one sessionId, target or to.");
+    }
+    const mode = input.mode ?? "kill";
+    if (mode !== "kill" && mode !== "cancel") {
+        throw new Fault(400, "invalid_input", "Stop mode must be cancel or kill.");
+    }
+    return {
+        route: mode === "cancel" ? "POST /v1/cancel" : route,
+        sessionId: label(input.sessionId ?? input.target ?? input.to, "session target", 256).trim(),
+        timeoutMs: timeout(input.timeoutMs, true),
+    };
+}
+function nativeControl(route, input) {
+    const verb = route === "POST /v1/control" ? input.verb : route.split("/").at(-1);
+    if (!isControlVerb(verb)) {
+        throw new Fault(400, "invalid_input", "Unknown native control verb.");
+    }
+    const timeoutMs = timeout(input.timeoutMs, true);
+    const to = label(input.to ?? input.target, "session target").trim();
+    if (verb === "transcript") {
+        const options = transcriptOptions(route === "POST /v1/control"
+            ? input.options
+            : { limit: input.limit, maxBytes: input.maxBytes, cursor: input.cursor });
+        return { route: "GET /v1/transcript", target: to, options, timeoutMs };
+    }
+    if (input.options !== undefined) {
+        throw new Fault(400, "invalid_input", "Only transcript accepts options.");
+    }
+    return { route: "POST /v1/control", verb, to, timeoutMs };
+}
+async function operationInput(req, route, signal) {
+    if (req.method === "POST") {
+        return object(await body(req, signal), fields[route]);
+    }
+    if (route !== "GET /v1/transcript") {
+        return {};
+    }
+    const input = {};
+    for (const [key, value] of queryFor(req, fields[route])) {
+        input[key] = ["limit", "maxBytes", "timeoutMs"].includes(key) ? Number(value) : value;
+    }
+    return input;
+}
+function messagingOperation(route, input, req) {
     switch (route) {
         case "GET /v1/list":
         case "POST /v1/register":
-        case "GET /v1/sessions":
+        case "GET /v1/groups":
             return { route };
         case "GET /v1/inbox":
             return inboxQuery(req);
-        case "POST /v1/start":
-            return { route, name: label(input.name, "session name", 64).trim() };
-        case "POST /v1/stop":
-            return { route, sessionId: label(input.sessionId, "session ID", 128) };
-        case "POST /v1/ack": {
+        case "GET /v1/sessions":
+            return { route, query: catalogQuery(req) };
+        case "POST /v1/ack":
             if (!isUnknownArray(input.ids) || input.ids.length > INBOX_COUNT) {
                 throw new Fault(400, "invalid_input", "ids must be an array of at most 256 message IDs.");
             }
             return { route, ids: [...new Set(input.ids.map((id) => label(id, "message ID")))] };
-        }
         case "POST /v1/send":
-            return { route, message: text(input.message), to: label(input.to, "to").trim() };
+            return send(input);
         case "POST /v1/ask":
             return {
                 route,
@@ -92,5 +200,65 @@ export async function operationFor(req, route, signal) {
             };
         case "POST /v1/reply":
             return { route, message: text(input.message), replyTo: label(input.replyTo, "replyTo") };
+        case "GET /v1/transcript":
+        case "POST /v1/control":
+        case "POST /v1/transcript":
+        case "POST /v1/capabilities":
+            return nativeControl(route, input);
+    }
+}
+function send(input) {
+    if (input.passive !== undefined && typeof input.passive !== "boolean") {
+        throw new Fault(400, "invalid_input", "passive must be a boolean.");
+    }
+    return {
+        route: "POST /v1/send",
+        message: text(input.message),
+        to: label(input.to, "to").trim(),
+        passive: input.passive,
+        messageId: input.messageId === undefined ? undefined : label(input.messageId, "message ID"),
+    };
+}
+export async function operationFor(req, route, signal) {
+    const input = await operationInput(req, route, signal);
+    switch (route) {
+        case "POST /v1/start":
+            return { route, name: label(input.name, "session name", 64).trim() };
+        case "POST /v1/spawn":
+            return {
+                route,
+                name: label(input.name, "session name", 64).trim(),
+                cwd: input.cwd === undefined ? undefined : label(input.cwd, "cwd", 4096),
+                provider: input.provider === undefined ? undefined : label(input.provider, "provider", 128),
+                model: input.model === undefined ? undefined : label(input.model, "model reference", 512),
+                task: input.task === undefined ? undefined : text(input.task),
+            };
+        case "POST /v1/resume":
+            return resume(input);
+        case "POST /v1/stop":
+        case "POST /v1/cancel":
+            return stop(route, input);
+        case "POST /v1/groups":
+            return { route, group: groupDefinition(input) };
+        case "POST /v1/broadcast":
+            return {
+                route,
+                message: text(input.message),
+                group: input.group === undefined ? undefined : label(input.group, "group", 64).trim(),
+            };
+        case "GET /v1/groups":
+        case "GET /v1/inbox":
+        case "GET /v1/list":
+        case "GET /v1/sessions":
+        case "GET /v1/transcript":
+        case "POST /v1/ack":
+        case "POST /v1/ask":
+        case "POST /v1/capabilities":
+        case "POST /v1/control":
+        case "POST /v1/register":
+        case "POST /v1/reply":
+        case "POST /v1/send":
+        case "POST /v1/transcript":
+            return messagingOperation(route, input, req);
     }
 }

package/dist/pi-intercom/bridge-rpc-process.js

@@ -2,14 +2,14 @@ import { spawn } from "node:child_process";
 import { StringDecoder } from "node:string_decoder";
 import { trySignalChildTree } from "../shared/post-exit-stdio-guard.js";
 import { isRecord } from "../shared/unknown.js";
-import { Fault, log, wait } from "./bridge-protocol.js";
+import { Fault, cancelled, log, wait } from "./bridge-protocol.js";
 const FRAME_LIMIT = 4 * 1024 * 1024;
 function launchEnvironment(packageRoot) {
     const environment = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith("PI_SUBAGENT_")));
     return { ...environment, PI_PACKAGE_DIR: packageRoot };
 }
 // Native RpcClient lacks public EOF/exit/UI control and retains/reprints unbounded stderr.
-// This owner implements only get_state and dialog cancellation, never a remote RPC proxy.
+// This owner implements state, owned-run cancellation and dialog dismissal, never a raw RPC proxy.
 export class RpcProcess {
     child;
     exited;
@@ -23,8 +23,9 @@ export class RpcProcess {
     stopping;
     stderrBytes = 0;
     exitObserved = false;
-    constructor(policy, cwd, sessionFile) {
-        this.child = spawn(process.execPath, this.arguments(policy, sessionFile), {
+    cancelling = false;
+    constructor(policy, cwd, sessionFile, resuming = false) {
+        this.child = spawn(process.execPath, this.arguments(policy, sessionFile, resuming), {
             cwd,
             detached: true,
             env: launchEnvironment(policy.packageRoot),
@@ -65,19 +66,19 @@ export class RpcProcess {
     get pid() {
         return this.child.pid;
     }
-    arguments(policy, sessionFile) {
+    arguments(policy, sessionFile, resuming) {
         const args = [
             policy.cli,
             "--mode",
             "rpc",
             "--session",
             sessionFile,
-            "--provider",
-            policy.provider,
-            "--model",
-            policy.model,
             policy.trustProject ? "--approve" : "--no-approve",
         ];
+        // Resume leaves native model/thinking restoration authoritative; never force the launch default.
+        if (!resuming && policy.provider !== undefined && policy.model !== undefined) {
+            args.push("--provider", policy.provider, "--model", policy.model);
+        }
         if (!policy.discoverResources) {
             args.push("--no-extensions", "--no-skills", "--no-prompt-templates", "--no-themes", "--no-context-files");
         }
@@ -175,8 +176,10 @@ export class RpcProcess {
     response(data) {
         const pending = this.pending;
         this.pending = undefined;
-        if (data.success === true && data.command === "get_state" && isRecord(data.data)) {
-            pending?.resolve(data.data);
+        if (data.success === true &&
+            data.command === pending?.command &&
+            (pending?.command !== "get_state" || isRecord(data.data))) {
+            pending?.resolve(isRecord(data.data) ? data.data : {});
         }
         else {
             pending?.reject(new Fault(503, "rpc_failed", "Pi RPC state request failed."));
@@ -200,14 +203,18 @@ export class RpcProcess {
             this.cleanup();
         }
     }
-    async state(signal) {
+    async command(command, signal) {
+        cancelled(signal);
         if (this.failure) {
             throw this.failure;
         }
-        const id = `state-${++this.sequence}`;
+        if (this.pending) {
+            throw new Fault(409, "control_in_progress", "A native control operation is already in flight.");
+        }
+        const id = `control-${++this.sequence}`;
         const result = new Promise((resolve, reject) => {
-            this.pending = { id, resolve, reject };
-            this.write({ type: "get_state", id });
+            this.pending = { id, command, resolve, reject };
+            this.write({ type: command, id });
         });
         try {
             return await wait(result, signal);
@@ -216,6 +223,27 @@ export class RpcProcess {
             this.pending = undefined;
         }
     }
+    async state(signal) {
+        return this.command("get_state", signal);
+    }
+    async cancel(signal) {
+        if (this.cancelling) {
+            throw new Fault(409, "control_in_progress", "Native cancellation is already in flight.");
+        }
+        this.cancelling = true;
+        try {
+            await this.command("abort", signal);
+            const state = await this.state(signal);
+            if (state.isStreaming !== false) {
+                throw new Fault(409, "cancel_unconfirmed", "Native Pi has not reached idle after abort.");
+            }
+            this.status = "idle";
+            return { isStreaming: false, pendingMessageCount: state.pendingMessageCount };
+        }
+        finally {
+            this.cancelling = false;
+        }
+    }
     ready() {
         if (this.failure || this.exitObserved) {
             throw this.failure ?? new Fault(503, "session_exited", "Pi exited during startup.");

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

@@ -1,8 +1,11 @@
 import { randomUUID } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
 import { IntercomClient } from "./broker/client.js";
-import { formatSessionTarget, resolveSessionProjectId, resolveSessionTarget, } from "./session-targets.js";
+import { resolveSessionProjectId } from "./session-targets.js";
 import { Fault, cancelled, log, wait } from "./bridge-protocol.js";
 import { Mailbox } from "./bridge-mailbox.js";
+import { resolveBridgeTarget, bridgeSessionList } from "./bridge-target.js";
+import { ControlReplies } from "./bridge-control.js";
 import { WaitingAsk } from "./bridge-ask.js";
 const MAX_REQUESTS = 8;
 const IDLE_TIMEOUT = 5 * 60 * 1000;
@@ -19,8 +22,10 @@ export class Session {
     });
     requests = new Set();
     inbox;
+    inboxChanged = new AbortController();
     replying = new Set();
     pending;
+    controls = new ControlReplies();
     closed = false;
     connecting;
     disconnecting;
@@ -45,12 +50,13 @@ export class Session {
         this.touch();
     }
     guard(signal) {
-        if (signal) {
-            cancelled(signal);
-        }
+        signal?.throwIfAborted();
         if (this.closed) {
             throw this.closeReason;
         }
+        this.authorize();
+    }
+    authorize() {
         if (!this.owner.allowed(this.identity)) {
             throw new Fault(403, "revoked", "Identity is no longer authorized.");
         }
@@ -143,27 +149,26 @@ export class Session {
         this.owner.retired(this.identity.fingerprint256, this.generation);
         log("session_closed", { ...this.fields(), result: this.closeReason.code });
     }
-    close(error) {
+    close(fault) {
         if (this.closed) {
             return;
         }
         this.closed = true;
-        this.closeReason = error;
+        this.closeReason = fault;
         clearTimeout(this.lease);
-        this.pending?.reject(error);
+        this.pending?.reject(fault);
+        this.controls.close(fault);
         for (const controller of this.requests) {
-            controller.abort(error);
+            controller.abort(fault);
         }
         // Retain the generation until acquisition/registration AND final disconnect settle.
-        this.startRetirement();
-    }
-    startRetirement() {
         this.retirement = this.retire().catch((caught) => this.cleanupFailed(caught));
     }
     async settled() {
         await this.retirement;
     }
     peerLeft(id) {
+        this.controls.peerLeft(id);
         if (this.pending?.peer === id && !this.pending.settled) {
             this.pending.reject(new Fault(409, "peer_offline", "Ask recipient disconnected.", { id: this.pending.id }));
         }
@@ -182,6 +187,9 @@ export class Session {
                 : new Fault(403, "revoked", "Identity is no longer authorized."));
             return;
         }
+        if (this.controls.receive(from.id, message)) {
+            return;
+        }
         if (!this.inbox.persistent && this.resolveReply(from, message)) {
             return;
         }
@@ -203,12 +211,22 @@ export class Session {
             this.close(new Fault(507, "mailbox_storage_failed", "Mailbox storage failed; inspect the metadata audit for unrecorded losses."));
             return;
         }
-        if (result === "lost" || (result === "duplicate" && !this.inbox.persistent)) {
-            this.owner.lost(this.identity.fingerprint256);
+        if (result !== "duplicate" || !this.inbox.persistent) {
+            if (result !== "stored") {
+                this.owner.lost(this.identity.fingerprint256);
+            }
+            this.inboxChanged.abort();
+            this.inboxChanged = new AbortController();
         }
-        this.recordReceive(from.id, message.id, result);
+        log(result === "lost" ? "inbox_overflow" : "received", {
+            ...this.fields(),
+            peer: from.id,
+            messageId: message.id,
+            result: result === "lost" && this.inbox.persistent ? "storage_failed" : result,
+        });
         if (result !== "lost") {
             this.resolveReply(from, message);
+            this.owner.mailboxChanged?.();
         }
         this.presence();
     }
@@ -220,14 +238,6 @@ export class Session {
         pending.resolve({ from, message });
         return true;
     }
-    recordReceive(peer, messageId, result) {
-        log(result === "lost" ? "inbox_overflow" : "received", {
-            ...this.fields(),
-            peer,
-            messageId,
-            result: result === "lost" && this.inbox.persistent ? "storage_failed" : result,
-        });
-    }
     presence() {
         if (this.closed) {
             return;
@@ -254,20 +264,16 @@ export class Session {
         await this.connect(signal);
         return this.peers(signal);
     }
+    async nativeControl(operation, certificate, context) {
+        await this.connect(context.signal);
+        const peer = await this.target(operation.to, context.signal);
+        return this.controls.request(this.client, { ...operation, peer: peer.id, certificate }, { ...context, guard: () => this.guard(context.signal) });
+    }
     async target(to, signal) {
-        const resolution = resolveSessionTarget(await this.peers(signal), to);
-        if (resolution.status === "none") {
-            throw new Fault(404, "peer_offline", "Peer is not connected.");
-        }
-        if (resolution.status !== "found" || !resolution.target) {
-            throw new Fault(409, "ambiguous_target", "Use an unambiguous peer name or session ID (prefixes need at least 8 characters).");
-        }
-        if (resolution.target.id === this.client.sessionId) {
-            throw new Fault(400, "self_target", "Choose another peer.");
-        }
-        return resolution.target;
+        return resolveBridgeTarget(await this.peers(signal), to, this.client.sessionId);
     }
     async send(peer, message, context, options = {}) {
+        await this.connect(context.signal);
         const { signal, requestId } = context;
         context.onPeer(peer);
         this.guard(signal);
@@ -307,17 +313,6 @@ export class Session {
         const waiting = new WaitingAsk();
         this.pending = waiting;
         const { signal } = context;
-        const abort = () => {
-            try {
-                cancelled(signal);
-            }
-            catch (error) {
-                waiting.reject(error instanceof Error
-                    ? error
-                    : new Fault(499, "client_aborted", "HTTP client disconnected; delivery may be unknown."));
-            }
-        };
-        signal.addEventListener("abort", abort, { once: true });
         try {
             await this.connect(signal);
             const peer = await this.target(operation.to, signal);
@@ -334,16 +329,37 @@ export class Session {
         }
         finally {
             waiting.clear();
-            signal.removeEventListener("abort", abort);
-            if (this.pending === waiting) {
-                this.pending = undefined;
-            }
+            this.pending = undefined;
         }
     }
-    ack(ids) {
-        const result = this.inbox.ack(ids);
-        this.presence();
-        return result;
+    async readInbox(operation, context) {
+        const read = () => ({
+            ...this.inbox.page(operation.after, operation.limit),
+            ...this.inbox.status(this.owner.losses(this.identity.fingerprint256)),
+        });
+        const deadline = performance.now() + operation.waitMs;
+        const losses = read().lostMessages;
+        for (;;) {
+            // Subscribe to the post-commit signal before rereading the authoritative cursor page.
+            const signal = AbortSignal.any([this.inboxChanged.signal, context.signal]);
+            const page = read();
+            const remaining = deadline - performance.now();
+            if (page.messages.length > 0 || page.lostMessages !== losses || remaining <= 0) {
+                return page;
+            }
+            log("inbox_wait", { ...this.fields(), requestId: context.requestId, after: operation.after });
+            try {
+                // A nonmatching commit must rearm the same cursor, not start parallel readers.
+                // oxlint-disable-next-line no-await-in-loop
+                await delay(remaining, undefined, { signal });
+            }
+            catch (error) {
+                if (!signal.aborted) {
+                    throw error;
+                }
+            }
+            this.guard(context.signal);
+        }
     }
     async answer(replyTo, message, context) {
         const entry = this.inbox.get(replyTo);
@@ -367,6 +383,7 @@ export class Session {
             }
             const data = { ...(await this.send(peer, message, context, { replyTo })) };
             this.inbox.remove(replyTo);
+            this.owner.mailboxChanged?.();
             this.presence();
             return data;
         }
@@ -385,30 +402,30 @@ export class Session {
                 await this.connect(context.signal);
             }
             if (operation.route === "POST /v1/ack") {
-                return this.ack(operation.ids);
+                const result = this.inbox.ack(operation.ids);
+                this.owner.mailboxChanged?.();
+                this.presence();
+                return result;
             }
-            return {
-                ...this.inbox.page(operation.after, operation.limit),
-                ...this.inbox.status(this.owner.losses(this.identity.fingerprint256)),
-            };
+            return this.readInbox(operation, context);
         }
         await this.connect(context.signal);
         switch (operation.route) {
             case "POST /v1/register":
                 return { sessionId: this.client.sessionId, name: this.identity.name };
-            case "GET /v1/list": {
-                const sessions = await this.peers(context.signal);
+            case "GET /v1/list":
                 return {
                     sessionId: this.client.sessionId,
-                    sessions: sessions.map(({ topics: _topics, subscriptions: _subscriptions, ...entry }) => {
-                        return Object.assign(entry, { target: formatSessionTarget(entry, sessions) });
-                    }),
+                    sessions: bridgeSessionList(await this.peers(context.signal)),
                 };
+            case "POST /v1/send": {
+                const peer = await this.target(operation.to, context.signal);
+                const receipt = await this.send(peer.id, operation.message, context, {
+                    messageId: operation.messageId,
+                    delivery: operation.passive === true ? "passive" : "steer",
+                });
+                return { ...receipt };
             }
-            case "POST /v1/send":
-                return {
-                    ...(await this.send((await this.target(operation.to, context.signal)).id, operation.message, context)),
-                };
             case "POST /v1/reply":
                 return this.answer(operation.replyTo, operation.message, context);
         }