@fitchmultz/pi-subagents 0.49.0 → 0.50.0

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

@@ -5,8 +5,6 @@ import { resolveSessionProjectId } from "./session-targets.js";
 import { Fault, cancelled, log, wait } from "./bridge-protocol.js";
 import { Mailbox } from "./bridge-mailbox.js";
 import { resolveBridgeTarget, bridgeSessionList } from "./bridge-target.js";
-import { ControlReplies } from "./bridge-control.js";
-import { WaitingAsk } from "./bridge-ask.js";
 const MAX_REQUESTS = 8;
 const IDLE_TIMEOUT = 5 * 60 * 1000;
 const SEND_TIMEOUT = 8000;
@@ -23,9 +21,6 @@ export class Session {
     requests = new Set();
     inbox;
     inboxChanged = new AbortController();
-    replying = new Set();
-    pending;
-    controls = new ControlReplies();
     closed = false;
     connecting;
     disconnecting;
@@ -46,7 +41,6 @@ export class Session {
             }
         });
         this.client.on("message", (from, message) => this.receive(from, message));
-        this.client.on("session_left", (id) => this.peerLeft(id));
         this.touch();
     }
     guard(signal) {
@@ -156,8 +150,6 @@ export class Session {
         this.closed = true;
         this.closeReason = fault;
         clearTimeout(this.lease);
-        this.pending?.reject(fault);
-        this.controls.close(fault);
         for (const controller of this.requests) {
             controller.abort(fault);
         }
@@ -167,13 +159,6 @@ export class Session {
     async settled() {
         await this.retirement;
     }
-    peerLeft(id) {
-        this.controls.peerLeft(id);
-        if (this.pending?.peer === id && !this.pending.settled) {
-            this.pending.reject(new Fault(409, "peer_offline", "Ask recipient disconnected.", { id: this.pending.id }));
-        }
-        this.presence();
-    }
     receive(from, message) {
         if (this.closed) {
             return;
@@ -187,12 +172,6 @@ export class Session {
                 : new Fault(403, "revoked", "Identity is no longer authorized."));
             return;
         }
-        if (this.controls.receive(from.id, message)) {
-            return;
-        }
-        if (!this.inbox.persistent && this.resolveReply(from, message)) {
-            return;
-        }
         this.storeReceive(from, message);
     }
     storeReceive(from, message) {
@@ -225,19 +204,10 @@ export class Session {
             result: result === "lost" && this.inbox.persistent ? "storage_failed" : result,
         });
         if (result !== "lost") {
-            this.resolveReply(from, message);
             this.owner.mailboxChanged?.();
         }
         this.presence();
     }
-    resolveReply(from, message) {
-        const pending = this.pending;
-        if (pending?.matches(from.id, message.replyTo) !== true) {
-            return false;
-        }
-        pending.resolve({ from, message });
-        return true;
-    }
     presence() {
         if (this.closed) {
             return;
@@ -264,11 +234,6 @@ export class Session {
         await this.connect(signal);
         return this.peers(signal);
     }
-    async nativeControl(operation, certificate, context) {
-        await this.connect(context.signal);
-        const peer = await this.target(operation.to, context.signal);
-        return this.controls.request(this.client, { ...operation, peer: peer.id, certificate }, { ...context, guard: () => this.guard(context.signal) });
-    }
     async target(to, signal) {
         return resolveBridgeTarget(await this.peers(signal), to, this.client.sessionId);
     }
@@ -306,32 +271,6 @@ export class Session {
         }
         return result;
     }
-    async ask(operation, context) {
-        if (this.pending) {
-            throw new Fault(409, "ask_in_progress", "Only one concurrent ask is allowed per identity.");
-        }
-        const waiting = new WaitingAsk();
-        this.pending = waiting;
-        const { signal } = context;
-        try {
-            await this.connect(signal);
-            const peer = await this.target(operation.to, signal);
-            this.guard(signal);
-            waiting.peer = peer.id;
-            waiting.deadline(operation.timeoutMs, (error) => this.close(error));
-            waiting.receipt = await this.send(peer.id, operation.message, context, {
-                messageId: waiting.id,
-                expectsReply: true,
-            });
-            const answer = await wait(waiting.reply, signal);
-            this.guard(signal);
-            return { ...waiting.receipt, replied: true, reply: answer };
-        }
-        finally {
-            waiting.clear();
-            this.pending = undefined;
-        }
-    }
     async readInbox(operation, context) {
         const read = () => ({
             ...this.inbox.page(operation.after, operation.limit),
@@ -361,41 +300,8 @@ export class Session {
             this.guard(context.signal);
         }
     }
-    async answer(replyTo, message, context) {
-        const entry = this.inbox.get(replyTo);
-        if (entry?.message.expectsReply !== true) {
-            throw new Fault(404, "unknown_ask", "replyTo must identify an unanswered inbound ask.");
-        }
-        if (this.replying.has(replyTo)) {
-            throw new Fault(409, "reply_in_progress", "This ask already has a reply in flight.");
-        }
-        this.replying.add(replyTo);
-        const peer = entry.from.id;
-        context.onPeer(peer);
-        try {
-            const peers = await this.peers(context.signal);
-            if (!peers.some((candidate) => candidate.id === peer)) {
-                throw new Fault(409, "peer_offline", "Original ask sender is disconnected.");
-            }
-            this.guard(context.signal);
-            if (!this.inbox.get(replyTo)) {
-                throw new Fault(409, "ask_retired", "Inbound ask is no longer replyable.");
-            }
-            const data = { ...(await this.send(peer, message, context, { replyTo })) };
-            this.inbox.remove(replyTo);
-            this.owner.mailboxChanged?.();
-            this.presence();
-            return data;
-        }
-        finally {
-            this.replying.delete(replyTo);
-        }
-    }
     async execute(operation, context) {
         this.guard(context.signal);
-        if (operation.route === "POST /v1/ask") {
-            return this.ask(operation, context);
-        }
         if (operation.route === "GET /v1/inbox" || operation.route === "POST /v1/ack") {
             // Durable reads/acks remain available while the local broker is down.
             if (!this.inbox.persistent) {
@@ -422,12 +328,12 @@ export class Session {
                 const peer = await this.target(operation.to, context.signal);
                 const receipt = await this.send(peer.id, operation.message, context, {
                     messageId: operation.messageId,
+                    replyTo: operation.replyTo,
+                    expectsReply: operation.expectsReply,
                     delivery: operation.passive === true ? "passive" : "steer",
                 });
                 return { ...receipt };
             }
-            case "POST /v1/reply":
-                return this.answer(operation.replyTo, operation.message, context);
         }
     }
 }

package/dist/pi-intercom/bridge.js

@@ -4,24 +4,14 @@ import { TLSSocket } from "node:tls";
 import { randomUUID } from "node:crypto";
 import { getBrokerSocketPath } from "./broker/paths.js";
 import { loadConfig, sameListener } from "./bridge-config.js";
-import { ASK_TIMEOUT, Fault, fingerprint, log } from "./bridge-protocol.js";
+import { Fault, fingerprint, log } from "./bridge-protocol.js";
 import { Session } from "./bridge-session.js";
 import { operationFor, routeFor } from "./bridge-routes.js";
 import { reply, replyFault } from "./bridge-http.js";
-import { sameIdentity } from "./bridge-launch.js";
-import { BridgeOperations } from "./bridge-operations.js";
-import { authenticatedCertificateChain } from "./native-control-auth.js";
 import { PersistentPresence } from "./bridge-presence.js";
 import { WakeDeliveries } from "./bridge-wake.js";
 import { spawnBrokerIfNeeded } from "./broker/spawn.js";
 const MAX_CONNECTIONS = 128;
-const LONG_ROUTES = new Set([
-    "POST /v1/start",
-    "POST /v1/spawn",
-    "POST /v1/resume",
-    "GET /v1/transcript",
-    "POST /v1/transcript",
-]);
 function validCertificateDates(starts, expires) {
     return (Number.isFinite(starts) &&
         Number.isFinite(expires) &&
@@ -33,7 +23,6 @@ class Bridge {
     configPath;
     sessions = new Map();
     losses = new Map();
-    operations;
     sockets = new Set();
     connections = new Map();
     server;
@@ -44,7 +33,6 @@ class Bridge {
     constructor(config, configPath) {
         this.config = config;
         this.configPath = configPath;
-        this.operations = new BridgeOperations(config.stateDir);
         this.deliveries = new WakeDeliveries(config.stateDir, (identity) => this.allowed(identity));
         if (config.stateDir !== undefined) {
             this.presence = new PersistentPresence({
@@ -118,8 +106,9 @@ class Bridge {
     allowed(identity) {
         const current = this.config.clients.get(identity.fingerprint256);
         return (!this.stopping &&
-            sameIdentity(identity, current) &&
-            JSON.stringify(identity.wake) === JSON.stringify(current?.wake));
+            current?.name === identity.name &&
+            current.cwd === identity.cwd &&
+            JSON.stringify(identity.wake) === JSON.stringify(current.wake));
     }
     lost(fp, count = 1) {
         if (count > 0 && this.config.clients.has(fp)) {
@@ -233,15 +222,11 @@ class Bridge {
             }
             this.config = next;
             this.revokeRemoved();
-            this.operations.revoke(next.clients).catch(() => log("launch_cleanup", { result: "failed" }));
             log("allowlist_reloaded", { result: "accepted", clients: next.clients.size });
         }
         catch {
             this.config = { ...this.config, clients: new Map() };
             this.deliveries.reload();
-            this.operations
-                .revoke(this.config.clients)
-                .catch(() => log("launch_cleanup", { result: "failed" }));
             for (const session of this.sessions.values()) {
                 session.close(new Fault(503, "configuration_invalid", "Configuration reload failed; all identities denied."));
             }
@@ -295,7 +280,6 @@ class Bridge {
         await Promise.all([
             ...this.handlers,
             ...sessions.map((session) => session.settled()),
-            this.operations.shutdown(),
             this.presence?.stop(),
             this.deliveries.stop(),
         ]);
@@ -320,7 +304,6 @@ class Bridge {
         return {
             identity,
             expires: connection.expires,
-            certificate: authenticatedCertificateChain(socket),
         };
     }
     async handle(req, res) {
@@ -343,7 +326,7 @@ class Bridge {
             deadline = setTimeout(() => cancel(new Fault(504, "request_timeout", "HTTP operation deadline exceeded; delivery may be unknown.")), Math.max(1, ms - (Date.now() - started)));
         };
         try {
-            const { identity, expires, certificate } = this.admission(req);
+            const { identity, expires } = this.admission(req);
             const route = routeFor(req);
             readOnlyInbox = route === "GET /v1/inbox";
             session = this.session(identity, expires);
@@ -351,20 +334,11 @@ class Bridge {
             const signal = controller.signal;
             req.once("aborted", abort);
             res.once("close", onClose);
-            const duration = route === "POST /v1/ask" ? ASK_TIMEOUT + 15000 : 15000;
-            setDeadline(LONG_ROUTES.has(route) ? 75000 : duration);
+            setDeadline(15000);
             const operation = await operationFor(req, route, signal);
-            if (operation.route === "POST /v1/ask") {
-                setDeadline(operation.timeoutMs + 15000);
-            }
-            else if (operation.route === "GET /v1/transcript") {
-                setDeadline(75000);
-            }
-            const data = await this.operations.execute(operation, session, {
+            const data = await session.execute(operation, {
                 signal,
                 requestId,
-                expires,
-                certificate,
                 onPeer: (id) => {
                     peer = id;
                 },
@@ -405,8 +379,11 @@ function main() {
         const path = resolve(args[1]);
         new Bridge(loadConfig(path), path).start();
     }
-    catch {
-        process.stderr.write("Bridge startup failed: check config schema, file ownership/mode 0600, absolute TLS/cwd paths, TLS credentials, stateDir (owned 0700 directory), and launch policy (0700 sessionDir, Pi packageRoot, extension paths).\n");
+    catch (error) {
+        if (error instanceof Fault) {
+            process.stderr.write(`${error.message}\n`);
+        }
+        process.stderr.write("Bridge startup failed: check config schema, file ownership/mode 0600, absolute TLS/cwd paths, TLS credentials, and stateDir (owned 0700 directory).\n");
         process.exitCode = 1;
     }
 }

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

@@ -1,25 +1,27 @@
 import net from "net";
-import { chmodSync, writeFileSync, unlinkSync, mkdirSync } from "fs";
+import { chmodSync, writeFileSync, unlinkSync } from "fs";
 import { join } from "path";
 import { randomUUID } from "crypto";
-import { getPiAgentDir } from "../agent-dir.js";
-import { writeMessage, createMessageReader, validateIntercomMessageSize } from "./framing.js";
-import { prepareBrokerSocketPath } from "./paths.js";
+import { writeMessage, validateIntercomMessageSize } from "./framing.js";
+import { getBrokerRuntimeDir, prepareBrokerSocketPath } from "./paths.js";
 import { brokerPidRecord } from "./pid.js";
+import { assertBrokerCanStart } from "./spawn.js";
+import { LastMessageRelay } from "./last.js";
+import { assertMainParent, canSeeSession, findSessions } from "./targets.js";
+import { acceptBrokerConnection } from "./server-connection.js";
 import { compactTopicMessage, isSessionRegistration, normalizeMessage, normalizeSessionInfo, } from "../types.js";
 import { errorMessage, isRecord } from "../../shared/unknown.js";
 import { messageSender, snapshotFrames, TopicSnapshot, publicationMessage, deliveryAcknowledgement, shouldReplaceDelivery, } from "./snapshots.js";
-const INTERCOM_DIR = join(getPiAgentDir(), "intercom");
-const PID_PATH = join(INTERCOM_DIR, "broker.pid");
+const PID_PATH = join(getBrokerRuntimeDir(), "broker.pid");
 const REPLACE_DELIVERY_DELAY_MS = 1500;
 class IntercomBroker {
     sessions = new Map();
+    lastMessages = new LastMessageRelay(this.sessions);
     pendingReplaceDeliveries = new Map();
     server;
     shutdownTimer = null;
     socketPath;
     constructor() {
-        mkdirSync(INTERCOM_DIR, { recursive: true });
         this.socketPath = prepareBrokerSocketPath();
         try {
             unlinkSync(this.socketPath);
@@ -45,23 +47,7 @@ class IntercomBroker {
         process.on("SIGINT", () => this.shutdown());
     }
     handleConnection(socket) {
-        let sessionId = null;
-        const reader = createMessageReader((msg) => {
-            this.handleMessage(socket, msg, sessionId, (id) => {
-                sessionId = id;
-            });
-        }, (error) => {
-            socket.destroy(error);
-        });
-        socket.on("data", reader);
-        socket.on("close", () => {
-            if (sessionId !== null) {
-                this.removeSession(sessionId);
-            }
-        });
-        socket.on("error", (error) => {
-            console.error("Socket error:", error);
-        });
+        acceptBrokerConnection(socket, this.handleMessage.bind(this), this.removeSession.bind(this));
     }
     scheduleShutdownCheck() {
         if (this.shutdownTimer) {
@@ -106,6 +92,12 @@ class IntercomBroker {
             case "send":
                 this.send(socket, msg, currentId);
                 break;
+            case "last_request":
+                this.lastMessages.request(currentId, msg);
+                break;
+            case "last_response":
+                this.lastMessages.respond(currentId, msg);
+                break;
             case "presence":
                 this.presence(msg, currentId);
                 break;
@@ -117,6 +109,7 @@ class IntercomBroker {
         if (!isSessionRegistration(msg.session)) {
             throw new Error("Invalid register message");
         }
+        assertMainParent(msg.session, this.sessions);
         const requestedId = typeof msg.requestedId === "string" && /^[a-zA-Z0-9_-]{8,80}$/.test(msg.requestedId)
             ? msg.requestedId
             : undefined;
@@ -129,6 +122,7 @@ class IntercomBroker {
             info: messageSender(info),
             topics: new TopicSnapshot(info),
             topicFrames,
+            lastMessages: msg.lastMessages === true,
         });
         setId(id);
         if (this.shutdownTimer) {
@@ -138,13 +132,19 @@ class IntercomBroker {
         writeMessage(socket, {
             type: "registered",
             sessionId: id,
+            lastMessages: true,
             ...(topicFrames ? { topicsSupported: true, topicFrames: true } : {}),
         });
     }
     removeSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return;
+        }
         this.sessions.delete(sessionId);
+        this.lastMessages.disconnected(sessionId);
         this.clearPendingReplaceDeliveries(sessionId);
-        this.broadcast({ type: "session_left", sessionId }, sessionId);
+        this.broadcast({ type: "session_left", sessionId }, session.info);
         this.scheduleShutdownCheck();
     }
     planPublications(fromId, from, publication) {
@@ -154,7 +154,7 @@ class IntercomBroker {
         }
         for (const target of this.sessions.values()) {
             const subscription = target.topics.subscription(publication.topic);
-            if (target.info.id === fromId || !subscription) {
+            if (target.info.id === fromId || !subscription || !canSeeSession(from, target.info)) {
                 continue;
             }
             const message = publicationMessage(publication, subscription.awaitRelease === true);
@@ -188,7 +188,9 @@ class IntercomBroker {
             }
             const infos = prepared.restore
                 ? []
-                : [...this.sessions.values()].map((entry) => {
+                : [...this.sessions.values()]
+                    .filter((entry) => canSeeSession(from, entry.info))
+                    .map((entry) => {
                     if (entry === session) {
                         return nextInfo;
                     }
@@ -235,7 +237,7 @@ class IntercomBroker {
             });
             return;
         }
-        const targets = this.findSessions(msg.to);
+        const targets = findSessions(this.sessions, msg.to, currentId);
         const target = targets[0];
         if (targets.length === 1) {
             const fromSession = this.sessions.get(currentId);
@@ -395,17 +397,9 @@ class IntercomBroker {
             return error instanceof Error ? error.message : errorMessage(error);
         }
     }
-    findSessions(nameOrId) {
-        const byId = this.sessions.get(nameOrId);
-        if (byId) {
-            return [byId];
-        }
-        const lowerName = nameOrId.toLowerCase();
-        return Array.from(this.sessions.values()).filter((session) => session.info.name?.toLowerCase() === lowerName);
-    }
-    broadcast(msg, exclude) {
+    broadcast(msg, from) {
         for (const [id, session] of this.sessions) {
-            if (id !== exclude) {
+            if (id !== from.id && canSeeSession(session.info, from)) {
                 writeMessage(session.socket, msg);
             }
         }
@@ -432,4 +426,5 @@ class IntercomBroker {
         process.exit(0);
     }
 }
+await assertBrokerCanStart();
 new IntercomBroker().start();

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

@@ -0,0 +1,48 @@
+import { randomUUID } from "node:crypto";
+import { errorMessage } from "../../shared/unknown.js";
+import { isLastMessageQuery, isLastMessageResult } from "./last.js";
+import { writeMessage } from "./framing.js";
+export class LastMessageRequests {
+    pending = new Map();
+    fail(error) {
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+    receive(message) {
+        if (typeof message.requestId !== "string" || !isLastMessageResult(message.result)) {
+            throw new Error("Invalid last-message response");
+        }
+        const pending = this.pending.get(message.requestId);
+        if (!pending) {
+            return;
+        }
+        clearTimeout(pending.timer);
+        this.pending.delete(message.requestId);
+        pending.resolve(message.result);
+    }
+    request(socket, to, query, timeoutMs) {
+        if (!isLastMessageQuery(query)) {
+            return Promise.reject(new Error("Invalid last-message query"));
+        }
+        return new Promise((resolve, reject) => {
+            const requestId = randomUUID();
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error("Last-message read timeout"));
+            }, timeoutMs);
+            timer.unref();
+            this.pending.set(requestId, { resolve, reject, timer });
+            try {
+                writeMessage(socket, { type: "last_request", requestId, to, query });
+            }
+            catch (error) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error(errorMessage(error)));
+            }
+        });
+    }
+}

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

@@ -3,6 +3,8 @@ import { randomUUID } from "crypto";
 import { writeMessage } from "./framing.js";
 import { BrokerConnection, connectBrokerSocket } from "./connection.js";
 import { SnapshotReader } from "./snapshot-reader.js";
+import { LastMessageRequests } from "./client-last.js";
+import { isLastMessageQuery, isLastMessageResult } from "./last.js";
 import { errorMessage, isRecord, isUnknownArray, } from "../../shared/unknown.js";
 import { compactTopicMessage, normalizeMessage, normalizeSessionInfo, } from "../types.js";
 /** Default delivery-ack timeout for `send` (broker acknowledges quickly). */
@@ -28,6 +30,8 @@ export class IntercomClient extends EventEmitter {
     connection = null;
     _sessionId = null;
     _topicsSupported = false;
+    lastMessagesSupported = false;
+    lastRequests = new LastMessageRequests();
     pendingSends = new Map();
     pendingLists = new Map();
     connecting = false;
@@ -40,6 +44,7 @@ export class IntercomClient extends EventEmitter {
         this.listTimeoutMs = options.listTimeoutMs ?? DEFAULT_LIST_TIMEOUT_MS;
     }
     failPending(error) {
+        this.lastRequests.fail(error);
         for (const pending of this.pendingSends.values()) {
             pending.reject(error);
         }
@@ -93,6 +98,7 @@ export class IntercomClient extends EventEmitter {
                     this.connection = null;
                     this._sessionId = null;
                     this._topicsSupported = false;
+                    this.lastMessagesSupported = false;
                     this.disconnecting = false;
                     this.failPending(error);
                     if (established && !expected) {
@@ -108,6 +114,7 @@ export class IntercomClient extends EventEmitter {
                     session: identity,
                     requestedId,
                     topicFrames: true,
+                    lastMessages: true,
                 });
             }
             catch (error) {
@@ -152,6 +159,12 @@ export class IntercomClient extends EventEmitter {
             case "sessions":
                 this.receiveSessions(brokerMessage);
                 break;
+            case "last_request":
+                this.receiveLastRequest(brokerMessage);
+                break;
+            case "last_response":
+                this.lastRequests.receive(brokerMessage);
+                break;
             case "message":
                 this.receiveMessage(brokerMessage);
                 break;
@@ -179,9 +192,19 @@ export class IntercomClient extends EventEmitter {
         }
         this._sessionId = msg.sessionId;
         this._topicsSupported = msg.topicsSupported === true && msg.topicFrames === true;
+        this.lastMessagesSupported = msg.lastMessages === true;
         this.connection?.confirmRegistration();
         this.emit("_registered", { type: "registered", sessionId: msg.sessionId });
     }
+    receiveLastRequest(msg) {
+        const from = normalizeSessionInfo(msg.from);
+        if (typeof msg.requestId !== "string" || !from || !isLastMessageQuery(msg.query)) {
+            throw new Error("Invalid last-message request");
+        }
+        if (!this.emit("last_request", { requestId: msg.requestId, from, query: msg.query })) {
+            this.respondLast(msg.requestId, { error: "Recipient has no last-message reader." });
+        }
+    }
     receiveMessage(msg) {
         const message = normalizeMessage(msg.message);
         const from = normalizeSessionInfo(msg.from);
@@ -246,6 +269,24 @@ export class IntercomClient extends EventEmitter {
     listSessions() {
         return this.requestSessions().then((snapshot) => [...snapshot.sessions]);
     }
+    last(to, query = {}) {
+        try {
+            const socket = this.requireActiveSocket();
+            if (!this.lastMessagesSupported) {
+                throw new Error("This broker does not support last-message reads; reload after it exits.");
+            }
+            return this.lastRequests.request(socket, to, query, this.listTimeoutMs);
+        }
+        catch (error) {
+            return Promise.reject(toError(error));
+        }
+    }
+    respondLast(requestId, result) {
+        if (!isLastMessageResult(result)) {
+            throw new Error("Invalid last-message result");
+        }
+        writeMessage(this.requireActiveSocket(), { type: "last_response", requestId, result });
+    }
     updateTopics(change, onAccepted) {
         if (!this.supportsTopics) {
             return Promise.reject(new Error("This broker does not support topic snapshots."));
@@ -320,7 +361,6 @@ export class IntercomClient extends EventEmitter {
             expectsReply: options.expectsReply,
             ...(options.human ? { human: options.human } : {}),
             ...(options.topic ? { topic: options.topic } : {}),
-            ...(options.control ? { control: options.control } : {}),
             delivery: messageDelivery(options),
             queueMode: options.queueMode,
             threadId: options.threadId,

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

@@ -1,6 +1,6 @@
 import net from "node:net";
 import { errorMessage } from "../../shared/unknown.js";
-import { getBrokerSocketPath, getLegacyBrokerSocketPath, isOwnedBrokerSocket } from "./paths.js";
+import { getBrokerSocketPath, isOwnedBrokerSocket } from "./paths.js";
 import { createMessageReader, writeMessage } from "./framing.js";
 function connectSocket(socketPath, timeoutMs = 500) {
     return new Promise((resolve, reject) => {
@@ -26,24 +26,11 @@ function connectSocket(socketPath, timeoutMs = 500) {
     });
 }
 export async function connectBrokerSocket() {
-    const preferred = getBrokerSocketPath();
-    const legacy = getLegacyBrokerSocketPath();
-    const candidates = [preferred, ...(legacy !== preferred ? [legacy] : [])];
-    let lastError;
-    for (const candidate of candidates) {
-        if (!isOwnedBrokerSocket(candidate)) {
-            continue;
-        }
-        try {
-            // Preferred and legacy sockets must be tried in order, never connected concurrently.
-            // oxlint-disable-next-line no-await-in-loop
-            return await connectSocket(candidate);
-        }
-        catch (error) {
-            lastError = error instanceof Error ? error : new Error(errorMessage(error));
-        }
+    const socketPath = getBrokerSocketPath();
+    if (!isOwnedBrokerSocket(socketPath)) {
+        throw new Error(`Intercom broker socket is unavailable: ${socketPath}`);
     }
-    throw lastError ?? new Error(`Intercom broker socket is unavailable: ${preferred}`);
+    return await connectSocket(socketPath);
 }
 /** One socket owns registration, read/error listeners, and graceful shutdown. */
 export class BrokerConnection {