@fitchmultz/pi-subagents 0.52.4 → 0.52.6

package/dist/agent/process.js

@@ -7,8 +7,8 @@ import { setTimeout as delay } from "node:timers/promises";
 import { isChildProcessReplaced, observeChildProcessReplaced, readChildProcessIdentity, readProcessClock, trySignalChildTree, } from "../shared/post-exit-stdio-guard.js";
 import { agentObservationSocketPath } from "../pi-intercom/broker/paths.js";
 import { hasErrorCode } from "../shared/unknown.js";
-import { attachmentSchema, parkedSchema, processSchema, } from "./contracts.js";
-import { conversation, enqueue, launchAt, list, read, write } from "./storage.js";
+import { attachmentSchema, parkedSchema, processSchema, wakeFailureSchema, } from "./contracts.js";
+import { conversation, enqueue, read, write } from "./storage.js";
 import { errorText } from "./host.js";
 /** Owner records follow their process's birth; stat after read only moves the bound later. */
 export function published(file, record) {
@@ -119,33 +119,64 @@ function childEnvironment(launch) {
         PI_INTERCOM_PARENT_SESSION_ID: launch.owner,
     });
 }
-function spawnActor(base, launch, token) {
+function saveSpawnFailure(dir, error) {
+    try {
+        write(path.join(dir, "spawn-error.json"), { error: error.message });
+        return error;
+    }
+    catch (failure) {
+        return Object.assign(new Error(`${error.message}; could not save the spawn diagnostic: ${errorText(failure)}`, {
+            cause: error,
+        }), "code" in error ? { code: error.code } : {});
+    }
+}
+async function spawnActor(base, launch, token, claim) {
     const dir = conversation(base, launch);
-    const log = fs.openSync(path.join(dir, "runner.log"), "a", 0o600);
-    const runner = fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "./runner.ts" : "./runner.js", import.meta.url));
     let child;
+    let spawnError;
     try {
-        child = spawn(process.execPath, [runner, base, launch.rootId, token, launch.id], {
-            cwd: launch.cwd,
-            env: childEnvironment(launch),
-            detached: true,
-            stdio: ["ignore", log, log],
-        });
+        const log = fs.openSync(path.join(dir, "runner.log"), "a", 0o600);
+        try {
+            const runner = fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "./runner.ts" : "./runner.js", import.meta.url));
+            child = spawn(process.execPath, [runner, base, launch.rootId, token, launch.id], {
+                cwd: launch.cwd,
+                env: childEnvironment(launch),
+                detached: true,
+                stdio: ["ignore", log, log],
+            });
+            if (child.pid === undefined) {
+                spawnError = new Promise((resolve) => {
+                    child.once("error", (error) => resolve(saveSpawnFailure(dir, error)));
+                });
+                claim.release();
+            }
+            else {
+                claim.spawned();
+                child.on("error", (error) => {
+                    write(path.join(dir, "spawn-error.json"), { error: error.message });
+                });
+            }
+        }
+        finally {
+            fs.closeSync(log);
+        }
+    }
+    catch (error) {
+        claim.release();
+        throw error;
     }
-    finally {
-        fs.closeSync(log);
+    if (child.pid === undefined && spawnError) {
+        throw await spawnError;
+    }
+    if (child.pid === undefined) {
+        claim.spawned();
+        throw new Error("Actor spawn outcome is ambiguous.");
     }
-    child.on("error", (error) => {
-        write(path.join(dir, "spawn-error.json"), { error: error.message });
-    });
     child.on("exit", (code, signal) => {
         write(path.join(dir, `exit-${token}.json`), { pid: child.pid, code, signal, at: Date.now() });
         trySignalChildTree(child, "SIGKILL");
     });
     child.unref();
-    if (child.pid === undefined) {
-        throw new Error("Actor was not spawned; retained launch claim requires inspection.");
-    }
     write(path.join(dir, "actor.lock", "process.json"), {
         pid: child.pid,
         identity: readChildProcessIdentity(child.pid) ?? "unverified",
@@ -170,6 +201,48 @@ async function awaitStopping(dir, existing, signal) {
         }
     }
 }
+function releaseClaim(lock, identity, token) {
+    try {
+        const current = fs.lstatSync(lock, { throwIfNoEntry: false });
+        if (current && identity && current.dev === identity.dev && current.ino === identity.ino) {
+            const file = path.join(lock, "claim.json");
+            const claim = read(file, processSchema);
+            if (claim === undefined || claim.token === token) {
+                fs.rmSync(file, { force: true });
+                fs.rmdirSync(lock);
+            }
+        }
+    }
+    catch {
+        // Keep the original failure; an unremovable claim remains safely ambiguous.
+    }
+}
+async function launchClaimedActor(base, launch, lock) {
+    let identity;
+    let token;
+    let state = "claimed";
+    const claim = {
+        spawned: () => {
+            state = "spawned";
+        },
+        release: () => {
+            if (state === "claimed") {
+                state = "released";
+                releaseClaim(lock, identity, token);
+            }
+        },
+    };
+    try {
+        identity = fs.lstatSync(lock);
+        token = randomUUID();
+        write(path.join(lock, "claim.json"), { ...ownIdentity(), token });
+        await spawnActor(base, launch, token, claim);
+    }
+    catch (error) {
+        claim.release();
+        throw error;
+    }
+}
 export async function ensureActor(base, launch, signal) {
     const dir = conversation(base, launch);
     const lock = path.join(dir, "actor.lock");
@@ -199,16 +272,26 @@ export async function ensureActor(base, launch, signal) {
         }
         throw error;
     }
-    const token = randomUUID();
-    write(path.join(lock, "claim.json"), { ...ownIdentity(), token });
-    spawnActor(base, launch, token);
+    await launchClaimedActor(base, launch, lock);
+}
+/** A failed restore can hand the old cut forward only before native open and after death. */
+function failedBeforeOpenToken(dir, exited, current) {
+    const failure = read(path.join(dir, `wake-failure-${exited.token}.json`), wakeFailureSchema);
+    if (current?.token === exited.token &&
+        !alive(current) &&
+        failure?.beforeOpen?.actorToken === exited.token) {
+        return failure.beforeOpen.parkedToken;
+    }
+    return undefined;
 }
 /** A failed park keeps its input queued; exact state is lost, so nothing restarts it implicitly. */
 export function parkFailure(base, launch, exited) {
     const dir = conversation(base, launch);
     const parked = read(path.join(dir, "parked.json"), parkedSchema);
-    if (exited && parked && parked.token !== exited.token) {
-        // Only the exited claim that saved this state may hand it to the next generation.
+    if (exited &&
+        parked &&
+        parked.token !== exited.token &&
+        failedBeforeOpenToken(dir, exited, actor(base, launch)) !== parked.token) {
         throw new Error("Parked working state belongs to another actor generation; nothing was reopened.");
     }
     const file = path.join(dir, "park-failed.json");
@@ -307,45 +390,6 @@ export function requestStop(base, launch, onError) {
     });
     return { targets: live, command };
 }
-export async function stopChildren(base, owner) {
-    const roots = new Set();
-    const targets = [];
-    for (const id of list(base)) {
-        try {
-            const launch = launchAt(base, id, owner);
-            if (!roots.has(launch.rootId)) {
-                roots.add(launch.rootId);
-                targets.push(...requestStop(base, launch, (error) => {
-                    console.error(`Child shutdown ${id}: ${errorText(error)}`);
-                }).targets);
-            }
-        }
-        catch (error) {
-            console.error(`Child shutdown ${id}: ${errorText(error)}`);
-        }
-    }
-    await waitForExit(targets, 3000);
-    for (const target of targets) {
-        try {
-            signalProcess(target, "SIGKILL");
-        }
-        catch (error) {
-            console.error(`Child shutdown ${target.pid}: ${errorText(error)}`);
-        }
-    }
-    await waitForExit(targets, 1000);
-    if (targets.some(alive)) {
-        console.error("Child shutdown could not confirm every owned process exit.");
-    }
-}
-async function waitForExit(targets, timeout) {
-    const deadline = Date.now() + timeout;
-    while (Date.now() < deadline && targets.some(alive)) {
-        // Join actual process exit while native abort persists the interrupted turn.
-        // oxlint-disable-next-line no-await-in-loop
-        await delay(25);
-    }
-}
 export function shell(file, token) {
     const identity = published(file, read(file, processSchema));
     if (identity && identity.token !== token) {

package/dist/agent/receipts.js

@@ -135,13 +135,30 @@ function owned(file, owner) {
     const header = journal.entries.at(0);
     return header?.type === "session" && header.id === owner ? journal : undefined;
 }
+/** Without a session file (`--no-session`), Pi's append-only memory is the whole native transcript. */
+function remembered(manager, owner) {
+    const header = manager.getHeader();
+    if (header?.id !== owner) {
+        return;
+    }
+    const journal = { end: 0, entries: [], completions: new Map() };
+    // Index the same record frames the physical journal scan accepts.
+    for (const entry of [header, ...manager.getEntries()]) {
+        if (isRecord(entry)) {
+            addEntry(journal, entry);
+        }
+    }
+    return journal;
+}
 export function receiptId(file, owner, matches) {
     const found = owned(file, owner)?.entries.find((entry) => entry.type !== "session" && matches(entry));
     return typeof found?.id === "string" ? found.id : undefined;
 }
-/** Live read-only completion IDs by run; later appends extend this view.
- * A matching entry without an ID is unpublished. Invalidations replace the view.
+/** Completion IDs by run from the native transcript: the session file when Pi persists one,
+ * otherwise Pi's in-memory entries. A matching entry without an ID is unpublished.
  */
-export function completionReceipts(file, owner) {
-    return owned(file, owner)?.completions ?? new Map();
+export function completionReceipts(manager, owner) {
+    const file = manager.getSessionFile();
+    const journal = file === undefined ? remembered(manager, owner) : owned(file, owner);
+    return journal?.completions ?? new Map();
 }

package/dist/agent/runner.js

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { commandSchema } from "./contracts.js";
+import { commandSchema, parkedSchema, } from "./contracts.js";
 import { launchAt, missing, read, runDirectory, write } from "./storage.js";
 import { ownIdentity, ParentCheck, shells, signalProcess } from "./process.js";
 import { errorText, loadSDK } from "./host.js";
@@ -351,7 +351,7 @@ class Actor {
         }
         return this.parking;
     }
-    failure(error) {
+    failure(error, unopened) {
         const launch = this.current ?? this.initial;
         const result = {
             id: launch.id,
@@ -361,6 +361,16 @@ class Actor {
             error: errorText(error),
         };
         const directory = runDirectory(this.base, launch.id);
+        if (fs.existsSync(path.join(this.dir, "parked.json"))) {
+            const parked = read(path.join(this.dir, "parked.json"), parkedSchema);
+            write(path.join(this.dir, `wake-failure-${this.token}.json`), {
+                at: Date.now(),
+                reason: errorText(error),
+                ...(unopened !== undefined && parked?.token === unopened
+                    ? { beforeOpen: { actorToken: this.token, parkedToken: unopened } }
+                    : {}),
+            });
+        }
         if (!fs.existsSync(path.join(directory, "result.json"))) {
             fs.writeFileSync(path.join(directory, "output.txt"), "", { mode: 0o600 });
             write(path.join(directory, "result.json"), result);
@@ -427,10 +437,14 @@ class Actor {
         parked.adopt();
     }
     async serve() {
-        const sdk = await loadSDK(this.initial.sdk);
-        const parked = new Parking(this.base, this.initial, this.token, sdk);
         let runtime;
+        let parked;
+        let parkedToken;
         try {
+            // Capture the old generation before SDK import or any native working-state operation.
+            parkedToken = read(path.join(this.dir, "parked.json"), parkedSchema)?.token;
+            const sdk = await loadSDK(this.initial.sdk);
+            parked = new Parking(this.base, this.initial, this.token, sdk);
             runtime = await this.start(sdk, parked);
             process.on("SIGTERM", this.stop);
             process.on("SIGINT", this.stop);
@@ -438,7 +452,7 @@ class Actor {
             await this.active;
         }
         catch (error) {
-            this.failure(error);
+            this.failure(error, parked?.opened === true ? undefined : parkedToken);
         }
         finally {
             await this.finish(runtime);

package/dist/agent/shutdown.js

@@ -0,0 +1,43 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { errorText } from "./host.js";
+import { alive, requestStop, signalProcess } from "./process.js";
+import { launchAt, list } from "./storage.js";
+export async function stopChildren(base, owner, report) {
+    const roots = new Set();
+    const targets = [];
+    for (const id of list(base)) {
+        try {
+            const launch = launchAt(base, id, owner);
+            if (!roots.has(launch.rootId)) {
+                roots.add(launch.rootId);
+                targets.push(...requestStop(base, launch, (error) => {
+                    report(`Child shutdown ${id}: ${errorText(error)}`);
+                }).targets);
+            }
+        }
+        catch (error) {
+            report(`Child shutdown ${id}: ${errorText(error)}`);
+        }
+    }
+    await waitForExit(targets, 3000);
+    for (const target of targets) {
+        try {
+            signalProcess(target, "SIGKILL");
+        }
+        catch (error) {
+            report(`Child shutdown ${target.pid}: ${errorText(error)}`);
+        }
+    }
+    await waitForExit(targets, 1000);
+    if (targets.some(alive)) {
+        report("Child shutdown could not confirm every owned process exit.");
+    }
+}
+async function waitForExit(targets, timeout) {
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline && targets.some(alive)) {
+        // Join actual process exit while native abort persists the interrupted turn.
+        // oxlint-disable-next-line no-await-in-loop
+        await delay(25);
+    }
+}

package/dist/agent/view.js

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { readOutputPage } from "../shared/output-page.js";
 import { actor, alive, observeAlive } from "./process.js";
-import { admissionSchema, commandSchema, exitSchema, successorSchema, } from "./contracts.js";
+import { admissionSchema, commandSchema, exitSchema, successorSchema, wakeFailureSchema, } from "./contracts.js";
 import { conversation, read, runDirectory } from "./storage.js";
 import { published } from "./notifications.js";
 import { readCanonicalResult, readResult } from "./usage.js";
@@ -98,6 +98,7 @@ function metadata(base, launch, result, options) {
         result,
         nativeReceipt: options.ctx ? (published(options.ctx, launch) ?? null) : null,
         process,
+        lastWakeFailure: read(path.join(conversation(base, launch), "wake-failure.json"), wakeFailureSchema),
         sessionId: launch.sessionId,
         sessionFile: launch.sessionFile,
         outputFile,
@@ -178,6 +179,9 @@ function resultText(details) {
         `Agent run ${details.id}: ${details.status}; admission ${details.admission}; process ${details.process.live ? "live" : "not observed live"}.`,
         receiptText(details),
         exitText(details),
+        details.lastWakeFailure
+            ? `Last wake failure at ${new Date(details.lastWakeFailure.at).toISOString()}: ${details.lastWakeFailure.reason} Retained intercom messages may still arrive after a later wake.`
+            : "",
         `Guidance (latest 20):\n${guidance.length > 0 ? guidance : "  none"}`,
         "Guidance states: pending = not yet admitted; accepted = native queue admission, not journal publication or model consumption; stale = rejected, no new work was started (retry the entire prompt as a continuation).",
         details.result?.error ?? "",

package/dist/build-info.js

@@ -1 +1 @@
-export const EXTENSION_BUILD = Object.freeze({"version":"0.52.4","sha256":"d8c708fa06701cc0d5f8770cc729ba6fa204bdc8f76c5f06f5aa9cc3e37b3cc9"});
+export const EXTENSION_BUILD = Object.freeze({"version":"0.52.6","sha256":"ccb2b2cb4725bfa7f5e813494a2007dc60ed9c04e677502d08df23612cc30af8"});

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

@@ -71,9 +71,7 @@ class IntercomBroker {
         if (currentId === null && msg.type !== "register") {
             throw new Error(`Received ${msg.type} before register`);
         }
-        if (currentId !== null) {
-            this.touchActivity(currentId, false);
-        }
+        this.touchActivity(currentId, false);
         if (msg.type === "register") {
             if (currentId !== null) {
                 throw new Error("Received duplicate register message");
@@ -107,7 +105,8 @@ class IntercomBroker {
                 break;
             case "park":
             case "unpark":
-                this.parking.park(socket, currentId, msg.type === "park");
+            case "wake_result":
+                this.parking.handle(socket, currentId, msg);
                 break;
             default:
                 throw new Error(`Unknown client message type: ${msg.type}`);
@@ -126,7 +125,7 @@ class IntercomBroker {
             topics: resumed?.topics ?? new TopicSnapshot(info),
             topicFrames,
             lastMessages: msg.lastMessages === true,
-            parking: msg.parking === true,
+            ...this.parking.features(msg),
             receiptReads: msg.receiptReads === 1,
         });
         setId(id);
@@ -139,6 +138,7 @@ class IntercomBroker {
             sessionId: id,
             lastMessages: true,
             parking: msg.parking === true,
+            ...this.parking.capabilities(msg),
             receiptReads: 1,
             ...(msg.guardedDelivery === 1 ? { guardedDelivery: 1 } : {}),
             ...(topicFrames ? { topicsSupported: true, topicFrames: true } : {}),
@@ -331,12 +331,13 @@ class IntercomBroker {
             accepted: reason === null,
             delivered: reason === null && !queued,
             ...(queued ? { queued } : {}),
+            ...(queued ? { reason: this.parking.queueReason(target, message.id) } : {}),
             ...(reason !== null ? { reason } : {}),
         };
     }
     /** Update liveness/intercom-activity timestamps for a connected session. */
     touchActivity(sessionId, comms) {
-        const session = this.sessions.get(sessionId);
+        const session = sessionId === null ? undefined : this.sessions.get(sessionId);
         if (!session) {
             return;
         }

package/dist/pi-intercom/broker/client-wake.d.ts

@@ -0,0 +1,17 @@
+import type net from "node:net";
+import type { EventEmitter } from "node:events";
+import type { WakeResult } from "../types.ts";
+import type { UnknownRecord } from "../../shared/unknown.ts";
+/** Negotiated wake outcomes; old brokers and clients keep the original wake event. */
+export declare class WakeMessages {
+    supported: boolean;
+    private readonly events;
+    private readonly socket;
+    constructor(events: EventEmitter, socket: () => net.Socket);
+    registration(): {
+        wakeResults?: 1;
+        wakeNotices?: 1;
+    };
+    receive(msg: UnknownRecord): void;
+    respond(requestId: string, result: WakeResult): void;
+}

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

@@ -0,0 +1,54 @@
+import { validateIntercomMessageSize, writeMessage } from "./framing.js";
+/** Negotiated wake outcomes; old brokers and clients keep the original wake event. */
+export class WakeMessages {
+    supported = false;
+    events;
+    socket;
+    constructor(events, socket) {
+        this.events = events;
+        this.socket = socket;
+    }
+    registration() {
+        return {
+            ...(this.events.listenerCount("wake_request") > 0 ? { wakeResults: 1 } : {}),
+            ...(this.events.listenerCount("wake_failed") > 0 ? { wakeNotices: 1 } : {}),
+        };
+    }
+    receive(msg) {
+        if (msg.type === "wake_registered") {
+            if (typeof msg.requestId !== "string") {
+                throw new Error("Invalid wake registration");
+            }
+            this.events.emit("wake_registered", msg.requestId);
+            return;
+        }
+        if (typeof msg.sessionId !== "string") {
+            throw new Error("Invalid wake message");
+        }
+        if (msg.type === "wake") {
+            if (this.supported && typeof msg.requestId === "string") {
+                this.events.emit("wake_request", msg.sessionId, msg.requestId);
+            }
+            else {
+                this.events.emit("wake", msg.sessionId);
+            }
+            return;
+        }
+        if (typeof msg.messageId !== "string" || typeof msg.reason !== "string") {
+            throw new Error("Invalid wake failure");
+        }
+        this.events.emit("wake_failed", msg.sessionId, msg.messageId, msg.reason);
+    }
+    respond(requestId, result) {
+        if (!this.supported) {
+            return;
+        }
+        const frame = { type: "wake_result", requestId, result };
+        writeMessage(this.socket(), validateIntercomMessageSize(frame) === null
+            ? frame
+            : {
+                ...frame,
+                result: { status: "failed", reason: "Wake failed; inspect the agent run for details." },
+            });
+    }
+}

package/dist/pi-intercom/broker/client.d.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from "events";
+import { WakeMessages } from "./client-wake.ts";
 import { type SessionInfo, type TopicUpdate, type TopicChange, type SessionSnapshot, type SendResult, type LastMessageQuery, type LastMessageResult, type SendOptions, type ReceiptQuery, type ReceiptResult } from "../types.ts";
 export type { SendResult } from "../types.ts";
 export interface IntercomClientOptions {
@@ -12,6 +13,7 @@ export declare class IntercomClient extends EventEmitter {
     private _sessionId;
     private _topicsSupported;
     private readonly parking;
+    readonly wakes: WakeMessages;
     private guardedDeliverySupported;
     private readonly lastRequests;
     private readonly pendingSends;

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

@@ -5,6 +5,7 @@ import { BrokerConnection, connectBrokerSocket } from "./connection.js";
 import { SnapshotReader } from "./snapshot-reader.js";
 import { LastMessageRequests, lastRequest } from "./client-last.js";
 import { ParkRequests } from "./client-park.js";
+import { WakeMessages } from "./client-wake.js";
 import { isNativeReadResult } from "./last.js";
 import { errorMessage, isRecord, isUnknownArray, } from "../../shared/unknown.js";
 import { compactTopicMessage, normalizeMessage, normalizeSessionInfo, } from "../types.js";
@@ -32,6 +33,7 @@ export class IntercomClient extends EventEmitter {
     _sessionId = null;
     _topicsSupported = false;
     parking = new ParkRequests();
+    wakes = new WakeMessages(this, () => this.requireActiveSocket());
     guardedDeliverySupported = false;
     lastRequests;
     pendingSends = new Map();
@@ -106,6 +108,7 @@ export class IntercomClient extends EventEmitter {
                     this._topicsSupported = false;
                     this.parking.settle(false);
                     this.guardedDeliverySupported = false;
+                    this.wakes.supported = false;
                     this.disconnecting = false;
                     this.failPending(error);
                     if (established && !expected) {
@@ -125,6 +128,7 @@ export class IntercomClient extends EventEmitter {
                     parking: true,
                     receiptReads: 1,
                     guardedDelivery: 1,
+                    ...this.wakes.registration(),
                 });
             }
             catch (error) {
@@ -157,44 +161,46 @@ export class IntercomClient extends EventEmitter {
         if (!isRecord(msg) || typeof msg.type !== "string") {
             throw new Error("Invalid broker message");
         }
-        const brokerMessage = msg;
-        const type = msg.type;
-        if (this._sessionId === null && type !== "registered") {
-            throw new Error(`Received ${type} before registered`);
+        if (this._sessionId === null && msg.type !== "registered") {
+            throw new Error(`Received ${msg.type} before registered`);
         }
-        switch (type) {
+        switch (msg.type) {
             case "registered":
-                this.receiveRegistration(brokerMessage);
+                this.receiveRegistration(msg);
                 break;
             case "sessions":
-                this.receiveSessions(brokerMessage);
+                this.receiveSessions(msg);
                 break;
             case "last_request":
-                this.receiveLastRequest(brokerMessage);
+                this.receiveLastRequest(msg);
                 break;
             case "last_response":
-                this.lastRequests.receive(brokerMessage);
+                this.lastRequests.receive(msg);
                 break;
             case "message":
-                this.receiveMessage(brokerMessage);
+                this.receiveMessage(msg);
                 break;
             case "delivered":
             case "delivery_queued":
             case "delivery_failed":
-                this.receiveDelivery(brokerMessage);
+                this.receiveDelivery(msg);
                 break;
             case "parked":
                 this.parking.settle(true);
                 break;
-            case "wake":
             case "session_left":
-                if (typeof brokerMessage.sessionId !== "string") {
-                    throw new Error(`Invalid ${type} message`);
+                if (typeof msg.sessionId !== "string") {
+                    throw new Error(`Invalid ${msg.type} message`);
                 }
-                this.emit(type, brokerMessage.sessionId);
+                this.emit(msg.type, msg.sessionId);
+                break;
+            case "wake":
+            case "wake_failed":
+            case "wake_registered":
+                this.wakes.receive(msg);
                 break;
             default:
-                throw new Error(`Unknown broker message type: ${type}`);
+                throw new Error(`Unknown broker message type: ${msg.type}`);
         }
     }
     receiveRegistration(msg) {
@@ -210,6 +216,7 @@ export class IntercomClient extends EventEmitter {
         this.parking.supported = msg.parking === true;
         this.lastRequests.receiptReads = msg.receiptReads === 1;
         this.guardedDeliverySupported = msg.guardedDelivery === 1;
+        this.wakes.supported = msg.wakeResults === 1;
         this.connection?.confirmRegistration();
         this.emit("_registered", { type: "registered", sessionId: msg.sessionId });
     }