@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/src/pi-intercom/subagent-events.ts

@@ -0,0 +1,299 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { IntercomLifecycle } from "./lifecycle.ts";
+import { resolveConnectedTarget, type IntercomConnection } from "./connection.ts";
+import type { InboundDeliveryOwner } from "./inbound-delivery.ts";
+import type { InboundJournal } from "./inbound-journal.ts";
+import type { IntercomSessionScope, SubagentCompletion } from "./runtime-types.ts";
+import { isCompletedChild } from "./inbound-record.ts";
+import { isRecord, isUnknownArray, errorMessage } from "./validation.ts";
+import { registerSubagentLiveEventHandlers } from "./subagent-live-events.ts";
+type Lifecycle = Readonly<
+  Pick<IntercomLifecycle, "generation" | "live" | "runtimeStarted" | "targetMatches">
+>;
+type Connection = Readonly<
+  Pick<IntercomConnection, "active" | "ensure" | "isConnecting" | "syncStatus">
+>;
+type InboundDeliveryHandle = Readonly<Pick<InboundDeliveryOwner, "local" | "restoring">>;
+type Journal = Readonly<Pick<InboundJournal, "remove" | "retire">>;
+
+interface RelayPayload {
+  readonly to: string;
+  readonly message: string;
+  readonly requestId?: string;
+  readonly source?: "foreground" | "async";
+  readonly completion?: SubagentCompletion;
+}
+function relayCompletion(
+  payload: Readonly<Record<string, unknown>>,
+  source: RelayPayload["source"],
+): SubagentCompletion | undefined {
+  const children = isUnknownArray(payload.children)
+    ? payload.children.filter(isCompletedChild)
+    : [];
+  if (
+    source === undefined ||
+    typeof payload.runId !== "string" ||
+    typeof payload.status !== "string" ||
+    children.length === 0
+  ) {
+    return;
+  }
+  return {
+    runId: payload.runId,
+    status: payload.status,
+    children,
+    ...(typeof payload.completionId === "string" ? { completionId: payload.completionId } : {}),
+  };
+}
+function parseRelay(payload: unknown): RelayPayload | null {
+  if (!isRecord(payload) || typeof payload.to !== "string" || typeof payload.message !== "string") {
+    return null;
+  }
+  const source =
+    payload.source === "foreground" || payload.source === "async" ? payload.source : undefined;
+  const completion = relayCompletion(payload, source);
+  return {
+    to: payload.to,
+    message: payload.message,
+    requestId: typeof payload.requestId === "string" ? payload.requestId : undefined,
+    source,
+    completion,
+  };
+}
+interface RelayOptions {
+  readonly sender: "subagent-control" | "subagent-result";
+  readonly status: string;
+  readonly errorEntryType: string;
+  readonly acknowledge?: boolean;
+}
+interface BridgeOwners {
+  readonly pi: ExtensionAPI;
+  readonly journal: Journal;
+  readonly open: (ctx: ExtensionContext, scope?: IntercomSessionScope) => Promise<void>;
+}
+/** Owns event subscriptions and detached event work; stop prevents new admission. */
+export class SubagentEventBridges {
+  private unsubscribes: (() => void)[] = [];
+  private active = false;
+  private readonly pending = new Set<Promise<void>>();
+  private readonly lifecycle: Lifecycle;
+  private readonly connection: Connection;
+  private readonly delivery: InboundDeliveryHandle;
+  private readonly owners: BridgeOwners;
+  constructor(
+    lifecycle: Lifecycle,
+    connection: Connection,
+    delivery: InboundDeliveryHandle,
+    owners: BridgeOwners,
+  ) {
+    this.lifecycle = lifecycle;
+    this.connection = connection;
+    this.delivery = delivery;
+    this.owners = owners;
+  }
+  private own(operation: () => Promise<void>): void {
+    const task = operation();
+    this.pending.add(task);
+    task
+      .then(
+        () => {
+          this.pending.delete(task);
+        },
+        (error: unknown) => {
+          this.pending.delete(task);
+          console.error("Intercom event bridge failed:", error);
+        },
+      )
+      .catch((error: unknown) => {
+        console.error("Intercom event bridge cleanup failed:", error);
+      });
+  }
+  stop(): void {
+    for (const unsubscribe of this.unsubscribes) {
+      try {
+        unsubscribe();
+      } catch {
+        /* Best-effort cleanup during native reload/replacement. */
+      }
+    }
+    this.unsubscribes = [];
+    this.active = false;
+  }
+  async drain(): Promise<void> {
+    await Promise.allSettled(this.pending);
+  }
+  private acknowledge(requestId: string | undefined, delivered: boolean, error?: unknown): void {
+    if (requestId === undefined || requestId === "") {
+      return;
+    }
+    this.owners.pi.events.emit("subagent:result-intercom-delivery", {
+      requestId,
+      delivered,
+      ...(error !== undefined ? { error: errorMessage(error) } : {}),
+    });
+  }
+  private isLive(generation: number): boolean {
+    return (
+      !this.lifecycle.runtimeStarted ||
+      (this.lifecycle.generation === generation && this.lifecycle.live() !== null)
+    );
+  }
+  private async remote(
+    parsed: RelayPayload,
+    options: RelayOptions,
+    generation: number,
+  ): Promise<boolean> {
+    if (this.lifecycle.targetMatches(parsed.to)) {
+      return false;
+    }
+    const client = await this.connection.ensure("background");
+    const target = (await resolveConnectedTarget(client, parsed.to)) ?? parsed.to;
+    if (!this.isLive(generation)) {
+      return true;
+    }
+    if (this.lifecycle.targetMatches(parsed.to, target, client.sessionId)) {
+      return false;
+    }
+    const result = await client.send(target, { text: parsed.message });
+    if (!this.isLive(generation)) {
+      return true;
+    }
+    if (!result.accepted) {
+      throw new Error(result.reason ?? "Session may not exist or has disconnected.");
+    }
+    if (options.acknowledge === true) {
+      this.acknowledge(parsed.requestId, true);
+    }
+    return true;
+  }
+  private async relay(payload: unknown, options: RelayOptions): Promise<void> {
+    const parsed = parseRelay(payload);
+    if (!parsed) {
+      return;
+    }
+    const generation = this.lifecycle.generation;
+    try {
+      const restoring = this.delivery.restoring;
+      if (restoring) {
+        await restoring;
+      }
+      if (!this.isLive(generation) || (await this.remote(parsed, options, generation))) {
+        return;
+      }
+      this.local(parsed, options);
+    } catch (error) {
+      if (!this.isLive(generation)) {
+        return;
+      }
+      this.owners.pi.appendEntry(options.errorEntryType, {
+        to: parsed.to,
+        message: parsed.message,
+        error: errorMessage(error),
+        timestamp: Date.now(),
+      });
+      if (options.acknowledge === true) {
+        this.acknowledge(parsed.requestId, false, error);
+      }
+    }
+  }
+  private local(parsed: RelayPayload, options: RelayOptions): void {
+    const ownedControl =
+      options.sender === "subagent-control" &&
+      (parsed.source === "foreground" || parsed.source === "async");
+    if (!ownedControl) {
+      this.delivery.local(options.sender, options.status, {
+        text: parsed.message,
+        completion: parsed.completion,
+      });
+    }
+    if (options.acknowledge === true) {
+      this.acknowledge(parsed.requestId, true);
+    }
+  }
+  private registerCoordination(): (() => void)[] {
+    const { pi, journal, open } = this.owners;
+    return [
+      pi.events.on("subagent:supervisor-question-resolved", (payload) => {
+        if (!isRecord(payload) || typeof payload.questionId !== "string") {
+          return;
+        }
+        journal.retire(
+          payload.questionId,
+          journal.remove(payload.questionId) ? "discarded" : "reply-retired",
+        );
+        this.connection.syncStatus();
+      }),
+      pi.events.on("intercom:open", () => {
+        const ctx = this.lifecycle.live();
+        if (ctx?.mode === "tui") {
+          // Native custom UI owns this user-lived promise; bounded relay shutdown must not join it.
+          open(ctx, "all").catch((error: unknown) => {
+            console.error("Intercom overlay failed:", error);
+          });
+        }
+      }),
+      pi.events.on("subagent:intercom-identity-request", (payload) => {
+        const client = this.connection.active;
+        if (
+          isRecord(payload) &&
+          typeof payload.requestId === "string" &&
+          client?.isConnected() === true &&
+          client.sessionId !== null &&
+          client.sessionId !== ""
+        ) {
+          pi.events.emit("subagent:intercom-identity-response", {
+            requestId: payload.requestId,
+            sessionId: client.sessionId,
+          });
+        }
+      }),
+      pi.events.on("subagent:control-intercom", (payload) => {
+        this.own(() =>
+          this.relay(payload, {
+            sender: "subagent-control",
+            status: "needs_attention",
+            errorEntryType: "intercom_control_error",
+          }),
+        );
+      }),
+      pi.events.on("subagent:result-intercom", (payload) => {
+        this.own(() =>
+          this.relay(payload, {
+            sender: "subagent-result",
+            status: "result",
+            errorEntryType: "intercom_result_error",
+            acknowledge: true,
+          }),
+        );
+      }),
+    ];
+  }
+  start(): void {
+    if (this.active) {
+      return;
+    }
+    this.active = true;
+    this.unsubscribes = [
+      ...registerSubagentLiveEventHandlers({
+        events: this.owners.pi.events,
+        ensureConnected: () => this.connection.ensure("background"),
+        getConnection: () => ({
+          client: this.connection.active,
+          connecting: this.connection.isConnecting,
+          started: this.lifecycle.runtimeStarted,
+        }),
+        resolveSessionTarget: resolveConnectedTarget,
+        currentSessionTargetMatches: (to, resolved, client) =>
+          this.lifecycle.targetMatches(to, resolved, client?.sessionId),
+        getLivenessCheck: () => {
+          const generation = this.lifecycle.generation;
+          return () => this.isLive(generation);
+        },
+        own: (operation) => {
+          this.own(operation);
+        },
+      }),
+      ...this.registerCoordination(),
+    ];
+  }
+}

package/src/pi-intercom/subagent-live-events.ts

@@ -1,133 +1,236 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { IntercomClient } from "./broker/client.ts";
+import type { IntercomTransport } from "./transport.ts";
 import type { SubagentIntercomConnection } from "../shared/types.ts";
-import { formatSessionTarget, resolveSessionTarget as resolveSessionTargetValue } from "./session-targets.ts";
-import { isAttachment, isHumanMessageOrigin, type Attachment, type HumanMessageOrigin } from "./types.ts";
-
-const SUBAGENT_LIVE_INTERCOM_EVENT = "subagent:live-intercom";
-const SUBAGENT_LIVE_INTERCOM_DELIVERY_EVENT = "subagent:live-intercom-delivery";
-const SUBAGENT_INTERCOM_HEALTH_REQUEST_EVENT = "subagent:intercom-health-request";
-const SUBAGENT_INTERCOM_HEALTH_RESPONSE_EVENT = "subagent:intercom-health-response";
-
-type PiEvents = ExtensionAPI["events"];
-
-type LiveEventDeps = {
-  events: PiEvents;
-  ensureConnected: () => Promise<IntercomClient>;
-  getConnection: () => { client: IntercomClient | null; connecting: boolean; started: boolean };
-  resolveSessionTarget: (client: IntercomClient, target: string) => Promise<string | null | undefined>;
-  currentSessionTargetMatches: (requestedTarget: string, resolvedTarget?: string, client?: IntercomClient) => boolean;
-  getLivenessCheck: () => () => boolean;
-};
-
-function getErrorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
+import { formatSessionTarget, resolveSessionTarget } from "./session-targets.ts";
+import {
+  isAttachment,
+  isHumanMessageOrigin,
+  type Attachment,
+  type HumanMessageOrigin,
+  type SessionInfo,
+} from "./types.ts";
+import { errorMessage, isRecord, isUnknownArray } from "./validation.ts";
+type PiEvents = Readonly<ExtensionAPI["events"]>;
+interface LiveEventDeps {
+  readonly events: PiEvents;
+  readonly ensureConnected: () => Promise<IntercomTransport>;
+  readonly getConnection: () => {
+    readonly client: IntercomTransport | null;
+    readonly connecting: boolean;
+    readonly started: boolean;
+  };
+  readonly resolveSessionTarget: (
+    client: IntercomTransport,
+    target: string,
+  ) => Promise<string | null | undefined>;
+  readonly currentSessionTargetMatches: (
+    requestedTarget: string,
+    resolvedTarget?: string,
+    client?: IntercomTransport,
+  ) => boolean;
+  readonly getLivenessCheck: () => () => boolean;
+  readonly own: (operation: () => Promise<void>) => void;
+}
+interface LivePayload {
+  readonly requestId: string;
+  readonly to: string;
+  readonly message: string;
+  readonly delivery: "queue" | "steer";
+  readonly messageId?: string;
+  readonly human?: HumanMessageOrigin;
+  readonly attachments?: readonly Attachment[];
 }
-
-function emitLiveDelivery(events: PiEvents, requestId: string | undefined, delivered: boolean, reason?: string, receipt?: { id: string; accepted: boolean; queued?: boolean }): void {
-  if (!requestId) return;
-  events.emit(SUBAGENT_LIVE_INTERCOM_DELIVERY_EVENT, {
+interface LiveReceipt {
+  readonly id: string;
+  readonly accepted: boolean;
+  readonly queued?: boolean;
+}
+function emitDelivery(
+  events: PiEvents,
+  requestId: string | undefined,
+  delivered: boolean,
+  result: { readonly reason?: string; readonly receipt?: LiveReceipt } = {},
+): void {
+  if (requestId === undefined || requestId === "") {
+    return;
+  }
+  const { reason, receipt } = result;
+  events.emit("subagent:live-intercom-delivery", {
     requestId,
     delivered,
-    ...(receipt ? { messageId: receipt.id, accepted: receipt.accepted, queued: receipt.queued } : {}),
-    ...(reason ? { reason } : {}),
+    ...(receipt
+      ? { messageId: receipt.id, accepted: receipt.accepted, queued: receipt.queued }
+      : {}),
+    ...(reason !== undefined && reason !== "" ? { reason } : {}),
   });
 }
-
-function parseLiveMessagePayload(payload: unknown): { requestId: string; to: string; message: string; delivery: "queue" | "steer"; messageId?: string; human?: HumanMessageOrigin; attachments?: Attachment[] } | undefined {
-  if (!payload || typeof payload !== "object") return undefined;
-  const parsed = payload as { requestId?: unknown; to?: unknown; message?: unknown; delivery?: unknown; messageId?: unknown; human?: unknown; attachments?: unknown };
-  if (typeof parsed.requestId !== "string" || typeof parsed.to !== "string" || typeof parsed.message !== "string") return undefined;
+function parseLivePayload(payload: unknown): LivePayload | undefined {
+  if (
+    !isRecord(payload) ||
+    typeof payload.requestId !== "string" ||
+    typeof payload.to !== "string" ||
+    typeof payload.message !== "string"
+  ) {
+    return;
+  }
+  const attachments = payload.attachments;
   return {
-    requestId: parsed.requestId,
-    to: parsed.to,
-    message: parsed.message,
-    delivery: parsed.delivery === "queue" ? "queue" : "steer",
-    ...(typeof parsed.messageId === "string" ? { messageId: parsed.messageId } : {}),
-    ...(isHumanMessageOrigin(parsed.human) ? { human: parsed.human } : {}),
-    ...(Array.isArray(parsed.attachments) && parsed.attachments.every(isAttachment) ? { attachments: parsed.attachments } : {}),
+    requestId: payload.requestId,
+    to: payload.to,
+    message: payload.message,
+    delivery: payload.delivery === "queue" ? "queue" : "steer",
+    ...(typeof payload.messageId === "string" ? { messageId: payload.messageId } : {}),
+    ...(isHumanMessageOrigin(payload.human) ? { human: payload.human } : {}),
+    ...(isUnknownArray(attachments) && attachments.every(isAttachment) ? { attachments } : {}),
   };
 }
-
-async function relayLiveSubagentMessage(payload: unknown, deps: LiveEventDeps): Promise<void> {
-  const parsed = parseLiveMessagePayload(payload);
-  if (!parsed) return;
-  const isLive = deps.getLivenessCheck();
-    if (!isLive()) return;
-    let activeClient: IntercomClient;
-    let target: string;
-    try {
-      activeClient = await deps.ensureConnected();
-      target = await deps.resolveSessionTarget(activeClient, parsed.to) ?? parsed.to;
-    } catch (error) {
-      if (isLive()) emitLiveDelivery(deps.events, parsed.requestId, false, getErrorMessage(error));
+async function relayLive(payload: unknown, deps: LiveEventDeps): Promise<void> {
+  const parsed = parseLivePayload(payload);
+  if (!parsed) {
+    return;
+  }
+  const live = deps.getLivenessCheck();
+  if (!live()) {
+    return;
+  }
+  try {
+    const client = await deps.ensureConnected();
+    const target = (await deps.resolveSessionTarget(client, parsed.to)) ?? parsed.to;
+    if (!live()) {
       return;
     }
-    if (!isLive()) return;
-    if (deps.currentSessionTargetMatches(parsed.to, target, activeClient)) {
-      emitLiveDelivery(deps.events, parsed.requestId, false, "Cannot message the current session");
+    if (deps.currentSessionTargetMatches(parsed.to, target, client)) {
+      emitDelivery(deps.events, parsed.requestId, false, {
+        reason: "Cannot message the current session",
+      });
       return;
     }
-    try {
-      const result = await activeClient.send(target, { text: parsed.message, delivery: parsed.delivery, messageId: parsed.messageId, human: parsed.human, attachments: parsed.attachments });
-      if (isLive()) emitLiveDelivery(deps.events, parsed.requestId, result.delivered, result.reason, result);
-    } catch (error) {
-      if (isLive()) emitLiveDelivery(deps.events, parsed.requestId, false, getErrorMessage(error));
+    const result = await client.send(target, {
+      text: parsed.message,
+      delivery: parsed.delivery,
+      messageId: parsed.messageId,
+      human: parsed.human,
+      attachments: parsed.attachments,
+    });
+    if (live()) {
+      emitDelivery(deps.events, parsed.requestId, result.delivered, {
+        reason: result.reason,
+        receipt: result,
+      });
     }
+  } catch (error) {
+    if (live()) {
+      emitDelivery(deps.events, parsed.requestId, false, { reason: errorMessage(error) });
+    }
+  }
 }
-
-function parseHealthPayload(payload: unknown): { requestId: string; targets: string[] } | undefined {
-  if (!payload || typeof payload !== "object") return undefined;
-  const parsed = payload as { requestId?: unknown; targets?: unknown };
-  if (typeof parsed.requestId !== "string" || !Array.isArray(parsed.targets)) return undefined;
-  const targets = parsed.targets.filter((target): target is string => typeof target === "string" && target.trim().length > 0);
-  return { requestId: parsed.requestId, targets };
-}
-
-async function answerLiveIntercomHealth(payload: unknown, deps: LiveEventDeps): Promise<void> {
-  const parsed = parseHealthPayload(payload);
-  if (!parsed) return;
-  const isLive = deps.getLivenessCheck();
-  const connectionSnapshot = (): SubagentIntercomConnection => {
-    const { client, connecting, started } = deps.getConnection();
-    return { status: !started ? "unknown" : connecting ? "connecting" : client?.isConnected() ? "unknown" : "disconnected", ...(client?.sessionId ? { sessionId: client.sessionId } : {}) };
+function parseHealth(
+  payload: unknown,
+): { readonly requestId: string; readonly targets: readonly string[] } | undefined {
+  if (
+    !isRecord(payload) ||
+    typeof payload.requestId !== "string" ||
+    !isUnknownArray(payload.targets)
+  ) {
+    return;
+  }
+  return {
+    requestId: payload.requestId,
+    targets: payload.targets.filter(
+      (target): target is string => typeof target === "string" && target.trim().length > 0,
+    ),
   };
-  const respond = (health: unknown[], connection: SubagentIntercomConnection) => {
-    if (isLive()) deps.events.emit(SUBAGENT_INTERCOM_HEALTH_RESPONSE_EVENT, { requestId: parsed.requestId, health, connection });
+}
+function connectionSnapshot(deps: LiveEventDeps): SubagentIntercomConnection {
+  const { client, connecting, started } = deps.getConnection();
+  let status: SubagentIntercomConnection["status"] = "unknown";
+  if (started) {
+    if (connecting) {
+      status = "connecting";
+    } else if (client?.isConnected() !== true) {
+      status = "disconnected";
+    }
+  }
+  const id = client?.sessionId;
+  return { status, ...(id !== undefined && id !== null && id !== "" ? { sessionId: id } : {}) };
+}
+function sessionNames(session: SessionInfo): Readonly<Record<string, string>> {
+  return {
+    ...(session.name !== undefined && session.name !== "" ? { sessionName: session.name } : {}),
+    ...(session.status !== undefined && session.status !== ""
+      ? { sessionStatus: session.status }
+      : {}),
   };
-    if (!isLive()) return;
-    try {
-      // An empty target list is a read-only check of this bridge, not a reconnect request.
-      const activeClient = parsed.targets.length ? await deps.ensureConnected() : deps.getConnection().client;
-      if (!activeClient?.isConnected()) { respond([], connectionSnapshot()); return; }
-      const sessions = await activeClient.listSessions();
-      const health = parsed.targets.map((target) => {
-        const resolution = resolveSessionTargetValue(sessions, target);
-        if (resolution.status !== "found") return { target, status: resolution.status };
-        const session = resolution.target!;
-        return {
-          target,
-          status: "registered" as const,
-          resolvedTarget: formatSessionTarget(session, sessions),
-          sessionId: session.id,
-          ...(session.name ? { sessionName: session.name } : {}),
-          ...(session.status ? { sessionStatus: session.status } : {}),
-          ...(session.acceptsAsks !== undefined ? { acceptsAsks: session.acceptsAsks } : {}),
-          ...(session.pendingAsks !== undefined ? { pendingAsks: session.pendingAsks } : {}),
-          ...(session.lastSeen !== undefined ? { lastSeen: session.lastSeen } : {}),
-          ...(session.lastIntercomActivity !== undefined ? { lastIntercomActivity: session.lastIntercomActivity } : {}),
-        };
+}
+async function answerHealth(payload: unknown, deps: LiveEventDeps): Promise<void> {
+  const parsed = parseHealth(payload);
+  if (!parsed) {
+    return;
+  }
+  const live = deps.getLivenessCheck();
+  const respond = (health: readonly unknown[], connection: SubagentIntercomConnection) => {
+    if (live()) {
+      deps.events.emit("subagent:intercom-health-response", {
+        requestId: parsed.requestId,
+        health,
+        connection,
       });
-      const registered = activeClient.isConnected() && sessions.some((session) => session.id === activeClient.sessionId);
-      respond(health, registered ? { status: "connected", sessionId: activeClient.sessionId! } : { ...connectionSnapshot(), reason: "Current broker registration was not confirmed." });
-    } catch (error) {
-      respond(parsed.targets.map((target) => ({ target, status: "missing" })), { ...connectionSnapshot(), reason: getErrorMessage(error) });
     }
+  };
+  if (!live()) {
+    return;
+  }
+  try {
+    // Empty targets observe the bridge without reconnecting.
+    const client =
+      parsed.targets.length > 0 ? await deps.ensureConnected() : deps.getConnection().client;
+    if (client?.isConnected() !== true) {
+      respond([], connectionSnapshot(deps));
+      return;
+    }
+    const sessions = await client.listSessions();
+    const health = parsed.targets.map((target) => {
+      const resolution = resolveSessionTarget(sessions, target);
+      const session = resolution.target;
+      if (resolution.status !== "found" || !session) {
+        return { target, status: resolution.status };
+      }
+      return {
+        target,
+        status: "registered",
+        resolvedTarget: formatSessionTarget(session, sessions),
+        sessionId: session.id,
+        ...sessionNames(session),
+        ...(session.acceptsAsks !== undefined ? { acceptsAsks: session.acceptsAsks } : {}),
+        ...(session.pendingAsks !== undefined ? { pendingAsks: session.pendingAsks } : {}),
+        ...(session.lastSeen !== undefined ? { lastSeen: session.lastSeen } : {}),
+        ...(session.lastIntercomActivity !== undefined
+          ? { lastIntercomActivity: session.lastIntercomActivity }
+          : {}),
+      };
+    });
+    const id = client.sessionId;
+    const registered = client.isConnected() && sessions.some((session) => session.id === id);
+    respond(
+      health,
+      registered && id !== null
+        ? { status: "connected", sessionId: id }
+        : { ...connectionSnapshot(deps), reason: "Current broker registration was not confirmed." },
+    );
+  } catch (error) {
+    respond(
+      parsed.targets.map((target) => ({ target, status: "missing" })),
+      { ...connectionSnapshot(deps), reason: errorMessage(error) },
+    );
+  }
 }
-
-export function registerSubagentLiveEventHandlers(deps: LiveEventDeps): Array<() => void> {
+export function registerSubagentLiveEventHandlers(deps: LiveEventDeps): (() => void)[] {
   return [
-    deps.events.on(SUBAGENT_LIVE_INTERCOM_EVENT, (payload) => relayLiveSubagentMessage(payload, deps)),
-    deps.events.on(SUBAGENT_INTERCOM_HEALTH_REQUEST_EVENT, (payload) => answerLiveIntercomHealth(payload, deps)),
+    deps.events.on("subagent:live-intercom", (payload) => {
+      deps.own(() => relayLive(payload, deps));
+    }),
+    deps.events.on("subagent:intercom-health-request", (payload) => {
+      deps.own(() => answerHealth(payload, deps));
+    }),
   ];
 }