agent-embassy 1.7.0 → 1.8.0

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

@@ -1,5 +1,5 @@
 import { execFile } from "node:child_process";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { chmod, constants as fsConstants, lstat, open, opendir, realpath, rename, unlink, writeFile, } from "node:fs/promises";
 import net from "node:net";
 import os from "node:os";
@@ -7,23 +7,13 @@ import path from "node:path";
 import { TextDecoder } from "node:util";
 import { BridgeError } from "../errors.js";
 import { KeyedMutex } from "../mutex.js";
-import { createCodexRegistrationGeneration, isCodexRegistrationGeneration, } from "./codex-registration-generation.js";
 import { isDashboardLocale } from "./locale.js";
-import { isCompatibilityVersionEvidence } from "./compatibility.js";
-/**
- * This adapter intentionally pins the inspected, implementation-specific
- * local peer boundary. The feature is documented in Claude Code, but its
- * registry and NDJSON formats are not a stable public integration contract.
- */
-export const CLAUDE_PEER_COMPATIBILITY = Object.freeze({
-    claudeCodeVersion: "2.1.227",
-    peerProtocol: 1,
-    messageVersion: 1,
-});
+export const CLAUDE_PEER_COMPATIBILITY = Object.freeze({ peerProtocol: 1 });
 const EMBASSY_ADVERTISEMENT_VERSION = 1;
 const EMBASSY_SOURCE_NAME_PATTERN = /^(?:codex-|dsh-|grok-)/;
 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}$/;
 const CLAUDE_PEER_NOTICE_COPY = {
     en: {
         stall: "The local gateway is still waiting to deliver the preceding message. Run `embassy status` or inspect the dashboard for details. Queued mail reaches a busy recipient when its turn ends.",
@@ -37,24 +27,12 @@ const CLAUDE_PEER_NOTICE_COPY = {
 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;
-export const claudePeerStatuses = [
-    "busy",
-    "shell",
-    "idle",
-    "waiting",
-];
-export const claudePeerKinds = [
-    "interactive",
-    "bg",
-    "daemon",
-    "daemon-worker",
-];
+export const claudePeerStatuses = ["busy", "shell", "idle", "waiting"];
+export const claudePeerKinds = ["interactive", "bg", "daemon", "daemon-worker"];
 export const claudePeerRejectionCodes = [
     "ENTRY_LIMIT_EXCEEDED",
     "INVALID_FILE_NAME",
     "REGISTRY_NOT_REGULAR",
-    "REGISTRY_OWNER_MISMATCH",
-    "REGISTRY_MODE_UNSAFE",
     "REGISTRY_TOO_LARGE",
     "REGISTRY_RACED",
     "REGISTRY_INVALID_JSON",
@@ -64,26 +42,14 @@ export const claudePeerRejectionCodes = [
     "PID_OWNER_MISMATCH",
     "SOCKET_OUTSIDE_ROOT",
     "SOCKET_NOT_SOCKET",
-    "SOCKET_OWNER_MISMATCH",
-    "SOCKET_MODE_UNSAFE",
     "SELF_TARGET",
     "SESSION_ID_COLLISION",
 ];
 export const claudePeerInboundStallReasons = [
     "ROUTE_BUSY",
     "ROUTE_UNAVAILABLE",
-    "CODEX_ROUTE_STALE",
     "AWAITING_EXTERNAL_APPROVAL",
 ];
-function pendingReceiptDeadlineStatus(pending) {
-    if (pending.writeEvidence === "transport_written" ||
-        pending.state === "held") {
-        return "unconfirmed";
-    }
-    return pending.writeEvidence === "transport_uncertain"
-        ? "ambiguous"
-        : "expired";
-}
 const MAX_CLAUDE_STALL_QUEUED_MS = 3_600_000;
 const CAPACITY_SETTLEMENT_MAX_ATTEMPTS = 3;
 const CAPACITY_SETTLEMENT_RETRY_MS = 25;
@@ -101,6 +67,9 @@ function byteLength(value) {
 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 ||
@@ -110,16 +79,9 @@ function validateContent(content, maxBytes) {
     }
     return content;
 }
-function exactMode(mode) {
-    return mode & 0o777;
-}
+function exactMode(mode) { return mode & 0o777; }
 function generationOf(stat) {
-    return {
-        dev: stat.dev,
-        ino: stat.ino,
-        size: stat.size,
-        mtimeMs: stat.mtimeMs,
-    };
+    return { dev: stat.dev, ino: stat.ino, size: stat.size, mtimeMs: stat.mtimeMs };
 }
 function sameFileGeneration(left, right) {
     return (left.dev === right.dev &&
@@ -133,17 +95,6 @@ function sameSocketGeneration(left, right) {
 function sameDirectoryGeneration(left, right) {
     return left.dev === right.dev && left.ino === right.ino;
 }
-function sameTargetGeneration(left, right) {
-    return (left.registryPath === right.registryPath &&
-        left.record.pid === right.record.pid &&
-        left.record.sessionId === right.record.sessionId &&
-        left.record.name === right.record.name &&
-        left.record.cwd === right.record.cwd &&
-        left.record.kind === right.record.kind &&
-        left.record.messagingSocketPath === right.record.messagingSocketPath &&
-        left.processGeneration === right.processGeneration &&
-        sameSocketGeneration(left.socketGeneration, right.socketGeneration));
-}
 function pathContains(parent, child) {
     const relative = path.relative(parent, child);
     return (relative === "" ||
@@ -179,31 +130,20 @@ function configuredLimit(value, fallback, minimum, maximum, label) {
 function boundedStallQueuedForMs(value) {
     if (Number.isNaN(value) || value === Number.NEGATIVE_INFINITY)
         return 0;
-    if (value === Number.POSITIVE_INFINITY) {
+    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;
-    const required = [
-        "pid",
-        "sessionId",
-        "cwd",
-        "startedAt",
-        "procStart",
-        "peerProtocol",
-        "kind",
-        "entrypoint",
-        "messagingSocketPath",
-        "name",
-        "updatedAt",
-    ];
+    const required = ["pid", "sessionId", "cwd", "startedAt", "procStart",
+        "peerProtocol", "kind", "entrypoint", "messagingSocketPath", "name",
+        "updatedAt"];
     if (!required.every((key) => Object.hasOwn(value, key)))
         return undefined;
     const embassyAdvertisement = value.embassyAdvertisementVersion === EMBASSY_ADVERTISEMENT_VERSION &&
-        isCompatibilityVersionEvidence(value.version) &&
+        isDiagnosticVersion(value.version) &&
         typeof value.name === "string" &&
         EMBASSY_SOURCE_NAME_PATTERN.test(value.name) &&
         ALIAS_PATTERN.test(value.name) &&
@@ -212,18 +152,13 @@ function parseRegistryRecord(value, expectedPid) {
         value.peerProtocol === CLAUDE_PEER_COMPATIBILITY.peerProtocol &&
         value.status !== undefined &&
         value.statusUpdatedAt !== undefined;
-    if (value.embassyAdvertisementVersion !== undefined &&
-        !embassyAdvertisement) {
+    if (value.embassyAdvertisementVersion !== undefined && !embassyAdvertisement)
         return undefined;
-    }
-    const versionObserved = value.version === undefined ||
-        isCompatibilityVersionEvidence(value.version);
+    const versionObserved = value.version === undefined || isDiagnosticVersion(value.version);
     if (value.pid !== expectedPid)
         return undefined;
-    if (typeof value.sessionId !== "string" ||
-        !UUID_PATTERN.test(value.sessionId)) {
+    if (typeof value.sessionId !== "string" || !UUID_PATTERN.test(value.sessionId))
         return undefined;
-    }
     if (!isBoundedString(value.cwd, 4096) ||
         !path.isAbsolute(value.cwd) ||
         value.cwd.includes("\0")) {
@@ -273,13 +208,9 @@ function parseRegistryRecord(value, expectedPid) {
         pid: expectedPid,
         sessionId: value.sessionId.toLowerCase(),
         cwd: value.cwd,
-        peerProtocol: 1,
         kind: value.kind,
         messagingSocketPath: value.messagingSocketPath,
         name: value.name,
-        // Some reviewed Claude Code print/SDK session records omit status fields
-        // while the model turn is active. Treat that live process conservatively
-        // as busy.
         status: (value.status ?? "busy"),
         embassyAdvertisement,
     };
@@ -431,15 +362,49 @@ async function invokeHook(hook, value) {
         return;
     await hook(value);
 }
-async function invokeObservationalHook(hook, value) {
+function writeSocketPayload(connect, socketPath, payload, timeoutMs, onWriteStart) {
+    return new Promise((resolve, reject) => {
+        const socket = connect(socketPath);
+        let settled = false;
+        const timer = setTimeout(() => finish(new Error("peer write timeout")), timeoutMs);
+        timer.unref();
+        const finish = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            error === undefined ? resolve() : reject(error);
+        };
+        socket.once("error", finish);
+        socket.once("connect", () => {
+            try {
+                onWriteStart();
+                socket.end(payload, () => finish());
+            }
+            catch (error) {
+                finish(error);
+            }
+        });
+    });
+}
+async function socketOwnership(socketPath, generation) {
     try {
-        await invokeHook(hook, value);
+        const stat = await lstat(socketPath);
+        return stat.isSocket() &&
+            sameSocketGeneration({ dev: stat.dev, ino: stat.ino }, generation)
+            ? "owned"
+            : "changed";
     }
-    catch {
-        // Status observation must never change a possibly-written transport
-        // outcome or invite an unsafe caller retry.
+    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;
@@ -449,33 +414,27 @@ export class ClaudePeerAdapter {
     #connect;
     #now;
     #createId;
-    #createGeneration;
+    #createArtifactToken;
     #locale;
-    #attestedClaudeCodeVersion;
     #deliveryNotices;
     #registryRename;
     #registryOperationHook;
     #userHome;
     #tempRoots;
-    #listenerOwner = Object.freeze({});
     #registryMutex = new KeyedMutex();
-    #registryPublicationHook;
     #postBindHook;
     #targets = new Map();
-    #workspacePolicies = 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 (!isCompatibilityVersionEvidence(options.attestedClaudeCodeVersion)) {
-            throw new BridgeError("INVALID_GATEWAY_CONFIGURATION", "The Claude version metadata is malformed.");
-        }
         if (options.locale !== undefined && !isDashboardLocale(options.locale)) {
             throw new BridgeError("DASHBOARD_LOCALE_UNSUPPORTED", "The Claude peer notice locale is unsupported.");
         }
         this.#locale = options.locale ?? "en";
-        this.#attestedClaudeCodeVersion = options.attestedClaudeCodeVersion;
         if (options.deliveryNotices !== undefined &&
             !["merged", "verbose", "quiet"].includes(options.deliveryNotices)) {
             throw new BridgeError("INVALID_GATEWAY_CONFIGURATION", "The Claude peer delivery notice mode is unsupported.");
@@ -487,17 +446,16 @@ export class ClaudePeerAdapter {
         if (!Number.isSafeInteger(this.#expectedUid) || this.#expectedUid < 0) {
             throw new BridgeError("INVALID_PEER_UID", "expectedUid must be a non-negative integer.");
         }
+        const limit = (name, fallback, minimum, maximum) => configuredLimit(options[name], fallback, minimum, maximum, name);
         this.#limits = {
-            maxRegistryEntries: configuredLimit(options.maxRegistryEntries, 256, 1, 4_096, "maxRegistryEntries"),
-            maxRegistryBytes: configuredLimit(options.maxRegistryBytes, 16 * 1024, 512, 1024 * 1024, "maxRegistryBytes"),
-            maxFrameBytes: configuredLimit(options.maxFrameBytes, 64 * 1024, 256, 1024 * 1024, "maxFrameBytes"),
-            targetLeaseMs: configuredLimit(options.targetLeaseMs, 30_000, 100, 5 * 60_000, "targetLeaseMs"),
-            connectTimeoutMs: configuredLimit(options.connectTimeoutMs, 2_000, 10, 30_000, "connectTimeoutMs"),
-            receiptDeadlineMs: configuredLimit(options.receiptDeadlineMs, 5 * 60_000, 10, 10 * 60_000, "receiptDeadlineMs"),
-            maxPendingReceipts: configuredLimit(options.maxPendingReceipts, 256, 1, 4_096, "maxPendingReceipts"),
-            maxConnections: configuredLimit(options.maxConnections, 32, 1, 1_024, "maxConnections"),
-            connectionIdleMs: configuredLimit(options.connectionIdleMs, 5_000, 10, 60_000, "connectionIdleMs"),
-            maxFramesPerConnection: configuredLimit(options.maxFramesPerConnection, 8, 1, 128, "maxFramesPerConnection"),
+            maxRegistryEntries: limit("maxRegistryEntries", 256, 1, 4_096),
+            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 =
@@ -505,31 +463,29 @@ export class ClaudePeerAdapter {
                 ((socketPath) => net.createConnection({ path: socketPath }));
         this.#now = testing.now ?? Date.now;
         this.#createId = testing.createId ?? randomUUID;
-        this.#createGeneration =
-            testing.createGeneration ?? createCodexRegistrationGeneration;
+        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.#registryPublicationHook = testing.registryPublicationHook;
         this.#postBindHook = testing.postBindHook;
     }
-    async #validateRealDirectory(directory) {
-        const stat = await lstat(directory);
-        if (stat.isSymbolicLink() || !stat.isDirectory()) {
-            throw new BridgeError("UNSAFE_PEER_DIRECTORY", "The Claude peer directory is not an accessible real directory.");
-        }
-    }
-    async #validateSessionsDirectory() {
-        const stat = await lstat(this.#sessionsDir);
+    async #validateRoots() {
+        const [stat, sockets] = await Promise.all([
+            lstat(this.#sessionsDir),
+            lstat(this.#socketDir),
+        ]);
         if (stat.isSymbolicLink() ||
             !stat.isDirectory() ||
             stat.uid !== this.#expectedUid ||
             exactMode(stat.mode) !== 0o700) {
             throw new BridgeError("UNSAFE_PEER_DIRECTORY", "The Claude sessions directory failed its exact owner and mode policy.");
         }
+        if (sockets.isSymbolicLink() || !sockets.isDirectory()) {
+            throw new BridgeError("UNSAFE_PEER_DIRECTORY", "The Claude peer socket directory is not an accessible real directory.");
+        }
     }
     async #readRegistryFile(registryPath) {
         const before = await lstat(registryPath);
@@ -592,7 +548,7 @@ export class ClaudePeerAdapter {
         return { dev: stat.dev, ino: stat.ino };
     }
     async #bindingFromRegistry(registryPath, expectedPid, _existingTargetId, onParsed) {
-        const { value, generation: registryGeneration } = await this.#readRegistryFile(registryPath);
+        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.");
         }
@@ -613,27 +569,18 @@ export class ClaudePeerAdapter {
         if (processIdentity.uid !== this.#expectedUid) {
             throw new BridgeError("PID_OWNER_MISMATCH", "Registry process owner is unsafe.");
         }
-        const socketGeneration = await this.#validateSocket(record.messagingSocketPath, expectedPid);
+        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
             // coordinates for that session and are revalidated before every write.
             targetId: record.sessionId,
             alias: record.name,
-            registryPath,
-            registryGeneration,
-            socketGeneration,
             record,
-            processGeneration: processIdentity.generation,
-            expiresAt: this.#now() + this.#limits.targetLeaseMs,
         };
     }
     async discover() {
-        await Promise.all([
-            this.#validateSessionsDirectory(),
-            this.#validateRealDirectory(this.#socketDir),
-        ]);
-        const previousTargets = [...this.#targets.values()];
+        await this.#validateRoots();
         const nextTargets = new Map();
         const collidedSessionIds = new Set();
         const rejected = {};
@@ -670,17 +617,9 @@ export class ClaudePeerAdapter {
             }
             const registryPath = path.join(this.#sessionsDir, entry.name);
             try {
-                let binding = await this.#bindingFromRegistry(registryPath, pid, undefined, () => {
+                const binding = await this.#bindingFromRegistry(registryPath, pid, undefined, () => {
                     parseableRecords += 1;
                 });
-                const previous = previousTargets.find((candidate) => sameTargetGeneration(candidate, binding));
-                if (previous !== undefined) {
-                    binding = {
-                        ...binding,
-                        targetId: previous.targetId,
-                        expiresAt: this.#now() + this.#limits.targetLeaseMs,
-                    };
-                }
                 if (collidedSessionIds.has(binding.targetId) ||
                     nextTargets.has(binding.targetId)) {
                     nextTargets.delete(binding.targetId);
@@ -718,10 +657,6 @@ export class ClaudePeerAdapter {
         for (const [targetId, binding] of nextTargets) {
             this.#targets.set(targetId, binding);
         }
-        for (const targetId of this.#workspacePolicies.keys()) {
-            if (!nextTargets.has(targetId))
-                this.#workspacePolicies.delete(targetId);
-        }
         return {
             peers,
             rejected,
@@ -730,111 +665,47 @@ export class ClaudePeerAdapter {
             parseableRecords,
         };
     }
-    async #revalidateBinding(binding) {
-        await Promise.all([
-            this.#validateSessionsDirectory(),
-            this.#validateRealDirectory(this.#socketDir),
-        ]);
-        if (binding.expiresAt < this.#now()) {
-            this.#targets.delete(binding.targetId);
-            this.#workspacePolicies.delete(binding.targetId);
-            throw new BridgeError("CLAUDE_PEER_TARGET_STALE", "The Claude peer discovery lease expired; discover again.", true);
-        }
-        const current = await this.#bindingFromRegistry(binding.registryPath, binding.record.pid, binding.targetId);
-        if (!sameTargetGeneration(binding, current)) {
-            this.#targets.delete(binding.targetId);
-            this.#workspacePolicies.delete(binding.targetId);
-            throw new BridgeError("CLAUDE_PEER_TARGET_CHANGED", "The Claude peer generation changed; discover again.", true);
-        }
-        current.expiresAt = binding.expiresAt;
-        this.#targets.set(current.targetId, current);
-        return current;
-    }
-    async #canonicalStateRoot(stateRoot) {
+    async #attestOwnedDirectory(candidate, exactPrivate, code) {
         try {
-            const configured = assertAbsoluteConfiguredPath(stateRoot, "controllerStateRoot");
+            const configured = assertAbsoluteConfiguredPath(candidate, "peerDirectory");
             const before = await lstat(configured);
+            const canonical = await realpath(configured);
+            const after = await lstat(configured);
+            const safeMode = (mode) => exactPrivate ? exactMode(mode) === 0o700 : (exactMode(mode) & 0o022) === 0;
             if (before.isSymbolicLink() ||
                 !before.isDirectory() ||
                 before.uid !== this.#expectedUid ||
-                exactMode(before.mode) !== 0o700) {
-                throw new BridgeError("CLAUDE_PEER_STATE_ROOT_UNSAFE", "The controller state root failed its canonical ownership policy.");
-            }
-            const canonical = await realpath(configured);
-            const after = await lstat(configured);
-            if (canonical !== configured ||
+                !safeMode(before.mode) ||
+                canonical !== configured ||
                 after.isSymbolicLink() ||
                 !after.isDirectory() ||
                 after.uid !== this.#expectedUid ||
-                exactMode(after.mode) !== 0o700 ||
+                !safeMode(after.mode) ||
                 before.dev !== after.dev ||
                 before.ino !== after.ino) {
-                throw new BridgeError("CLAUDE_PEER_STATE_ROOT_UNSAFE", "The controller state root changed or is not canonical.");
+                throw new BridgeError(code, "The peer directory failed its exact ownership policy.");
             }
-            return {
-                path: canonical,
-                generation: { dev: after.dev, ino: after.ino },
-            };
+            return canonical;
         }
         catch (error) {
             if (error instanceof BridgeError)
                 throw error;
-            throw new BridgeError("CLAUDE_PEER_STATE_ROOT_UNSAFE", "The controller state root could not be safely attested.");
+            throw new BridgeError(code, "The peer directory could not be safely attested.");
         }
     }
-    async #assertBindingWorkspaceDisjoint(binding, _canonicalStateRoot) {
-        try {
-            const cwd = binding.record.cwd;
-            const before = await lstat(cwd);
-            if (before.isSymbolicLink() || !before.isDirectory()) {
-                throw new BridgeError("CLAUDE_PEER_WORKSPACE_UNSAFE", "The selected Claude workspace failed its directory policy.");
-            }
-            const canonicalWorkspace = await realpath(cwd);
-            const homeBefore = await lstat(this.#userHome);
-            const canonicalHome = await realpath(this.#userHome);
-            const homeAfter = await lstat(this.#userHome);
-            if (canonicalWorkspace !== cwd ||
-                homeBefore.isSymbolicLink() ||
-                !homeBefore.isDirectory() ||
-                canonicalHome !== this.#userHome ||
-                homeBefore.uid !== this.#expectedUid ||
-                (exactMode(homeBefore.mode) & 0o022) !== 0 ||
-                homeAfter.isSymbolicLink() ||
-                !homeAfter.isDirectory() ||
-                homeAfter.uid !== this.#expectedUid ||
-                (exactMode(homeAfter.mode) & 0o022) !== 0 ||
-                homeBefore.dev !== homeAfter.dev ||
-                homeBefore.ino !== homeAfter.ino) {
-                throw new BridgeError("CLAUDE_PEER_WORKSPACE_UNSAFE", "The selected Claude workspace or local home is non-canonical.");
-            }
-            const filesystemRoot = path.parse(canonicalWorkspace).root;
-            if (canonicalWorkspace === filesystemRoot) {
-                throw new BridgeError("CLAUDE_PEER_WORKSPACE_BROAD", "The selected Claude workspace is broader than the safe local boundary.");
-            }
-            if (this.#tempRoots.some((tempRoot) => pathContains(tempRoot, canonicalWorkspace) ||
-                pathContains(canonicalWorkspace, tempRoot))) {
-                throw new BridgeError("CLAUDE_PEER_WORKSPACE_BROAD", "The selected Claude workspace is inside or contains a temporary root.");
-            }
-            const after = await lstat(cwd);
-            if (after.isSymbolicLink() ||
-                !after.isDirectory() ||
-                before.uid !== this.#expectedUid ||
-                after.uid !== this.#expectedUid ||
-                (exactMode(before.mode) & 0o022) !== 0 ||
-                (exactMode(after.mode) & 0o022) !== 0 ||
-                before.dev !== after.dev ||
-                before.ino !== after.ino) {
-                throw new BridgeError("CLAUDE_PEER_WORKSPACE_UNSAFE", "The selected Claude workspace changed or failed its owner and mode policy.");
-            }
-            return {
-                path: canonicalWorkspace,
-                generation: { dev: after.dev, ino: after.ino },
-            };
+    async #assertBindingWorkspaceDisjoint(binding) {
+        const code = "CLAUDE_PEER_WORKSPACE_UNSAFE";
+        const configured = assertAbsoluteConfiguredPath(binding.record.cwd, "peerDirectory");
+        if (configured === path.parse(configured).root ||
+            this.#tempRoots.some((root) => pathContains(root, configured) || pathContains(configured, root))) {
+            throw new BridgeError("CLAUDE_PEER_WORKSPACE_BROAD", "The selected Claude workspace is broader than the safe local boundary.");
         }
-        catch (error) {
-            if (error instanceof BridgeError)
-                throw error;
-            throw new BridgeError("CLAUDE_PEER_WORKSPACE_UNSAFE", "The selected Claude workspace could not be safely attested.");
+        const [workspace] = await Promise.all([
+            this.#attestOwnedDirectory(configured, false, code),
+            this.#attestOwnedDirectory(this.#userHome, false, code),
+        ]);
+        if (workspace !== configured) {
+            throw new BridgeError(code, "The peer workspace changed during attestation.");
         }
     }
     /**
@@ -846,34 +717,12 @@ export class ClaudePeerAdapter {
         if (target === undefined) {
             throw new BridgeError("CLAUDE_PEER_TARGET_UNKNOWN", "The Claude peer target is unknown; discover it first.", true);
         }
-        const binding = await this.#revalidateBinding(target);
-        const state = await this.#canonicalStateRoot(controllerStateRoot);
-        const workspace = await this.#assertBindingWorkspaceDisjoint(binding, state.path);
-        const existing = this.#workspacePolicies.get(targetId);
-        if (existing !== undefined) {
-            if (existing.stateRoot !== state.path ||
-                !sameDirectoryGeneration(existing.stateGeneration, state.generation)) {
-                this.#workspacePolicies.delete(targetId);
-                throw new BridgeError("CLAUDE_PEER_STATE_ROOT_CHANGED", "The selected Claude target is already bound to another controller state generation.");
-            }
-            if (existing.workspace !== workspace.path ||
-                !sameDirectoryGeneration(existing.workspaceGeneration, workspace.generation)) {
-                this.#workspacePolicies.delete(targetId);
-                throw new BridgeError("CLAUDE_PEER_WORKSPACE_CHANGED", "The selected Claude workspace generation changed; select it again.", true);
-            }
-        }
-        this.#workspacePolicies.set(targetId, {
-            stateRoot: state.path,
-            stateGeneration: state.generation,
-            workspace: workspace.path,
-            workspaceGeneration: workspace.generation,
-        });
+        const stateRoot = await this.#attestOwnedDirectory(controllerStateRoot, true, "CLAUDE_PEER_STATE_ROOT_UNSAFE");
+        await this.#assertBindingWorkspaceDisjoint(target);
+        this.#selectedStateRoots.set(targetId, stateRoot);
     }
     async #resolveReplyAddress(address) {
-        await Promise.all([
-            this.#validateSessionsDirectory(),
-            this.#validateRealDirectory(this.#socketDir),
-        ]);
+        await this.#validateRoots();
         if (!address.startsWith("uds:")) {
             throw new BridgeError("UNREGISTERED_REPLY_ADDRESS", "Only local registered UDS reply addresses are accepted.");
         }
@@ -889,18 +738,10 @@ export class ClaudePeerAdapter {
             throw new BridgeError("UNREGISTERED_REPLY_ADDRESS", "Reply address is not a registered Claude peer socket.");
         }
         const registryPath = path.join(this.#sessionsDir, `${pid}.json`);
-        let binding = await this.#bindingFromRegistry(registryPath, pid);
+        const binding = await this.#bindingFromRegistry(registryPath, pid);
         if (binding.record.messagingSocketPath !== socketPath) {
             throw new BridgeError("UNREGISTERED_REPLY_ADDRESS", "Reply address does not match its live registry generation.");
         }
-        const previous = [...this.#targets.values()].find((candidate) => sameTargetGeneration(candidate, binding));
-        if (previous !== undefined) {
-            binding = {
-                ...binding,
-                targetId: previous.targetId,
-                expiresAt: this.#now() + this.#limits.targetLeaseMs,
-            };
-        }
         this.#targets.set(binding.targetId, binding);
         return binding;
     }
@@ -910,10 +751,6 @@ export class ClaudePeerAdapter {
      * every later delivery resolves the UUID to fresh transport coordinates.
      */
     async resolveReplyAddress(address) {
-        await Promise.all([
-            this.#validateSessionsDirectory(),
-            this.#validateRealDirectory(this.#socketDir),
-        ]);
         const binding = await this.#resolveReplyAddress(address);
         return {
             targetId: binding.targetId,
@@ -923,14 +760,11 @@ export class ClaudePeerAdapter {
             compatibility: "compatible",
         };
     }
-    async #listen(options, preparedGeneration) {
-        await Promise.all([
-            this.#validateSessionsDirectory(),
-            this.#validateRealDirectory(this.#socketDir),
-        ]);
-        const generation = preparedGeneration ?? this.#createGeneration();
-        if (!isCodexRegistrationGeneration(generation)) {
-            throw new BridgeError("INVALID_CODEX_PEER_GENERATION", "A native Codex listener requires one bounded opaque generation.");
+    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.");
@@ -942,10 +776,8 @@ export class ClaudePeerAdapter {
             limits: this.#limits,
             createId: this.#createId,
             connect: this.#connect,
-            now: this.#now,
             locale: this.#locale,
             deliveryNotices: this.#deliveryNotices,
-            attestedClaudeCodeVersion: this.#attestedClaudeCodeVersion,
             resolveReplyAddress: async (address) => await this.#resolveReplyAddress(address),
             resolveSessionBinding: async (sessionId) => {
                 // Native receipt handles retain only the stable Claude session UUID.
@@ -959,199 +791,122 @@ export class ClaudePeerAdapter {
                 if (target === undefined) {
                     throw new BridgeError("CLAUDE_PEER_TARGET_UNKNOWN", "The Claude peer receipt target is no longer discoverable.", true);
                 }
-                return await this.#revalidateBinding(target);
+                return target;
             },
-            revalidateBinding: async (binding) => await this.#revalidateBinding(binding),
             options,
-            owner: this.#listenerOwner,
             generation,
             registryRename: this.#registryRename,
             ...(this.#registryOperationHook === undefined
                 ? {}
                 : { registryOperationHook: this.#registryOperationHook }),
             runRegistryMutation: async (operation) => await this.#registryMutex.run("codex-registry", operation),
-            ...(preparedGeneration === undefined ? {} : { preparedGeneration }),
-            ...(this.#registryPublicationHook === undefined
-                ? {}
-                : { registryPublicationHook: this.#registryPublicationHook }),
             postBindHook: this.#postBindHook,
             onClosed: () => this.#listeners.delete(listener),
         });
         this.#listeners.add(listener);
         return listener;
     }
-    async listen(options) {
-        return await this.#listen(options);
-    }
-    async listenPrepared(generation, options) {
-        if (!isCodexRegistrationGeneration(generation)) {
-            throw new BridgeError("INVALID_CODEX_PEER_GENERATION", "A prepared native Codex listener requires one bounded opaque generation.");
+    async prepareSend(targetId, content, options) {
+        if (!Number.isSafeInteger(options.deadlineAt) ||
+            options.deadlineAt < 0) {
+            throw new BridgeError("INVALID_PEER_MESSAGE_DEADLINE", "The Claude peer message deadline must be an epoch-millisecond timestamp.");
         }
-        return await this.#listen(options, generation);
-    }
-    async send(targetId, content, options = {}) {
-        // Session UUIDs survive registry rewrites, renames, and endpoint rotation.
-        // Refresh the replaceable transport coordinates before any write begins.
+        if (options.deadlineAt <= this.#now()) {
+            throw new BridgeError("CLAUDE_PEER_MESSAGE_EXPIRED", "The Claude peer message deadline elapsed before preparation.", true);
+        }
+        // Preparation positively resolves every replaceable coordinate and exact
+        // workspace generation. The resulting operation owns only immutable wire
+        // bytes and the already-validated socket path; it performs no connection
+        // or write until its one-shot perform function is invoked.
         await this.discover();
         const target = this.#targets.get(targetId);
         if (target === undefined) {
             throw new BridgeError("CLAUDE_PEER_TARGET_UNKNOWN", "The Claude peer target is unknown; discover it first.", true);
         }
-        const binding = await this.#revalidateBinding(target);
-        const workspacePolicy = this.#workspacePolicies.get(targetId);
-        if (workspacePolicy === undefined) {
+        const stateRoot = this.#selectedStateRoots.get(targetId);
+        if (stateRoot === undefined) {
             throw new BridgeError("CLAUDE_PEER_WORKSPACE_UNATTESTED", "The Claude peer workspace must pass selection validation before send.");
         }
         try {
-            const state = await this.#canonicalStateRoot(workspacePolicy.stateRoot);
-            const workspace = await this.#assertBindingWorkspaceDisjoint(binding, state.path);
-            if (!sameDirectoryGeneration(workspacePolicy.stateGeneration, state.generation)) {
-                throw new BridgeError("CLAUDE_PEER_STATE_ROOT_CHANGED", "The controller state root generation changed; select the target again.", true);
-            }
-            if (workspacePolicy.workspace !== workspace.path ||
-                !sameDirectoryGeneration(workspacePolicy.workspaceGeneration, workspace.generation)) {
-                throw new BridgeError("CLAUDE_PEER_WORKSPACE_CHANGED", "The selected Claude workspace generation changed; select it again.", true);
-            }
+            await this.#attestOwnedDirectory(stateRoot, true, "CLAUDE_PEER_STATE_ROOT_UNSAFE");
+            await this.#assertBindingWorkspaceDisjoint(target);
         }
         catch (error) {
-            this.#workspacePolicies.delete(targetId);
+            this.#selectedStateRoots.delete(targetId);
             throw error;
         }
         const messageId = this.#createId();
         if (!UUID_PATTERN.test(messageId)) {
             throw new BridgeError("INVALID_PEER_MESSAGE_ID", "The configured ID source did not produce a UUID.");
         }
-        const listener = options.listener;
-        if (listener !== undefined && !this.#listeners.has(listener)) {
+        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,
-            ...(listener === undefined ? {} : { from: listener.address }),
+            ...(options.replyListener === undefined
+                ? {}
+                : { from: options.replyListener.address }),
             maxFrameBytes: this.#limits.maxFrameBytes,
         });
-        if (options.receiptDeadlineAt !== undefined &&
-            (!Number.isSafeInteger(options.receiptDeadlineAt) ||
-                options.receiptDeadlineAt < 0)) {
-            throw new BridgeError("INVALID_PEER_RECEIPT_DEADLINE", "The Claude peer receipt deadline must be an epoch-millisecond timestamp.");
-        }
-        if (options.receiptDeadlineAt !== undefined &&
-            options.receiptDeadlineAt <= this.#now()) {
-            throw new BridgeError("CLAUDE_PEER_MESSAGE_EXPIRED", "The Claude peer message deadline elapsed before any socket write.", true);
-        }
-        if (listener !== undefined) {
-            listener.track(messageId, binding, options.receiptDeadlineAt);
-        }
-        await invokeObservationalHook(options.onTransportStatus, {
-            messageId,
-            status: "connecting",
-        });
-        if (options.receiptDeadlineAt !== undefined &&
-            options.receiptDeadlineAt <= this.#now()) {
-            listener?.untrack(messageId);
-            await invokeObservationalHook(options.onTransportStatus, {
-                messageId,
-                status: "not_written",
-            });
-            throw new BridgeError("CLAUDE_PEER_MESSAGE_EXPIRED", "The Claude peer message deadline elapsed before any socket write.", true);
-        }
-        let written = false;
-        let writeStarted = false;
-        try {
-            await new Promise((resolve, reject) => {
-                const socket = this.#connect(binding.record.messagingSocketPath);
-                const timeoutMs = Math.max(1, Math.min(this.#limits.connectTimeoutMs, options.receiptDeadlineAt === undefined
-                    ? this.#limits.connectTimeoutMs
-                    : options.receiptDeadlineAt - this.#now()));
-                const timer = setTimeout(() => {
-                    socket.destroy();
-                    const deadlineElapsed = options.receiptDeadlineAt !== undefined &&
-                        this.#now() >= options.receiptDeadlineAt;
-                    reject(new BridgeError(writeStarted
-                        ? "CLAUDE_PEER_WRITE_AMBIGUOUS"
-                        : deadlineElapsed
-                            ? "CLAUDE_PEER_MESSAGE_EXPIRED"
-                            : "CLAUDE_PEER_CONNECT_TIMEOUT", writeStarted
-                        ? "The Claude peer write began but did not finish in time; do not retry automatically."
-                        : deadlineElapsed
-                            ? "The Claude peer message deadline elapsed before any socket write."
-                            : "The Claude peer socket did not accept the write in time.", !writeStarted));
-                }, timeoutMs);
-                timer.unref();
-                socket.once("error", (error) => {
-                    clearTimeout(timer);
-                    reject(error);
-                });
-                socket.once("connect", () => {
-                    if (options.receiptDeadlineAt !== undefined &&
-                        options.receiptDeadlineAt <= this.#now()) {
-                        clearTimeout(timer);
-                        socket.destroy();
-                        reject(new BridgeError("CLAUDE_PEER_MESSAGE_EXPIRED", "The Claude peer message deadline elapsed before any socket write.", true));
-                        return;
-                    }
-                    writeStarted = true;
-                    listener?.recordTransportOutcome(messageId, "transport_uncertain");
-                    void invokeObservationalHook(options.onTransportStatus, {
-                        messageId,
-                        status: "write_started",
-                    });
-                    try {
-                        socket.end(frame, () => {
-                            written = true;
-                            clearTimeout(timer);
-                            socket.destroy();
-                            resolve();
-                        });
-                    }
-                    catch (error) {
-                        clearTimeout(timer);
-                        socket.destroy();
-                        reject(error);
-                    }
-                });
-            });
-        }
-        catch (error) {
-            if (listener !== undefined) {
-                if (writeStarted) {
-                    listener.recordTransportOutcome(messageId, "transport_uncertain");
-                }
-                else {
-                    listener.untrack(messageId);
+        const socketPath = target.record.messagingSocketPath;
+        let state = "prepared";
+        const cancel = () => {
+            if (state !== "prepared")
+                return;
+            state = "cancelled";
+            this.#preparedSends.delete(cancel);
+        };
+        this.#preparedSends.add(cancel);
+        const perform = () => {
+            if (state !== "prepared") {
+                return Promise.reject(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));
+            }
+            let writeStarted = false;
+            const write = writeSocketPayload(this.#connect, socketPath, frame, Math.max(1, Math.min(this.#limits.connectTimeoutMs, options.deadlineAt - this.#now())), () => {
+                if (options.deadlineAt <= this.#now()) {
+                    throw new BridgeError("CLAUDE_PEER_MESSAGE_EXPIRED", "The Claude peer message deadline elapsed before any socket write.", true);
                 }
-            }
-            await invokeObservationalHook(options.onTransportStatus, {
-                messageId,
-                status: writeStarted ? "ambiguous" : "not_written",
+                writeStarted = true;
             });
-            if (error instanceof BridgeError)
-                throw error;
-            if (writeStarted) {
-                throw new BridgeError("CLAUDE_PEER_WRITE_AMBIGUOUS", "The Claude peer write began but its outcome is ambiguous; do not retry automatically.");
-            }
-            throw new BridgeError("CLAUDE_PEER_WRITE_FAILED", "The Claude peer message was not confirmed written.", true);
-        }
-        if (!written) {
-            listener?.recordTransportOutcome(messageId, "transport_uncertain");
-            throw new BridgeError("CLAUDE_PEER_WRITE_AMBIGUOUS", "The Claude peer write outcome is ambiguous; do not retry automatically.");
-        }
-        listener?.recordTransportOutcome(messageId, "transport_written");
-        await invokeObservationalHook(options.onTransportStatus, {
+            return write.then(() => ({ messageId, transportStatus: "transport_written" }), (error) => {
+                if (error instanceof BridgeError)
+                    throw error;
+                const expired = this.#now() >= options.deadlineAt;
+                throw new BridgeError(writeStarted
+                    ? "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."
+                    : expired
+                        ? "The Claude peer message deadline elapsed before any socket write."
+                        : "The Claude peer message was not confirmed written.", !writeStarted);
+            });
+        };
+        return Object.freeze({
             messageId,
-            status: "transport_written",
+            frameBytes: frame.length,
+            sha256: createHash("sha256").update(frame).digest("hex"),
+            perform,
+            cancel,
         });
-        return {
-            messageId,
-            transportStatus: "transport_written",
-            receiptStatus: listener === undefined ? "unavailable" : "pending",
-        };
     }
     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.#workspacePolicies.clear();
+        this.#selectedStateRoots.clear();
         const failed = results.find((result) => result.status === "rejected");
         if (failed !== undefined)
             throw failed.reason;
@@ -1160,32 +915,12 @@ export class ClaudePeerAdapter {
 export class ClaudePeerListener {
     address;
     generation;
-    #sessionsDir;
     #sessionsGeneration;
-    #expectedUid;
     #socketPath;
     #socketGeneration;
     #server;
-    #limits;
-    #createId;
-    #connect;
-    #now;
-    #locale;
-    #deliveryNotices;
-    #attestedClaudeCodeVersion;
-    #resolveReplyAddress;
-    #resolveSessionBinding;
-    #revalidateBinding;
-    #options;
-    #owner;
-    #registryRename;
-    #registryOperationHook;
-    #runRegistryMutation;
-    #preparedGeneration;
-    #registryPublicationHook;
-    #onClosed;
+    #context;
     #connections = new Set();
-    #pending = new Map();
     #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
@@ -1195,52 +930,23 @@ export class ClaudePeerListener {
     #queuedFrames = 0;
     #inboundQuiesced = false;
     #inboundQuiesceWaiters = new Set();
-    #advertisedRecord;
-    #advertisedGeneration;
-    #preparedRecord;
-    #publicationAttempted = false;
-    #publicationSourceGeneration;
-    #publicationConfirmed = false;
-    #activationGranted = false;
+    #advertisement;
     #closing = false;
     #closed = false;
     #closeOperation;
     constructor(options, server, socketPath, generation, sessionsGeneration) {
         this.address = `uds:${socketPath}`;
         this.generation = options.generation;
-        this.#sessionsDir = options.sessionsDir;
         this.#sessionsGeneration = sessionsGeneration;
-        this.#expectedUid = options.expectedUid;
         this.#socketPath = socketPath;
         this.#socketGeneration = generation;
         this.#server = server;
-        this.#limits = options.limits;
-        this.#createId = options.createId;
-        this.#connect = options.connect;
-        this.#now = options.now;
-        this.#locale = options.locale;
-        this.#deliveryNotices = options.deliveryNotices;
-        this.#attestedClaudeCodeVersion = options.attestedClaudeCodeVersion;
-        this.#resolveReplyAddress = options.resolveReplyAddress;
-        this.#resolveSessionBinding = options.resolveSessionBinding;
-        this.#revalidateBinding = options.revalidateBinding;
-        this.#options = options.options;
-        this.#owner = options.owner;
-        this.#registryRename = options.registryRename;
-        this.#registryOperationHook = options.registryOperationHook;
-        this.#runRegistryMutation = options.runRegistryMutation;
-        this.#preparedGeneration = options.preparedGeneration;
-        this.#registryPublicationHook = options.registryPublicationHook;
-        this.#onClosed = options.onClosed;
-        this.#inboundQuiesced = options.preparedGeneration !== undefined;
-        this.#activationGranted = options.preparedGeneration === undefined;
+        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, options.preparedGeneration === undefined
-            ? `${process.pid}.sock`
-            : `${process.pid}.${options.preparedGeneration}.sock`);
+        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.");
@@ -1303,36 +1009,17 @@ export class ClaudePeerListener {
             return listener;
         }
         catch (error) {
-            let stillOwned = false;
-            if (createdGeneration !== undefined) {
-                try {
-                    const current = await lstat(socketPath);
-                    stillOwned =
-                        current.isSocket() &&
-                            sameSocketGeneration({ dev: current.dev, ino: current.ino }, createdGeneration);
-                }
-                catch {
-                    // A missing or unreadable path cannot be safely unlinked by
-                    // net.Server.close(), which deletes by pathname.
-                }
-            }
-            let closeConfirmed = false;
-            if (stillOwned) {
-                try {
-                    await new Promise((resolve, reject) => server.close((closeError) => closeError === undefined ? resolve() : reject(closeError)));
-                    try {
-                        await lstat(socketPath);
-                    }
-                    catch (closeError) {
-                        closeConfirmed =
-                            closeError.code === "ENOENT";
-                    }
+            try {
+                if (createdGeneration === undefined ||
+                    await socketOwnership(socketPath, createdGeneration) !== "owned") {
+                    throw new Error("callback ownership changed");
                 }
-                catch {
-                    // An unconfirmed close cannot safely downgrade a callback failure.
+                await closeServer(server);
+                if (await socketOwnership(socketPath, createdGeneration) !== "missing") {
+                    throw new Error("callback close unconfirmed");
                 }
             }
-            if (!closeConfirmed) {
+            catch {
                 server.unref();
                 throw new BridgeError("CLAUDE_PEER_CALLBACK_UNSAFE", "The newly bound callback socket could not be safely closed.");
             }
@@ -1342,35 +1029,20 @@ export class ClaudePeerListener {
     get closed() {
         return this.#closing || this.#closed;
     }
-    #isClosingOrClosed() {
-        return this.#closing || this.#closed;
-    }
     #registryPath() {
-        return path.join(this.#sessionsDir, `${process.pid}.json`);
+        return path.join(this.#context.sessionsDir, `${process.pid}.json`);
     }
     #registryTemporaryPath() {
-        return path.join(this.#sessionsDir, `.${process.pid}.${this.generation}.registry.tmp`);
+        return path.join(this.#context.sessionsDir, `.${process.pid}.${this.generation}.registry.tmp`);
     }
     #serializeRecord(record) {
         return `${JSON.stringify(record)}\n`;
     }
-    #recordBelongsToThisListener(record) {
-        return (record.embassyAdvertisementVersion === EMBASSY_ADVERTISEMENT_VERSION &&
-            record.pid === process.pid &&
-            UUID_PATTERN.test(record.sessionId) &&
-            record.messagingSocketPath === this.#socketPath &&
-            record.version === this.#attestedClaudeCodeVersion &&
-            record.peerProtocol === CLAUDE_PEER_COMPATIBILITY.peerProtocol &&
-            record.kind === "interactive" &&
-            record.entrypoint === "cli" &&
-            EMBASSY_SOURCE_NAME_PATTERN.test(record.name) &&
-            ALIAS_PATTERN.test(record.name));
-    }
     async #assertRegistryDirectory() {
-        const current = await lstat(this.#sessionsDir);
+        const current = await lstat(this.#context.sessionsDir);
         if (current.isSymbolicLink() ||
             !current.isDirectory() ||
-            current.uid !== this.#expectedUid ||
+            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.");
@@ -1379,43 +1051,36 @@ export class ClaudePeerListener {
     async #readRegistryExact() {
         await this.#assertRegistryDirectory();
         const registryPath = this.#registryPath();
-        let before;
+        let handle;
         try {
-            before = await lstat(registryPath);
+            handle = await open(registryPath, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
         }
         catch (error) {
             if (error.code === "ENOENT")
                 return undefined;
             throw error;
         }
-        if (before.isSymbolicLink() ||
-            !before.isFile() ||
-            before.uid !== this.#expectedUid ||
-            exactMode(before.mode) !== 0o600 ||
-            before.size > this.#limits.maxRegistryBytes) {
-            throw new BridgeError("REGISTRY_RACED", "The native Codex registry record failed its exact ownership policy.");
-        }
-        const beforeGeneration = generationOf(before);
-        const handle = await open(registryPath, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
         try {
             const opened = await handle.stat();
             const openedGeneration = generationOf(opened);
             if (!opened.isFile() ||
-                opened.uid !== this.#expectedUid ||
+                opened.uid !== this.#context.expectedUid ||
                 exactMode(opened.mode) !== 0o600 ||
-                !sameFileGeneration(beforeGeneration, openedGeneration)) {
-                throw new BridgeError("REGISTRY_RACED", "The native Codex registry record changed while opening.");
+                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.#limits.maxRegistryBytes) {
+            if (byteLength(serialized) > this.#context.limits.maxRegistryBytes) {
                 throw new BridgeError("REGISTRY_TOO_LARGE", "The native Codex registry record exceeded its bound.");
             }
-            const after = await lstat(registryPath);
-            if (after.isSymbolicLink() ||
-                !after.isFile() ||
-                after.uid !== this.#expectedUid ||
-                exactMode(after.mode) !== 0o600 ||
-                !sameFileGeneration(openedGeneration, generationOf(after))) {
+            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 };
@@ -1447,46 +1112,21 @@ export class ClaudePeerListener {
             flag: "wx",
             mode: 0o600,
         });
-        let generation;
-        try {
-            const created = await lstat(temporaryPath);
-            if (created.isSymbolicLink() ||
-                !created.isFile() ||
-                created.uid !== this.#expectedUid ||
-                exactMode(created.mode) !== 0o600) {
-                throw new BridgeError("REGISTRY_RACED", "The native Codex temporary registry record is unsafe.");
-            }
-            generation = generationOf(created);
-            const handle = await open(temporaryPath, fsConstants.O_RDWR | fsConstants.O_NOFOLLOW);
-            try {
-                const openedStat = await handle.stat();
-                const opened = generationOf(openedStat);
-                if (!openedStat.isFile() ||
-                    openedStat.uid !== this.#expectedUid ||
-                    exactMode(openedStat.mode) !== 0o600 ||
-                    !sameFileGeneration(generation, opened)) {
-                    throw new BridgeError("REGISTRY_RACED", "The native Codex temporary registry record changed while opening.");
-                }
-                await handle.sync();
-            }
-            finally {
-                await handle.close();
-            }
-            return { path: temporaryPath, generation };
-        }
-        catch (error) {
-            if (generation !== undefined) {
-                await this.#cleanupOwnedFile(temporaryPath, generation).catch(() => undefined);
-            }
-            throw error;
+        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.#expectedUid &&
+                current.uid === this.#context.expectedUid &&
                 exactMode(current.mode) === 0o600 &&
                 sameFileGeneration(generationOf(current), generation)) {
                 await unlink(candidate);
@@ -1497,23 +1137,6 @@ export class ClaudePeerListener {
                 throw error;
         }
     }
-    async #syncRegistryDirectory() {
-        await this.#assertRegistryDirectory();
-        const handle = await open(this.#sessionsDir, fsConstants.O_RDONLY);
-        try {
-            const opened = await handle.stat();
-            if (!opened.isDirectory() ||
-                opened.uid !== this.#expectedUid ||
-                exactMode(opened.mode) !== 0o700 ||
-                !sameDirectoryGeneration({ dev: opened.dev, ino: opened.ino }, this.#sessionsGeneration)) {
-                throw new BridgeError("UNSAFE_PEER_DIRECTORY", "The native peer registry directory changed while syncing.");
-            }
-            await handle.sync();
-        }
-        finally {
-            await handle.close();
-        }
-    }
     #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.");
@@ -1521,7 +1144,7 @@ export class ClaudePeerListener {
         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.#createId();
+        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.");
         }
@@ -1533,7 +1156,7 @@ export class ClaudePeerListener {
             cwd,
             startedAt: now,
             procStart: new Date(now - process.uptime() * 1_000).toString(),
-            version: this.#attestedClaudeCodeVersion,
+            version: "unknown",
             peerProtocol: CLAUDE_PEER_COMPATIBILITY.peerProtocol,
             kind: "interactive",
             entrypoint: "cli",
@@ -1545,8 +1168,8 @@ export class ClaudePeerListener {
         };
     }
     async #mutateRegistry(operation, mutation) {
-        return await this.#runRegistryMutation(async () => {
-            await this.#registryOperationHook?.({
+        return await this.#context.runRegistryMutation(async () => {
+            await this.#context.registryOperationHook?.({
                 operation,
                 phase: "entered",
                 generation: this.generation,
@@ -1555,7 +1178,7 @@ export class ClaudePeerListener {
                 return await mutation();
             }
             finally {
-                await this.#registryOperationHook?.({
+                await this.#context.registryOperationHook?.({
                     operation,
                     phase: "exited",
                     generation: this.generation,
@@ -1565,17 +1188,13 @@ export class ClaudePeerListener {
     }
     async advertise(name, cwd) {
         await this.#mutateRegistry("advertise", async () => {
-            if (this.#isClosingOrClosed()) {
+            if (this.closed) {
                 throw new BridgeError("CLAUDE_PEER_LISTENER_CLOSED", "The Claude peer callback listener is closed.");
             }
-            if (this.#preparedGeneration !== undefined) {
-                throw new BridgeError("CODEX_PEER_PREPARED_NOT_ACTIVE", "A prepared native Codex listener must use atomic succession publication.");
-            }
-            if (this.#advertisedRecord !== undefined &&
-                this.#advertisedRecord.name !== name) {
+            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.#advertisedRecord?.name === name)
+            if (this.#advertisement?.record.name === name)
                 return;
             const record = this.#newAdvertisedRecord(name, cwd);
             await this.#assertRegistryDirectory();
@@ -1588,197 +1207,52 @@ export class ClaudePeerListener {
             if (!exact.matches) {
                 throw new BridgeError("REGISTRY_RACED", "The native Codex registry record could not be exactly confirmed.");
             }
-            this.#advertisedRecord = record;
-            this.#advertisedGeneration = exact.generation;
+            this.#advertisement = { record, generation: exact.generation };
         });
     }
-    async #classifyPublication(current, record) {
-        const sourceGeneration = this.#publicationSourceGeneration;
-        if (sourceGeneration !== undefined) {
-            const published = await this.#recordMatches(record, sourceGeneration);
-            if (published.matches) {
-                this.#advertisedRecord = record;
-                this.#advertisedGeneration = published.generation;
-                this.#publicationConfirmed = true;
-                return "published";
-            }
-        }
-        return (await this.#oldPublicationStillPresent(current))
-            ? "not_published"
-            : "unknown";
-    }
-    async #oldPublicationStillPresent(current) {
-        const oldRecord = current.#advertisedRecord;
-        const oldGeneration = current.#advertisedGeneration;
-        if (oldRecord === undefined || oldGeneration === undefined)
-            return false;
-        return (await current.#recordMatches(oldRecord, oldGeneration)).matches;
-    }
-    async publishReplacing(current, name, cwd) {
-        return await this.#mutateRegistry("publish", async () => await this.#publishReplacingLocked(current, name, cwd));
-    }
-    async #publishReplacingLocked(current, name, cwd) {
-        if (this.#isClosingOrClosed() ||
-            current.#isClosingOrClosed() ||
-            this === current ||
-            this.#preparedGeneration === undefined ||
-            this.generation === current.generation ||
-            !current.#activationGranted ||
-            this.#owner !== current.#owner ||
-            this.#sessionsDir !== current.#sessionsDir ||
-            this.#expectedUid !== current.#expectedUid ||
-            !sameDirectoryGeneration(this.#sessionsGeneration, current.#sessionsGeneration)) {
-            throw new BridgeError("CODEX_PEER_SUCCESSION_INVALID", "Native Codex listener succession requires two live generations from one adapter owner.");
-        }
-        if (!this.#inboundQuiesced || !current.#inboundQuiesced) {
-            throw new BridgeError("CODEX_PEER_SUCCESSION_NOT_QUIESCED", "Both native Codex listener generations must be inbound-quiesced before publication.");
-        }
-        if (current.#advertisedRecord === undefined ||
-            current.#advertisedGeneration === undefined ||
-            !current.#recordBelongsToThisListener(current.#advertisedRecord)) {
-            throw new BridgeError("CODEX_PEER_SUCCESSION_CURRENT_UNOWNED", "The current native Codex listener does not own an exact advertised record.");
-        }
-        if (name === current.#advertisedRecord.name) {
-            throw new BridgeError("CODEX_PEER_SUCCESSION_ALIAS_UNCHANGED", "Native Codex succession requires a distinct alias.");
-        }
-        if (this.#preparedRecord === undefined) {
-            this.#preparedRecord = this.#newAdvertisedRecord(name, cwd);
-        }
-        else if (this.#preparedRecord.name !== name ||
-            this.#preparedRecord.cwd !== cwd) {
-            throw new BridgeError("CODEX_PEER_SUCCESSION_CHANGED", "A prepared native Codex publication cannot change identity after preparation.");
-        }
-        const record = this.#preparedRecord;
-        if (this.#publicationAttempted) {
-            return await this.#classifyPublication(current, record);
-        }
-        let temporary;
-        let renameInvoked = false;
-        try {
-            temporary = await this.#createRegistryTemporary(record);
-            this.#publicationSourceGeneration = temporary.generation;
-            await this.#registryPublicationHook?.("before_rename");
-            if (this.#isClosingOrClosed() ||
-                current.#isClosingOrClosed() ||
-                !this.#inboundQuiesced ||
-                !current.#inboundQuiesced) {
-                return (await this.#oldPublicationStillPresent(current))
-                    ? "not_published"
-                    : "unknown";
+    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 currentExact = await current.#recordMatches(current.#advertisedRecord, current.#advertisedGeneration);
-            if (!currentExact.matches)
-                return "unknown";
-            renameInvoked = true;
-            this.#publicationAttempted = true;
-            await this.#registryRename(temporary.path, this.#registryPath());
-            temporary = undefined;
-            await this.#registryPublicationHook?.("after_rename");
-            await this.#syncRegistryDirectory();
-            return await this.#classifyPublication(current, record);
-        }
-        catch {
-            if (!renameInvoked) {
-                return (await this.#oldPublicationStillPresent(current))
-                    ? "not_published"
-                    : "unknown";
+            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 };
             }
-            return await this.#classifyPublication(current, record);
-        }
-        finally {
-            if (temporary !== undefined) {
+            finally {
                 await this.#cleanupOwnedFile(temporary.path, temporary.generation).catch(() => undefined);
             }
-        }
-    }
-    async updateAdvertisedStatus(status) {
-        await this.#mutateRegistry("status", async () => await this.#updateAdvertisedStatusLocked(status));
-    }
-    async #updateAdvertisedStatusLocked(status) {
-        if (this.#isClosingOrClosed() ||
-            this.#advertisedRecord === undefined ||
-            this.#advertisedRecord.status === status) {
-            return;
-        }
-        const currentExact = await this.#recordMatches(this.#advertisedRecord, this.#advertisedGeneration);
-        if (!currentExact.matches) {
-            this.#advertisedRecord = undefined;
-            this.#advertisedGeneration = undefined;
-            return;
-        }
-        const now = Date.now();
-        const record = {
-            ...this.#advertisedRecord,
-            status,
-            updatedAt: now,
-            statusUpdatedAt: now,
-        };
-        const temporary = await this.#createRegistryTemporary(record);
-        try {
-            const stillCurrent = await this.#recordMatches(this.#advertisedRecord, this.#advertisedGeneration);
-            if (!stillCurrent.matches)
-                return;
-            await this.#registryRename(temporary.path, this.#registryPath());
-            await this.#syncRegistryDirectory();
-            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.#advertisedRecord = record;
-            this.#advertisedGeneration = exact.generation;
-        }
-        finally {
-            await this.#cleanupOwnedFile(temporary.path, temporary.generation).catch(() => undefined);
-        }
+        });
     }
     async unadvertise(name) {
-        await this.#mutateRegistry("unadvertise", async () => await this.#unadvertiseLocked(name));
-    }
-    async #unadvertiseLocked(name) {
-        if (this.#advertisedRecord === undefined ||
-            (name !== undefined && name !== this.#advertisedRecord.name)) {
-            return;
-        }
-        const record = this.#advertisedRecord;
-        const generation = this.#advertisedGeneration;
-        this.#advertisedRecord = undefined;
-        this.#advertisedGeneration = undefined;
-        if (generation === undefined)
-            return;
-        const exact = await this.#recordMatches(record, generation);
-        if (!exact.matches)
-            return;
-        await unlink(this.#registryPath()).catch((error) => {
-            if (error.code !== "ENOENT")
-                throw error;
+        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;
+            });
         });
     }
-    grantSuccessionActivation() {
-        if (this.#isClosingOrClosed()) {
-            throw new BridgeError("CLAUDE_PEER_LISTENER_CLOSED", "The Claude peer callback listener is closed.");
-        }
-        if (this.#preparedGeneration === undefined ||
-            !this.#publicationAttempted ||
-            !this.#publicationConfirmed ||
-            this.#publicationSourceGeneration === undefined ||
-            this.#advertisedRecord === undefined ||
-            this.#advertisedGeneration === undefined ||
-            !sameFileGeneration(this.#publicationSourceGeneration, this.#advertisedGeneration)) {
-            throw new BridgeError("CODEX_PEER_PREPARED_NOT_ACTIVE", "A prepared native Codex listener requires exact confirmed publication before activation can be granted.");
-        }
-        this.#activationGranted = true;
-    }
-    resumeInbound() {
-        if (this.#isClosingOrClosed()) {
-            throw new BridgeError("CLAUDE_PEER_LISTENER_CLOSED", "The Claude peer callback listener is closed.");
-        }
-        if (!this.#activationGranted) {
-            throw new BridgeError("CODEX_PEER_PREPARED_NOT_ACTIVE", "A prepared native Codex listener cannot resume before durable succession activation.");
-        }
-        this.#inboundQuiesced = false;
-    }
     async acknowledge(receiptHandle, status, diagnostic) {
-        if (this.#isClosingOrClosed()) {
+        if (this.closed) {
             throw new BridgeError("CLAUDE_PEER_LISTENER_CLOSED", "The Claude peer callback listener is closed.");
         }
         const receipt = this.#inboundReceipts.get(receiptHandle);
@@ -1813,7 +1287,7 @@ export class ClaudePeerListener {
      * its later exact terminal acknowledgement or explicit release.
      */
     async notifyInboundProgress(receiptHandle, progress) {
-        if (this.#isClosingOrClosed()) {
+        if (this.closed) {
             throw new BridgeError("CLAUDE_PEER_LISTENER_CLOSED", "The Claude peer callback listener is closed.");
         }
         const receipt = this.#inboundReceipts.get(receiptHandle);
@@ -1830,7 +1304,7 @@ export class ClaudePeerListener {
         if (receipt.stallNotification !== "available") {
             throw new BridgeError("CLAUDE_PEER_PROGRESS_ALREADY_NOTIFIED", "The native Claude peer receipt already has a stall notification.");
         }
-        if (this.#deliveryNotices === "quiet") {
+        if (this.#context.deliveryNotices === "quiet") {
             receipt.stallNotification = "settled";
             return { transportStatus: "suppressed" };
         }
@@ -1839,16 +1313,16 @@ export class ClaudePeerListener {
             `queued-for-ms="${queuedForMs}">`;
         const detailedContent = [
             openingTag,
-            CLAUDE_PEER_NOTICE_COPY[this.#locale].stall,
+            CLAUDE_PEER_NOTICE_COPY[this.#context.locale].stall,
             "</gateway-delivery-stall>",
         ].join("\n");
-        const messageId = this.#createId();
+        const messageId = this.#context.createId();
         let progressFrame;
         try {
             progressFrame = encodeClaudePeerUserFrame({
                 messageId,
                 content: detailedContent,
-                maxFrameBytes: this.#limits.maxFrameBytes,
+                maxFrameBytes: this.#context.limits.maxFrameBytes,
             });
         }
         catch (error) {
@@ -1858,7 +1332,7 @@ export class ClaudePeerListener {
             progressFrame = encodeClaudePeerUserFrame({
                 messageId,
                 content: `${openingTag.slice(0, -1)}/>`,
-                maxFrameBytes: this.#limits.maxFrameBytes,
+                maxFrameBytes: this.#context.limits.maxFrameBytes,
             });
         }
         receipt.stallNotification = "writing";
@@ -1912,18 +1386,18 @@ export class ClaudePeerListener {
             from: this.address,
             orig_msg_id: receipt.originalMessageId,
             msgV: 1,
-            msg_id: this.#createId(),
+            msg_id: this.#context.createId(),
         })}\n`, "utf8");
-        const diagnosticFrame = diagnostic === undefined || this.#deliveryNotices !== "verbose"
+        const diagnosticFrame = diagnostic === undefined || this.#context.deliveryNotices !== "verbose"
             ? undefined
             : encodeClaudePeerUserFrame({
-                messageId: this.#createId(),
+                messageId: this.#context.createId(),
                 content: [
                     `<gateway-delivery-diagnostic status="expired" code="${diagnostic.code}">`,
-                    CLAUDE_PEER_NOTICE_COPY[this.#locale].diagnostic,
+                    CLAUDE_PEER_NOTICE_COPY[this.#context.locale].diagnostic,
                     "</gateway-delivery-diagnostic>",
                 ].join("\n"),
-                maxFrameBytes: this.#limits.maxFrameBytes,
+                maxFrameBytes: this.#context.limits.maxFrameBytes,
             });
         const payload = diagnosticFrame === undefined
             ? statusFrame
@@ -1933,31 +1407,9 @@ export class ClaudePeerListener {
     async #writeInboundPayload(receipt, payload) {
         let writeStarted = false;
         try {
-            const binding = await this.#resolveSessionBinding(receipt.sourceSessionId);
-            await new Promise((resolve, reject) => {
-                const socket = this.#connect(binding.record.messagingSocketPath);
-                let settled = false;
-                const finish = (error) => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    socket.destroy();
-                    if (error === undefined)
-                        resolve();
-                    else
-                        reject(error);
-                };
-                socket.setTimeout(this.#limits.connectTimeoutMs, () => finish(new Error("peer status timeout")));
-                socket.once("error", finish);
-                socket.once("connect", () => {
-                    writeStarted = true;
-                    try {
-                        socket.end(payload, () => finish());
-                    }
-                    catch (error) {
-                        finish(error);
-                    }
-                });
+            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) {
@@ -1970,63 +1422,15 @@ export class ClaudePeerListener {
         }
         return { transportStatus: "transport_written" };
     }
-    track(messageId, binding, receiptDeadlineAt) {
-        if (this.#isClosingOrClosed()) {
-            throw new BridgeError("CLAUDE_PEER_LISTENER_CLOSED", "The Claude peer callback listener is closed.");
-        }
-        if (this.#pending.size >= this.#limits.maxPendingReceipts) {
-            throw new BridgeError("CLAUDE_PEER_RECEIPT_LIMIT", "The bounded Claude peer receipt table is full.", true);
-        }
-        if (this.#pending.has(messageId)) {
-            throw new BridgeError("CLAUDE_PEER_MESSAGE_ID_COLLISION", "The peer message ID collided with an outstanding receipt.");
-        }
-        const now = this.#now();
-        const deadlineAt = receiptDeadlineAt ?? now + this.#limits.receiptDeadlineMs;
-        const timer = setTimeout(() => {
-            const pending = this.#pending.get(messageId);
-            if (pending === undefined)
-                return;
-            this.#pending.delete(messageId);
-            void this.#emitReceipt({
-                messageId,
-                status: pendingReceiptDeadlineStatus(pending),
-                trust: "untrusted_same_uid_peer",
-            });
-        }, Math.max(1, deadlineAt - now));
-        timer.unref();
-        this.#pending.set(messageId, {
-            binding,
-            state: "pending",
-            writeEvidence: "none",
-            deadlineAt,
-            timer,
-        });
-    }
-    recordTransportOutcome(messageId, outcome) {
-        const pending = this.#pending.get(messageId);
-        if (pending === undefined)
-            return;
-        if (pending.writeEvidence !== "transport_written" ||
-            outcome === "transport_written") {
-            pending.writeEvidence = outcome;
-        }
-    }
-    untrack(messageId) {
-        const pending = this.#pending.get(messageId);
-        if (pending === undefined)
-            return;
-        clearTimeout(pending.timer);
-        this.#pending.delete(messageId);
-    }
     #accept(socket) {
-        if (this.#isClosingOrClosed() ||
-            this.#connections.size >= this.#limits.maxConnections) {
+        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.#limits.connectionIdleMs);
+        socket.setTimeout(this.#context.limits.connectionIdleMs);
         let buffered = Buffer.alloc(0);
         let frames = 0;
         let chain = Promise.resolve();
@@ -2045,9 +1449,9 @@ export class ClaudePeerListener {
             if (rejected)
                 return;
             buffered = Buffer.concat([buffered, chunk]);
-            if (buffered.length > this.#limits.maxFrameBytes + 1) {
+            if (buffered.length > this.#context.limits.maxFrameBytes + 1) {
                 const newline = buffered.indexOf(0x0a);
-                if (newline < 0 || newline > this.#limits.maxFrameBytes) {
+                if (newline < 0 || newline > this.#context.limits.maxFrameBytes) {
                     reject("FRAME_TOO_LARGE");
                     return;
                 }
@@ -2056,20 +1460,20 @@ export class ClaudePeerListener {
                 const newline = buffered.indexOf(0x0a);
                 if (newline < 0)
                     break;
-                if (newline > this.#limits.maxFrameBytes) {
+                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.#limits.maxFramesPerConnection) {
+                if (frames > this.#context.limits.maxFramesPerConnection) {
                     reject("INVALID_FRAME");
                     break;
                 }
                 let frame;
                 try {
-                    frame = parseFrame(line, this.#limits.maxFrameBytes);
+                    frame = parseFrame(line, this.#context.limits.maxFrameBytes);
                 }
                 catch (error) {
                     if (error instanceof BridgeError &&
@@ -2086,7 +1490,7 @@ export class ClaudePeerListener {
                     break;
                 }
                 if (this.#queuedFrames >=
-                    this.#limits.maxConnections * this.#limits.maxFramesPerConnection) {
+                    this.#context.limits.maxConnections * this.#context.limits.maxFramesPerConnection) {
                     reject("CONNECTION_LIMIT");
                     break;
                 }
@@ -2112,7 +1516,7 @@ export class ClaudePeerListener {
                     }
                 });
             }
-            if (!rejected && buffered.length > this.#limits.maxFrameBytes) {
+            if (!rejected && buffered.length > this.#context.limits.maxFrameBytes) {
                 reject("FRAME_TOO_LARGE");
             }
         });
@@ -2122,10 +1526,11 @@ export class ClaudePeerListener {
         });
     }
     async #handleFrame(frame, rejectTransport) {
-        if (this.#isClosingOrClosed())
+        if (this.closed)
             return;
         if (frame.type === "control") {
-            await this.#handleControl(frame);
+            // Native outbound status is accepted for wire compatibility but is not
+            // settlement authority. A confirmed mailbox write is terminal.
             return;
         }
         if (this.#inboundQuiesced) {
@@ -2135,16 +1540,16 @@ export class ClaudePeerListener {
         let binding;
         if (frame.from !== undefined) {
             try {
-                binding = await this.#resolveReplyAddress(frame.from);
+                binding = await this.#context.resolveReplyAddress(frame.from);
             }
             catch {
                 await this.#notice("UNREGISTERED_REPLY_ADDRESS");
                 return;
             }
         }
-        const inboundId = this.#createId();
+        const inboundId = this.#context.createId();
         if (binding !== undefined && frame.messageId !== undefined) {
-            if (this.#inboundReceipts.size >= this.#limits.maxPendingReceipts) {
+            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
@@ -2171,7 +1576,7 @@ export class ClaudePeerListener {
                 stallNotification: "available",
             });
         }
-        await invokeHook(this.#options.onMessage, {
+        await invokeHook(this.#context.options.onMessage, {
             inboundId,
             content: frame.content,
             ...(binding === undefined
@@ -2190,7 +1595,7 @@ export class ClaudePeerListener {
         });
     }
     async #attemptCapacitySettlement(settlement) {
-        if (this.#isClosingOrClosed() || this.#capacitySettlement !== settlement) {
+        if (this.closed || this.#capacitySettlement !== settlement) {
             return;
         }
         settlement.attempts += 1;
@@ -2205,7 +1610,7 @@ export class ClaudePeerListener {
                 return;
             const retryable = error instanceof BridgeError &&
                 error.recoverable &&
-                !this.#isClosingOrClosed();
+                !this.closed;
             if (!retryable ||
                 settlement.attempts >= CAPACITY_SETTLEMENT_MAX_ATTEMPTS) {
                 // An ambiguous write must never be replayed. Exhausted clean
@@ -2222,74 +1627,9 @@ export class ClaudePeerListener {
             settlement.retryTimer.unref();
         }
     }
-    async #handleControl(frame) {
-        const pending = this.#pending.get(frame.originalMessageId);
-        if (pending === undefined) {
-            await this.#notice("UNKNOWN_RECEIPT");
-            return;
-        }
-        let currentBinding;
-        try {
-            // Receipt authority is the stable Claude session UUID, not the
-            // short-lived send-time registry/socket lease. Re-discover the exact
-            // session on every receipt so legitimate held/terminal frames remain
-            // valid for the full message deadline and across socket rotation.
-            currentBinding = await this.#resolveSessionBinding(pending.binding.targetId);
-        }
-        catch {
-            await this.#notice("UNKNOWN_RECEIPT");
-            return;
-        }
-        if (frame.from !== `uds:${currentBinding.record.messagingSocketPath}`) {
-            await this.#notice("UNKNOWN_RECEIPT");
-            return;
-        }
-        pending.binding = currentBinding;
-        if (this.#now() >= pending.deadlineAt) {
-            clearTimeout(pending.timer);
-            this.#pending.delete(frame.originalMessageId);
-            await this.#emitReceipt({
-                messageId: frame.originalMessageId,
-                status: pendingReceiptDeadlineStatus(pending),
-                trust: "untrusted_same_uid_peer",
-            });
-            return;
-        }
-        if (frame.status === "held") {
-            if (pending.state !== "pending") {
-                await this.#notice("INVALID_RECEIPT_TRANSITION");
-                return;
-            }
-            pending.state = "held";
-            pending.writeEvidence = "transport_written";
-            await this.#emitReceipt({
-                messageId: frame.originalMessageId,
-                status: "held",
-                trust: "untrusted_same_uid_peer",
-            });
-            return;
-        }
-        clearTimeout(pending.timer);
-        this.#pending.delete(frame.originalMessageId);
-        await this.#emitReceipt({
-            messageId: frame.originalMessageId,
-            status: frame.status === "delivered"
-                ? "released"
-                : frame.status,
-            trust: "untrusted_same_uid_peer",
-        });
-    }
-    async #emitReceipt(event) {
-        try {
-            await invokeHook(this.#options.onReceipt, event);
-        }
-        catch {
-            await this.#notice("CALLBACK_ERROR");
-        }
-    }
     async #notice(code) {
         try {
-            await invokeHook(this.#options.onProtocolNotice, { code });
+            await invokeHook(this.#context.options.onProtocolNotice, { code });
         }
         catch {
             // Protocol callbacks are observational. Never feed callback failures
@@ -2315,34 +1655,17 @@ export class ClaudePeerListener {
         catch (error) {
             errors.push(error);
         }
-        const unsettledReceipts = [...this.#pending.entries()];
-        for (const pending of this.#pending.values())
-            clearTimeout(pending.timer);
-        this.#pending.clear();
         this.#inboundReceipts.clear();
         if (this.#capacitySettlement?.retryTimer !== undefined) {
             clearTimeout(this.#capacitySettlement.retryTimer);
         }
         this.#capacitySettlement = undefined;
-        const receiptResults = await Promise.allSettled(unsettledReceipts.map(async ([messageId, pending]) => this.#emitReceipt({
-            messageId,
-            status: pendingReceiptDeadlineStatus(pending) === "unconfirmed"
-                ? "unconfirmed"
-                : "ambiguous",
-            trust: "untrusted_same_uid_peer",
-        })));
-        for (const result of receiptResults) {
-            if (result.status === "rejected")
-                errors.push(result.reason);
-        }
         for (const socket of this.#connections)
             socket.destroy();
         this.#connections.clear();
-        let callbackPathOwned = false;
         try {
-            const beforeClose = await lstat(this.#socketPath);
-            if (!beforeClose.isSocket() ||
-                !sameSocketGeneration({ dev: beforeClose.dev, ino: beforeClose.ino }, this.#socketGeneration)) {
+            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
@@ -2351,43 +1674,21 @@ export class ClaudePeerListener {
                 errors.push(new BridgeError("CLAUDE_PEER_CALLBACK_CHANGED", "The callback path changed; foreign replacement was preserved."));
             }
             else {
-                callbackPathOwned = true;
-            }
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                this.#server.unref();
-                errors.push(new BridgeError("CLAUDE_PEER_CALLBACK_CHANGED", "The callback path disappeared; cleanup failed closed."));
-            }
-            else {
-                this.#server.unref();
-                errors.push(error);
-            }
-        }
-        if (callbackPathOwned) {
-            try {
-                await new Promise((resolve, reject) => this.#server.close((error) => error === undefined ? resolve() : reject(error)));
-            }
-            catch (error) {
-                errors.push(error);
-            }
-            try {
-                const stat = await lstat(this.#socketPath);
-                if (stat.isSocket() &&
-                    sameSocketGeneration({ dev: stat.dev, ino: stat.ino }, this.#socketGeneration)) {
+                await closeServer(this.#server);
+                if (await socketOwnership(this.#socketPath, this.#socketGeneration) ===
+                    "owned") {
                     await unlink(this.#socketPath);
                 }
             }
-            catch (error) {
-                if (error.code !== "ENOENT") {
-                    errors.push(error);
-                }
-            }
+        }
+        catch (error) {
+            this.#server.unref();
+            errors.push(error);
         }
         this.#closing = false;
         this.#closed = true;
         try {
-            this.#onClosed();
+            this.#context.onClosed();
         }
         catch (error) {
             errors.push(error);