agent-embassy 3.1.0 → 4.0.0

package/dist/src/gateway/claude-peer.js

@@ -1,23 +1,14 @@
 import { execFile } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
-import { chmod, constants as fsConstants, lstat, open, opendir, realpath, rename, unlink, writeFile, } from "node:fs/promises";
+import { constants as fsConstants, lstat, open, opendir, realpath, } from "node:fs/promises";
 import net from "node:net";
 import os from "node:os";
 import path from "node:path";
 import { TextDecoder } from "node:util";
 import { BridgeError } from "../errors.js";
-import { KeyedMutex } from "../mutex.js";
 export const CLAUDE_PEER_COMPATIBILITY = Object.freeze({ peerProtocol: 1 });
-const EMBASSY_ADVERTISEMENT_VERSION = 1;
-const EMBASSY_SOURCE_NAME_PATTERN = /^(?:codex-|peer-)/;
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 const ALIAS_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
-const PRIVATE_ARTIFACT_TOKEN_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
-/** Bounded notices the gateway writes into a live Claude session; the framing tags around them are the wire contract. */
-const CLAUDE_PEER_NOTICE_COPY = {
-    stall: "The local gateway is still waiting to deliver the preceding message. Run `embassy status` for details. Queued mail reaches a busy recipient when its turn ends.",
-    diagnostic: "The local gateway could not deliver the preceding message. Run `embassy status` for details. Queued mail reaches a busy recipient when its turn ends.",
-};
 const REGISTRY_FILE_PATTERN = /^([1-9][0-9]{0,9})\.json$/;
 const SOCKET_FILE_PATTERN = /^([1-9][0-9]{0,9})\.sock$/;
 const MAX_PID = 2_147_483_647;
@@ -39,31 +30,15 @@ export const claudePeerRejectionCodes = [
     "SELF_TARGET",
     "SESSION_ID_COLLISION",
 ];
-export const claudePeerInboundStallReasons = [
-    "ROUTE_BUSY",
-    "ROUTE_UNAVAILABLE",
-    "AWAITING_EXTERNAL_APPROVAL",
-];
-const MAX_CLAUDE_STALL_QUEUED_MS = 3_600_000;
-const CAPACITY_SETTLEMENT_MAX_ATTEMPTS = 3;
-const CAPACITY_SETTLEMENT_RETRY_MS = 25;
 function isObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function hasExactKeys(value, required, optional = []) {
-    const permitted = new Set([...required, ...optional]);
-    return (required.every((key) => Object.hasOwn(value, key)) &&
-        Object.keys(value).every((key) => permitted.has(key)));
-}
 function byteLength(value) {
     return Buffer.byteLength(value, "utf8");
 }
 function isBoundedString(value, maxBytes) {
     return typeof value === "string" && byteLength(value) <= maxBytes;
 }
-function isDiagnosticVersion(value) {
-    return isBoundedString(value, 64) && value.length > 0 && !value.includes("\0");
-}
 function validateContent(content, maxBytes) {
     if (typeof content !== "string" ||
         content.length === 0 ||
@@ -84,10 +59,7 @@ function sameFileGeneration(left, right) {
         left.mtimeMs === right.mtimeMs);
 }
 function sameSocketGeneration(left, right) {
-    return left.dev === right.dev && left.ino === right.ino;
-}
-function sameDirectoryGeneration(left, right) {
-    return left.dev === right.dev && left.ino === right.ino;
+    return left.dev === right.dev && left.ino === right.ino && left.ctimeNs === right.ctimeNs;
 }
 function pathContains(parent, child) {
     const relative = path.relative(parent, child);
@@ -121,13 +93,6 @@ function configuredLimit(value, fallback, minimum, maximum, label) {
     }
     return resolved;
 }
-function boundedStallQueuedForMs(value) {
-    if (Number.isNaN(value) || value === Number.NEGATIVE_INFINITY)
-        return 0;
-    if (value === Number.POSITIVE_INFINITY)
-        return MAX_CLAUDE_STALL_QUEUED_MS;
-    return Math.min(MAX_CLAUDE_STALL_QUEUED_MS, Math.max(0, Math.trunc(value)));
-}
 function parseRegistryRecord(value, expectedPid) {
     if (!isObject(value))
         return undefined;
@@ -136,19 +101,6 @@ function parseRegistryRecord(value, expectedPid) {
         "updatedAt"];
     if (!required.every((key) => Object.hasOwn(value, key)))
         return undefined;
-    const embassyAdvertisement = value.embassyAdvertisementVersion === EMBASSY_ADVERTISEMENT_VERSION &&
-        isDiagnosticVersion(value.version) &&
-        typeof value.name === "string" &&
-        EMBASSY_SOURCE_NAME_PATTERN.test(value.name) &&
-        ALIAS_PATTERN.test(value.name) &&
-        value.kind === "interactive" &&
-        value.entrypoint === "cli" &&
-        value.peerProtocol === CLAUDE_PEER_COMPATIBILITY.peerProtocol &&
-        value.status !== undefined &&
-        value.statusUpdatedAt !== undefined;
-    if (value.embassyAdvertisementVersion !== undefined && !embassyAdvertisement)
-        return undefined;
-    const versionObserved = value.version === undefined || isDiagnosticVersion(value.version);
     if (value.pid !== expectedPid)
         return undefined;
     if (typeof value.sessionId !== "string" || !UUID_PATTERN.test(value.sessionId))
@@ -168,7 +120,6 @@ function parseRegistryRecord(value, expectedPid) {
         !isBoundedString(value.procStart, 256) ||
         value.procStart.length === 0 ||
         value.procStart.includes("\0") ||
-        !versionObserved ||
         !isBoundedString(value.entrypoint, 64) ||
         !/^[A-Za-z0-9._-]+$/.test(value.entrypoint) ||
         (value.nameSource !== undefined &&
@@ -206,113 +157,20 @@ function parseRegistryRecord(value, expectedPid) {
         messagingSocketPath: value.messagingSocketPath,
         name: value.name,
         status: (value.status ?? "busy"),
-        embassyAdvertisement,
     };
 }
-function parseFrame(line, maxFrameBytes) {
-    if (line.length === 0 || line.length > maxFrameBytes) {
-        throw new BridgeError("INVALID_PEER_FRAME", "Invalid peer frame size.");
-    }
-    let text;
-    try {
-        text = new TextDecoder("utf-8", { fatal: true }).decode(line);
-    }
-    catch {
-        throw new BridgeError("INVALID_PEER_UTF8", "Invalid peer frame encoding.");
-    }
-    let value;
-    try {
-        value = JSON.parse(text);
-    }
-    catch {
-        throw new BridgeError("INVALID_PEER_FRAME", "Invalid peer frame JSON.");
-    }
-    if (!isObject(value) || typeof value.type !== "string") {
-        throw new BridgeError("INVALID_PEER_FRAME", "Invalid peer frame shape.");
-    }
-    if (value.type === "user") {
-        if (!hasExactKeys(value, ["type", "message"], ["msgV", "msg_id", "priority", "from"]) ||
-            !isObject(value.message) ||
-            !hasExactKeys(value.message, ["role", "content"]) ||
-            value.message.role !== "user") {
-            throw new BridgeError("INVALID_PEER_FRAME", "Invalid user frame shape.");
-        }
-        const canonicalFields = [value.msgV, value.msg_id, value.priority];
-        const canonicalCount = canonicalFields.filter((field) => field !== undefined).length;
-        if (canonicalCount !== 0 &&
-            (canonicalCount !== 3 ||
-                value.msgV !== 1 ||
-                typeof value.msg_id !== "string" ||
-                !UUID_PATTERN.test(value.msg_id) ||
-                value.priority !== "next")) {
-            throw new BridgeError("INVALID_PEER_FRAME", "Invalid canonical user frame fields.");
-        }
-        if (value.from !== undefined &&
-            (!isBoundedString(value.from, 4096) || !value.from.startsWith("uds:"))) {
-            throw new BridgeError("INVALID_PEER_FRAME", "Invalid reply address.");
-        }
-        const content = validateContent(value.message.content, maxFrameBytes);
-        return {
-            type: "user",
-            content,
-            ...(typeof value.msg_id === "string"
-                ? { messageId: value.msg_id }
-                : {}),
-            ...(typeof value.from === "string" ? { from: value.from } : {}),
-        };
-    }
-    if (value.type === "control") {
-        if (!hasExactKeys(value, [
-            "type",
-            "action",
-            "status",
-            "reason",
-            "from",
-            "orig_msg_id",
-            "msgV",
-            "msg_id",
-        ]) ||
-            value.action !== "peer_message_status" ||
-            !["held", "denied", "expired", "delivered"].includes(String(value.status)) ||
-            !isBoundedString(value.reason, 1024) ||
-            !isBoundedString(value.from, 4096) ||
-            !value.from.startsWith("uds:") ||
-            typeof value.orig_msg_id !== "string" ||
-            !UUID_PATTERN.test(value.orig_msg_id) ||
-            value.msgV !== 1 ||
-            typeof value.msg_id !== "string" ||
-            !UUID_PATTERN.test(value.msg_id)) {
-            throw new BridgeError("INVALID_PEER_FRAME", "Invalid peer status frame.");
-        }
-        return {
-            type: "control",
-            action: "peer_message_status",
-            status: value.status,
-            from: value.from,
-            originalMessageId: value.orig_msg_id,
-        };
-    }
-    throw new BridgeError("UNSUPPORTED_PEER_FRAME", "Unsupported Claude peer frame type.");
-}
 export function encodeClaudePeerUserFrame(input) {
     if (!UUID_PATTERN.test(input.messageId)) {
         throw new BridgeError("INVALID_PEER_MESSAGE_ID", "The peer message ID must be a UUID.");
     }
     const maxFrameBytes = configuredLimit(input.maxFrameBytes, 64 * 1024, 256, 1024 * 1024, "maxFrameBytes");
     const content = validateContent(input.content, maxFrameBytes);
-    if (input.from !== undefined &&
-        (!input.from.startsWith("uds:") ||
-            !path.isAbsolute(input.from.slice(4)) ||
-            input.from.includes("\0"))) {
-        throw new BridgeError("INVALID_PEER_REPLY_ADDRESS", "The peer reply address must be an absolute uds address.");
-    }
     const frame = {
         msgV: 1,
         msg_id: input.messageId,
         type: "user",
         message: { role: "user", content },
         priority: "next",
-        ...(input.from === undefined ? {} : { from: input.from }),
     };
     const encoded = Buffer.from(`${JSON.stringify(frame)}\n`, "utf8");
     if (encoded.length > maxFrameBytes + 1) {
@@ -351,12 +209,7 @@ async function defaultProcessInspector(pid) {
         });
     });
 }
-async function invokeHook(hook, value) {
-    if (hook === undefined)
-        return;
-    await hook(value);
-}
-function writeSocketPayload(connect, socketPath, payload, timeoutMs, onWriteStart) {
+function writeSocketPayload(connect, socketPath, payload, timeoutMs, beforeWrite, onWriteStart) {
     return new Promise((resolve, reject) => {
         const socket = connect(socketPath);
         let settled = false;
@@ -371,34 +224,20 @@ function writeSocketPayload(connect, socketPath, payload, timeoutMs, onWriteStar
             error === undefined ? resolve() : reject(error);
         };
         socket.once("error", finish);
-        socket.once("connect", () => {
+        socket.once("connect", () => void (async () => {
             try {
+                await beforeWrite();
+                if (settled)
+                    return;
                 onWriteStart();
                 socket.end(payload, () => finish());
             }
             catch (error) {
                 finish(error);
             }
-        });
+        })());
     });
 }
-async function socketOwnership(socketPath, generation) {
-    try {
-        const stat = await lstat(socketPath);
-        return stat.isSocket() &&
-            sameSocketGeneration({ dev: stat.dev, ino: stat.ino }, generation)
-            ? "owned"
-            : "changed";
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return "missing";
-        throw error;
-    }
-}
-function closeServer(server) {
-    return new Promise((resolve, reject) => server.close((error) => error === undefined ? resolve() : reject(error)));
-}
 export class ClaudePeerAdapter {
     #sessionsDir;
     #socketDir;
@@ -408,27 +247,15 @@ export class ClaudePeerAdapter {
     #connect;
     #now;
     #createId;
-    #createArtifactToken;
-    #deliveryNotices;
-    #registryRename;
-    #registryOperationHook;
     #userHome;
     #tempRoots;
-    #registryMutex = new KeyedMutex();
-    #postBindHook;
     #targets = new Map();
     #selectedStateRoots = new Map();
-    #listeners = new Set();
     #preparedSends = new Set();
     constructor(options, testing = {}) {
         if (process.platform === "win32" || process.getuid === undefined) {
             throw new BridgeError("CLAUDE_PEER_PLATFORM_UNSUPPORTED", "Claude peer sockets are supported only on macOS and Linux.");
         }
-        if (options.deliveryNotices !== undefined &&
-            !["merged", "verbose", "quiet"].includes(options.deliveryNotices)) {
-            throw new BridgeError("INVALID_GATEWAY_CONFIGURATION", "The Claude peer delivery notice mode is unsupported.");
-        }
-        this.#deliveryNotices = options.deliveryNotices ?? "merged";
         this.#sessionsDir = assertAbsoluteConfiguredPath(options.sessionsDir, "sessionsDir");
         this.#socketDir = assertAbsoluteConfiguredPath(options.socketDir, "socketDir");
         this.#expectedUid = testing.expectedUid ?? process.getuid();
@@ -441,10 +268,6 @@ export class ClaudePeerAdapter {
             maxRegistryBytes: limit("maxRegistryBytes", 16 * 1024, 512, 1024 * 1024),
             maxFrameBytes: limit("maxFrameBytes", 64 * 1024, 256, 1024 * 1024),
             connectTimeoutMs: limit("connectTimeoutMs", 2_000, 10, 30_000),
-            maxPendingReceipts: limit("maxPendingReceipts", 256, 1, 4_096),
-            maxConnections: limit("maxConnections", 32, 1, 1_024),
-            connectionIdleMs: limit("connectionIdleMs", 5_000, 10, 60_000),
-            maxFramesPerConnection: limit("maxFramesPerConnection", 8, 1, 128),
         };
         this.#inspectProcess = testing.processInspector ?? defaultProcessInspector;
         this.#connect =
@@ -452,14 +275,10 @@ export class ClaudePeerAdapter {
                 ((socketPath) => net.createConnection({ path: socketPath }));
         this.#now = testing.now ?? Date.now;
         this.#createId = testing.createId ?? randomUUID;
-        this.#createArtifactToken = testing.createArtifactToken ?? randomUUID;
-        this.#registryRename = testing.registryRename ?? rename;
-        this.#registryOperationHook = testing.registryOperationHook;
         this.#userHome = assertAbsoluteConfiguredPath(testing.userHome ?? os.userInfo().homedir, "userHome");
         this.#tempRoots = Object.freeze([
             ...(testing.tempRoots ?? ["/tmp", "/private/tmp", os.tmpdir()]),
         ].map((root) => assertAbsoluteConfiguredPath(root, "tempRoot")));
-        this.#postBindHook = testing.postBindHook;
     }
     async #validateRoots() {
         const [stat, sockets] = await Promise.all([
@@ -515,7 +334,7 @@ export class ClaudePeerAdapter {
             catch {
                 throw new BridgeError("REGISTRY_INVALID_JSON", "Registry JSON is invalid.");
             }
-            return { value, generation: openedGeneration };
+            return value;
         }
         finally {
             await handle.close();
@@ -530,14 +349,14 @@ export class ClaudePeerAdapter {
         if (match === null || parsePositiveInteger(match[1] ?? "") !== expectedPid) {
             throw new BridgeError("SOCKET_OUTSIDE_ROOT", "Peer socket filename does not match its process.");
         }
-        const stat = await lstat(socketPath);
+        const stat = await lstat(socketPath, { bigint: true });
         if (stat.isSymbolicLink() || !stat.isSocket()) {
             throw new BridgeError("SOCKET_NOT_SOCKET", "Peer endpoint is not a socket.");
         }
-        return { dev: stat.dev, ino: stat.ino };
+        return { dev: stat.dev, ino: stat.ino, ctimeNs: stat.ctimeNs };
     }
-    async #bindingFromRegistry(registryPath, expectedPid, _existingTargetId, onParsed) {
-        const { value } = await this.#readRegistryFile(registryPath);
+    async #bindingFromRegistry(registryPath, expectedPid, onParsed) {
+        const value = await this.#readRegistryFile(registryPath);
         if (isObject(value) && value.pid !== expectedPid) {
             throw new BridgeError("PID_MISMATCH", "Registry filename and process identifier do not match.");
         }
@@ -545,9 +364,7 @@ export class ClaudePeerAdapter {
         if (record === undefined) {
             throw new BridgeError("REGISTRY_INVALID_SCHEMA", "Registry schema is incompatible.");
         }
-        // Embassy advertisements are addressable by Claude, never Claude delivery
-        // targets or evidence that a Claude record parsed.
-        if (record.embassyAdvertisement || expectedPid === process.pid) {
+        if (expectedPid === process.pid) {
             throw new BridgeError("SELF_TARGET", "The gateway cannot target itself.");
         }
         onParsed?.();
@@ -558,7 +375,7 @@ export class ClaudePeerAdapter {
         if (processIdentity.uid !== this.#expectedUid) {
             throw new BridgeError("PID_OWNER_MISMATCH", "Registry process owner is unsafe.");
         }
-        await this.#validateSocket(record.messagingSocketPath, expectedPid);
+        const socketGeneration = await this.#validateSocket(record.messagingSocketPath, expectedPid);
         return {
             // Claude's native session UUID is the logical route identity. The
             // process, registry file, and socket below are replaceable transport
@@ -566,8 +383,29 @@ export class ClaudePeerAdapter {
             targetId: record.sessionId,
             alias: record.name,
             record,
+            registryPath,
+            processGeneration: processIdentity.generation,
+            socketGeneration,
         };
     }
+    async #revalidatePreparedBinding(expected, stateRoot) {
+        try {
+            await this.#validateRoots();
+            const current = await this.#bindingFromRegistry(expected.registryPath, expected.record.pid);
+            if (current.targetId !== expected.targetId ||
+                current.record.cwd !== expected.record.cwd ||
+                current.record.messagingSocketPath !== expected.record.messagingSocketPath ||
+                current.processGeneration !== expected.processGeneration ||
+                !sameSocketGeneration(current.socketGeneration, expected.socketGeneration)) {
+                throw new Error("prepared Claude peer generation changed");
+            }
+            await this.#attestOwnedDirectory(stateRoot, true, "CLAUDE_PEER_STATE_ROOT_UNSAFE");
+            await this.#assertBindingWorkspaceDisjoint(current);
+        }
+        catch {
+            throw new BridgeError("CLAUDE_PEER_TARGET_CHANGED", "The prepared Claude peer generation changed before the write.", true);
+        }
+    }
     async discover() {
         await this.#validateRoots();
         const nextTargets = new Map();
@@ -606,7 +444,7 @@ export class ClaudePeerAdapter {
             }
             const registryPath = path.join(this.#sessionsDir, entry.name);
             try {
-                const binding = await this.#bindingFromRegistry(registryPath, pid, undefined, () => {
+                const binding = await this.#bindingFromRegistry(registryPath, pid, () => {
                     parseableRecords += 1;
                 });
                 if (collidedSessionIds.has(binding.targetId) ||
@@ -749,51 +587,6 @@ export class ClaudePeerAdapter {
             compatibility: "compatible",
         };
     }
-    async listen(options) {
-        await this.#validateRoots();
-        const generation = this.#createArtifactToken();
-        if (!PRIVATE_ARTIFACT_TOKEN_PATTERN.test(generation)) {
-            throw new BridgeError("INVALID_CODEX_PEER_GENERATION", "A native source listener requires one bounded private artifact token.");
-        }
-        if ([...this.#listeners].some((listener) => !listener.closed && listener.generation === generation)) {
-            throw new BridgeError("CODEX_PEER_GENERATION_EXISTS", "A live native Codex listener already owns this exact generation.");
-        }
-        const listener = await ClaudePeerListener.create({
-            sessionsDir: this.#sessionsDir,
-            socketDir: this.#socketDir,
-            expectedUid: this.#expectedUid,
-            limits: this.#limits,
-            createId: this.#createId,
-            connect: this.#connect,
-            deliveryNotices: this.#deliveryNotices,
-            resolveReplyAddress: async (address) => await this.#resolveReplyAddress(address),
-            resolveSessionBinding: async (sessionId) => {
-                // Native receipt handles retain only the stable Claude session UUID.
-                // Registry names, PIDs, and sockets are replaceable coordinates, so
-                // refresh discovery before every receipt or progress write.
-                const discovery = await this.discover();
-                if (discovery.truncated) {
-                    throw new BridgeError("CLAUDE_PEER_DISCOVERY_INCOMPLETE", "The Claude peer receipt target cannot be proven from an incomplete registry scan.", true);
-                }
-                const target = this.#targets.get(sessionId);
-                if (target === undefined) {
-                    throw new BridgeError("CLAUDE_PEER_TARGET_UNKNOWN", "The Claude peer receipt target is no longer discoverable.", true);
-                }
-                return target;
-            },
-            options,
-            generation,
-            registryRename: this.#registryRename,
-            ...(this.#registryOperationHook === undefined
-                ? {}
-                : { registryOperationHook: this.#registryOperationHook }),
-            runRegistryMutation: async (operation) => await this.#registryMutex.run("codex-registry", operation),
-            postBindHook: this.#postBindHook,
-            onClosed: () => this.#listeners.delete(listener),
-        });
-        this.#listeners.add(listener);
-        return listener;
-    }
     async prepareSend(targetId, content, options) {
         if (!Number.isSafeInteger(options.deadlineAt) ||
             options.deadlineAt < 0) {
@@ -827,16 +620,9 @@ export class ClaudePeerAdapter {
         if (!UUID_PATTERN.test(messageId)) {
             throw new BridgeError("INVALID_PEER_MESSAGE_ID", "The configured ID source did not produce a UUID.");
         }
-        if (options.replyListener !== undefined &&
-            !this.#listeners.has(options.replyListener)) {
-            throw new BridgeError("CLAUDE_PEER_LISTENER_FOREIGN", "The reply listener is not owned by this adapter.");
-        }
         const frame = encodeClaudePeerUserFrame({
             messageId,
             content,
-            ...(options.replyListener === undefined
-                ? {}
-                : { from: options.replyListener.address }),
             maxFrameBytes: this.#limits.maxFrameBytes,
         });
         const socketPath = target.record.messagingSocketPath;
@@ -848,37 +634,52 @@ export class ClaudePeerAdapter {
             this.#preparedSends.delete(cancel);
         };
         this.#preparedSends.add(cancel);
-        const perform = () => {
+        const perform = async (authorize) => {
             if (state !== "prepared") {
-                return Promise.reject(new BridgeError("CLAUDE_PEER_PREPARATION_CONSUMED", "The prepared Claude peer write was already performed or cancelled."));
+                throw new BridgeError("CLAUDE_PEER_PREPARATION_CONSUMED", "The prepared Claude peer write was already performed or cancelled.");
             }
             state = "performed";
             this.#preparedSends.delete(cancel);
             if (options.deadlineAt <= this.#now()) {
-                return Promise.reject(new BridgeError("CLAUDE_PEER_MESSAGE_EXPIRED", "The Claude peer message deadline elapsed before any socket write.", true));
+                throw new BridgeError("CLAUDE_PEER_MESSAGE_EXPIRED", "The Claude peer message deadline elapsed before any socket write.", true);
             }
             let writeStarted = false;
-            const write = writeSocketPayload(this.#connect, socketPath, frame, Math.max(1, Math.min(this.#limits.connectTimeoutMs, options.deadlineAt - this.#now())), () => {
+            let authorizationStarted = false;
+            await this.#revalidatePreparedBinding(target, stateRoot);
+            const write = writeSocketPayload(this.#connect, socketPath, frame, Math.max(1, Math.min(this.#limits.connectTimeoutMs, options.deadlineAt - this.#now())), async () => {
+                await this.#revalidatePreparedBinding(target, stateRoot);
+                authorizationStarted = true;
+                let authorized;
+                try {
+                    authorized = await authorize();
+                }
+                catch {
+                    throw new BridgeError("WRITE_AUTHORIZATION_UNCERTAIN", "The final write authorization outcome is uncertain; do not retry automatically.");
+                }
+                if (!authorized) {
+                    throw new BridgeError("WRITE_AUTHORIZATION_DENIED", "The final write authorization was denied before any socket write.", true);
+                }
+            }, () => {
                 if (options.deadlineAt <= this.#now()) {
                     throw new BridgeError("CLAUDE_PEER_MESSAGE_EXPIRED", "The Claude peer message deadline elapsed before any socket write.", true);
                 }
                 writeStarted = true;
             });
-            return write.then(() => ({ messageId, transportStatus: "transport_written" }), (error) => {
+            return await write.then(() => ({ messageId, transportStatus: "transport_written" }), (error) => {
                 if (error instanceof BridgeError)
                     throw error;
                 const expired = this.#now() >= options.deadlineAt;
-                throw new BridgeError(writeStarted
+                throw new BridgeError(writeStarted || authorizationStarted
                     ? "CLAUDE_PEER_WRITE_AMBIGUOUS"
                     : expired
                         ? "CLAUDE_PEER_MESSAGE_EXPIRED"
                         : error instanceof Error && error.message === "peer write timeout"
                             ? "CLAUDE_PEER_CONNECT_TIMEOUT"
-                            : "CLAUDE_PEER_WRITE_FAILED", writeStarted
-                    ? "The Claude peer write began but its outcome is ambiguous; do not retry automatically."
+                            : "CLAUDE_PEER_WRITE_FAILED", writeStarted || authorizationStarted
+                    ? "The Claude write or final authorization began but its outcome is ambiguous; do not retry automatically."
                     : expired
                         ? "The Claude peer message deadline elapsed before any socket write."
-                        : "The Claude peer message was not confirmed written.", !writeStarted);
+                        : "The Claude peer message was not confirmed written.", !writeStarted && !authorizationStarted);
             });
         };
         return Object.freeze({
@@ -892,800 +693,8 @@ export class ClaudePeerAdapter {
     async close() {
         for (const cancel of [...this.#preparedSends])
             cancel();
-        const results = await Promise.allSettled([...this.#listeners].map(async (listener) => listener.close()));
         this.#targets.clear();
         this.#selectedStateRoots.clear();
-        const failed = results.find((result) => result.status === "rejected");
-        if (failed !== undefined)
-            throw failed.reason;
-    }
-}
-export class ClaudePeerListener {
-    address;
-    generation;
-    #sessionsGeneration;
-    #socketPath;
-    #socketGeneration;
-    #server;
-    #context;
-    #connections = new Set();
-    #inboundReceipts = new Map();
-    // One bounded exception slot owns an overflow message only long enough to
-    // return its terminal capacity rejection. It never forwards content to the
-    // service, retries only proven pre-write failures, and is released after a
-    // successful, ambiguous, non-retryable, or exhausted write.
-    #capacitySettlement;
-    #queuedFrames = 0;
-    #inboundQuiesced = false;
-    #inboundQuiesceWaiters = new Set();
-    #advertisement;
-    #closing = false;
-    #closed = false;
-    #closeOperation;
-    constructor(options, server, socketPath, generation, sessionsGeneration) {
-        this.address = `uds:${socketPath}`;
-        this.generation = options.generation;
-        this.#sessionsGeneration = sessionsGeneration;
-        this.#socketPath = socketPath;
-        this.#socketGeneration = generation;
-        this.#server = server;
-        this.#context = options;
-    }
-    static async create(options) {
-        // One gateway process owns one native peer socket. It may advertise one
-        // registered Codex task through Claude's native session registry.
-        const socketPath = path.join(options.socketDir, `${process.pid}.sock`);
-        try {
-            await lstat(socketPath);
-            throw new BridgeError("CLAUDE_PEER_CALLBACK_EXISTS", "The gateway callback path already exists; it will not be unlinked.");
-        }
-        catch (error) {
-            if (error instanceof BridgeError ||
-                error.code !== "ENOENT") {
-                throw error;
-            }
-        }
-        let listener;
-        const server = net.createServer((socket) => {
-            if (listener === undefined) {
-                socket.destroy();
-                return;
-            }
-            listener.#accept(socket);
-        });
-        server.on("error", () => {
-            if (listener !== undefined)
-                void listener.#notice("CALLBACK_ERROR");
-        });
-        await new Promise((resolve, reject) => {
-            const onError = (error) => reject(error);
-            server.once("error", onError);
-            server.listen(socketPath, () => {
-                server.off("error", onError);
-                resolve();
-            });
-        });
-        let createdGeneration;
-        try {
-            const created = await lstat(socketPath);
-            if (!created.isSocket() ||
-                created.isSymbolicLink()) {
-                throw new BridgeError("CLAUDE_PEER_CALLBACK_UNSAFE", "The newly bound callback path did not satisfy its type and ownership policy.");
-            }
-            createdGeneration = { dev: created.dev, ino: created.ino };
-            if (created.uid !== options.expectedUid) {
-                throw new BridgeError("CLAUDE_PEER_CALLBACK_UNSAFE", "The newly bound callback path did not satisfy its type and ownership policy.");
-            }
-            await chmod(socketPath, 0o600);
-            const attested = await lstat(socketPath);
-            if (!attested.isSocket() ||
-                attested.isSymbolicLink() ||
-                attested.uid !== options.expectedUid ||
-                exactMode(attested.mode) !== 0o600 ||
-                !sameSocketGeneration({ dev: attested.dev, ino: attested.ino }, createdGeneration)) {
-                throw new BridgeError("CLAUDE_PEER_CALLBACK_UNSAFE", "The gateway callback socket did not satisfy its ownership policy.");
-            }
-            await options.postBindHook?.(socketPath);
-            const sessions = await lstat(options.sessionsDir);
-            if (sessions.isSymbolicLink() ||
-                !sessions.isDirectory() ||
-                sessions.uid !== options.expectedUid ||
-                exactMode(sessions.mode) !== 0o700) {
-                throw new BridgeError("UNSAFE_PEER_DIRECTORY", "The native peer registry directory failed its ownership policy.");
-            }
-            listener = new ClaudePeerListener(options, server, socketPath, createdGeneration, { dev: sessions.dev, ino: sessions.ino });
-            return listener;
-        }
-        catch (error) {
-            try {
-                if (createdGeneration === undefined ||
-                    await socketOwnership(socketPath, createdGeneration) !== "owned") {
-                    throw new Error("callback ownership changed");
-                }
-                await closeServer(server);
-                if (await socketOwnership(socketPath, createdGeneration) !== "missing") {
-                    throw new Error("callback close unconfirmed");
-                }
-            }
-            catch {
-                server.unref();
-                throw new BridgeError("CLAUDE_PEER_CALLBACK_UNSAFE", "The newly bound callback socket could not be safely closed.");
-            }
-            throw error;
-        }
-    }
-    get closed() {
-        return this.#closing || this.#closed;
-    }
-    #registryPath() {
-        return path.join(this.#context.sessionsDir, `${process.pid}.json`);
-    }
-    #registryTemporaryPath() {
-        return path.join(this.#context.sessionsDir, `.${process.pid}.${this.generation}.registry.tmp`);
-    }
-    #serializeRecord(record) {
-        return `${JSON.stringify(record)}\n`;
-    }
-    async #assertRegistryDirectory() {
-        const current = await lstat(this.#context.sessionsDir);
-        if (current.isSymbolicLink() ||
-            !current.isDirectory() ||
-            current.uid !== this.#context.expectedUid ||
-            exactMode(current.mode) !== 0o700 ||
-            !sameDirectoryGeneration({ dev: current.dev, ino: current.ino }, this.#sessionsGeneration)) {
-            throw new BridgeError("UNSAFE_PEER_DIRECTORY", "The native peer registry directory changed or failed its ownership policy.");
-        }
-    }
-    async #readRegistryExact() {
-        await this.#assertRegistryDirectory();
-        const registryPath = this.#registryPath();
-        let handle;
-        try {
-            handle = await open(registryPath, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
-        }
-        catch (error) {
-            if (error.code === "ENOENT")
-                return undefined;
-            throw error;
-        }
-        try {
-            const opened = await handle.stat();
-            const openedGeneration = generationOf(opened);
-            if (!opened.isFile() ||
-                opened.uid !== this.#context.expectedUid ||
-                exactMode(opened.mode) !== 0o600 ||
-                opened.size > this.#context.limits.maxRegistryBytes) {
-                throw new BridgeError("REGISTRY_RACED", "The native Codex registry record failed its exact ownership policy.");
-            }
-            const serialized = await handle.readFile({ encoding: "utf8" });
-            if (byteLength(serialized) > this.#context.limits.maxRegistryBytes) {
-                throw new BridgeError("REGISTRY_TOO_LARGE", "The native Codex registry record exceeded its bound.");
-            }
-            const [afterOpen, afterPath] = await Promise.all([
-                handle.stat(),
-                lstat(registryPath),
-            ]);
-            if (afterPath.isSymbolicLink() ||
-                !afterPath.isFile() ||
-                !sameFileGeneration(openedGeneration, generationOf(afterOpen)) ||
-                !sameFileGeneration(openedGeneration, generationOf(afterPath))) {
-                throw new BridgeError("REGISTRY_RACED", "The native Codex registry record changed while reading.");
-            }
-            return { serialized, generation: openedGeneration };
-        }
-        finally {
-            await handle.close();
-        }
-    }
-    async #recordMatches(record, generation) {
-        try {
-            const current = await this.#readRegistryExact();
-            if (current === undefined ||
-                current.serialized !== this.#serializeRecord(record) ||
-                (generation !== undefined &&
-                    !sameFileGeneration(current.generation, generation))) {
-                return { matches: false };
-            }
-            return { matches: true, generation: current.generation };
-        }
-        catch {
-            return { matches: false };
-        }
-    }
-    async #createRegistryTemporary(record) {
-        await this.#assertRegistryDirectory();
-        const temporaryPath = this.#registryTemporaryPath();
-        await writeFile(temporaryPath, this.#serializeRecord(record), {
-            encoding: "utf8",
-            flag: "wx",
-            mode: 0o600,
-        });
-        const created = await lstat(temporaryPath);
-        if (created.isSymbolicLink() ||
-            !created.isFile() ||
-            created.uid !== this.#context.expectedUid ||
-            exactMode(created.mode) !== 0o600) {
-            throw new BridgeError("REGISTRY_RACED", "The native Codex temporary registry record is unsafe.");
-        }
-        return { path: temporaryPath, generation: generationOf(created) };
-    }
-    async #cleanupOwnedFile(candidate, generation) {
-        try {
-            const current = await lstat(candidate);
-            if (current.isFile() &&
-                !current.isSymbolicLink() &&
-                current.uid === this.#context.expectedUid &&
-                exactMode(current.mode) === 0o600 &&
-                sameFileGeneration(generationOf(current), generation)) {
-                await unlink(candidate);
-            }
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                throw error;
-        }
-    }
-    #newAdvertisedRecord(name, cwd) {
-        if (!EMBASSY_SOURCE_NAME_PATTERN.test(name) || !ALIAS_PATTERN.test(name)) {
-            throw new BridgeError("INVALID_CODEX_PEER_NAME", "A native source peer name must use its provider prefix.");
-        }
-        if (!path.isAbsolute(cwd) || cwd.includes("\0")) {
-            throw new BridgeError("INVALID_CODEX_PEER_CWD", "A native Codex peer requires an absolute working directory.");
-        }
-        const sessionId = this.#context.createId();
-        if (!UUID_PATTERN.test(sessionId)) {
-            throw new BridgeError("INVALID_CODEX_PEER_SESSION_ID", "The configured ID source did not produce a native peer session UUID.");
-        }
-        const now = Date.now();
-        return {
-            embassyAdvertisementVersion: EMBASSY_ADVERTISEMENT_VERSION,
-            pid: process.pid,
-            sessionId,
-            cwd,
-            startedAt: now,
-            procStart: new Date(now - process.uptime() * 1_000).toString(),
-            version: "unknown",
-            peerProtocol: CLAUDE_PEER_COMPATIBILITY.peerProtocol,
-            kind: "interactive",
-            entrypoint: "cli",
-            messagingSocketPath: this.#socketPath,
-            name,
-            status: "idle",
-            updatedAt: now,
-            statusUpdatedAt: now,
-        };
-    }
-    async #mutateRegistry(operation, mutation) {
-        return await this.#context.runRegistryMutation(async () => {
-            await this.#context.registryOperationHook?.({
-                operation,
-                phase: "entered",
-                generation: this.generation,
-            });
-            try {
-                return await mutation();
-            }
-            finally {
-                await this.#context.registryOperationHook?.({
-                    operation,
-                    phase: "exited",
-                    generation: this.generation,
-                });
-            }
-        });
-    }
-    async advertise(name, cwd) {
-        await this.#mutateRegistry("advertise", async () => {
-            if (this.closed) {
-                throw new BridgeError("CLAUDE_PEER_LISTENER_CLOSED", "The Claude peer callback listener is closed.");
-            }
-            if (this.#advertisement !== undefined && this.#advertisement.record.name !== name) {
-                throw new BridgeError("CODEX_PEER_ALREADY_ADVERTISED", "This gateway process already advertises another Codex peer.");
-            }
-            if (this.#advertisement?.record.name === name)
-                return;
-            const record = this.#newAdvertisedRecord(name, cwd);
-            await this.#assertRegistryDirectory();
-            await writeFile(this.#registryPath(), this.#serializeRecord(record), {
-                encoding: "utf8",
-                flag: "wx",
-                mode: 0o600,
-            });
-            const exact = await this.#recordMatches(record);
-            if (!exact.matches) {
-                throw new BridgeError("REGISTRY_RACED", "The native Codex registry record could not be exactly confirmed.");
-            }
-            this.#advertisement = { record, generation: exact.generation };
-        });
-    }
-    async updateAdvertisedStatus(status) {
-        await this.#mutateRegistry("status", async () => {
-            const owned = this.#advertisement;
-            if (this.closed || owned === undefined || owned.record.status === status)
-                return;
-            if (!(await this.#recordMatches(owned.record, owned.generation)).matches) {
-                this.#advertisement = undefined;
-                return;
-            }
-            const now = Date.now();
-            const record = { ...owned.record, status, updatedAt: now, statusUpdatedAt: now };
-            const temporary = await this.#createRegistryTemporary(record);
-            try {
-                if (!(await this.#recordMatches(owned.record, owned.generation)).matches)
-                    return;
-                await this.#context.registryRename(temporary.path, this.#registryPath());
-                const exact = await this.#recordMatches(record, temporary.generation);
-                if (!exact.matches) {
-                    throw new BridgeError("REGISTRY_RACED", "The updated native Codex registry record could not be exactly confirmed.");
-                }
-                this.#advertisement = { record, generation: exact.generation };
-            }
-            finally {
-                await this.#cleanupOwnedFile(temporary.path, temporary.generation).catch(() => undefined);
-            }
-        });
-    }
-    async unadvertise(name) {
-        await this.#mutateRegistry("unadvertise", async () => {
-            const owned = this.#advertisement;
-            if (owned === undefined || (name !== undefined && name !== owned.record.name))
-                return;
-            this.#advertisement = undefined;
-            if (!(await this.#recordMatches(owned.record, owned.generation)).matches)
-                return;
-            await unlink(this.#registryPath()).catch((error) => {
-                if (error.code !== "ENOENT")
-                    throw error;
-            });
-        });
-    }
-    async acknowledge(receiptHandle, status, diagnostic) {
-        if (this.closed) {
-            throw new BridgeError("CLAUDE_PEER_LISTENER_CLOSED", "The Claude peer callback listener is closed.");
-        }
-        const receipt = this.#inboundReceipts.get(receiptHandle);
-        if (receipt === undefined) {
-            throw new BridgeError("CLAUDE_PEER_RECEIPT_UNKNOWN", "The native Claude peer receipt is unknown or already settled.");
-        }
-        if (diagnostic !== undefined &&
-            (status !== "expired" ||
-                !/^[A-Z][A-Z0-9_]{0,63}$/.test(diagnostic.code))) {
-            throw new BridgeError("INVALID_PEER_DELIVERY_DIAGNOSTIC", "A peer delivery diagnostic requires an expired receipt and a safe code.");
-        }
-        try {
-            const result = await this.#writeInboundStatus(receipt, status, diagnostic);
-            if (status !== "held")
-                this.#inboundReceipts.delete(receiptHandle);
-            return result;
-        }
-        catch (error) {
-            // A terminal write that may have started must never be replayed. A
-            // proven pre-write failure retains the handle for a bounded caller retry.
-            if (status !== "held" &&
-                error instanceof BridgeError &&
-                !error.recoverable) {
-                this.#inboundReceipts.delete(receiptHandle);
-            }
-            throw error;
-        }
-    }
-    /**
-     * Writes one nonterminal gateway progress frame without synthesizing a
-     * native peer_message_status transition. The receipt remains available for
-     * its later exact terminal acknowledgement or explicit release.
-     */
-    async notifyInboundProgress(receiptHandle, progress) {
-        if (this.closed) {
-            throw new BridgeError("CLAUDE_PEER_LISTENER_CLOSED", "The Claude peer callback listener is closed.");
-        }
-        const receipt = this.#inboundReceipts.get(receiptHandle);
-        if (receipt === undefined) {
-            throw new BridgeError("CLAUDE_PEER_RECEIPT_UNKNOWN", "The native Claude peer receipt is unknown or already settled.");
-        }
-        if (!isObject(progress) ||
-            !hasExactKeys(progress, ["kind", "reason", "queuedForMs"]) ||
-            progress.kind !== "stall" ||
-            !claudePeerInboundStallReasons.includes(progress.reason) ||
-            typeof progress.queuedForMs !== "number") {
-            throw new BridgeError("INVALID_PEER_PROGRESS", "Claude peer progress must be one bounded gateway stall notice.");
-        }
-        if (receipt.stallNotification !== "available") {
-            throw new BridgeError("CLAUDE_PEER_PROGRESS_ALREADY_NOTIFIED", "The native Claude peer receipt already has a stall notification.");
-        }
-        if (this.#context.deliveryNotices === "quiet") {
-            receipt.stallNotification = "settled";
-            return { transportStatus: "suppressed" };
-        }
-        const queuedForMs = boundedStallQueuedForMs(progress.queuedForMs);
-        const openingTag = `<gateway-delivery-stall terminal="false" reason="${progress.reason}" ` +
-            `queued-for-ms="${queuedForMs}">`;
-        const detailedContent = [
-            openingTag,
-            CLAUDE_PEER_NOTICE_COPY.stall,
-            "</gateway-delivery-stall>",
-        ].join("\n");
-        const messageId = this.#context.createId();
-        let progressFrame;
-        try {
-            progressFrame = encodeClaudePeerUserFrame({
-                messageId,
-                content: detailedContent,
-                maxFrameBytes: this.#context.limits.maxFrameBytes,
-            });
-        }
-        catch (error) {
-            if (!(error instanceof BridgeError) || error.code !== "PEER_FRAME_TOO_LARGE") {
-                throw error;
-            }
-            progressFrame = encodeClaudePeerUserFrame({
-                messageId,
-                content: `${openingTag.slice(0, -1)}/>`,
-                maxFrameBytes: this.#context.limits.maxFrameBytes,
-            });
-        }
-        receipt.stallNotification = "writing";
-        try {
-            const result = await this.#writeInboundPayload(receipt, progressFrame);
-            receipt.stallNotification = "settled";
-            return result;
-        }
-        catch (error) {
-            // A proven pre-write failure can be retried; an ambiguous write counts
-            // as the one allowed notice so the peer is never spammed by a replay.
-            receipt.stallNotification =
-                error instanceof BridgeError && error.recoverable
-                    ? "available"
-                    : "settled";
-            throw error;
-        }
-    }
-    /**
-     * Releases a listener-owned native receipt capability without writing to the
-     * peer. The service uses this after a terminal notification becomes
-     * definitively undeliverable so bounded receipt capacity cannot leak.
-     */
-    releaseInboundReceipt(receiptHandle) {
-        return this.#inboundReceipts.delete(receiptHandle);
-    }
-    /**
-     * Stop admitting new user-message frames while keeping the listener alive
-     * for terminal receipt writes. The promise joins every frame already
-     * admitted, so controller shutdown can drain service receipt work before
-     * closing the provider socket.
-     */
-    async quiesceInbound() {
-        this.#inboundQuiesced = true;
-        if (this.#queuedFrames === 0)
-            return;
-        await new Promise((resolve) => {
-            this.#inboundQuiesceWaiters.add(resolve);
-            if (this.#queuedFrames === 0) {
-                this.#inboundQuiesceWaiters.delete(resolve);
-                resolve();
-            }
-        });
-    }
-    async #writeInboundStatus(receipt, status, diagnostic) {
-        const statusFrame = Buffer.from(`${JSON.stringify({
-            type: "control",
-            action: "peer_message_status",
-            status,
-            reason: diagnostic?.code ?? status,
-            from: this.address,
-            orig_msg_id: receipt.originalMessageId,
-            msgV: 1,
-            msg_id: this.#context.createId(),
-        })}\n`, "utf8");
-        const diagnosticFrame = diagnostic === undefined || this.#context.deliveryNotices !== "verbose"
-            ? undefined
-            : encodeClaudePeerUserFrame({
-                messageId: this.#context.createId(),
-                content: [
-                    `<gateway-delivery-diagnostic status="expired" code="${diagnostic.code}">`,
-                    CLAUDE_PEER_NOTICE_COPY.diagnostic,
-                    "</gateway-delivery-diagnostic>",
-                ].join("\n"),
-                maxFrameBytes: this.#context.limits.maxFrameBytes,
-            });
-        const payload = diagnosticFrame === undefined
-            ? statusFrame
-            : Buffer.concat([statusFrame, diagnosticFrame]);
-        return await this.#writeInboundPayload(receipt, payload);
-    }
-    async #writeInboundPayload(receipt, payload) {
-        let writeStarted = false;
-        try {
-            const binding = await this.#context.resolveSessionBinding(receipt.sourceSessionId);
-            await writeSocketPayload(this.#context.connect, binding.record.messagingSocketPath, payload, this.#context.limits.connectTimeoutMs, () => {
-                writeStarted = true;
-            });
-        }
-        catch (error) {
-            if (writeStarted) {
-                throw new BridgeError("CLAUDE_PEER_RECEIPT_WRITE_AMBIGUOUS", "The Claude peer receipt write began but its outcome is ambiguous; do not retry automatically.");
-            }
-            if (error instanceof BridgeError && !error.recoverable)
-                throw error;
-            throw new BridgeError("CLAUDE_PEER_RECEIPT_NOT_WRITTEN", "The Claude peer receipt was not confirmed written.", true);
-        }
-        return { transportStatus: "transport_written" };
-    }
-    #accept(socket) {
-        if (this.closed ||
-            this.#connections.size >= this.#context.limits.maxConnections) {
-            socket.destroy();
-            void this.#notice("CONNECTION_LIMIT");
-            return;
-        }
-        this.#connections.add(socket);
-        socket.setTimeout(this.#context.limits.connectionIdleMs);
-        let buffered = Buffer.alloc(0);
-        let frames = 0;
-        let chain = Promise.resolve();
-        let rejected = false;
-        const reject = (code) => {
-            if (rejected)
-                return;
-            rejected = true;
-            socket.destroy();
-            void this.#notice(code);
-        };
-        socket.on("timeout", () => reject("CONNECTION_TIMEOUT"));
-        socket.on("error", () => undefined);
-        socket.on("close", () => this.#connections.delete(socket));
-        socket.on("data", (chunk) => {
-            if (rejected)
-                return;
-            buffered = Buffer.concat([buffered, chunk]);
-            if (buffered.length > this.#context.limits.maxFrameBytes + 1) {
-                const newline = buffered.indexOf(0x0a);
-                if (newline < 0 || newline > this.#context.limits.maxFrameBytes) {
-                    reject("FRAME_TOO_LARGE");
-                    return;
-                }
-            }
-            while (!rejected) {
-                const newline = buffered.indexOf(0x0a);
-                if (newline < 0)
-                    break;
-                if (newline > this.#context.limits.maxFrameBytes) {
-                    reject("FRAME_TOO_LARGE");
-                    break;
-                }
-                const line = buffered.subarray(0, newline);
-                buffered = buffered.subarray(newline + 1);
-                frames += 1;
-                if (frames > this.#context.limits.maxFramesPerConnection) {
-                    reject("INVALID_FRAME");
-                    break;
-                }
-                let frame;
-                try {
-                    frame = parseFrame(line, this.#context.limits.maxFrameBytes);
-                }
-                catch (error) {
-                    if (error instanceof BridgeError &&
-                        error.code === "INVALID_PEER_UTF8") {
-                        reject("INVALID_UTF8");
-                    }
-                    else if (error instanceof BridgeError &&
-                        error.code === "UNSUPPORTED_PEER_FRAME") {
-                        reject("UNSUPPORTED_FRAME");
-                    }
-                    else {
-                        reject("INVALID_FRAME");
-                    }
-                    break;
-                }
-                if (this.#queuedFrames >=
-                    this.#context.limits.maxConnections * this.#context.limits.maxFramesPerConnection) {
-                    reject("CONNECTION_LIMIT");
-                    break;
-                }
-                this.#queuedFrames += 1;
-                chain = chain
-                    .then(async () => {
-                    if (rejected)
-                        return;
-                    await this.#handleFrame(frame, () => {
-                        if (rejected)
-                            return;
-                        rejected = true;
-                        socket.destroy();
-                    });
-                })
-                    .catch(async () => this.#notice("CALLBACK_ERROR"))
-                    .finally(() => {
-                    this.#queuedFrames -= 1;
-                    if (this.#queuedFrames === 0) {
-                        for (const resolve of this.#inboundQuiesceWaiters)
-                            resolve();
-                        this.#inboundQuiesceWaiters.clear();
-                    }
-                });
-            }
-            if (!rejected && buffered.length > this.#context.limits.maxFrameBytes) {
-                reject("FRAME_TOO_LARGE");
-            }
-        });
-        socket.on("end", () => {
-            if (!rejected && buffered.length !== 0)
-                reject("INVALID_FRAME");
-        });
-    }
-    async #handleFrame(frame, rejectTransport) {
-        if (this.closed)
-            return;
-        if (frame.type === "control") {
-            // Native outbound status is accepted for wire compatibility but is not
-            // settlement authority. A confirmed mailbox write is terminal.
-            return;
-        }
-        if (this.#inboundQuiesced) {
-            rejectTransport();
-            return;
-        }
-        let binding;
-        if (frame.from !== undefined) {
-            try {
-                binding = await this.#context.resolveReplyAddress(frame.from);
-            }
-            catch {
-                await this.#notice("UNREGISTERED_REPLY_ADDRESS");
-                return;
-            }
-        }
-        const inboundId = this.#context.createId();
-        if (binding !== undefined && frame.messageId !== undefined) {
-            if (this.#inboundReceipts.size >= this.#context.limits.maxPendingReceipts) {
-                await this.#notice("RECEIPT_LIMIT");
-                if (this.#capacitySettlement !== undefined) {
-                    // Both the configured receipt table and its single terminal-only
-                    // overflow slot are occupied. Close this transport rather than
-                    // making another native send appear accepted without settlement.
-                    rejectTransport();
-                    return;
-                }
-                const settlement = {
-                    receipt: {
-                        sourceSessionId: binding.targetId,
-                        originalMessageId: frame.messageId,
-                        stallNotification: "settled",
-                    },
-                    attempts: 0,
-                };
-                this.#capacitySettlement = settlement;
-                await this.#attemptCapacitySettlement(settlement);
-                return;
-            }
-            this.#inboundReceipts.set(inboundId, {
-                sourceSessionId: binding.targetId,
-                originalMessageId: frame.messageId,
-                stallNotification: "available",
-            });
-        }
-        await invokeHook(this.#context.options.onMessage, {
-            inboundId,
-            content: frame.content,
-            ...(binding === undefined
-                ? {}
-                : {
-                    sourceTargetId: binding.targetId,
-                    sourceAlias: binding.alias,
-                    ...(frame.messageId === undefined
-                        ? {}
-                        : { receiptHandle: inboundId }),
-                }),
-            replySupported: binding !== undefined,
-            trust: binding === undefined
-                ? "untrusted_anonymous_local_peer"
-                : "untrusted_same_uid_peer",
-        });
-    }
-    async #attemptCapacitySettlement(settlement) {
-        if (this.closed || this.#capacitySettlement !== settlement) {
-            return;
-        }
-        settlement.attempts += 1;
-        try {
-            await this.#writeInboundStatus(settlement.receipt, "expired", { code: "GATEWAY_RECEIPT_CAPACITY" });
-            if (this.#capacitySettlement === settlement) {
-                this.#capacitySettlement = undefined;
-            }
-        }
-        catch (error) {
-            if (this.#capacitySettlement !== settlement)
-                return;
-            const retryable = error instanceof BridgeError &&
-                error.recoverable &&
-                !this.closed;
-            if (!retryable ||
-                settlement.attempts >= CAPACITY_SETTLEMENT_MAX_ATTEMPTS) {
-                // An ambiguous write must never be replayed. Exhausted clean
-                // pre-write failures are released with a local protocol notice rather
-                // than leaking the bounded overflow slot or an unhandled rejection.
-                this.#capacitySettlement = undefined;
-                await this.#notice("CALLBACK_ERROR");
-                return;
-            }
-            settlement.retryTimer = setTimeout(() => {
-                delete settlement.retryTimer;
-                void this.#attemptCapacitySettlement(settlement);
-            }, CAPACITY_SETTLEMENT_RETRY_MS);
-            settlement.retryTimer.unref();
-        }
-    }
-    async #notice(code) {
-        try {
-            await invokeHook(this.#context.options.onProtocolNotice, { code });
-        }
-        catch {
-            // Protocol callbacks are observational. Never feed callback failures
-            // back into the socket or expose raw frame data.
-        }
-    }
-    close() {
-        if (this.#closeOperation !== undefined)
-            return this.#closeOperation;
-        if (this.#closed)
-            return Promise.resolve();
-        this.#closing = true;
-        this.#inboundQuiesced = true;
-        const operation = this.#performClose();
-        this.#closeOperation = operation;
-        return operation;
-    }
-    async #performClose() {
-        const errors = [];
-        try {
-            await this.unadvertise();
-        }
-        catch (error) {
-            errors.push(error);
-        }
-        this.#inboundReceipts.clear();
-        if (this.#capacitySettlement?.retryTimer !== undefined) {
-            clearTimeout(this.#capacitySettlement.retryTimer);
-        }
-        this.#capacitySettlement = undefined;
-        for (const socket of this.#connections)
-            socket.destroy();
-        this.#connections.clear();
-        try {
-            if (await socketOwnership(this.#socketPath, this.#socketGeneration) !==
-                "owned") {
-                // Node's net.Server.close() unlinks its original pathname even when
-                // another same-user object replaced it. Do not call it after an
-                // observed generation change. The now-unreachable descriptor is
-                // unref'd and left for process exit rather than deleting foreign data.
-                this.#server.unref();
-                errors.push(new BridgeError("CLAUDE_PEER_CALLBACK_CHANGED", "The callback path changed; foreign replacement was preserved."));
-            }
-            else {
-                await closeServer(this.#server);
-                if (await socketOwnership(this.#socketPath, this.#socketGeneration) ===
-                    "owned") {
-                    await unlink(this.#socketPath);
-                }
-            }
-        }
-        catch (error) {
-            this.#server.unref();
-            errors.push(error);
-        }
-        this.#closing = false;
-        this.#closed = true;
-        try {
-            this.#context.onClosed();
-        }
-        catch (error) {
-            errors.push(error);
-        }
-        if (errors.length === 1)
-            throw errors[0];
-        if (errors.length > 1) {
-            throw new AggregateError(errors, "The Claude peer listener closed with multiple cleanup failures.");
-        }
     }
 }
 //# sourceMappingURL=claude-peer.js.map