@bastani/atomic 0.9.18 → 0.9.19-alpha.10

package/dist/builtin/intercom/broker/broker.ts

@@ -4,7 +4,7 @@ import "./bounded-stderr-install.js";
 import net from "net";
 import { chmodSync, writeFileSync, unlinkSync, mkdirSync, readFileSync } from "fs";
 import { randomUUID } from "crypto";
-import { createMessageReader } from "./framing.js";
+import { createMessageReader, type JsonWireValue } from "./framing.js";
 import { writeMessageIfOpen, writeMessageWithOutcome } from "./socket-writes.js";
 import {
 	getBrokerDeliveredMessagesPath,
@@ -21,6 +21,7 @@ import type {
 	WorkflowStageRosterEntry,
 	WorkflowPossibleStageAnnouncement,
 	WorkflowFutureStageRosterEntry,
+	WorkflowRunParentAnnouncement,
 } from "../types.js";
 import {
 	formatWorkflowStageTarget,
@@ -50,6 +51,7 @@ import {
 import { PendingQuestionIndex } from "./pending-question-index.js";
 import { matchStagePathSegments } from "../workflow-stage-path-matching.js";
 import { DELIVERED_MESSAGE_TTL_MS } from "../retry-policy.js";
+import { isAgentRecipient } from "../recipient-purpose.js";
 
 const INTERCOM_DIR = getIntercomDirPath();
 const SOCKET_PATH = getBrokerSocketPath();
@@ -68,6 +70,7 @@ interface WorkflowRosterRegistration {
 	readonly group: string;
 	readonly stages: WorkflowStageRosterAnnouncement[];
 	readonly possibleStages?: readonly WorkflowPossibleStageAnnouncement[];
+	readonly parent?: WorkflowRunParentAnnouncement;
 }
 
 
@@ -83,6 +86,7 @@ interface PendingStageAcknowledgment {
 	readonly message: Message;
 	readonly liveTargetId?: string;
 	readonly signature?: string;
+	readonly resolveReplyTarget?: true;
   readonly timeout: NodeJS.Timeout;
 }
 
@@ -135,7 +139,11 @@ function isSessionRegistration(value: unknown): value is Omit<SessionInfo, "id">
     return false;
   }
 
-
+  if (session.replyCapability !== undefined && session.replyCapability !== "live" && session.replyCapability !== "terminal") return false;
+  if (session.recipientPurpose !== undefined &&
+    session.recipientPurpose !== "agent" && session.recipientPurpose !== "control") {
+    return false;
+  }
   if (session.groups !== undefined &&
     (!Array.isArray(session.groups) || !session.groups.every((group) => typeof group === "string"))) {
     return false;
@@ -155,6 +163,16 @@ function invocationOwnsGroup(invocationGroup: string, candidateGroup: string): b
 	return candidate === owner || candidate.startsWith(`${owner}/`);
 }
 
+function readWorkflowRunParentAnnouncement(value: JsonWireValue | undefined): WorkflowRunParentAnnouncement | undefined {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+	if (
+		typeof value.runId !== "string" ||
+		!Array.isArray(value.stageKeys) ||
+		!value.stageKeys.every((key) => typeof key === "string")
+	) return undefined;
+	return { runId: value.runId, stageKeys: value.stageKeys };
+}
+
 function isWorkflowStageRosterAnnouncements(
 	value: unknown,
 	runId: string,
@@ -183,6 +201,9 @@ function isWorkflowStageRosterAnnouncements(
 					parsed.segments.slice(0, -1).includes(runId)) &&
 				(announcement.lifecycle === "pending" || announcement.lifecycle === "running") &&
 				typeof announcement.routeEligible === "boolean" &&
+				(announcement.recipientPurpose === undefined ||
+					announcement.recipientPurpose === "agent" ||
+					announcement.recipientPurpose === "control") &&
 				typeof announcement.group === "string"
 			);
 		})
@@ -371,6 +392,35 @@ class IntercomBroker {
 		const matches = roster.stages.filter((stage) => stage.stageId === stageKey || stage.stageName === stageKey);
 		return matches.length === 1 ? matches[0]!.target : undefined;
 	};
+	private isNonAgentWorkflowTarget = (target: string): boolean => {
+		const parsed = parseWorkflowStageTarget(target);
+		if (parsed?.kind !== "path") return false;
+		// A connected agent's registered alias outlives its pending roster row.
+		// A same-name control announcement must not revoke that live identity.
+		if (this.resolveLiveWorkflowStage(target) !== undefined) return false;
+		const rosters = [...this.workflowRosters].filter(([, roster]) => roster.group === `workflow:${parsed.rootRunId}`);
+		let runId: string | undefined = parsed.rootRunId;
+		for (const segment of parsed.segments.slice(0, -1)) {
+			// Match the host's materialized-stage traversal: run IDs can jump at any
+			// depth; otherwise follow a uniquely resolved boundary ID/name edge.
+			if (rosters.some(([id]) => id === segment)) {
+				runId = segment;
+				continue;
+			}
+			const children = rosters.filter(([, roster]) => roster.parent?.runId === runId && roster.parent.stageKeys.includes(segment));
+			runId = children.length === 1 ? children[0]![0] : undefined;
+			if (runId === undefined) break;
+		}
+		const stageKey = parsed.segments.at(-1);
+		const stages = rosters.find(([id]) => id === runId)?.[1].stages;
+		const byId = stages?.filter((stage) => stage.stageId === stageKey) ?? [];
+		// Hosts without parent-edge metadata still support their advertised literal targets.
+		const matches = stages === undefined ? rosters.flatMap(([, roster]) => roster.stages.filter((stage) =>
+			stage.target === target || withWorkflowStageTargetFinalSegment(stage.target, stage.stageName) === target,
+		)) : byId.length > 0 ? byId : stages.filter((stage) => stage.stageName === stageKey);
+		return matches.some((stage) => !isAgentRecipient(stage)) && !matches.some(isAgentRecipient);
+	};
+
 
 	private resolveLiveWorkflowStage = (target: string): ConnectedSession | undefined => {
 		const registration = this.liveWorkflowStageRoutes.get(target);
@@ -392,7 +442,7 @@ class IntercomBroker {
 			return undefined;
 		}
 		const session = this.sessions.get(registration.sessionId);
-		if (session !== undefined) return session;
+		if (session !== undefined && isAgentRecipient(session.info)) return session;
 		this.liveWorkflowStageRoutes.delete(target);
 		return undefined;
 	};
@@ -440,7 +490,7 @@ class IntercomBroker {
 	const entries: WorkflowStageRosterEntry[] = [];
 	for (const [runId, roster] of this.workflowRosters) {
 		for (const stage of roster.stages) {
-			if (!stage.routeEligible) continue;
+			if (!stage.routeEligible || !isAgentRecipient(stage)) continue;
 			const parentControl =
 				this.canControlWorkflowInvocation(requester, roster.group) && invocationOwnsGroup(roster.group, stage.group);
 			const directMembership = requesterGroups.has(stage.group);
@@ -485,6 +535,7 @@ class IntercomBroker {
 			if (![...requesterGroups].some((group) => invocationOwnsGroup(roster.group, group))) continue;
 			if (selected !== undefined && selected !== roster.group) continue;
 			for (const row of roster.possibleStages) {
+				if (this.isNonAgentWorkflowTarget(row.target)) continue;
 				entries.push({
 					kind: "workflow-future-stage",
 					runId,
@@ -528,6 +579,10 @@ class IntercomBroker {
 		// swaps its final segment. Without a roster entry, fall back to the flat run-id prefix
 		// (still an accepted resolver input).
 		const roster = this.workflowRosters.get(runId);
+		if (uniqueStageKeys.some((key) => {
+			const matches = roster?.stages.filter((stage) => stage.stageId === key || stage.stageName === key) ?? [];
+			return matches.length > 0 && matches.every((stage) => !isAgentRecipient(stage));
+		})) return false;
 		const targets = uniqueStageKeys.map((stageKey) => {
 			const entry = roster?.stages.find((stage) => stage.stageId === stageKey || stage.stageName === stageKey);
 			const entryTarget = entry === undefined ? undefined : parseWorkflowStageTarget(entry.target);
@@ -627,6 +682,7 @@ class IntercomBroker {
 		message: route.message,
 		...(route.liveTargetId === undefined ? {} : { liveTargetId: route.liveTargetId }),
 		...(route.signature === undefined ? {} : { signature: route.signature }),
+		...(route.resolveReplyTarget === true ? { resolveReplyTarget: true } : {}),
       timeout,
     });
     if (
@@ -774,6 +830,8 @@ class IntercomBroker {
 						return;
 					}
 					this.pendingQuestions.record(from.info.id, target.info.id, pending.messageId);
+					if (pending.resolveReplyTarget === true && pending.attemptId !== undefined)
+						writeMessageIfOpen(pending.senderSocket, { type: "question_target", messageId: pending.messageId, attemptId: pending.attemptId, sessionId: target.info.id });
 				}
 				writeMessageIfOpen(pending.senderSocket, {
 					type: "delivered",
@@ -826,6 +884,8 @@ class IntercomBroker {
 					return;
 				}
 				this.pendingQuestions.record(from.info.id, target.info.id, pending.messageId);
+				if (pending.resolveReplyTarget === true && pending.attemptId !== undefined)
+					writeMessageIfOpen(pending.senderSocket, { type: "question_target", messageId: pending.messageId, attemptId: pending.attemptId, sessionId: target.info.id });
 			}
 			writeMessageIfOpen(pending.senderSocket, {
 				type: "delivered",
@@ -849,6 +909,8 @@ class IntercomBroker {
 			});
 			return;
 		}
+		if (pending.message.expectsReply === true && pending.resolveReplyTarget === true && pending.attemptId !== undefined)
+			writeMessageIfOpen(pending.senderSocket, { type: "question_target", messageId: pending.messageId, attemptId: pending.attemptId, sessionId: target.info.id });
 		if (!writeMessageIfOpen(target.socket, { type: "message", from: pending.sender, message: pending.message })) {
 			this.deliveredMessages.forget(pending.messageId, pending.signature);
 			writeMessageIfOpen(pending.senderSocket, {
@@ -1029,6 +1091,7 @@ class IntercomBroker {
 		}
 		if (
 			target === undefined ||
+			!isAgentRecipient(target.info) ||
 			target.info.id === currentId ||
 			normalizeGroup(target.registrationGroup) !== routeGroup ||
 			!hasGroup(sessionGroups(target.info), routeGroup)
@@ -1164,15 +1227,15 @@ class IntercomBroker {
 
   private handleMessage(
     socket: net.Socket,
-    msg: unknown,
+    msg: JsonWireValue,
     currentId: string | null,
     setId: (id: string | null) => void,
   ): void {
-    if (typeof msg !== "object" || msg === null || !("type" in msg) || typeof msg.type !== "string") {
+    if (typeof msg !== "object" || msg === null || Array.isArray(msg) || typeof msg.type !== "string") {
       throw new Error("Invalid client message");
     }
 
-    const clientMessage = msg as { type: string } & Record<string, unknown>;
+    const clientMessage = msg;
 
     if (currentId === null && clientMessage.type !== "register") {
       throw new Error(`Received ${clientMessage.type} before register`);
@@ -1248,7 +1311,7 @@ class IntercomBroker {
         writeMessageIfOpen(socket, supervisorId
           ? { type: "registered", sessionId: id, supervisorSessionId: supervisorId }
           : { type: "registered", sessionId: id });
-        this.broadcastToMemberships({ type: "session_joined", session: info }, sessionGroups(info), id);
+        if (isAgentRecipient(info)) this.broadcastToMemberships({ type: "session_joined", session: info }, sessionGroups(info), id);
         break;
       }
 
@@ -1377,6 +1440,10 @@ class IntercomBroker {
           clientMessage.possibleStages !== undefined
             ? clientMessage.possibleStages
             : this.workflowRosters.get(clientMessage.runId)?.possibleStages;
+		// Optional path metadata is advisory for old hosts; omission retains a
+		// previously announced edge during two-session route replay.
+		const parent = readWorkflowRunParentAnnouncement(clientMessage.parent)
+			?? this.workflowRosters.get(clientMessage.runId)?.parent;
         if (activeExisting !== undefined && activeExisting.sessionId !== currentId) {
           // A stage replays the process-shared owner announcement before registering its live aliases.
           // It may publish the materialized roster, but the original workflow owner must continue to
@@ -1387,6 +1454,7 @@ class IntercomBroker {
               group: ownerGroup,
               stages: clientMessage.stages ?? [],
               ...(possibleStages === undefined ? {} : { possibleStages }),
+              ...(parent === undefined ? {} : { parent }),
             });
           }
           break;
@@ -1402,6 +1470,7 @@ class IntercomBroker {
             group: ownerGroup,
             stages: clientMessage.stages ?? [],
             ...(possibleStages === undefined ? {} : { possibleStages }),
+            ...(parent === undefined ? {} : { parent }),
           });
         }
         break;
@@ -1437,6 +1506,7 @@ class IntercomBroker {
         if (
           ownerRegistration === undefined ||
           registeringSession === undefined ||
+		  !isAgentRecipient(registeringSession.info) ||
           ownerRegistration.capability !== clientMessage.capability ||
 		  !invocationOwnsGroup(
 			ownerRegistration.group,
@@ -1509,6 +1579,7 @@ class IntercomBroker {
 				this.canControlLiveWorkflowStage,
 				this.resolveLegacyWorkflowStageTarget,
 				writeMessageWithOutcome,
+				this.isNonAgentWorkflowTarget,
 			);
 			break;
 		}
@@ -1535,6 +1606,7 @@ class IntercomBroker {
           currentId,
           this.sessions,
           (target, message) => writeMessageIfOpen(target, message),
+          this.pendingQuestions,
         );
         break;
       }
@@ -1597,7 +1669,7 @@ class IntercomBroker {
 		if (activation.sessionId === sessionId) this.liveWorkflowStageRouteActivations.delete(requestId);
 	}
 	this.sessions.delete(sessionId);
-	this.broadcastToMemberships({ type: "session_left", sessionId }, sessionGroups(departed.info), sessionId);
+	if (isAgentRecipient(departed.info)) this.broadcastToMemberships({ type: "session_left", sessionId }, sessionGroups(departed.info), sessionId);
 	}
   /** Deliver a broadcast once to each session represented in any given group. */
   private broadcastToMemberships(msg: BrokerMessage, groups: ReadonlySet<string>, exclude?: string): void {

package/dist/builtin/intercom/broker/client.ts

@@ -14,6 +14,7 @@ import type {
 	WorkflowStageRosterEntry,
 	WorkflowFutureStageRosterEntry,
 	WorkflowPossibleStageAnnouncement,
+	WorkflowRunParentAnnouncement,
 } from "../types.js";
 import { buildSendSignature, PendingSendRegistry } from "./pending-send-registry.js";
 import { readSubagentMessageSource } from "../source-ownership.js";
@@ -37,6 +38,10 @@ export interface SendOptions {
   logicalTarget?: string;
   /** Public reply must use the broker's exact pending reverse question route. */
   requirePendingReply?: true;
+  /** An explicit reply selector must resolve to this frozen recipient, never a namesake. */
+  expectedRecipientId?: string;
+  /** Broker-authorized identity for a canonical-path ask, delivered before its recipient can reply. */
+  onReplyTarget?: (sessionId: string) => void;
 }
 
 export interface SendResult {
@@ -92,6 +97,7 @@ export interface PresenceUpdates {
   model?: string;
   groups?: string[];
   group?: string;
+  replyCapability?: SessionInfo["replyCapability"];
 }
 
 
@@ -151,6 +157,7 @@ export class IntercomClient extends EventEmitter {
   /** Source identity is captured once at connect, never read from env per message. */
   private _messageSource: Message["source"] | undefined;
   private pendingSends = new PendingSendRegistry();
+  private pendingReplyTargets = new Map<string, { messageId: string; bind(sessionId: string): void }>();
   private pendingGroupLists = new Map<string, { resolve: (groups: GroupSummary[]) => void; reject: (error: Error) => void }>();
   private pendingLists = new Map<string, { resolve: (directory: SessionDirectory) => void; reject: (e: Error) => void }>();
   private pendingPresence = new Map<string, {
@@ -410,7 +417,34 @@ export class IntercomClient extends EventEmitter {
       }
       case "registration_failed": {
         if (typeof brokerMessage.reason !== "string") throw new Error("Invalid registration_failed message");
-        this.emit("_registration_failed", new Error(brokerMessage.reason));
+        const refusal = new Error(brokerMessage.reason);
+        if (this._sessionId === null) {
+          // Still registering: `connect()` owns the failure and its own cleanup.
+          this.emit("_registration_failed", refusal);
+          break;
+        }
+        // The broker reuses this frame to refuse an *established* client's request
+        // (for example a rejected pending-stage route update) and then ends the
+        // socket, deliberately dropping anything already pipelined behind it. By
+        // this point `connect()` has removed its `_registration_failed` listener,
+        // so emitting there would discard the refusal and leave every pipelined
+        // request — notably the `listSessions()` barrier — to expire on its own
+        // five-second timer with an unusable diagnostic. Record the refusal as the
+        // disconnect cause, settle outstanding work with it, and destroy the socket
+        // so no new work is accepted while we wait for the peer FIN. `onClose`
+        // still owns session/socket teardown and the `disconnected` emission.
+        this.disconnectError ??= refusal;
+        this.failPending(this.disconnectError);
+        this.socket?.destroy();
+        break;
+      }
+      case "question_target": {
+        const { messageId, attemptId, sessionId } = brokerMessage;
+        if (typeof messageId !== "string" || typeof attemptId !== "string" || typeof sessionId !== "string") {
+          throw new Error("Invalid question_target message");
+        }
+        const pending = this.pendingReplyTargets.get(attemptId);
+        if (pending?.messageId === messageId) pending.bind(sessionId);
         break;
       }
       case "sessions": {
@@ -855,6 +889,7 @@ export class IntercomClient extends EventEmitter {
 	capability: string,
 	stages?: WorkflowStageRosterAnnouncement[],
 	possibleStages?: WorkflowPossibleStageAnnouncement[],
+	parent?: WorkflowRunParentAnnouncement,
   ): void {
 	writeMessage(this.requireActiveSocket(), {
 		type: "register_pending_stage_route",
@@ -863,6 +898,7 @@ export class IntercomClient extends EventEmitter {
 		capability,
 		stages,
 		possibleStages,
+		...(parent === undefined ? {} : { parent }),
 	});
   }
 
@@ -970,6 +1006,7 @@ export class IntercomClient extends EventEmitter {
 			transportTarget: to,
 			logicalSignature: buildSendSignature(options.logicalTarget ?? to, options),
 			requirePendingReply: options.requirePendingReply ?? false,
+			...(options.expectedRecipientId === undefined ? {} : { expectedRecipientId: options.expectedRecipientId }),
 		});
 		acquired = this.pendingSends.acquire(messageId, pendingSignature, 10000);
     } catch (error) {
@@ -985,12 +1022,17 @@ export class IntercomClient extends EventEmitter {
       source: this._messageSource,
       content: { text: options.text, attachments: options.attachments },
     };
+    if (options.onReplyTarget !== undefined) {
+      this.pendingReplyTargets.set(acquired.attempt.attemptId, { messageId, bind: options.onReplyTarget });
+    }
     try {
 		writeMessage(socket, {
 			type,
 			to,
 			...(options.logicalTarget === undefined ? {} : { logicalTarget: options.logicalTarget }),
 			...(options.requirePendingReply === undefined ? {} : { requirePendingReply: options.requirePendingReply }),
+			...(options.expectedRecipientId === undefined ? {} : { expectedRecipientId: options.expectedRecipientId }),
+      ...(options.onReplyTarget === undefined ? {} : { resolveReplyTarget: true as const }),
 			message,
 			attemptId: acquired.attempt.attemptId,
 			...extra,
@@ -998,6 +1040,8 @@ export class IntercomClient extends EventEmitter {
     } catch (error) {
       this.pendingSends.reject(acquired.attempt, toError(error));
     }
+    const clearReplyTarget = () => { this.pendingReplyTargets.delete(acquired.attempt.attemptId); };
+    void acquired.attempt.promise.then(clearReplyTarget, clearReplyTarget);
     return acquired.attempt.promise;
   }
   updatePresence(updates: PresenceUpdates): boolean {

package/dist/builtin/intercom/broker/framing.ts

@@ -1,5 +1,8 @@
 import type { Socket } from "net";
 
+/** JSON values at the framing boundary, before protocol-specific validation. */
+export type JsonWireValue = string | number | boolean | null | JsonWireValue[] | { [key: string]: JsonWireValue };
+
 /**
  * Write a length-prefixed message to a socket.
  * Format: 4-byte big-endian length + JSON payload
@@ -20,7 +23,7 @@ export function writeMessage(socket: Socket, msg: unknown, callback?: (error?: E
  * Protocol or handler errors are reported to onError so the caller can close the socket.
  */
 export function createMessageReader(
-  onMessage: (msg: unknown) => void,
+  onMessage: (msg: JsonWireValue) => void,
   onError: (error: Error) => void,
 ) {
   let buffer = Buffer.alloc(0);
@@ -38,7 +41,7 @@ export function createMessageReader(
       const payload = buffer.subarray(4, 4 + length);
       buffer = buffer.subarray(4 + length);
 
-      let msg: unknown;
+      let msg: JsonWireValue;
       try {
         msg = JSON.parse(payload.toString("utf-8"));
       } catch (error) {

package/dist/builtin/intercom/broker/group-membership.ts

@@ -1,6 +1,7 @@
 import { hasGroup, normalizeGroup, normalizeGroups } from "../group.js";
 import type { GroupSummary, SessionInfo } from "../types.js";
 import type { BrokerConnectedSession } from "./send-handler.js";
+import { isAgentRecipient } from "../recipient-purpose.js";
 
 /** Return the normalized memberships carried by a wire session. */
 export function sessionGroups(session: SessionInfo): Set<string> {
@@ -28,7 +29,7 @@ export function sessionsVisibleTo(
 	sessions: ReadonlyMap<string, BrokerConnectedSession>,
 	requester: SessionInfo,
 ): SessionInfo[] {
-	return [...sessions.values()].map(({ info }) => info).filter((info) => sessionsShareGroup(requester, info));
+	return [...sessions.values()].map(({ info }) => info).filter((info) => isAgentRecipient(info) && sessionsShareGroup(requester, info));
 }
 
 /** Return sessions that belong to one explicit group. */
@@ -36,7 +37,7 @@ export function sessionsInGroup(
 	sessions: ReadonlyMap<string, BrokerConnectedSession>,
 	group: string | undefined,
 ): SessionInfo[] {
-	return [...sessions.values()].map(({ info }) => info).filter((info) => hasGroup(sessionGroups(info), group));
+	return [...sessions.values()].map(({ info }) => info).filter((info) => isAgentRecipient(info) && hasGroup(sessionGroups(info), group));
 }
 
 /** Summarize every group currently represented by a connected session. */
@@ -46,6 +47,7 @@ export function knownGroupSummaries(
 ): GroupSummary[] {
 	const counts = new Map<string, number>();
 	for (const { info } of sessions.values()) {
+		if (!isAgentRecipient(info)) continue;
 		for (const group of sessionGroups(info)) counts.set(group, (counts.get(group) ?? 0) + 1);
 	}
 	const requesterGroups = sessionGroups(requester);

package/dist/builtin/intercom/broker/presence-handler.ts

@@ -3,6 +3,9 @@ import { addGroup, normalizeGroups, removeGroup, validateRuntimeGroup } from "..
 import type { BrokerMessage } from "../types.js";
 import { sessionGroups, sessionsShareGroup, setSessionGroups } from "./group-membership.js";
 import type { BrokerConnectedSession } from "./send-handler.js";
+import { isAgentRecipient } from "../recipient-purpose.js";
+import type { PendingQuestionIndex } from "./pending-question-index.js";
+import { failTerminalQuestions } from "./terminal-questions.js";
 
 interface PresenceClientMessage extends Record<string, unknown> {
 	type: string;
@@ -16,6 +19,7 @@ function broadcastMembershipChange(
 	session: BrokerConnectedSession,
 	previous: ReadonlySet<string>,
 ): void {
+	if (!isAgentRecipient(session.info)) return;
 	const previousInfo = { ...session.info, groups: [...previous], group: previous.values().next().value };
 	for (const [id, peer] of sessions) {
 		if (id === session.info.id) continue;
@@ -38,6 +42,7 @@ export function handleBrokerPresence(
 	currentId: string | null,
 	sessions: Map<string, BrokerConnectedSession>,
 	write: WriteMessage,
+	pendingQuestions?: PendingQuestionIndex,
 ): void {
 	const rawRequestId = clientMessage.requestId;
 	if (rawRequestId !== undefined && typeof rawRequestId !== "string") {
@@ -97,10 +102,19 @@ export function handleBrokerPresence(
 	if (status !== undefined && typeof status !== "string") return void fail("Invalid presence status");
 	const model = clientMessage.model;
 	if (model !== undefined && typeof model !== "string") return void fail("Invalid presence model");
+	const capability = clientMessage.replyCapability;
+	if (capability !== undefined && capability !== "live" && capability !== "terminal") {
+		return void fail("Invalid reply capability");
+	}
+	if (capability === "live" && session.info.replyCapability === "terminal") {
+		return void fail("Terminal reply capability cannot be revived");
+	}
 
 	if (typeof name === "string") session.info.name = name;
 	if (typeof status === "string") session.info.status = status;
 	if (typeof model === "string") session.info.model = model;
+	if (capability === "live" || capability === "terminal") session.info.replyCapability = capability;
+	if (capability === "terminal" && pendingQuestions) failTerminalQuestions(session, sessions, pendingQuestions, write);
 	setSessionGroups(session.info, nextGroups, legacyGroup);
 	session.info.lastActivity = Date.now();
 	broadcastMembershipChange(sessions, write, session, previousGroups);