@fitchmultz/pi-subagents 0.51.0 → 0.52.1

package/src/pi-intercom/broker/client-last.ts

@@ -6,12 +6,42 @@ import {
   isNativeReadResult,
   isLastMessageResult,
   isReceiptResult,
+  type NativeReadQuery,
   type NativeReadResult,
 } from "./last.ts";
-import type { LastMessageQuery, LastMessageResult, ReceiptQuery, ReceiptResult } from "../types.ts";
+import {
+  normalizeSessionInfo,
+  type LastMessageQuery,
+  type LastMessageResult,
+  type ReceiptQuery,
+  type ReceiptResult,
+  type SessionInfo,
+} from "../types.ts";
 import { writeMessage } from "./framing.ts";
 
+/** A peer's read of this session or, for a main, of its exited `parked` child. */
+export function lastRequest(msg: UnknownRecord): {
+  readonly requestId: string;
+  readonly from: SessionInfo;
+  readonly query: NativeReadQuery;
+  readonly parked?: SessionInfo;
+} {
+  const from = normalizeSessionInfo(msg.from);
+  if (typeof msg.requestId !== "string" || !from || !isNativeReadQuery(msg.query)) {
+    throw new Error("Invalid last-message request");
+  }
+  return {
+    requestId: msg.requestId,
+    from,
+    query: msg.query,
+    parked: normalizeSessionInfo(msg.parked) ?? undefined,
+  };
+}
+
 export class LastMessageRequests {
+  /** Negotiated at registration; a failed connection supports neither. */
+  lastMessages = false;
+  receiptReads = false;
   private readonly timeoutMs: number;
   constructor(timeoutMs: number) {
     this.timeoutMs = timeoutMs;
@@ -26,6 +56,8 @@ export class LastMessageRequests {
   >();
 
   fail(error: Readonly<Error>): void {
+    this.lastMessages = false;
+    this.receiptReads = false;
     for (const pending of this.pending.values()) {
       clearTimeout(pending.timer);
       pending.reject(error);
@@ -55,9 +87,17 @@ export class LastMessageRequests {
     return isReceiptResult(result) ? result : { error: "Invalid receipt response" };
   }
   private request(socket: net.Socket, to: string, query: unknown): Promise<NativeReadResult> {
+    if (!this.lastMessages) {
+      return Promise.reject(
+        new Error("This broker does not support last-message reads; reload after it exits."),
+      );
+    }
     if (!isNativeReadQuery(query)) {
       return Promise.reject(new Error("Invalid last-message query"));
     }
+    if ("messageId" in query && !this.receiptReads) {
+      return Promise.reject(new Error("publication_unavailable"));
+    }
     return new Promise((resolve, reject) => {
       const requestId = randomUUID();
       const timer = setTimeout(() => {

package/src/pi-intercom/broker/client-park.ts

@@ -0,0 +1,23 @@
+import type net from "node:net";
+import { writeMessage } from "./framing.ts";
+
+/** Parking negotiation and its single outstanding broker acknowledgement. */
+export class ParkRequests {
+  supported = false;
+  private acknowledged?: (parked: boolean) => void;
+  settle(parked: boolean): void {
+    this.acknowledged?.(parked);
+  }
+  /** True once the broker retains later input; false when it cannot or the socket closed. */
+  request(socket: () => net.Socket, on: boolean): Promise<boolean> {
+    return new Promise((resolve) => {
+      this.acknowledged = on && this.supported ? resolve : undefined;
+      if (this.supported) {
+        writeMessage(socket(), { type: on ? "park" : "unpark" });
+      }
+      if (this.acknowledged === undefined) {
+        resolve(false);
+      }
+    });
+  }
+}

package/src/pi-intercom/broker/client.ts

@@ -4,8 +4,9 @@ import { randomUUID } from "crypto";
 import { writeMessage } from "./framing.ts";
 import { BrokerConnection, connectBrokerSocket } from "./connection.ts";
 import { SnapshotReader } from "./snapshot-reader.ts";
-import { LastMessageRequests } from "./client-last.ts";
-import { isNativeReadQuery, isNativeReadResult, type NativeReadQuery } from "./last.ts";
+import { LastMessageRequests, lastRequest } from "./client-last.ts";
+import { ParkRequests } from "./client-park.ts";
+import { isNativeReadResult } from "./last.ts";
 import {
   errorMessage,
   isRecord,
@@ -64,8 +65,7 @@ export class IntercomClient extends EventEmitter {
   private connection: BrokerConnection | null = null;
   private _sessionId: string | null = null;
   private _topicsSupported = false;
-  private lastMessagesSupported = false;
-  private receiptReadsSupported = false;
+  private readonly parking = new ParkRequests();
   private guardedDeliverySupported = false;
   private readonly lastRequests: LastMessageRequests;
   private readonly pendingSends = new Map<
@@ -156,8 +156,7 @@ export class IntercomClient extends EventEmitter {
           this.connection = null;
           this._sessionId = null;
           this._topicsSupported = false;
-          this.lastMessagesSupported = false;
-          this.receiptReadsSupported = false;
+          this.parking.settle(false);
           this.guardedDeliverySupported = false;
           this.disconnecting = false;
           this.failPending(error);
@@ -175,6 +174,7 @@ export class IntercomClient extends EventEmitter {
           requestedId,
           topicFrames: true,
           lastMessages: true,
+          parking: true,
           receiptReads: 1,
           guardedDelivery: 1,
         });
@@ -241,11 +241,15 @@ export class IntercomClient extends EventEmitter {
       case "delivery_failed":
         this.receiveDelivery(brokerMessage);
         break;
+      case "parked":
+        this.parking.settle(true);
+        break;
+      case "wake":
       case "session_left":
         if (typeof brokerMessage.sessionId !== "string") {
-          throw new Error("Invalid session_left message");
+          throw new Error(`Invalid ${type} message`);
         }
-        this.emit("session_left", brokerMessage.sessionId);
+        this.emit(type, brokerMessage.sessionId);
         break;
       default:
         throw new Error(`Unknown broker message type: ${type}`);
@@ -261,20 +265,18 @@ export class IntercomClient extends EventEmitter {
     }
     this._sessionId = msg.sessionId;
     this._topicsSupported = msg.topicsSupported === true && msg.topicFrames === true;
-    this.lastMessagesSupported = msg.lastMessages === true;
-    this.receiptReadsSupported = msg.receiptReads === 1;
+    this.lastRequests.lastMessages = msg.lastMessages === true;
+    this.parking.supported = msg.parking === true;
+    this.lastRequests.receiptReads = msg.receiptReads === 1;
     this.guardedDeliverySupported = msg.guardedDelivery === 1;
     this.connection?.confirmRegistration();
     this.emit("_registered", { type: "registered", sessionId: msg.sessionId });
   }
 
   private receiveLastRequest(msg: UnknownRecord): void {
-    const from = normalizeSessionInfo(msg.from);
-    if (typeof msg.requestId !== "string" || !from || !isNativeReadQuery(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." });
+    const request = lastRequest(msg);
+    if (!this.emit("last_request", request)) {
+      this.respondLast(request.requestId, { error: "Recipient has no last-message reader." });
     }
   }
 
@@ -335,6 +337,10 @@ export class IntercomClient extends EventEmitter {
     }
   }
 
+  park(on = true): Promise<boolean> {
+    return this.parking.request(() => this.requireActiveSocket(), on);
+  }
+
   async disconnect(): Promise<void> {
     const connection = this.connection;
     if (!connection) {
@@ -350,20 +356,10 @@ export class IntercomClient extends EventEmitter {
   }
 
   async last(to: string, query: LastMessageQuery = {}): Promise<LastMessageResult> {
-    return await this.lastRequests.last(this.readSocket(query), to, query);
+    return await this.lastRequests.last(this.requireActiveSocket(), to, query);
   }
   async receipt(to: string, query: ReceiptQuery): Promise<ReceiptResult> {
-    return await this.lastRequests.receipt(this.readSocket(query), to, query);
-  }
-  private readSocket(query: NativeReadQuery): net.Socket {
-    const socket = this.requireActiveSocket();
-    if (!this.lastMessagesSupported) {
-      throw new Error("This broker does not support last-message reads; reload after it exits.");
-    }
-    if ("messageId" in query && !this.receiptReadsSupported) {
-      throw new Error("publication_unavailable");
-    }
-    return socket;
+    return await this.lastRequests.receipt(this.requireActiveSocket(), to, query);
   }
 
   respondLast(requestId: string, result: unknown): void {

package/src/pi-intercom/broker/last.ts

@@ -100,19 +100,37 @@ interface LastPeer {
   readonly info: SessionInfo;
   readonly lastMessages: boolean;
   readonly receiptReads: boolean;
+  readonly parked?: { readonly closed: boolean };
 }
 interface PendingLast {
   readonly fromId: string;
   readonly toId: string;
+  /** A parked child's main answers from the child's captured native history. */
+  readonly via?: string;
   readonly requestId: string;
   readonly query: NativeReadQuery;
   readonly timer: NodeJS.Timeout;
 }
+/** An exited parked child answers nothing itself; only its main holds the captured history. */
+function exitedRefusal(
+  target: LastPeer,
+  query: NativeReadQuery,
+  via?: LastPeer,
+): string | undefined {
+  if (target.parked?.closed !== true) {
+    return undefined;
+  }
+  // No loaded journal owner answers receipts, with or without its main.
+  if ("messageId" in query) {
+    return "publication_unavailable";
+  }
+  return via === undefined ? "Parked session history is unavailable." : undefined;
+}
 function unavailable(
   targets: readonly LastPeer[],
   name: string,
   pending: number,
-  query: NativeReadQuery,
+  { query, via }: { readonly query: NativeReadQuery; readonly via?: LastPeer },
 ): string | undefined {
   if (targets.length === 0) {
     return "Session not found";
@@ -120,6 +138,10 @@ function unavailable(
   if (targets.length > 1) {
     return `Multiple sessions named "${name}" are connected. Use the session ID instead.`;
   }
+  const exited = exitedRefusal(targets[0], query, via);
+  if (exited !== undefined) {
+    return exited;
+  }
   if (!targets[0].lastMessages) {
     return "Recipient does not support last-message reads; reload its extension.";
   }
@@ -164,6 +186,17 @@ function matchesLastPage(
   );
 }
 
+function lastRequest(message: UnknownRecord): {
+  readonly requestId: string;
+  readonly to: string;
+  readonly query: NativeReadQuery;
+} {
+  const { requestId, to, query } = message;
+  if (typeof requestId !== "string" || typeof to !== "string" || !isNativeReadQuery(query)) {
+    throw new Error("Invalid last message request");
+  }
+  return { requestId, to, query };
+}
 /** Correlation belongs to the broker, not the requester or the recipient's model queue. */
 export class LastMessageRelay {
   private readonly pending = new Map<string, PendingLast>();
@@ -172,14 +205,13 @@ export class LastMessageRelay {
     this.sessions = sessions;
   }
 
-  request(fromId: string, message: UnknownRecord): void {
-    if (
-      typeof message.requestId !== "string" ||
-      typeof message.to !== "string" ||
-      !isNativeReadQuery(message.query)
-    ) {
-      throw new Error("Invalid last message request");
-    }
+  /** `reader` names another peer that answers for an exited target from its captured history. */
+  request(
+    fromId: string,
+    input: UnknownRecord,
+    reader: (id: string) => LastPeer | undefined,
+  ): void {
+    const message = lastRequest(input);
     const targets = findSessions(this.sessions, message.to, fromId);
     const target = targets[0];
     const from = this.sessions.get(fromId);
@@ -187,14 +219,16 @@ export class LastMessageRelay {
       return;
     }
     const token = randomUUID();
+    const via = targets.length === 1 ? reader(target.info.id) : undefined;
     const frame = {
       type: "last_request" as const,
       requestId: token,
       from: messageSender(from.info),
       query: message.query,
+      parked: via && messageSender(target.info),
     };
     const error =
-      unavailable(targets, message.to, this.pending.size, message.query) ??
+      unavailable(targets, message.to, this.pending.size, { query: message.query, via }) ??
       validateIntercomMessageSize(frame)?.message;
     if (error !== undefined) {
       writeMessage(from.socket, {
@@ -212,12 +246,13 @@ export class LastMessageRelay {
     this.pending.set(token, {
       fromId,
       toId: target.info.id,
+      via: via?.info.id,
       requestId: message.requestId,
       query: message.query,
       timer,
     });
     try {
-      writeMessage(target.socket, frame);
+      writeMessage((via ?? target).socket, frame);
     } catch {
       this.finish(token, { error: "Recipient disconnected before last-message read" });
     }
@@ -228,13 +263,13 @@ export class LastMessageRelay {
       throw new Error("Invalid last message response");
     }
     const pending = this.pending.get(message.requestId);
-    if (!pending || pending.toId !== fromId) {
+    if (!pending || (pending.via ?? pending.toId) !== fromId) {
       return;
     }
     const result = message.result;
     this.finish(
       message.requestId,
-      isNativeReadResult(result) && matchesPage(result, pending, fromId)
+      isNativeReadResult(result) && matchesPage(result, pending, pending.toId)
         ? result
         : { error: "Recipient returned an invalid last-message page" },
     );
@@ -242,7 +277,7 @@ export class LastMessageRelay {
 
   disconnected(sessionId: string): void {
     for (const [token, pending] of this.pending) {
-      if (pending.fromId === sessionId || pending.toId === sessionId) {
+      if ([pending.fromId, pending.toId, pending.via].includes(sessionId)) {
         this.finish(token, { error: "Peer disconnected during last-message read" });
       }
     }

package/src/pi-intercom/broker/parked.ts

@@ -0,0 +1,130 @@
+import type net from "net";
+import { randomUUID } from "crypto";
+import type { Message, SessionInfo } from "../types.ts";
+import { nativePeerId } from "../session-targets.ts";
+import { writeMessage } from "./framing.ts";
+
+type Retained = Array<{ readonly from: SessionInfo; readonly message: Message }>;
+interface Parked {
+  readonly retained: Retained;
+  /** The fenced actor's socket closed: input waits for its restored replacement. */
+  closed: boolean;
+}
+export interface ParkablePeer {
+  readonly socket: net.Socket;
+  readonly info: SessionInfo;
+  /** This client can park itself, or wake and answer for its parked children. */
+  readonly parking: boolean;
+  parked?: Parked;
+}
+export function reachable<T extends ParkablePeer>(target?: T): target is T {
+  const socket = target?.socket;
+  return socket !== undefined && !socket.destroyed && socket.writable && !socket.writableEnded;
+}
+type Deliver = (id: string, from: SessionInfo, message: Message) => string | null;
+function requested(id: unknown): string | undefined {
+  return typeof id === "string" && /^[a-zA-Z0-9_-]{8,80}$/.test(id) ? id : undefined;
+}
+
+/** A fenced child keeps its identity and queued input; it never departs while parked. */
+export class ParkedSessions<T extends ParkablePeer> {
+  private readonly sessions: ReadonlyMap<string, T>;
+  private readonly deliver: Deliver;
+  constructor(sessions: ReadonlyMap<string, T>, deliver: Deliver) {
+    this.sessions = sessions;
+    this.deliver = deliver;
+  }
+  park(socket: net.Socket, id: string, on: boolean): void {
+    const session = this.sessions.get(id);
+    if (on && session?.parking === true) {
+      session.parked ??= { retained: [], closed: false };
+      // Frames already written to this socket precede the acknowledgement.
+      writeMessage(socket, { type: "parked" });
+    } else if (!on && session?.parked?.closed === false) {
+      const { retained } = session.parked;
+      session.parked = undefined;
+      this.flush(id, retained);
+    }
+  }
+  /**
+   * Delivers retained input in order. A transport that fails mid-flush keeps the rest for its
+   * next generation; delivery refusals on a live transport follow resident delivery.
+   */
+  private flush(id: string, retained: Retained): void {
+    for (const [index, { from, message }] of retained.entries()) {
+      const session = this.sessions.get(id);
+      if (this.deliver(id, from, message) !== null && session?.socket.writable === false) {
+        session.parked = { retained: retained.slice(index), closed: false };
+        return;
+      }
+    }
+  }
+  /** A free requested identity, or a parked one resumed by the same child lineage. */
+  claim(requestedId: unknown, next: Omit<SessionInfo, "id">): { id: string; resumed?: T } {
+    const id = requested(requestedId);
+    const previous = id === undefined ? undefined : this.sessions.get(id);
+    const resumes =
+      previous?.parked !== undefined &&
+      previous.info.rootSessionId === next.rootSessionId &&
+      previous.info.parentSessionId === next.parentSessionId;
+    if (id === undefined || (previous && !resumes)) {
+      return { id: randomUUID() };
+    }
+    previous?.socket.destroy();
+    return { id, resumed: previous };
+  }
+  /** Flushes a restored child's input and re-sends wakes owed to a (re)registered main. */
+  registered(id: string, previous?: T): void {
+    this.flush(id, previous?.parked?.retained ?? []);
+    for (const child of this.sessions.values()) {
+      if (nativePeerId(child.info.rootSessionId ?? "") === id) {
+        this.wake(child);
+      }
+    }
+  }
+  /** A transport handoff, not a departure: no session_left and queued input stays. */
+  closed(session: T): boolean {
+    const { parked } = session;
+    if (parked) {
+      parked.closed = true;
+      this.wake(session);
+    }
+    return parked !== undefined;
+  }
+  /**
+   * Exited parked children keep identities while some live session remains. Input already
+   * admitted for one keeps the broker until a returning main wakes it.
+   */
+  get exited(): boolean {
+    return [...this.sessions.values()].every(
+      ({ parked }) => parked?.closed === true && parked.retained.length === 0,
+    );
+  }
+  retain(target: T | undefined, from: SessionInfo, message: Message): boolean {
+    target?.parked?.retained.push({ from, message });
+    if (target) {
+      this.wake(target);
+    }
+    return target?.parked !== undefined;
+  }
+  /** Reads of an exited parked child go to its main, which answers from captured history. */
+  reader(id: string): T | undefined {
+    const child = this.sessions.get(id);
+    return child?.parked?.closed === true ? this.main(child) : undefined;
+  }
+  // Passive breadcrumbs and topic updates wait for a genuine wake; they never spawn the child.
+  private wake(child: T): void {
+    const main = this.main(child);
+    const wakes = child.parked?.retained.some(
+      ({ message }) =>
+        message.passive !== true && message.delivery !== "passive" && message.topic === undefined,
+    );
+    if (main && child.parked?.closed === true && wakes === true) {
+      writeMessage(main.socket, { type: "wake", sessionId: child.info.id });
+    }
+  }
+  private main(child: T): T | undefined {
+    const main = this.sessions.get(nativePeerId(child.info.rootSessionId ?? ""));
+    return main?.parking === true && main.parked === undefined ? main : undefined;
+  }
+}

package/src/pi-intercom/broker/server-connection.ts

@@ -37,7 +37,7 @@ type ClientMessageHandler = (
 export function acceptBrokerConnection(
   socket: net.Socket,
   handleMessage: ClientMessageHandler,
-  disconnected: (sessionId: string) => void,
+  disconnected: (sessionId: string, socket: net.Socket) => void,
 ): void {
   let sessionId: string | null = null;
   socket.on(
@@ -54,7 +54,7 @@ export function acceptBrokerConnection(
   );
   socket.on("close", () => {
     if (sessionId !== null) {
-      disconnected(sessionId);
+      disconnected(sessionId, socket);
     }
   });
   socket.on("error", (error: Error) => {

package/src/pi-intercom/connection.ts

@@ -6,7 +6,7 @@ import type { IntercomConfig } from "./config.ts";
 import type { IntercomLifecycle } from "./lifecycle.ts";
 import type { Message, SessionInfo, ReceiptQuery, ReceiptResult } from "./types.ts";
 import type { NativeReadQuery } from "./broker/last.ts";
-import { readLastMessage } from "./last-message.ts";
+import { readLastMessage, type NativeHistory } from "./last-message.ts";
 import { asError } from "./validation.ts";
 import { RecoveryError } from "./tool-results.ts";
 import { formatTargetOptions, resolveSessionTarget, nativePeerId } from "./session-targets.ts";
@@ -24,10 +24,20 @@ interface ConnectionHooks {
   readonly incoming: (ctx: ExtensionContext, from: SessionInfo, message: Message) => Promise<void>;
   readonly peerLeft: (id: string) => void;
   readonly disconnected: (error: Readonly<Error>) => void;
+  /** A main answers for and wakes its exited parked children. */
+  readonly parkedHistory: (peer: SessionInfo) => Promise<NativeHistory | undefined>;
+  readonly wake: (peer: string) => void;
+}
+interface LastRequest {
+  readonly requestId: string;
+  readonly query: NativeReadQuery;
+  readonly parked?: SessionInfo;
 }
 /** Owns socket registration, coalesced connects and the reconnect/startup timers. */
 export class IntercomConnection {
   private client: IntercomClient | null = null;
+  /** The transport whose broker retains this actor's input while it parks. */
+  private parked: IntercomClient | null = null;
   private reconnectTimer: NodeJS.Timeout | null = null;
   private startupTimer: NodeJS.Timeout | null = null;
   private connecting: Promise<IntercomTransport> | null = null;
@@ -44,6 +54,22 @@ export class IntercomConnection {
   get active(): IntercomTransport | null {
     return this.client;
   }
+  async park(): Promise<boolean> {
+    const client = this.client;
+    this.parked = client !== null && (await client.park().catch(() => false)) ? client : null;
+    return this.parked !== null && this.parked === this.client;
+  }
+  get parking(): boolean {
+    return this.parked !== null;
+  }
+  get reconnected(): boolean {
+    return this.client !== null && this.client !== this.parked;
+  }
+  unpark(): Promise<boolean> {
+    const client = this.parked === this.client ? this.client : null;
+    this.parked = null;
+    return client?.park(false).catch(() => false) ?? Promise.resolve(false);
+  }
   start(ctx: ExtensionContext, generation: number): void {
     this.attempt = 0;
     this.clearTimers();
@@ -119,45 +145,67 @@ export class IntercomConnection {
       });
     }
   }
+  private answerLast(next: IntercomClient, request: LastRequest): void {
+    const ctx = this.lifecycle.live();
+    const id = next.sessionId;
+    if (this.client !== next || !ctx || id === null) {
+      next.respondLast(request.requestId, { error: "Intercom runtime no longer active" });
+      return;
+    }
+    const { parked, query } = request;
+    if ("messageId" in query) {
+      // The broker refuses receipt reads of an exited parked child before relaying them.
+      next.respondLast(
+        request.requestId,
+        parked ? { error: "publication_unavailable" } : this.hooks.receipt(query),
+      );
+      return;
+    }
+    if (parked) {
+      this.hooks
+        .parkedHistory(parked)
+        .then((history) =>
+          history
+            ? readLastMessage(history, parked, query)
+            : { error: "Parked session history is unavailable." },
+        )
+        .catch((error: unknown) => ({ error: asError(error).message }))
+        .then((result) => {
+          next.respondLast(request.requestId, result);
+        })
+        .catch(() => {
+          /* The requester's broker timeout reports a lost transport. */
+        });
+      return;
+    }
+    try {
+      next.respondLast(
+        request.requestId,
+        readLastMessage(
+          ctx.sessionManager,
+          {
+            id,
+            ...this.lifecycle.identity(ctx.sessionManager.getSessionId()),
+            cwd: ctx.cwd,
+            model: ctx.model?.id ?? "unknown",
+            status: this.lifecycle.status(),
+          },
+          query,
+        ),
+      );
+    } catch (error) {
+      next.respondLast(request.requestId, { error: asError(error).message });
+    }
+  }
   private createClient(): IntercomClient {
     const next = new IntercomClient({
       sendTimeoutMs: this.config.sendTimeoutMs,
       listTimeoutMs: this.config.listTimeoutMs,
     });
     this.client = next;
-    next.on(
-      "last_request",
-      (request: { readonly requestId: string; readonly query: NativeReadQuery }) => {
-        const ctx = this.lifecycle.live();
-        const id = next.sessionId;
-        if (this.client !== next || !ctx || id === null) {
-          next.respondLast(request.requestId, { error: "Intercom runtime no longer active" });
-          return;
-        }
-        try {
-          if ("messageId" in request.query) {
-            next.respondLast(request.requestId, this.hooks.receipt(request.query));
-            return;
-          }
-          next.respondLast(
-            request.requestId,
-            readLastMessage(
-              ctx.sessionManager,
-              {
-                id,
-                ...this.lifecycle.identity(ctx.sessionManager.getSessionId()),
-                cwd: ctx.cwd,
-                model: ctx.model?.id ?? "unknown",
-                status: this.lifecycle.status(),
-              },
-              request.query,
-            ),
-          );
-        } catch (error) {
-          next.respondLast(request.requestId, { error: asError(error).message });
-        }
-      },
-    );
+    next.on("last_request", (request: LastRequest) => {
+      this.answerLast(next, request);
+    });
     next.on("message", (from: SessionInfo, message: Message) => {
       const ctx = this.lifecycle.live();
       if (this.client !== next || !ctx) {
@@ -167,6 +215,11 @@ export class IntercomConnection {
         console.error("Intercom inbound delivery failed:", error);
       });
     });
+    next.on("wake", (peer: string) => {
+      if (this.client === next) {
+        this.hooks.wake(peer);
+      }
+    });
     next.on("session_left", (id: string) => {
       if (this.client !== next) {
         return;