pi-harness-runtime 1.1.397 → 1.1.402

package/packages/telegram/src/bus.js

@@ -0,0 +1,2732 @@
+/**
+ * Telegram multi-instance bus protocol and IPC helpers
+ * Zones: multi-instance bus, local IPC contract, live instance routing
+ * Owns serializable bus envelopes, socket/auth helpers, local IPC client/server primitives,
+ * cross-instance forwarding helpers, and the live follower registry model.
+ */
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readlinkSync, renameSync, symlinkSync, unlinkSync, } from "node:fs";
+import { createRequire } from "node:module";
+import { createConnection, createServer, } from "node:net";
+import { platform as getPlatform, tmpdir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { classifyTelegramBusTransportError, createTelegramBusTransportTimeoutError, delayTelegramBusTransportRetry, getTelegramBusEndpointDiagnostics, getTelegramBusFollowerEndpoint, getTelegramBusLeaderEndpoint, getTelegramBusPipePath, getTelegramBusTransportRetryPolicy, isRetryableTelegramBusTransportError, isTelegramBusPipePath, probeTelegramBusEndpoint, TELEGRAM_BUS_MAX_DIRECT_UNIX_ENDPOINT_BYTES, } from "./bus-transport.js";
+import { isSameTelegramLockOwner, TELEGRAM_BUS_LEADER_STALE_HEARTBEAT_MS, } from "./locks.js";
+import { resolveAgentDir } from "./paths.js";
+import { getTelegramProcessBirthIdentity } from "./process-identity.js";
+import { parseTelegramQueueHandoffPayload, TELEGRAM_QUEUE_HANDOFF_PAYLOAD_MAX_BYTES, } from "./queue.js";
+import { areTelegramTargetsEqual, parseTelegramTarget as parseTarget, } from "./target.js";
+import { normalizeTelegramSessionReplacementIntent, } from "./threads.js";
+import { hasOnlyWireKeys, isWireRecord as isRecord } from "./wire.js";
+export function createCurrentTelegramBusProcessRuntime(input) {
+    return createTelegramBusProcessRuntime({
+        getActiveProfileName: input.getActiveProfileName,
+        endpointLayout: input.endpointLayout,
+        pid: input.pid ?? process.pid,
+        parentPid: input.parentPid ?? process.ppid,
+        createdAtMs: input.createdAtMs ?? Date.now(),
+    });
+}
+export function createTelegramBusProcessRuntime(input) {
+    const getActiveProfileName = input.getActiveProfileName, endpointLayout = input.endpointLayout;
+    const instanceId = `${input.pid}:${input.createdAtMs}`;
+    const ownerPid = input.parentPid || input.pid;
+    const manualFollowerOwnerId = input.parentProcessIdentity ??
+        getTelegramProcessBirthIdentity(ownerPid, input.createdAtMs);
+    return {
+        instanceId,
+        processId: input.pid,
+        processBirthId: getTelegramProcessBirthIdentity(input.pid, instanceId),
+        manualFollowerOwnerId,
+        getLeaderSocketPath: () => getTelegramBusSocketPath(undefined, undefined, getActiveProfileName(), endpointLayout),
+        getFollowerSocketPath: () => getTelegramBusFollowerSocketPath(instanceId, undefined, undefined, getActiveProfileName(), endpointLayout),
+    };
+}
+export function createTelegramBusAuthSecret() {
+    return randomBytes(32).toString("base64url");
+}
+// v3: journal source serialization left the config transaction; mixed v2/v3 peers would not exclude each other.
+const TELEGRAM_BUS_PROTOCOL_VERSION = 3;
+export const TELEGRAM_BUS_CAPABILITY_DURABLE_FOLLOWER_ADMISSION = "durable-follower-admission-v1";
+export const TELEGRAM_BUS_CAPABILITY_QUEUE_HANDOFF = "queue-handoff-v1";
+export const TELEGRAM_BUS_CAPABILITY_INPUT_CUSTODY_REFERENCE = "input-custody-reference-v1";
+export const TELEGRAM_BUS_CAPABILITY_WORKSPACE_THREAD_RENAME = "workspace-thread-rename-v1";
+export const TELEGRAM_BUS_CAPABILITY_THREAD_DISPLAY_MODE = "thread-display-mode-v1";
+export const TELEGRAM_BUS_CAPABILITY_DIRECTORY_DISPLAY_FORMAT = "directory-display-format-v1";
+export const TELEGRAM_BUS_CAPABILITY_WORKSPACE_FOLLOWER_AUTO_CONNECT = "workspace-follower-auto-connect-v1";
+export const TELEGRAM_BUS_CAPABILITY_SESSION_REPLACEMENT_INTENT = "session-replacement-intent-v1";
+export const TELEGRAM_BUS_CAPABILITY_WORKSPACE_RESTORE = "workspace-restore-v1";
+export const TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_SAVE = "live-thread-rebind-save-v1";
+export const TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_APPLY = "live-thread-rebind-apply-v1";
+export const TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_SETTLE = "live-thread-rebind-settle-v1";
+/** Restricted recipient text/menu delivery; negotiated identity and captured effect authority remain required. */
+export const TELEGRAM_BUS_CAPABILITY_SELECTED_MENU_DELIVERY = "selected-menu-delivery-v1";
+/** Versioned held-command set; syntax is shared, while the captured recipient Commands registry owns supported plans. */
+export const TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_COMMAND_SET = "live-thread-rebind-command-set-v1";
+/** Every live rebinding needs the save/apply/settle trio; held command selections additionally need these two. */
+export const TELEGRAM_BUS_LIVE_REBIND_CAPABILITIES = [
+    TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_SAVE,
+    TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_APPLY,
+    TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_SETTLE,
+];
+export const TELEGRAM_BUS_HELD_COMMAND_CAPABILITIES = [
+    TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_COMMAND_SET,
+    TELEGRAM_BUS_CAPABILITY_SELECTED_MENU_DELIVERY,
+];
+function parseSelectedCommandInput(value) {
+    if (!isRecord(value) ||
+        !hasOnlyWireKeys(value, ["name", "target"]) ||
+        typeof value.name !== "string" ||
+        !/^[a-z0-9_]{1,32}$/u.test(value.name) ||
+        !isRecord(value.target) ||
+        !hasOnlyWireKeys(value.target, ["chatId", "threadId"]))
+        return undefined;
+    const target = parseThreadTarget(value.target);
+    return target &&
+        Number.isSafeInteger(target.chatId) &&
+        target.chatId > 0 &&
+        Number.isSafeInteger(target.threadId) &&
+        target.threadId > 0
+        ? { name: value.name, target }
+        : undefined;
+}
+/** Pure live-rebind recipient/operation identity shared by prepare/apply/settle envelopes. */
+function parseLiveRebindRecipient(value) {
+    const { recipientInstanceId, recipientRegistrationGeneration, recipientSessionId, recipientBindingKey, operationId, } = value;
+    return typeof recipientInstanceId === "string" &&
+        recipientInstanceId &&
+        typeof recipientRegistrationGeneration === "string" &&
+        recipientRegistrationGeneration &&
+        typeof recipientSessionId === "string" &&
+        recipientSessionId &&
+        typeof recipientBindingKey === "string" &&
+        recipientBindingKey &&
+        typeof operationId === "string" &&
+        operationId.length > 0 &&
+        operationId.length <= 128
+        ? {
+            recipientInstanceId,
+            recipientRegistrationGeneration,
+            recipientSessionId,
+            recipientBindingKey,
+            operationId,
+        }
+        : undefined;
+}
+/** Non-empty, duplicate-free, non-negative safe-integer Telegram update ids. */
+function isUniqueSourceUpdateIds(value) {
+    return (Array.isArray(value) &&
+        value.length > 0 &&
+        value.every((id) => Number.isSafeInteger(id) && id >= 0) &&
+        new Set(value).size === value.length);
+}
+function parsePreparedCommandSource(value) {
+    if (!isRecord(value) ||
+        !hasOnlyWireKeys(value, [
+            "journalBindingKey",
+            "updateId",
+            "sourceSha256",
+        ]) ||
+        typeof value.journalBindingKey !== "string" ||
+        !value.journalBindingKey ||
+        !Number.isSafeInteger(value.updateId) ||
+        value.updateId < 0 ||
+        typeof value.sourceSha256 !== "string" ||
+        !/^[a-f0-9]{64}$/u.test(value.sourceSha256))
+        return undefined;
+    return {
+        journalBindingKey: value.journalBindingKey,
+        updateId: value.updateId,
+        sourceSha256: value.sourceSha256,
+    };
+}
+export function createTelegramBusProtocolIdentity(input) {
+    const runtimeBuild = input.runtimeBuild.trim();
+    if (!runtimeBuild || runtimeBuild.length > 128) {
+        throw new Error("Telegram bus runtime build identity is invalid.");
+    }
+    const capabilities = [...new Set(input.capabilities ?? [])].sort();
+    if (capabilities.length > 32 ||
+        capabilities.some((capability) => capability.length > 128 || !/^[a-z0-9][a-z0-9._-]*$/u.test(capability))) {
+        throw new Error("Telegram bus capabilities must be canonical identifiers.");
+    }
+    return {
+        protocolVersion: TELEGRAM_BUS_PROTOCOL_VERSION,
+        runtimeBuild,
+        capabilities,
+    };
+}
+export function createTelegramCurrentBusProtocolIdentity(capabilities = []) {
+    const packageMetadata = createRequire(import.meta.url)("../package.json");
+    if (typeof packageMetadata.version !== "string") {
+        throw new Error("Telegram package build identity is unavailable.");
+    }
+    return createTelegramBusProtocolIdentity({
+        runtimeBuild: packageMetadata.version,
+        capabilities,
+    });
+}
+export function hasTelegramBusCapability(identity, capability) {
+    return identity?.capabilities.includes(capability) ?? false;
+}
+export function getTelegramInputCustodyPeerReadiness(followers) {
+    return followers.map((follower) => {
+        if (!follower.registrationGeneration || !follower.protocol)
+            return "unknown";
+        return hasTelegramBusCapability(follower.protocol, TELEGRAM_BUS_CAPABILITY_DURABLE_FOLLOWER_ADMISSION) &&
+            hasTelegramBusCapability(follower.protocol, TELEGRAM_BUS_CAPABILITY_INPUT_CUSTODY_REFERENCE)
+            ? "ready"
+            : "legacy";
+    });
+}
+/** Both peers advertise every required capability over a compatible protocol; reads only the two identities. */
+export function hasTelegramBusSharedCapabilities(local, remote, required) {
+    return (required.every((capability) => hasTelegramBusCapability(local, capability) &&
+        hasTelegramBusCapability(remote, capability)) && getTelegramBusProtocolCompatibility({ local, remote }).compatible);
+}
+export function getTelegramBusProtocolCompatibility(input) {
+    if (!input.remote) {
+        return {
+            compatible: false,
+            reason: "missing-identity",
+            missingCapabilities: [],
+        };
+    }
+    if (input.remote.protocolVersion !== input.local.protocolVersion) {
+        return {
+            compatible: false,
+            reason: "version-mismatch",
+            missingCapabilities: [],
+        };
+    }
+    const remoteCapabilities = new Set(input.remote.capabilities);
+    const missingCapabilities = input.local.capabilities
+        .filter((capability) => capability === TELEGRAM_BUS_CAPABILITY_DURABLE_FOLLOWER_ADMISSION)
+        .filter((capability) => !remoteCapabilities.has(capability));
+    return missingCapabilities.length > 0
+        ? {
+            compatible: false,
+            reason: "missing-capability",
+            missingCapabilities,
+        }
+        : { compatible: true, missingCapabilities: [] };
+}
+export function getTelegramBusSocketPath(agentDir = resolveAgentDir(), platform = getPlatform(), profileName, layout) {
+    return getTelegramBusLeaderEndpoint({
+        agentDir,
+        platform,
+        profileName,
+        layout,
+    });
+}
+export function getTelegramBusFollowerSocketPath(instanceId, agentDir = resolveAgentDir(), platform = getPlatform(), profileName, layout) {
+    return getTelegramBusFollowerEndpoint({
+        agentDir,
+        platform,
+        instanceId,
+        profileName,
+        layout,
+    });
+}
+/** Whether a live follower is still exactly the captured registration: identity, process, session, endpoint and negotiated protocol. */
+export function isSameTelegramBusFollowerRegistration(live, captured) {
+    return (live.instanceId === captured.instanceId &&
+        live.profileKey === captured.profileKey &&
+        live.sessionId === captured.sessionId &&
+        live.registrationGeneration === captured.registrationGeneration &&
+        live.pid === captured.pid &&
+        live.processBirthId === captured.processBirthId &&
+        live.sessionGeneration === captured.sessionGeneration &&
+        live.cwd === captured.cwd &&
+        live.slot === captured.slot &&
+        live.busSocketPath === captured.busSocketPath &&
+        isDeepStrictEqual(live.protocol, captured.protocol));
+}
+export function getTelegramFollowerTargetOwnership(input) {
+    const liveFollower = input.followers.find((follower) => {
+        return (follower.target?.chatId === input.target.chatId &&
+            follower.target.threadId === input.target.threadId);
+    });
+    if (liveFollower?.registrationGeneration &&
+        liveFollower.profileKey &&
+        liveFollower.protocol?.capabilities.includes(TELEGRAM_BUS_CAPABILITY_DURABLE_FOLLOWER_ADMISSION)) {
+        return {
+            instanceId: liveFollower.instanceId,
+            ownerGeneration: liveFollower.registrationGeneration,
+            recipientBindingKey: liveFollower.profileKey,
+            protocolIdentity: liveFollower.protocol,
+        };
+    }
+    // Persisted records are restart hints, not live routing authority. Only an
+    // authenticated current follower registration may receive forwarded work.
+    return undefined;
+}
+const TELEGRAM_BUS_AGGREGATE_DELIVERY_FIELD = "__piTelegramAggregateDelivery";
+const TELEGRAM_BUS_CROSS_TARGET_DELIVERY_FIELD = "__piTelegramCrossTargetDelivery";
+function hasTelegramBusDeliveryMarker(body, marker) {
+    return Boolean(body &&
+        typeof body === "object" &&
+        !Array.isArray(body) &&
+        body[marker] === true);
+}
+export function markTelegramBusAggregateDelivery(body) {
+    return { ...body, [TELEGRAM_BUS_AGGREGATE_DELIVERY_FIELD]: true };
+}
+export function markTelegramBusCrossTargetDelivery(body) {
+    return { ...body, [TELEGRAM_BUS_CROSS_TARGET_DELIVERY_FIELD]: true };
+}
+export function stripTelegramBusApiMetadata(body) {
+    if (!(TELEGRAM_BUS_AGGREGATE_DELIVERY_FIELD in body) &&
+        !(TELEGRAM_BUS_CROSS_TARGET_DELIVERY_FIELD in body)) {
+        return body;
+    }
+    const clean = { ...body };
+    delete clean[TELEGRAM_BUS_AGGREGATE_DELIVERY_FIELD];
+    delete clean[TELEGRAM_BUS_CROSS_TARGET_DELIVERY_FIELD];
+    return clean;
+}
+export function isTelegramFollowerApiCallAllowed(input) {
+    const allowedCallMethods = new Set([
+        "answerCallbackQuery",
+        "answerGuestQuery",
+        "closeForumTopic",
+        "deleteForumTopic",
+        "deleteMessage",
+        "editForumTopic",
+        "editMessageReplyMarkup",
+        "editMessageText",
+        "sendChatAction",
+        "sendMessage",
+        "sendMessageDraft",
+        "sendRichMessage",
+        "sendRichMessageDraft",
+    ]);
+    const allowedMultipartMethods = new Set([
+        "sendAudio",
+        "sendDocument",
+        "sendMediaGroup",
+        "sendPhoto",
+        "sendRichMessage",
+        "sendVoice",
+    ]);
+    const target = input.follower.target;
+    const matchesId = (value, expected) => value === expected || value === String(expected);
+    const isTargetScoped = (body) => {
+        if (!target)
+            return false;
+        if (!body || typeof body !== "object" || Array.isArray(body))
+            return false;
+        const record = body;
+        if (!matchesId(record.chat_id, target.chatId))
+            return false;
+        if (target.threadId === undefined)
+            return true;
+        return matchesId(record.message_thread_id, target.threadId);
+    };
+    const isTargetChatScoped = (body) => {
+        if (!target)
+            return false;
+        if (!body || typeof body !== "object" || Array.isArray(body))
+            return false;
+        const record = body;
+        return matchesId(record.chat_id, target.chatId);
+    };
+    const isDifferentTargetScoped = (body) => {
+        if (!target || !isTargetChatScoped(body))
+            return false;
+        const threadId = body.message_thread_id;
+        if (threadId === undefined)
+            return target.threadId !== undefined;
+        const parsedThreadId = typeof threadId === "number" ? threadId : Number(threadId);
+        return (Number.isInteger(parsedThreadId) &&
+            (target.threadId === undefined || !matchesId(threadId, target.threadId)));
+    };
+    const isTargetMessageScoped = (body) => {
+        if (!isTargetChatScoped(body))
+            return false;
+        const messageId = body.message_id;
+        const parsedMessageId = typeof messageId === "number" ? messageId : Number(messageId);
+        return (Number.isInteger(parsedMessageId) && matchesId(messageId, parsedMessageId));
+    };
+    const isBotCommandRegistration = (body) => {
+        if (!body || typeof body !== "object" || Array.isArray(body))
+            return false;
+        const commands = body.commands;
+        return (Array.isArray(commands) &&
+            commands.every((command) => command &&
+                typeof command === "object" &&
+                !Array.isArray(command) &&
+                typeof command.command === "string" &&
+                typeof command.description === "string"));
+    };
+    if (input.method === "downloadFile")
+        return true;
+    if (input.method === "call") {
+        const apiMethod = input.args[0];
+        if (typeof apiMethod !== "string")
+            return false;
+        if (apiMethod === "answerCallbackQuery" ||
+            apiMethod === "answerGuestQuery") {
+            return true;
+        }
+        if (apiMethod === "getMe")
+            return true;
+        if (apiMethod === "setMyCommands")
+            return isBotCommandRegistration(input.args[1]);
+        if (apiMethod === "sendChatAction")
+            return isTargetChatScoped(input.args[1]);
+        if (apiMethod === "sendMessage" &&
+            hasTelegramBusDeliveryMarker(input.args[1], TELEGRAM_BUS_AGGREGATE_DELIVERY_FIELD)) {
+            const body = input.args[1];
+            return body.message_thread_id === undefined && isTargetChatScoped(body);
+        }
+        if ((apiMethod === "sendMessage" || apiMethod === "sendRichMessage") &&
+            hasTelegramBusDeliveryMarker(input.args[1], TELEGRAM_BUS_CROSS_TARGET_DELIVERY_FIELD)) {
+            return isDifferentTargetScoped(input.args[1]);
+        }
+        if (apiMethod === "deleteMessage" ||
+            apiMethod === "editMessageReplyMarkup" ||
+            apiMethod === "editMessageText") {
+            if (!isTargetMessageScoped(input.args[1]))
+                return false;
+            const body = input.args[1];
+            const messageId = typeof body.message_id === "number"
+                ? body.message_id
+                : Number(body.message_id);
+            return input.isMessageOwned?.(target.chatId, messageId) === true;
+        }
+        return allowedCallMethods.has(apiMethod) && isTargetScoped(input.args[1]);
+    }
+    if (input.method === "callMultipart") {
+        const apiMethod = input.args[0];
+        return (typeof apiMethod === "string" &&
+            allowedMultipartMethods.has(apiMethod) &&
+            isTargetScoped(input.args[1]));
+    }
+    return false;
+}
+export function createTelegramFollowerApiCallAuthorizer(deps) {
+    return (input) => isTelegramFollowerApiCallAllowed({
+        ...input,
+        isMessageOwned(chatId, messageId) {
+            return deps.isMessageOwned({
+                chatId,
+                messageId,
+                follower: input.follower,
+            });
+        },
+    });
+}
+export function createTelegramBusFollowerDeliveryIdentity(input) {
+    if (!input.recipientBindingKey ||
+        !Number.isSafeInteger(input.sourceUpdateId) ||
+        input.sourceUpdateId < 0 ||
+        (input.sourceClaim !== undefined &&
+            (!input.sourceClaim.acquisitionId ||
+                input.sourceClaim.acquisitionId.length > 256 ||
+                !input.sourceClaim.handoffId ||
+                input.sourceClaim.handoffId.length > 256))) {
+        throw new Error("Telegram follower delivery identity is incomplete.");
+    }
+    const deliveryId = createHash("sha256")
+        .update(JSON.stringify({
+        version: 1,
+        kind: input.kind,
+        recipientBindingKey: input.recipientBindingKey,
+        sourceUpdateId: input.sourceUpdateId,
+    }))
+        .digest("hex");
+    return {
+        deliveryId: `telegram-follower-v1-${deliveryId}`,
+        sourceUpdateId: input.sourceUpdateId,
+        recipientBindingKey: input.recipientBindingKey,
+        ...(input.sourceRecoveryKey
+            ? { sourceRecoveryKey: input.sourceRecoveryKey }
+            : {}),
+        ...(input.sourceClaim ? { sourceClaim: { ...input.sourceClaim } } : {}),
+    };
+}
+export function canUseTelegramBusInputCustodyReference(input) {
+    return (hasTelegramBusCapability(input.local, TELEGRAM_BUS_CAPABILITY_INPUT_CUSTODY_REFERENCE) &&
+        hasTelegramBusCapability(input.remote, TELEGRAM_BUS_CAPABILITY_INPUT_CUSTODY_REFERENCE));
+}
+export function createTelegramBusFollowerSourceReferenceDeliveryIdentity(input) {
+    if (!input.sourceRecoveryKey || !input.source.owner.handoffId)
+        throw new Error("Telegram follower source-reference delivery requires an accepted handoff.");
+    return createTelegramBusFollowerDeliveryIdentity({
+        kind: input.kind,
+        recipientBindingKey: input.recipientBindingKey,
+        sourceUpdateId: input.source.updateId,
+        sourceRecoveryKey: input.sourceRecoveryKey,
+        sourceClaim: {
+            acquisitionId: input.source.owner.acquisitionId,
+            handoffId: input.source.owner.handoffId,
+        },
+    });
+}
+export function getTelegramBusEnvelopeTrafficClass(envelope) {
+    if (envelope.kind === "follower.register" ||
+        envelope.kind === "follower.restoreWorkspace" ||
+        envelope.kind === "bus.probe")
+        return "bootstrap";
+    if (envelope.kind === "bus.ack")
+        return "response";
+    return "generation-fenced";
+}
+export function createTelegramBusRequestId(input) {
+    return `${input.instanceId}:${input.sequence}`;
+}
+export function createTelegramBusRequestIdFactory(instanceId) {
+    let sequence = 0;
+    return () => {
+        sequence += 1;
+        return createTelegramBusRequestId({ instanceId, sequence });
+    };
+}
+export function encodeTelegramBusEnvelope(envelope) {
+    return `${JSON.stringify(envelope)}\n`;
+}
+export function parseTelegramBusEnvelope(line) {
+    let value;
+    try {
+        value = JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isRecord(value))
+        return undefined;
+    const kind = value.kind;
+    const requestId = value.requestId;
+    if (typeof kind !== "string" || typeof requestId !== "string") {
+        return undefined;
+    }
+    let envelope;
+    switch (kind) {
+        case "follower.register":
+        case "follower.restoreWorkspace":
+            envelope = parseRegisterEnvelope(value, requestId, kind);
+            break;
+        case "follower.heartbeat":
+        case "follower.disconnect":
+            envelope = parseFollowerPresenceEnvelope(value, requestId, kind);
+            break;
+        case "follower.setThreadDisplayMode":
+            if (typeof value.instanceId === "string" &&
+                typeof value.registrationGeneration === "string" &&
+                (value.mode === "letters" ||
+                    value.mode === "names" ||
+                    value.mode === "directory-snake" ||
+                    value.mode === "directory-title")) {
+                envelope = {
+                    kind,
+                    requestId,
+                    instanceId: value.instanceId,
+                    registrationGeneration: value.registrationGeneration,
+                    mode: value.mode,
+                };
+            }
+            break;
+        case "follower.renameThread":
+            envelope = parseRenameThreadEnvelope(value, requestId);
+            break;
+        case "follower.resetThreadName": {
+            const target = parseTarget(value.target);
+            if (typeof value.instanceId === "string" &&
+                typeof value.registrationGeneration === "string" &&
+                typeof value.sentAtMs === "number" &&
+                target?.threadId !== undefined) {
+                envelope = {
+                    kind,
+                    requestId,
+                    instanceId: value.instanceId,
+                    registrationGeneration: value.registrationGeneration,
+                    target: { chatId: target.chatId, threadId: target.threadId },
+                    sentAtMs: value.sentAtMs,
+                };
+            }
+            break;
+        }
+        case "follower.publishSessionReplacement":
+        case "follower.settleSessionReplacement": {
+            const intent = normalizeTelegramSessionReplacementIntent(value.intent);
+            if (typeof value.instanceId === "string" &&
+                typeof value.registrationGeneration === "string" &&
+                typeof value.sentAtMs === "number" &&
+                intent) {
+                envelope = {
+                    kind,
+                    requestId,
+                    instanceId: value.instanceId,
+                    registrationGeneration: value.registrationGeneration,
+                    intent,
+                    sentAtMs: value.sentAtMs,
+                };
+            }
+            break;
+        }
+        case "leader.forwardCallback":
+            envelope = parseForwardCallbackEnvelope(value, requestId);
+            break;
+        case "leader.forwardReaction":
+            envelope = parseForwardReactionEnvelope(value, requestId);
+            break;
+        case "leader.offerInputCustodyHandoff":
+            envelope = parseOfferInputCustodyHandoffEnvelope(value, requestId);
+            break;
+        case "leader.wakeInputCustody":
+            envelope = parseWakeInputCustodyEnvelope(value, requestId);
+            break;
+        case "leader.forwardMessage":
+            envelope = parseForwardMessageEnvelope(value, requestId, "leader.forwardMessage");
+            break;
+        case "leader.forwardEditedMessage":
+            envelope = parseForwardMessageEnvelope(value, requestId, "leader.forwardEditedMessage");
+            break;
+        case "leader.prepareLiveRebind": {
+            const selectedCommand = parseSelectedCommandInput(value.selectedCommand);
+            if (!hasOnlyWireKeys(value, [
+                "kind",
+                "requestId",
+                "auth",
+                "recipientInstanceId",
+                "recipientRegistrationGeneration",
+                "recipientSessionId",
+                "recipientBindingKey",
+                "operationId",
+                "updates",
+                "selectedCommand",
+                "sentAtMs",
+            ]) ||
+                (Object.hasOwn(value, "selectedCommand") &&
+                    (!selectedCommand ||
+                        !Array.isArray(value.updates) ||
+                        value.updates.length !== 1)))
+                break;
+            const recipient = parseLiveRebindRecipient(value);
+            if (recipient &&
+                Array.isArray(value.updates) &&
+                value.updates.every(isRecord) &&
+                isUniqueSourceUpdateIds(value.updates.map((update) => update.update_id)) &&
+                typeof value.sentAtMs === "number" &&
+                Number.isFinite(value.sentAtMs)) {
+                envelope = {
+                    kind: "leader.prepareLiveRebind",
+                    requestId,
+                    ...recipient,
+                    updates: value.updates,
+                    sentAtMs: value.sentAtMs,
+                    ...(selectedCommand ? { selectedCommand } : {}),
+                };
+            }
+            break;
+        }
+        case "leader.applyLiveRebind":
+        case "leader.settleLiveRebind": {
+            const selectedCommand = parseSelectedCommandInput(value.selectedCommand), preparedSource = parsePreparedCommandSource(value.preparedSource);
+            if (!hasOnlyWireKeys(value, [
+                "kind",
+                "requestId",
+                "auth",
+                "recipientInstanceId",
+                "recipientRegistrationGeneration",
+                "recipientSessionId",
+                "recipientBindingKey",
+                "operationId",
+                "sourceUpdateIds",
+                "mode",
+                "oldTarget",
+                "selectedCommand",
+                "preparedSource",
+                "sentAtMs",
+            ]) ||
+                (Object.hasOwn(value, "preparedSource") && !selectedCommand) ||
+                (value.mode === "observe-command" &&
+                    (!selectedCommand || Object.hasOwn(value, "oldTarget"))))
+                break;
+            if (Object.hasOwn(value, "selectedCommand") &&
+                (!selectedCommand ||
+                    !Array.isArray(value.sourceUpdateIds) ||
+                    value.sourceUpdateIds.length !== 1 ||
+                    !preparedSource ||
+                    preparedSource.updateId !== value.sourceUpdateIds[0] ||
+                    preparedSource.journalBindingKey !== value.recipientBindingKey))
+                break;
+            const recipient = parseLiveRebindRecipient(value);
+            if (recipient &&
+                (value.kind === "leader.applyLiveRebind"
+                    ? value.mode === "apply" || value.mode === "inspect"
+                    : value.mode === "release" ||
+                        value.mode === "discard" ||
+                        value.mode === "observe-command" ||
+                        (value.mode === "observe" &&
+                            !!parseThreadTarget(value.oldTarget))) &&
+                isUniqueSourceUpdateIds(value.sourceUpdateIds) &&
+                typeof value.sentAtMs === "number" &&
+                Number.isFinite(value.sentAtMs)) {
+                envelope = {
+                    kind: value.kind,
+                    requestId,
+                    ...recipient,
+                    sourceUpdateIds: value.sourceUpdateIds,
+                    mode: value.mode,
+                    sentAtMs: value.sentAtMs,
+                    ...(value.mode === "observe"
+                        ? { oldTarget: parseThreadTarget(value.oldTarget) }
+                        : {}),
+                    ...(selectedCommand ? { selectedCommand, preparedSource } : {}),
+                };
+            }
+            break;
+        }
+        case "leader.workspaceRestore":
+            if (typeof value.recipientInstanceId === "string" &&
+                value.recipientInstanceId &&
+                typeof value.recipientRegistrationGeneration === "string" &&
+                value.recipientRegistrationGeneration &&
+                typeof value.operationId === "string" &&
+                value.operationId.length > 0 &&
+                value.operationId.length <= 128 &&
+                (value.mode === "apply" || value.mode === "inspect") &&
+                typeof value.sentAtMs === "number" &&
+                Number.isFinite(value.sentAtMs)) {
+                envelope = {
+                    kind: "leader.workspaceRestore",
+                    requestId,
+                    recipientInstanceId: value.recipientInstanceId,
+                    recipientRegistrationGeneration: value.recipientRegistrationGeneration,
+                    operationId: value.operationId,
+                    mode: value.mode,
+                    sentAtMs: value.sentAtMs,
+                };
+            }
+            break;
+        case "leader.offerQueueHandoff":
+            envelope = parseQueueHandoffEnvelope(value, requestId, "leader.offerQueueHandoff");
+            break;
+        case "follower.offerQueueHandoff":
+            envelope = parseQueueHandoffEnvelope(value, requestId, "follower.offerQueueHandoff");
+            break;
+        case "follower.resolveAgentTarget":
+            envelope = parseResolveAgentTargetEnvelope(value, requestId);
+            break;
+        case "follower.routeAgentMessage":
+            envelope = parseRouteAgentMessageEnvelope(value, requestId);
+            break;
+        case "follower.deliverSelectedMenu":
+            envelope = parseSelectedMenuDeliveryEnvelope(value, requestId);
+            break;
+        case "follower.callApi":
+            envelope = parseCallApiEnvelope(value, requestId);
+            break;
+        case "bus.probe":
+            envelope = { kind, requestId };
+            break;
+        case "bus.ack":
+            envelope = parseAckEnvelope(value, requestId);
+            break;
+        default:
+            return undefined;
+    }
+    const auth = value.auth;
+    if (envelope && typeof auth === "string")
+        envelope.auth = auth;
+    return envelope;
+}
+export function probeTelegramBusLeader(input) {
+    const timeoutMs = input.timeoutMs ?? TELEGRAM_BUS_LEADER_STALE_HEARTBEAT_MS;
+    return new Promise((resolve) => {
+        let settled = false;
+        let socket;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket?.destroy();
+            resolve(result);
+        };
+        const timer = setTimeout(() => finish("silent"), timeoutMs);
+        let connected = false;
+        try {
+            socket = createConnection(resolveTelegramBusSocketPath(input.socketPath));
+        }
+        catch {
+            finish("unknown");
+            return;
+        }
+        socket.once("connect", () => {
+            connected = true;
+            socket.write(encodeTelegramBusEnvelope({
+                kind: "bus.probe",
+                requestId: `probe:${randomBytes(8).toString("hex")}`,
+                ...(input.secret ? { auth: input.secret } : {}),
+            }));
+        });
+        socket.once("data", () => finish("responsive"));
+        socket.once("end", () => finish("responsive"));
+        socket.once("error", (error) => {
+            const code = error.code;
+            finish(!connected && code === "ECONNREFUSED" ? "unreachable" : "unknown");
+        });
+    });
+}
+/**
+ * Takeover evidence replacing the retired file heartbeat: a full silent window, or an unreachable endpoint
+ * confirmed again after one more window (a just-started leader binds its socket well within it). The owner must
+ * stay the same throughout; the lock acquisition then CAS-checks that exact owner.
+ */
+export async function proveTelegramBusLeaderUnresponsive(input) {
+    const first = await input.probe();
+    if (first === "silent")
+        return input.isSameOwner();
+    if (first !== "unreachable")
+        return false;
+    await input.sleep(input.windowMs ?? TELEGRAM_BUS_LEADER_STALE_HEARTBEAT_MS);
+    if (!input.isSameOwner())
+        return false;
+    const second = await input.probe();
+    return (second === "silent" || second === "unreachable") && input.isSameOwner();
+}
+/** Composition-ready takeover proof for one profile's leader lock and endpoint. */
+export function createTelegramBusLeaderUnresponsivenessProof(deps) {
+    const probe = deps.probe ?? probeTelegramBusLeader;
+    const sleep = deps.sleep ??
+        ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    return (owner) => proveTelegramBusLeaderUnresponsive({
+        probe: () => probe({
+            socketPath: owner.busSocketPath ?? deps.getLeaderSocketPath(),
+            secret: owner.busSecret,
+        }),
+        isSameOwner: () => {
+            const state = deps.getLeaderState();
+            return (state.kind === "active-elsewhere" &&
+                isSameTelegramLockOwner(state.lock, owner));
+        },
+        sleep,
+    });
+}
+const TELEGRAM_ACTIVE_LOCAL_SERVERS = Symbol.for("@llblab/pi-telegram/active-local-servers");
+function getActiveTelegramBusLocalServers() {
+    const root = globalThis;
+    return (root[TELEGRAM_ACTIVE_LOCAL_SERVERS] ??= new Map());
+}
+export function resolveTelegramBusSocketPath(source, platform = getPlatform()) {
+    const endpoint = typeof source === "function" ? source() : source;
+    if (platform === "win32") {
+        if (isTelegramBusPipePath(endpoint))
+            return endpoint;
+        return getTelegramBusPipePath({
+            agentDir: dirname(endpoint),
+            scope: basename(endpoint),
+        });
+    }
+    const ownerScope = process.getuid?.() ?? "user";
+    const fallbackDir = join(tmpdir(), `pi-telegram-${ownerScope}`);
+    if (dirname(endpoint) === fallbackDir &&
+        /^[0-9a-f]{16}\.sock$/u.test(basename(endpoint))) {
+        return endpoint;
+    }
+    if (Buffer.byteLength(endpoint) <= TELEGRAM_BUS_MAX_DIRECT_UNIX_ENDPOINT_BYTES) {
+        return endpoint;
+    }
+    const digest = createHash("sha256")
+        .update(endpoint)
+        .digest("hex")
+        .slice(0, 16);
+    return join(fallbackDir, `${digest}.sock`);
+}
+/** Local IPC issuance proof only: this callback/error never enters the envelope or certifies a remote API effect. */
+export class TelegramBusLocalAuthorityError extends Error {
+    requestIssued;
+    constructor(requestIssued, reason) {
+        super(reason
+            ? `Telegram bus local authority is unavailable: ${reason}`
+            : "Telegram bus local authority is unavailable.");
+        this.name = "TelegramBusLocalAuthorityError";
+        this.requestIssued = requestIssued;
+    }
+}
+export function isTelegramBusForwardOwnershipCurrent(expected, current) {
+    return Boolean(current &&
+        current.instanceId === expected.instanceId &&
+        current.ownerGeneration === expected.ownerGeneration &&
+        current.recipientBindingKey === expected.recipientBindingKey &&
+        JSON.stringify(current.protocolIdentity) ===
+            JSON.stringify(expected.protocolIdentity));
+}
+function getTelegramBusForwardSourceUpdateId(value) {
+    if (!isRecord(value))
+        return undefined;
+    const updateId = value.pi_telegram_source_update_id;
+    return Number.isSafeInteger(updateId) && updateId >= 0
+        ? updateId
+        : undefined;
+}
+function createTelegramBusForwardDelivery(kind, sourceUpdateId, recipientBindingKey) {
+    return createTelegramBusFollowerDeliveryIdentity({
+        kind,
+        recipientBindingKey,
+        sourceUpdateId,
+    });
+}
+/**
+ * Leader-to-follower forwards and control replies share the stale-liveness window: a follower doing journal work or stalled
+ * by an ordinary multi-second Pi/TUI turn, or a slower Windows named pipe, is not a lost recipient.
+ */
+const TELEGRAM_BUS_FOLLOWER_CONTROL_TIMEOUT_MS = TELEGRAM_BUS_LEADER_STALE_HEARTBEAT_MS;
+export function createTelegramBusForeignOwnedUpdateForwarder(deps) {
+    const getNowMs = deps.getNowMs ?? Date.now;
+    const reject = (input) => {
+        const settlement = {
+            status: input.status,
+            failureClass: input.failureClass,
+            message: input.message,
+            ...(input.delivery ? { delivery: input.delivery } : {}),
+            ...(input.sourceUpdateId !== undefined
+                ? { sourceUpdateId: input.sourceUpdateId }
+                : {}),
+        };
+        deps.recordRuntimeEvent?.("bus", input.message, {
+            phase: "foreign-update-forward-rejected",
+            settlement: input.status,
+            failureClass: input.failureClass,
+            envelopeKind: input.envelopeKind,
+            recipientInstanceId: input.ownership.instanceId,
+            deliveryId: input.delivery?.deliveryId,
+            sourceUpdateId: input.delivery?.sourceUpdateId ?? input.sourceUpdateId,
+        });
+        return settlement;
+    };
+    const prepare = (kind, value, ownership) => {
+        const sourceUpdateId = getTelegramBusForwardSourceUpdateId(value);
+        if (sourceUpdateId === undefined) {
+            return {
+                settlement: reject({
+                    status: "terminal-rejected",
+                    failureClass: "source-update-identity-missing",
+                    message: "Forwarded Telegram update has no durable source identity.",
+                    envelopeKind: kind,
+                    ownership,
+                }),
+            };
+        }
+        if (!ownership.recipientBindingKey) {
+            return {
+                settlement: reject({
+                    status: "terminal-rejected",
+                    failureClass: "recipient-binding-missing",
+                    message: "Forwarded Telegram update has no stable recipient binding.",
+                    envelopeKind: kind,
+                    ownership,
+                    sourceUpdateId,
+                }),
+            };
+        }
+        const sourceReference = canUseTelegramBusInputCustodyReference({
+            local: deps.localProtocolIdentity,
+            remote: ownership.protocolIdentity,
+        });
+        const reference = sourceReference
+            ? deps.resolveInputCustodyReference?.({
+                sourceUpdateId,
+                recipientBindingKey: ownership.recipientBindingKey,
+            })
+            : undefined;
+        if (sourceReference && !reference)
+            return {
+                settlement: reject({
+                    status: "retryable",
+                    failureClass: "source-reference-missing",
+                    message: "Forwarded Telegram update has no exact custody reference.",
+                    envelopeKind: kind,
+                    ownership,
+                    sourceUpdateId,
+                }),
+            };
+        const delivery = reference
+            ? createTelegramBusFollowerSourceReferenceDeliveryIdentity({
+                kind: "leader.wakeInputCustody",
+                recipientBindingKey: ownership.recipientBindingKey,
+                sourceRecoveryKey: reference.sourceRecoveryKey,
+                source: reference.source,
+            })
+            : createTelegramBusForwardDelivery(kind, sourceUpdateId, ownership.recipientBindingKey);
+        if (!ownership.ownerGeneration) {
+            return {
+                settlement: reject({
+                    status: "retryable",
+                    failureClass: "recipient-generation-missing",
+                    message: "Forwarded Telegram update has no live recipient generation.",
+                    envelopeKind: kind,
+                    ownership,
+                    delivery,
+                }),
+            };
+        }
+        return {
+            delivery,
+            recipientRegistrationGeneration: ownership.ownerGeneration,
+            sourceReference,
+        };
+    };
+    const send = async (envelope, ownership) => {
+        if (deps.validateForwardOwnership &&
+            !deps.validateForwardOwnership(ownership))
+            return reject({
+                status: "retryable",
+                failureClass: "recipient-ownership-stale",
+                message: "Telegram follower ownership changed before forwarding.",
+                envelopeKind: envelope.kind,
+                ownership,
+                delivery: envelope.delivery,
+            });
+        if (deps.getAuthSecret)
+            envelope.auth = deps.getAuthSecret();
+        const socketPath = resolveTelegramBusSocketPath(deps.socketPath);
+        let response;
+        try {
+            response = await sendTelegramBusLocalEnvelope({
+                socketPath,
+                envelope,
+                timeoutMs: deps.timeoutMs ?? TELEGRAM_BUS_FOLLOWER_CONTROL_TIMEOUT_MS,
+                retry: getTelegramBusTransportRetryPolicy({
+                    endpoint: socketPath,
+                    operation: "operation",
+                }),
+            });
+        }
+        catch (error) {
+            return reject({
+                status: "retryable",
+                failureClass: "transport-failed",
+                message: error instanceof Error
+                    ? error.message
+                    : "Telegram follower forwarding transport failed.",
+                envelopeKind: envelope.kind,
+                ownership,
+                delivery: envelope.delivery,
+            });
+        }
+        if (response?.kind !== "bus.ack") {
+            return reject({
+                status: "retryable",
+                failureClass: "acknowledgement-missing",
+                message: "Follower returned no forwarding acknowledgement.",
+                envelopeKind: envelope.kind,
+                ownership,
+                delivery: envelope.delivery,
+            });
+        }
+        if (response.requestId !== envelope.requestId) {
+            return reject({
+                status: "terminal-rejected",
+                failureClass: "acknowledgement-mismatched",
+                message: "Follower returned a mismatched forwarding acknowledgement.",
+                envelopeKind: envelope.kind,
+                ownership,
+                delivery: envelope.delivery,
+            });
+        }
+        if (!response.ok) {
+            return reject({
+                status: "retryable",
+                failureClass: "acknowledgement-rejected",
+                message: response.message ?? "Follower rejected forwarded Telegram update.",
+                envelopeKind: envelope.kind,
+                ownership,
+                delivery: envelope.delivery,
+            });
+        }
+        const receipt = response.result;
+        if (!isRecord(receipt) ||
+            typeof receipt.deliveryId !== "string" ||
+            !Number.isSafeInteger(receipt.sourceUpdateId)) {
+            return reject({
+                status: "terminal-rejected",
+                failureClass: "durable-receipt-missing",
+                message: "Follower acknowledgement omitted the durable receipt.",
+                envelopeKind: envelope.kind,
+                ownership,
+                delivery: envelope.delivery,
+            });
+        }
+        if (receipt.deliveryId !== envelope.delivery.deliveryId ||
+            receipt.sourceUpdateId !== envelope.delivery.sourceUpdateId) {
+            return reject({
+                status: "terminal-rejected",
+                failureClass: "durable-receipt-mismatched",
+                message: "Follower acknowledgement returned a mismatched durable receipt.",
+                envelopeKind: envelope.kind,
+                ownership,
+                delivery: envelope.delivery,
+            });
+        }
+        return { status: "accepted", delivery: envelope.delivery };
+    };
+    // A recipient already holding the source reference is only woken; it never receives a second payload copy.
+    const forward = (kind, value, ownership, build) => {
+        const prepared = prepare(kind, value, ownership);
+        if ("settlement" in prepared)
+            return Promise.resolve(prepared.settlement);
+        const base = {
+            requestId: deps.createRequestId(),
+            recipientInstanceId: ownership.instanceId,
+            recipientRegistrationGeneration: prepared.recipientRegistrationGeneration,
+            delivery: prepared.delivery,
+        };
+        return send(prepared.sourceReference
+            ? { kind: "leader.wakeInputCustody", ...base, sentAtMs: getNowMs() }
+            : build(base, getNowMs()), ownership);
+    };
+    return {
+        forwardCallback: ({ query, ownership }) => forward("leader.forwardCallback", query, ownership, (base, sentAtMs) => ({
+            kind: "leader.forwardCallback",
+            ...base,
+            query,
+            sentAtMs,
+        })),
+        forwardReaction: ({ reactionUpdate, ownership }) => forward("leader.forwardReaction", reactionUpdate, ownership, (base, sentAtMs) => ({
+            kind: "leader.forwardReaction",
+            ...base,
+            reactionUpdate,
+            sentAtMs,
+        })),
+        forwardMessage: ({ message, ownership }) => forward("leader.forwardMessage", message, ownership, (base, sentAtMs) => {
+            const forwardCommentBatchPosition = deps.getForwardCommentBatchPosition?.(message);
+            return {
+                kind: "leader.forwardMessage",
+                ...base,
+                message,
+                ...(forwardCommentBatchPosition !== undefined
+                    ? { forwardCommentBatchPosition }
+                    : {}),
+                sentAtMs,
+            };
+        }),
+        forwardEditedMessage: ({ message, ownership }) => forward("leader.forwardEditedMessage", message, ownership, (base, sentAtMs) => ({
+            kind: "leader.forwardEditedMessage",
+            ...base,
+            message,
+            sentAtMs,
+        })),
+    };
+}
+export function listTelegramBusLiveThreadTargets(input) {
+    const targets = [];
+    if (input.leaderTarget?.threadId !== undefined) {
+        targets.push(input.leaderTarget);
+    }
+    for (const follower of input.followers) {
+        if (follower.target?.threadId !== undefined)
+            targets.push(follower.target);
+    }
+    return targets;
+}
+/** Caller owns the durable one-shot apply grant. Inspections never grant another apply. */
+export function createTelegramBusWorkspaceRestoreController(deps) {
+    return async (input) => {
+        const isCurrent = input.isCurrent.bind(input);
+        if (!isCurrent())
+            return undefined;
+        const follower = deps.getFollower(input.instanceId);
+        const secret = deps.getAuthSecret();
+        if (!secret ||
+            !follower?.registrationGeneration ||
+            !follower.busSocketPath ||
+            follower.sessionId !== input.sessionId ||
+            follower.slot !== input.slot ||
+            !hasTelegramBusSharedCapabilities(deps.localProtocolIdentity, follower.protocol, [TELEGRAM_BUS_CAPABILITY_WORKSPACE_RESTORE]))
+            return undefined;
+        const captured = structuredClone(follower);
+        const expected = {
+            operationId: input.operationId,
+            sessionId: input.sessionId,
+            slot: input.slot,
+            target: { ...input.target },
+            oldTarget: { ...input.oldTarget },
+            mode: input.mode,
+        };
+        const current = () => {
+            if (!isCurrent() ||
+                deps.getAuthSecret() !== secret ||
+                !hasTelegramBusCapability(deps.localProtocolIdentity, TELEGRAM_BUS_CAPABILITY_WORKSPACE_RESTORE))
+                return false;
+            const live = deps.getFollower(captured.instanceId);
+            return (!!live &&
+                live.registrationGeneration === captured.registrationGeneration &&
+                live.sessionId === captured.sessionId &&
+                live.cwd === captured.cwd &&
+                live.slot === captured.slot &&
+                live.busSocketPath === captured.busSocketPath &&
+                live.target?.chatId === captured.target?.chatId &&
+                live.target?.threadId === captured.target?.threadId &&
+                hasTelegramBusCapability(live.protocol, TELEGRAM_BUS_CAPABILITY_WORKSPACE_RESTORE) &&
+                getTelegramBusProtocolCompatibility({
+                    local: deps.localProtocolIdentity,
+                    remote: live.protocol,
+                }).compatible);
+        };
+        if (!current())
+            return undefined;
+        const requestId = deps.createRequestId();
+        const response = await sendTelegramBusLocalEnvelope({
+            socketPath: captured.busSocketPath,
+            timeoutMs: deps.timeoutMs ?? TELEGRAM_BUS_FOLLOWER_CONTROL_TIMEOUT_MS,
+            retry: { attempts: 1, delayMs: 0 },
+            envelope: {
+                kind: "leader.workspaceRestore",
+                requestId,
+                recipientInstanceId: captured.instanceId,
+                recipientRegistrationGeneration: captured.registrationGeneration,
+                operationId: expected.operationId,
+                mode: expected.mode,
+                auth: secret,
+                sentAtMs: Date.now(),
+            },
+        });
+        if (!current() ||
+            response?.kind !== "bus.ack" ||
+            response.requestId !== requestId ||
+            response.ok !== true ||
+            !response.result ||
+            typeof response.result !== "object")
+            return undefined;
+        const result = response.result;
+        const recipient = result.recipient;
+        const target = parseThreadTarget(result.target);
+        const wanted = result.ready === true ? expected.target : expected.oldTarget;
+        if (result.operationId !== expected.operationId ||
+            typeof result.ready !== "boolean" ||
+            result.slot !== expected.slot ||
+            !target ||
+            target.chatId !== wanted.chatId ||
+            target.threadId !== wanted.threadId ||
+            recipient?.kind !== "follower" ||
+            recipient.instanceId !== captured.instanceId ||
+            recipient.sessionId !== expected.sessionId ||
+            recipient.generation !== captured.registrationGeneration)
+            return undefined;
+        return {
+            operationId: expected.operationId,
+            recipient: {
+                kind: "follower",
+                instanceId: captured.instanceId,
+                sessionId: expected.sessionId,
+                generation: captured.registrationGeneration,
+            },
+            target,
+            slot: expected.slot,
+            ready: result.ready,
+        };
+    };
+}
+/** Each capability has its own effect boundary; transport retries never replay save/dispatch/disposal. */
+export function createTelegramBusLiveRebindController(deps) {
+    return async (input) => {
+        const isCurrent = input.isCurrent.bind(input), localProtocol = structuredClone(deps.localProtocolIdentity);
+        const selectedCommand = parseSelectedCommandInput(input.selectedCommand), held = selectedCommand, preparedSource = parsePreparedCommandSource(input.preparedSource);
+        if (!hasOnlyWireKeys(input, [
+            "operationId",
+            "instanceId",
+            "sessionId",
+            "recipientBindingKey",
+            "isCurrent",
+            "selectedCommand",
+            "preparedSource",
+            "updates",
+            "mode",
+            "sourceUpdateIds",
+            "slot",
+            "target",
+            "oldTarget",
+        ]) ||
+            ("mode" in input &&
+                (![
+                    "apply",
+                    "inspect",
+                    "release",
+                    "discard",
+                    "observe",
+                    "observe-command",
+                ].includes(input.mode) ||
+                    (input.mode === "observe-command" && !selectedCommand))))
+            return undefined;
+        if ((input.preparedSource !== undefined &&
+            (!held ||
+                !preparedSource ||
+                preparedSource.journalBindingKey !== input.recipientBindingKey ||
+                preparedSource.updateId !==
+                    ("mode" in input
+                        ? input.sourceUpdateIds[0]
+                        : input.updates[0]?.update_id))) ||
+            (held && "mode" in input && !preparedSource))
+            return undefined;
+        if (input.selectedCommand !== undefined &&
+            (!held ||
+                ("mode" in input
+                    ? input.sourceUpdateIds.length !== 1 ||
+                        !areTelegramTargetsEqual(input.target, held.target)
+                    : input.updates.length !== 1)))
+            return undefined;
+        const marker = selectedCommand ? { selectedCommand } : {};
+        const expected = structuredClone({
+            operationId: input.operationId,
+            instanceId: input.instanceId,
+            sessionId: input.sessionId,
+            recipientBindingKey: input.recipientBindingKey,
+            ...(held
+                ? { ...marker, ...(preparedSource ? { preparedSource } : {}) }
+                : {}),
+            ...("mode" in input
+                ? {
+                    mode: input.mode,
+                    sourceUpdateIds: input.sourceUpdateIds,
+                    slot: input.slot,
+                    target: input.target,
+                    oldTarget: input.oldTarget,
+                }
+                : { updates: input.updates }),
+        });
+        const observing = "mode" in expected && expected.mode === "observe";
+        const commandObserving = "mode" in expected && expected.mode === "observe-command";
+        const settling = "mode" in expected &&
+            (expected.mode === "release" ||
+                expected.mode === "discard" ||
+                observing ||
+                commandObserving);
+        const required = [
+            TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_SAVE,
+            ...("mode" in expected || held
+                ? [TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_APPLY]
+                : []),
+            ...(settling || held ? [TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_SETTLE] : []),
+            ...(held
+                ? [
+                    TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_COMMAND_SET,
+                    TELEGRAM_BUS_CAPABILITY_SELECTED_MENU_DELIVERY,
+                ]
+                : []),
+        ];
+        const follower = deps.getFollower(expected.instanceId), secret = deps.getAuthSecret();
+        if (!isCurrent() ||
+            !secret ||
+            !follower?.registrationGeneration ||
+            !follower.busSocketPath ||
+            follower.sessionId !== expected.sessionId ||
+            !hasTelegramBusSharedCapabilities(deps.localProtocolIdentity, follower.protocol, required))
+            return undefined;
+        const captured = structuredClone(follower);
+        /** The first failed authority condition, by fixed label; undefined while the captured recipient is current. */
+        const staleReason = () => {
+            if (!isCurrent())
+                return "caller authority";
+            if (deps.getAuthSecret() !== secret)
+                return "auth secret";
+            if (!isDeepStrictEqual(deps.localProtocolIdentity, localProtocol) ||
+                !required.every((cap) => hasTelegramBusCapability(deps.localProtocolIdentity, cap)))
+                return "local protocol";
+            const live = deps.getFollower(expected.instanceId);
+            if (!live)
+                return "follower registration";
+            if (live.sessionId !== captured.sessionId ||
+                live.registrationGeneration !== captured.registrationGeneration ||
+                live.sessionGeneration !== captured.sessionGeneration)
+                return "follower generation";
+            if (live.pid !== captured.pid ||
+                live.processBirthId !== captured.processBirthId)
+                return "follower process";
+            if (live.busSocketPath !== captured.busSocketPath ||
+                live.slot !== captured.slot ||
+                live.cwd !== captured.cwd)
+                return "follower endpoint";
+            if ("mode" in expected
+                ? live.slot !== expected.slot ||
+                    !live.target ||
+                    (!areTelegramTargetsEqual(live.target, expected.target) &&
+                        !areTelegramTargetsEqual(live.target, expected.oldTarget))
+                : !isDeepStrictEqual(live.target, captured.target))
+                return "follower target";
+            if (!required.every((cap) => hasTelegramBusCapability(live.protocol, cap)) ||
+                !isDeepStrictEqual(live.protocol, captured.protocol) ||
+                !getTelegramBusProtocolCompatibility({
+                    local: deps.localProtocolIdentity,
+                    remote: live.protocol,
+                }).compatible)
+                return "follower protocol";
+            return undefined;
+        };
+        const current = () => staleReason() === undefined;
+        if (!current())
+            return undefined;
+        const requestId = deps.createRequestId();
+        const response = await sendTelegramBusLocalEnvelope({
+            socketPath: captured.busSocketPath,
+            timeoutMs: deps.timeoutMs ?? TELEGRAM_BUS_FOLLOWER_CONTROL_TIMEOUT_MS,
+            retry: { attempts: 1, delayMs: 0 },
+            ...(held
+                ? {
+                    assertAuthority: () => {
+                        const reason = staleReason();
+                        if (reason)
+                            throw new Error(`Selected held input sender authority changed (${reason}).`);
+                    },
+                }
+                : {}),
+            envelope: {
+                requestId,
+                auth: secret,
+                ...(held
+                    ? {
+                        ...marker,
+                        ...("mode" in expected
+                            ? { preparedSource: expected.preparedSource }
+                            : {}),
+                    }
+                    : {}),
+                recipientInstanceId: expected.instanceId,
+                recipientRegistrationGeneration: captured.registrationGeneration,
+                recipientSessionId: expected.sessionId,
+                recipientBindingKey: expected.recipientBindingKey,
+                operationId: expected.operationId,
+                sentAtMs: Date.now(),
+                ...("mode" in expected
+                    ? settling
+                        ? {
+                            kind: "leader.settleLiveRebind",
+                            mode: expected.mode,
+                            sourceUpdateIds: expected.sourceUpdateIds,
+                            ...(observing ? { oldTarget: expected.oldTarget } : {}),
+                        }
+                        : {
+                            kind: "leader.applyLiveRebind",
+                            mode: expected.mode,
+                            sourceUpdateIds: expected.sourceUpdateIds,
+                        }
+                    : {
+                        kind: "leader.prepareLiveRebind",
+                        updates: expected.updates,
+                    }),
+            },
+        });
+        if (!current() ||
+            response?.kind !== "bus.ack" ||
+            response.requestId !== requestId ||
+            response.ok !== true ||
+            !isRecord(response.result))
+            return undefined;
+        const result = response.result, recipient = result.recipient;
+        if (!hasOnlyWireKeys(result, [
+            "operationId",
+            "recipient",
+            "sourceUpdateIds",
+            "selectedCommand",
+            "preparedSource",
+            "status",
+            "command",
+            "sourceAck",
+            "target",
+            "slot",
+            "action",
+            "oldTarget",
+            "work",
+        ]))
+            return undefined;
+        if (selectedCommand
+            ? !isDeepStrictEqual(parseSelectedCommandInput(result.selectedCommand), selectedCommand)
+            : Object.hasOwn(result, "selectedCommand"))
+            return undefined;
+        const ids = ("mode" in expected
+            ? [...expected.sourceUpdateIds]
+            : expected.updates.map((update) => update.update_id)).sort((a, b) => a - b);
+        const observedSource = parsePreparedCommandSource(result.preparedSource);
+        if (held
+            ? !observedSource ||
+                observedSource.updateId !== ids[0] ||
+                observedSource.journalBindingKey !== expected.recipientBindingKey ||
+                (expected.preparedSource &&
+                    !isDeepStrictEqual(observedSource, expected.preparedSource))
+            : Object.hasOwn(result, "preparedSource"))
+            return undefined;
+        if (result.operationId !== expected.operationId ||
+            !(commandObserving
+                ? result.status === "command-observed"
+                : observing
+                    ? result.status === "observed"
+                    : settling
+                        ? result.status === "protected" ||
+                            result.status === "unknown" ||
+                            result.status ===
+                                (expected.mode === "release" ? "released" : "discarded")
+                        : "mode" in expected
+                            ? result.status === "saved" || result.status === "applied"
+                            : result.status === "saved") ||
+            !isRecord(recipient) ||
+            recipient.instanceId !== expected.instanceId ||
+            recipient.sessionId !== expected.sessionId ||
+            recipient.generation !== captured.registrationGeneration ||
+            recipient.bindingKey !== expected.recipientBindingKey ||
+            !Array.isArray(result.sourceUpdateIds) ||
+            result.sourceUpdateIds.length !== ids.length ||
+            result.sourceUpdateIds.some((id, index) => id !== ids[index]))
+            return undefined;
+        const observation = {
+            operationId: expected.operationId,
+            recipient: {
+                instanceId: expected.instanceId,
+                sessionId: expected.sessionId,
+                generation: captured.registrationGeneration,
+                bindingKey: expected.recipientBindingKey,
+            },
+            sourceUpdateIds: ids,
+            ...(held
+                ? { ...structuredClone(marker), preparedSource: { ...observedSource } }
+                : {}),
+            status: "saved",
+        };
+        if (!("mode" in expected))
+            return observation;
+        if (commandObserving) {
+            const sourceAck = parsePreparedCommandSource(result.sourceAck);
+            if (!hasOnlyWireKeys(result, [
+                "operationId",
+                "recipient",
+                "sourceUpdateIds",
+                "selectedCommand",
+                "preparedSource",
+                "status",
+                "command",
+                "sourceAck",
+            ]) ||
+                !hasOnlyWireKeys(recipient, [
+                    "instanceId",
+                    "sessionId",
+                    "generation",
+                    "bindingKey",
+                ]) ||
+                !["completed", "unknown", "not-issued"].includes(result.command) ||
+                (Object.hasOwn(result, "sourceAck") &&
+                    (!sourceAck ||
+                        !isDeepStrictEqual(sourceAck, expected.preparedSource) ||
+                        result.command === "not-issued")))
+                return undefined;
+            const settled = {
+                command: result.command,
+                ...(sourceAck ? { sourceAck: { ...sourceAck } } : {}),
+            };
+            return {
+                ...observation,
+                status: "command-observed",
+                selectedCommand: structuredClone(selectedCommand),
+                preparedSource: { ...observedSource },
+                ...settled,
+            };
+        }
+        if (observing) {
+            const work = result.work, oldTarget = parseThreadTarget(result.oldTarget);
+            if (!oldTarget ||
+                !isDeepStrictEqual(oldTarget, expected.oldTarget) ||
+                !isRecord(work) ||
+                [
+                    work.sessionBusy,
+                    work.targetWork,
+                    work.deliveryPending,
+                    work.unknown,
+                ].some((flag) => typeof flag !== "boolean"))
+                return undefined;
+            return {
+                ...observation,
+                status: "observed",
+                oldTarget,
+                work: {
+                    sessionBusy: work.sessionBusy,
+                    targetWork: work.targetWork,
+                    deliveryPending: work.deliveryPending,
+                    unknown: work.unknown,
+                },
+            };
+        }
+        if (settling) {
+            if (result.action !== expected.mode)
+                return undefined;
+            return {
+                ...observation,
+                action: expected.mode,
+                status: result.status,
+            };
+        }
+        const target = parseThreadTarget(result.target), wanted = result.status === "applied" ? expected.target : expected.oldTarget;
+        if (!target ||
+            !isDeepStrictEqual(target, wanted) ||
+            result.slot !== expected.slot)
+            return undefined;
+        return {
+            ...observation,
+            status: result.status,
+            target,
+            slot: expected.slot,
+        };
+    };
+}
+export function isTelegramBusEnvelopeAuthorized(envelope, secret) {
+    if (!secret)
+        return true;
+    if (typeof envelope.auth !== "string")
+        return false;
+    const auth = Buffer.from(envelope.auth);
+    const expected = Buffer.from(secret);
+    return auth.length === expected.length && timingSafeEqual(auth, expected);
+}
+/** Negative acknowledgement carrying only a diagnostic message. */
+export function rejectTelegramBusRequest(requestId, message) {
+    return { kind: "bus.ack", requestId, ok: false, message };
+}
+export function createUnauthorizedBusAck(requestId) {
+    return rejectTelegramBusRequest(requestId, "Unauthorized Telegram bus envelope.");
+}
+export function createTelegramBusLocalServer(deps) {
+    const requestLedger = new Map();
+    const requestLedgerMaxEntries = Math.max(1, deps.requestLedgerMaxEntries ?? 4096);
+    const getRequestLedgerKey = (envelope) => {
+        const identity = envelope.kind === "follower.register" ||
+            envelope.kind === "follower.restoreWorkspace"
+            ? envelope.registration.instanceId
+            : "instanceId" in envelope
+                ? envelope.instanceId
+                : "recipientInstanceId" in envelope
+                    ? envelope.recipientInstanceId
+                    : "ack";
+        return `${envelope.auth ?? ""}:${identity}:${envelope.requestId}`;
+    };
+    const handleEnvelopeOnce = (envelope) => {
+        const key = getRequestLedgerKey(envelope);
+        const fingerprint = JSON.stringify(envelope);
+        const existing = requestLedger.get(key);
+        if (existing) {
+            if (existing.fingerprint === fingerprint)
+                return existing.result;
+            return Promise.resolve({
+                kind: "bus.ack",
+                requestId: envelope.requestId,
+                ok: false,
+                message: "Telegram bus request id was reused with a different payload.",
+                error: { code: "request-id-collision" },
+            });
+        }
+        if (requestLedger.size >= requestLedgerMaxEntries) {
+            const settledKey = Array.from(requestLedger.entries()).find(([, entry]) => entry.settled)?.[0];
+            if (settledKey)
+                requestLedger.delete(settledKey);
+        }
+        if (requestLedger.size >= requestLedgerMaxEntries) {
+            return Promise.resolve({
+                kind: "bus.ack",
+                requestId: envelope.requestId,
+                ok: false,
+                message: "Telegram bus request ledger is full.",
+                error: { code: "ledger-overloaded" },
+            });
+        }
+        const entry = {
+            fingerprint,
+            settled: false,
+            result: Promise.resolve().then(() => deps.handleEnvelope(envelope)),
+        };
+        requestLedger.set(key, entry);
+        const settled = () => {
+            entry.settled = true;
+        };
+        void entry.result.then(settled, settled);
+        return entry.result;
+    };
+    let server;
+    let activeSocketPath;
+    let activeListenPath;
+    let endpointRecovery;
+    let stopGeneration = 0;
+    const sockets = new Set();
+    const closeSocket = (socket) => {
+        sockets.delete(socket);
+        socket.destroy();
+    };
+    const runtime = {
+        start: async () => {
+            if (server)
+                return;
+            const socketPath = resolveTelegramBusSocketPath(deps.socketPath);
+            const activeServers = getActiveTelegramBusLocalServers();
+            const replacedServer = activeServers.get(socketPath);
+            if (replacedServer && replacedServer !== runtime) {
+                await replacedServer.stop();
+            }
+            const usesWindowsPipe = isTelegramBusPipePath(socketPath);
+            const endpointGeneration = randomBytes(8).toString("hex");
+            const listenPath = usesWindowsPipe
+                ? socketPath
+                : join(dirname(socketPath), `.pt-${endpointGeneration}.sock`);
+            activeSocketPath = socketPath;
+            activeListenPath = listenPath;
+            deps.recordTransportEvent?.("server-start", getTelegramBusEndpointDiagnostics(socketPath));
+            if (!usesWindowsPipe) {
+                const socketDir = dirname(socketPath);
+                mkdirSync(socketDir, { recursive: true, mode: 0o700 });
+                chmodSync(socketDir, 0o700);
+                if (existsSync(listenPath))
+                    unlinkSync(listenPath);
+                const legacyDeadlineMs = Date.now() + 2000;
+                while (true) {
+                    let isLegacySocket = false;
+                    try {
+                        isLegacySocket = lstatSync(socketPath).isSocket();
+                    }
+                    catch {
+                        /* endpoint does not exist */
+                    }
+                    if (!isLegacySocket)
+                        break;
+                    const probe = await probeTelegramBusEndpoint({
+                        endpoint: socketPath,
+                        timeoutMs: 50,
+                    });
+                    if (!probe.reachable)
+                        break;
+                    if (Date.now() >= legacyDeadlineMs) {
+                        throw new Error(`Timed out waiting for legacy Telegram bus endpoint: ${socketPath}`);
+                    }
+                    await delayTelegramBusTransportRetry(25);
+                }
+            }
+            if (usesWindowsPipe) {
+                await deps.beforeEndpointPublication?.();
+                const committed = deps.commitEndpointPublication
+                    ? deps.commitEndpointPublication(() => { })
+                    : true;
+                if (!committed) {
+                    activeSocketPath = undefined;
+                    activeListenPath = undefined;
+                    throw new Error("Telegram bus endpoint publication lost transport ownership.");
+                }
+            }
+            server = createServer((socket) => {
+                sockets.add(socket);
+                let buffer = "";
+                socket.setEncoding("utf8");
+                socket.on("data", (chunk) => {
+                    buffer += chunk;
+                    const lines = buffer.split("\n");
+                    buffer = lines.pop() ?? "";
+                    for (const line of lines) {
+                        void handleTelegramBusSocketLine(line, socket, handleEnvelopeOnce, deps.recordTransportEvent, socketPath, deps.shouldDropResponse);
+                    }
+                });
+                socket.on("close", () => sockets.delete(socket));
+                socket.on("error", (error) => {
+                    deps.recordTransportEvent?.("server-socket-error", {
+                        ...getTelegramBusEndpointDiagnostics(socketPath),
+                        ...classifyTelegramBusTransportError(error),
+                    });
+                    closeSocket(socket);
+                });
+            });
+            try {
+                await new Promise((resolve, reject) => {
+                    server?.once("error", reject);
+                    server?.listen(listenPath, resolve);
+                });
+                activeServers.set(socketPath, runtime);
+                deps.recordTransportEvent?.("server-started", getTelegramBusEndpointDiagnostics(socketPath));
+            }
+            catch (error) {
+                server = undefined;
+                activeSocketPath = undefined;
+                activeListenPath = undefined;
+                deps.recordTransportEvent?.("server-start-failed", {
+                    ...getTelegramBusEndpointDiagnostics(socketPath),
+                    ...classifyTelegramBusTransportError(error),
+                });
+                throw error;
+            }
+            if (!usesWindowsPipe) {
+                chmodSync(listenPath, 0o600);
+                const linkPath = `${socketPath}.link.${endpointGeneration}`;
+                try {
+                    symlinkSync(basename(listenPath), linkPath);
+                    await deps.beforeEndpointPublication?.();
+                    const committed = deps.commitEndpointPublication
+                        ? deps.commitEndpointPublication(() => renameSync(linkPath, socketPath))
+                        : (renameSync(linkPath, socketPath), true);
+                    if (!committed) {
+                        throw new Error("Telegram bus endpoint publication lost transport ownership.");
+                    }
+                }
+                catch (error) {
+                    try {
+                        if (lstatSync(linkPath).isSymbolicLink())
+                            unlinkSync(linkPath);
+                    }
+                    catch {
+                        /* no unpublished link to remove */
+                    }
+                    const failedServer = server;
+                    server = undefined;
+                    activeSocketPath = undefined;
+                    activeListenPath = undefined;
+                    if (activeServers.get(socketPath) === runtime) {
+                        activeServers.delete(socketPath);
+                    }
+                    if (failedServer) {
+                        await new Promise((resolve) => failedServer.close(() => resolve()));
+                    }
+                    throw error;
+                }
+            }
+        },
+        stop: async () => {
+            stopGeneration += 1;
+            requestLedger.clear();
+            const activeServer = server;
+            const socketPath = activeSocketPath;
+            const listenPath = activeListenPath;
+            if (socketPath &&
+                getActiveTelegramBusLocalServers().get(socketPath) === runtime) {
+                getActiveTelegramBusLocalServers().delete(socketPath);
+            }
+            server = undefined;
+            activeSocketPath = undefined;
+            activeListenPath = undefined;
+            for (const socket of sockets)
+                closeSocket(socket);
+            if (activeServer) {
+                await new Promise((resolve) => activeServer.close(() => resolve()));
+            }
+            if (socketPath && listenPath && !isTelegramBusPipePath(socketPath)) {
+                try {
+                    if (lstatSync(socketPath).isSymbolicLink() &&
+                        readlinkSync(socketPath) === basename(listenPath)) {
+                        // Leave the generation link in place. Node removes only the unique
+                        // listen path on close; a later generation atomically replaces this
+                        // link, and existsSync() treats the stopped dangling link as missing.
+                    }
+                }
+                catch {
+                    /* endpoint already moved or removed */
+                }
+            }
+            if (socketPath) {
+                deps.recordTransportEvent?.("server-stopped", getTelegramBusEndpointDiagnostics(socketPath));
+            }
+        },
+        ensureEndpoint: async () => {
+            const socketPath = activeSocketPath;
+            if (!server ||
+                !socketPath ||
+                isTelegramBusPipePath(socketPath) ||
+                existsSync(socketPath)) {
+                return false;
+            }
+            if (endpointRecovery)
+                return endpointRecovery;
+            endpointRecovery = (async () => {
+                deps.recordTransportEvent?.("server-endpoint-missing", getTelegramBusEndpointDiagnostics(socketPath));
+                const recoveryStopGeneration = stopGeneration + 1;
+                await runtime.stop();
+                if (stopGeneration !== recoveryStopGeneration)
+                    return false;
+                await runtime.start();
+                if (stopGeneration !== recoveryStopGeneration) {
+                    await runtime.stop();
+                    return false;
+                }
+                deps.recordTransportEvent?.("server-endpoint-recovered", getTelegramBusEndpointDiagnostics(socketPath));
+                return true;
+            })();
+            try {
+                return await endpointRecovery;
+            }
+            finally {
+                endpointRecovery = undefined;
+            }
+        },
+    };
+    return runtime;
+}
+function getTelegramBusEnvelopeDiagnostics(envelope) {
+    return {
+        envelopeKind: envelope.kind,
+        requestId: envelope.requestId,
+    };
+}
+function sendTelegramBusLocalEnvelopeOnce(options) {
+    const timeoutMs = options.timeoutMs ?? 1000;
+    return new Promise((resolve, reject) => {
+        const assertAuthority = options.assertAuthority;
+        let issued = false;
+        const assertCurrent = () => {
+            try {
+                assertAuthority?.();
+            }
+            catch (error) {
+                // The caller's reason is a fixed condition label, never request or credential content.
+                throw new TelegramBusLocalAuthorityError(issued, error instanceof Error ? error.message : undefined);
+            }
+        };
+        try {
+            assertCurrent();
+        }
+        catch (error) {
+            reject(error);
+            return;
+        }
+        const socket = createConnection(options.socketPath);
+        let settled = false;
+        let buffer = "";
+        let timeoutFinalizer;
+        const settle = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            if (timeoutFinalizer)
+                clearImmediate(timeoutFinalizer);
+            socket.destroy();
+            callback();
+        };
+        const timeout = setTimeout(() => {
+            // A long synchronous Pi/TUI turn can resume in the timers phase after
+            // the peer acknowledgement is already buffered. Give pending socket I/O
+            // two poll phases before converting elapsed wall time into a transport
+            // failure; Darwin can surface buffered Unix-socket input only on the
+            // second cycle after a long stall, while a silent peer stays bounded.
+            timeoutFinalizer = setImmediate(() => {
+                timeoutFinalizer = setImmediate(() => {
+                    settle(() => reject(createTelegramBusTransportTimeoutError("Timed out waiting for Telegram bus response")));
+                });
+            });
+        }, timeoutMs);
+        socket.setEncoding("utf8");
+        socket.once("connect", () => {
+            try {
+                assertCurrent();
+                const encoded = encodeTelegramBusEnvelope(options.envelope);
+                assertCurrent();
+                issued = true;
+                socket.write(encoded);
+            }
+            catch (error) {
+                settle(() => reject(error));
+            }
+        });
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex < 0)
+                return;
+            const line = buffer.slice(0, newlineIndex);
+            try {
+                const response = parseTelegramBusEnvelope(line);
+                assertCurrent();
+                settle(() => resolve(response));
+            }
+            catch (error) {
+                settle(() => reject(error));
+            }
+        });
+        socket.once("error", (error) => settle(() => reject(error)));
+        socket.once("end", () => settle(() => resolve(undefined)));
+    });
+}
+export async function sendTelegramBusLocalEnvelope(options) {
+    const resolvedOptions = {
+        ...options,
+        socketPath: resolveTelegramBusSocketPath(options.socketPath),
+    };
+    const attempts = Math.max(1, resolvedOptions.retry?.attempts ?? 1);
+    const delayMs = Math.max(0, resolvedOptions.retry?.delayMs ?? 0);
+    for (let attempt = 1;; attempt += 1) {
+        try {
+            return await sendTelegramBusLocalEnvelopeOnce(resolvedOptions);
+        }
+        catch (error) {
+            const info = classifyTelegramBusTransportError(error);
+            resolvedOptions.recordTransportEvent?.("client-failed", {
+                ...getTelegramBusEndpointDiagnostics(resolvedOptions.socketPath),
+                ...getTelegramBusEnvelopeDiagnostics(resolvedOptions.envelope),
+                attempt,
+                attempts,
+                ...info,
+            });
+            if (error instanceof TelegramBusLocalAuthorityError ||
+                attempt >= attempts ||
+                !isRetryableTelegramBusTransportError(error)) {
+                throw error;
+            }
+            resolvedOptions.recordTransportEvent?.("client-retry", {
+                ...getTelegramBusEndpointDiagnostics(resolvedOptions.socketPath),
+                ...getTelegramBusEnvelopeDiagnostics(resolvedOptions.envelope),
+                attempt,
+                attempts,
+                delayMs,
+                ...info,
+            });
+            await delayTelegramBusTransportRetry(delayMs);
+        }
+    }
+}
+export function createTelegramBusForwardOwnershipValidator(registry) {
+    return (ownership) => {
+        const follower = registry.get(ownership.instanceId);
+        return isTelegramBusForwardOwnershipCurrent(ownership, follower?.registrationGeneration &&
+            follower.profileKey &&
+            follower.protocol
+            ? {
+                instanceId: follower.instanceId,
+                ownerGeneration: follower.registrationGeneration,
+                recipientBindingKey: follower.profileKey,
+                protocolIdentity: follower.protocol,
+            }
+            : undefined);
+    };
+}
+function hasTelegramBusFollowerIdentityOverlap(first, second) {
+    return (first.instanceId === second.instanceId ||
+        (first.profileKey !== undefined &&
+            first.profileKey === second.profileKey) ||
+        (first.target !== undefined &&
+            first.target.chatId === second.target?.chatId &&
+            first.target.threadId === second.target.threadId));
+}
+export function createTelegramBusFollowerRegistry() {
+    const followers = new Map();
+    const observations = new Set();
+    const clone = (follower) => ({
+        ...follower,
+        target: follower.target ? { ...follower.target } : undefined,
+        ...(follower.protocol
+            ? {
+                protocol: {
+                    ...follower.protocol,
+                    capabilities: [...follower.protocol.capabilities],
+                },
+            }
+            : {}),
+    });
+    return {
+        register: (registration) => {
+            const existing = followers.get(registration.instanceId);
+            for (const [instanceId, follower] of followers.entries()) {
+                if (instanceId === registration.instanceId)
+                    continue;
+                if (hasTelegramBusFollowerIdentityOverlap(registration, follower))
+                    followers.delete(instanceId);
+            }
+            const next = {
+                ...registration,
+                target: registration.target ? { ...registration.target } : undefined,
+                ...(registration.protocol
+                    ? {
+                        protocol: {
+                            ...registration.protocol,
+                            capabilities: [...registration.protocol.capabilities],
+                        },
+                    }
+                    : {}),
+                lastHeartbeatMs: existing?.lastHeartbeatMs ?? registration.connectedAtMs,
+            };
+            followers.set(registration.instanceId, next);
+            for (const observation of observations) {
+                if (!hasTelegramBusFollowerIdentityOverlap(next, observation.follower))
+                    continue;
+                observation.current = false;
+                observations.delete(observation);
+            }
+            return clone(next);
+        },
+        heartbeat: (instanceId, nowMs) => {
+            const existing = followers.get(instanceId);
+            if (!existing)
+                return undefined;
+            const next = { ...existing, lastHeartbeatMs: nowMs };
+            followers.set(instanceId, next);
+            return clone(next);
+        },
+        get: (instanceId) => {
+            const existing = followers.get(instanceId);
+            return existing ? clone(existing) : undefined;
+        },
+        getByTarget: (target) => {
+            for (const follower of followers.values()) {
+                if (follower.target?.chatId === target.chatId &&
+                    follower.target.threadId === target.threadId) {
+                    return clone(follower);
+                }
+            }
+            return undefined;
+        },
+        list: () => [...followers.values()].map(clone),
+        remove: (instanceId) => followers.delete(instanceId),
+        clear: () => {
+            followers.clear();
+            for (const observation of observations)
+                observation.current = false;
+            observations.clear();
+        },
+        observeUnregistered: (follower) => {
+            // This watches replacement, not process death or delivery authority.
+            const observation = {
+                follower: clone(follower),
+                current: ![...followers.values()].some((current) => hasTelegramBusFollowerIdentityOverlap(current, follower)),
+            };
+            if (observation.current)
+                observations.add(observation);
+            return {
+                isCurrent: () => observation.current,
+                release() {
+                    observation.current = false;
+                    observations.delete(observation);
+                },
+            };
+        },
+        pruneStale: (nowMs, staleAfterMs) => {
+            const removed = [];
+            for (const [instanceId, follower] of followers.entries()) {
+                if (nowMs - follower.lastHeartbeatMs <= staleAfterMs)
+                    continue;
+                followers.delete(instanceId);
+                removed.push(clone(follower));
+            }
+            return removed;
+        },
+    };
+}
+async function handleTelegramBusSocketLine(line, socket, handleEnvelope, recordTransportEvent, socketPath, shouldDropResponse) {
+    const envelope = parseTelegramBusEnvelope(line);
+    if (!envelope) {
+        recordTransportEvent?.("server-invalid-envelope", {
+            ...getTelegramBusEndpointDiagnostics(socketPath),
+            byteLength: Buffer.byteLength(line),
+        });
+        socket.write(encodeTelegramBusEnvelope({
+            kind: "bus.ack",
+            requestId: "invalid",
+            ok: false,
+            message: "Invalid Telegram bus envelope.",
+        }));
+        return;
+    }
+    try {
+        const response = await handleEnvelope(envelope);
+        if (response && !shouldDropResponse?.(envelope, response)) {
+            socket.write(encodeTelegramBusEnvelope(response));
+        }
+    }
+    catch (error) {
+        recordTransportEvent?.("server-handler-failed", {
+            ...getTelegramBusEndpointDiagnostics(socketPath),
+            ...getTelegramBusEnvelopeDiagnostics(envelope),
+            ...classifyTelegramBusTransportError(error),
+        });
+        socket.write(encodeTelegramBusEnvelope(rejectTelegramBusRequest(envelope.requestId, "Telegram bus handler failed.")));
+    }
+}
+function parseRegisterEnvelope(value, requestId, kind) {
+    const registration = parseRegistration(value.registration);
+    return registration ? { kind, requestId, registration } : undefined;
+}
+function parseFollowerPresenceEnvelope(value, requestId, kind) {
+    return typeof value.instanceId === "string" &&
+        typeof value.sentAtMs === "number"
+        ? {
+            kind,
+            requestId,
+            instanceId: value.instanceId,
+            ...(typeof value.registrationGeneration === "string"
+                ? { registrationGeneration: value.registrationGeneration }
+                : {}),
+            sentAtMs: value.sentAtMs,
+        }
+        : undefined;
+}
+function parseRenameThreadEnvelope(value, requestId) {
+    const target = parseTarget(value.target);
+    return typeof value.instanceId === "string" &&
+        typeof value.registrationGeneration === "string" &&
+        target?.threadId !== undefined &&
+        typeof value.threadName === "string" &&
+        typeof value.sentAtMs === "number"
+        ? {
+            kind: "follower.renameThread",
+            requestId,
+            instanceId: value.instanceId,
+            registrationGeneration: value.registrationGeneration,
+            target: { chatId: target.chatId, threadId: target.threadId },
+            threadName: value.threadName,
+            sentAtMs: value.sentAtMs,
+        }
+        : undefined;
+}
+function parseTelegramBusFollowerDeliveryIdentity(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (typeof value.deliveryId !== "string" ||
+        !/^telegram-follower-v1-[a-f0-9]{64}$/u.test(value.deliveryId) ||
+        !Number.isSafeInteger(value.sourceUpdateId) ||
+        value.sourceUpdateId < 0 ||
+        typeof value.recipientBindingKey !== "string" ||
+        !value.recipientBindingKey ||
+        (value.sourceRecoveryKey !== undefined &&
+            (typeof value.sourceRecoveryKey !== "string" ||
+                !value.sourceRecoveryKey ||
+                value.sourceRecoveryKey.length > 1_024)) ||
+        (value.sourceClaim !== undefined &&
+            (!isRecord(value.sourceClaim) ||
+                typeof value.sourceClaim.acquisitionId !== "string" ||
+                !value.sourceClaim.acquisitionId ||
+                value.sourceClaim.acquisitionId.length > 256 ||
+                typeof value.sourceClaim.handoffId !== "string" ||
+                !value.sourceClaim.handoffId ||
+                value.sourceClaim.handoffId.length > 256))) {
+        return undefined;
+    }
+    return {
+        deliveryId: value.deliveryId,
+        sourceUpdateId: value.sourceUpdateId,
+        recipientBindingKey: value.recipientBindingKey,
+        ...(typeof value.sourceRecoveryKey === "string"
+            ? { sourceRecoveryKey: value.sourceRecoveryKey }
+            : {}),
+        ...(isRecord(value.sourceClaim)
+            ? {
+                sourceClaim: {
+                    acquisitionId: value.sourceClaim.acquisitionId,
+                    handoffId: value.sourceClaim.handoffId,
+                },
+            }
+            : {}),
+    };
+}
+function parseForwardCallbackEnvelope(value, requestId) {
+    const delivery = parseTelegramBusFollowerDeliveryIdentity(value.delivery);
+    return delivery &&
+        typeof value.recipientInstanceId === "string" &&
+        typeof value.recipientRegistrationGeneration === "string" &&
+        typeof value.sentAtMs === "number"
+        ? {
+            kind: "leader.forwardCallback",
+            requestId,
+            recipientInstanceId: value.recipientInstanceId,
+            recipientRegistrationGeneration: value.recipientRegistrationGeneration,
+            delivery,
+            query: value.query,
+            sentAtMs: value.sentAtMs,
+        }
+        : undefined;
+}
+function parseForwardReactionEnvelope(value, requestId) {
+    const delivery = parseTelegramBusFollowerDeliveryIdentity(value.delivery);
+    return delivery &&
+        typeof value.recipientInstanceId === "string" &&
+        typeof value.recipientRegistrationGeneration === "string" &&
+        typeof value.sentAtMs === "number"
+        ? {
+            kind: "leader.forwardReaction",
+            requestId,
+            recipientInstanceId: value.recipientInstanceId,
+            recipientRegistrationGeneration: value.recipientRegistrationGeneration,
+            delivery,
+            reactionUpdate: value.reactionUpdate,
+            sentAtMs: value.sentAtMs,
+        }
+        : undefined;
+}
+function parseForwardMessageEnvelope(value, requestId, kind) {
+    const delivery = parseTelegramBusFollowerDeliveryIdentity(value.delivery);
+    return delivery &&
+        typeof value.recipientInstanceId === "string" &&
+        typeof value.recipientRegistrationGeneration === "string" &&
+        typeof value.sentAtMs === "number"
+        ? {
+            kind,
+            requestId,
+            recipientInstanceId: value.recipientInstanceId,
+            recipientRegistrationGeneration: value.recipientRegistrationGeneration,
+            delivery,
+            message: value.message,
+            ...(kind === "leader.forwardMessage" &&
+                (value.forwardCommentBatchPosition === "comment" ||
+                    value.forwardCommentBatchPosition === "forward")
+                ? {
+                    forwardCommentBatchPosition: value.forwardCommentBatchPosition,
+                }
+                : {}),
+            sentAtMs: value.sentAtMs,
+        }
+        : undefined;
+}
+function parseOfferInputCustodyHandoffEnvelope(value, requestId) {
+    const source = value.source;
+    if (!isRecord(source) ||
+        typeof value.recipientInstanceId !== "string" ||
+        typeof value.recipientRegistrationGeneration !== "string" ||
+        typeof value.recipientBindingKey !== "string" ||
+        !value.recipientBindingKey ||
+        typeof value.sourceRecoveryKey !== "string" ||
+        !value.sourceRecoveryKey ||
+        value.sourceRecoveryKey.length > 1_024 ||
+        typeof source.journalBindingKey !== "string" ||
+        !source.journalBindingKey ||
+        source.journalBindingKey !== value.sourceRecoveryKey ||
+        typeof source.tokenSha256 !== "string" ||
+        !/^[a-f0-9]{64}$/u.test(source.tokenSha256) ||
+        !Number.isSafeInteger(source.updateId) ||
+        source.updateId < 0 ||
+        typeof value.handoffId !== "string" ||
+        !value.handoffId ||
+        value.handoffId.length > 256 ||
+        typeof value.sentAtMs !== "number")
+        return undefined;
+    return {
+        kind: "leader.offerInputCustodyHandoff",
+        requestId,
+        recipientInstanceId: value.recipientInstanceId,
+        recipientRegistrationGeneration: value.recipientRegistrationGeneration,
+        recipientBindingKey: value.recipientBindingKey,
+        sourceRecoveryKey: value.sourceRecoveryKey,
+        source: {
+            journalBindingKey: source.journalBindingKey,
+            tokenSha256: source.tokenSha256,
+            updateId: source.updateId,
+        },
+        handoffId: value.handoffId,
+        sentAtMs: value.sentAtMs,
+    };
+}
+function parseWakeInputCustodyEnvelope(value, requestId) {
+    const delivery = parseTelegramBusFollowerDeliveryIdentity(value.delivery);
+    return delivery &&
+        delivery.sourceRecoveryKey &&
+        delivery.sourceClaim &&
+        typeof value.recipientInstanceId === "string" &&
+        typeof value.recipientRegistrationGeneration === "string" &&
+        typeof value.sentAtMs === "number"
+        ? {
+            kind: "leader.wakeInputCustody",
+            requestId,
+            recipientInstanceId: value.recipientInstanceId,
+            recipientRegistrationGeneration: value.recipientRegistrationGeneration,
+            delivery,
+            sentAtMs: value.sentAtMs,
+        }
+        : undefined;
+}
+function parseQueueHandoffEnvelope(value, requestId, kind) {
+    let serializedPayloadBytes;
+    try {
+        serializedPayloadBytes = Buffer.byteLength(JSON.stringify(value.payload));
+    }
+    catch {
+        return undefined;
+    }
+    if (serializedPayloadBytes > TELEGRAM_QUEUE_HANDOFF_PAYLOAD_MAX_BYTES) {
+        return undefined;
+    }
+    const payload = parseTelegramQueueHandoffPayload(value.payload);
+    if (!payload ||
+        typeof value.recipientInstanceId !== "string" ||
+        typeof value.recipientRegistrationGeneration !== "string" ||
+        !Number.isSafeInteger(value.donorProcessId) ||
+        value.donorProcessId <= 0 ||
+        typeof value.donorProcessBirthId !== "string" ||
+        !value.donorProcessBirthId ||
+        !Number.isSafeInteger(value.donorSessionGeneration) ||
+        value.donorSessionGeneration <= 0 ||
+        typeof value.donorAcquisitionId !== "string" ||
+        !value.donorAcquisitionId ||
+        !Number.isSafeInteger(value.donorAcquiredAtMs) ||
+        value.donorAcquiredAtMs < 0 ||
+        typeof value.handoffToken !== "string" ||
+        value.handoffToken.length < 32 ||
+        value.handoffToken.length > 256 ||
+        value.donorProcessBirthId.length > 256 ||
+        value.donorAcquisitionId.length > 256 ||
+        typeof value.sentAtMs !== "number") {
+        return undefined;
+    }
+    const fields = {
+        requestId,
+        recipientInstanceId: value.recipientInstanceId,
+        recipientRegistrationGeneration: value.recipientRegistrationGeneration,
+        donorProcessId: value.donorProcessId,
+        donorProcessBirthId: value.donorProcessBirthId,
+        donorSessionGeneration: value.donorSessionGeneration,
+        donorAcquisitionId: value.donorAcquisitionId,
+        donorAcquiredAtMs: value.donorAcquiredAtMs,
+        handoffToken: value.handoffToken,
+        payload,
+        sentAtMs: value.sentAtMs,
+    };
+    if (kind === "leader.offerQueueHandoff") {
+        return typeof value.donorInstanceId === "string"
+            ? { kind, donorInstanceId: value.donorInstanceId, ...fields }
+            : undefined;
+    }
+    return typeof value.instanceId === "string" &&
+        typeof value.registrationGeneration === "string"
+        ? {
+            kind,
+            instanceId: value.instanceId,
+            registrationGeneration: value.registrationGeneration,
+            ...fields,
+        }
+        : undefined;
+}
+function parseResolveAgentTargetEnvelope(value, requestId) {
+    const selectorValue = isRecord(value.selector) ? value.selector : undefined;
+    if (typeof value.instanceId !== "string" ||
+        !selectorValue ||
+        typeof value.sentAtMs !== "number") {
+        return undefined;
+    }
+    const chatId = typeof selectorValue.chatId === "number" &&
+        Number.isInteger(selectorValue.chatId)
+        ? selectorValue.chatId
+        : undefined;
+    const threadId = typeof selectorValue.threadId === "number" &&
+        Number.isInteger(selectorValue.threadId) &&
+        selectorValue.threadId > 0
+        ? selectorValue.threadId
+        : undefined;
+    const threadName = typeof selectorValue.threadName === "string" &&
+        selectorValue.threadName.trim()
+        ? selectorValue.threadName.trim()
+        : undefined;
+    if ((threadId === undefined) === (threadName === undefined))
+        return undefined;
+    return {
+        kind: "follower.resolveAgentTarget",
+        requestId,
+        instanceId: value.instanceId,
+        ...(typeof value.registrationGeneration === "string"
+            ? { registrationGeneration: value.registrationGeneration }
+            : {}),
+        selector: {
+            ...(chatId !== undefined ? { chatId } : {}),
+            ...(threadId !== undefined ? { threadId } : {}),
+            ...(threadName !== undefined ? { threadName } : {}),
+        },
+        sentAtMs: value.sentAtMs,
+    };
+}
+function parseRouteAgentMessageEnvelope(value, requestId) {
+    const messageValue = isRecord(value.message) ? value.message : undefined;
+    const target = parseThreadTarget(messageValue?.target);
+    if (typeof value.instanceId !== "string" ||
+        !messageValue ||
+        !target ||
+        typeof messageValue.messageId !== "number" ||
+        !Number.isInteger(messageValue.messageId) ||
+        messageValue.messageId <= 0 ||
+        typeof messageValue.text !== "string" ||
+        !messageValue.text.trim() ||
+        typeof value.sentAtMs !== "number") {
+        return undefined;
+    }
+    return {
+        kind: "follower.routeAgentMessage",
+        requestId,
+        instanceId: value.instanceId,
+        ...(typeof value.registrationGeneration === "string"
+            ? { registrationGeneration: value.registrationGeneration }
+            : {}),
+        message: {
+            target,
+            messageId: messageValue.messageId,
+            text: messageValue.text,
+        },
+        sentAtMs: value.sentAtMs,
+    };
+}
+const nonempty = (input, limit = 128) => typeof input === "string" && !!input.trim() && input.length <= limit;
+const positive = (input) => Number.isSafeInteger(input) && input > 0;
+const nonnegative = (input) => Number.isSafeInteger(input) && input >= 0;
+/** Shared closed text-effect codec; parsing alone supplies no recipient or issuance authority. */
+export function parseTelegramBusSelectedMenuTextEffect(effect) {
+    if (!isRecord(effect) ||
+        (effect.kind !== "send-text" && effect.kind !== "edit-text") ||
+        !hasOnlyWireKeys(effect, [
+            "kind",
+            "text",
+            "parseMode",
+            "replyMarkup",
+            ...(effect.kind === "send-text" ? ["replyToMessageId"] : ["messageId"]),
+        ]) ||
+        !nonempty(effect.text, 4096) ||
+        (effect.parseMode !== undefined && effect.parseMode !== "HTML") ||
+        (effect.kind === "send-text"
+            ? effect.replyToMessageId !== undefined &&
+                !positive(effect.replyToMessageId)
+            : !positive(effect.messageId)))
+        return undefined;
+    let replyMarkup;
+    if (effect.replyMarkup !== undefined) {
+        const markup = effect.replyMarkup;
+        if (!isRecord(markup) ||
+            !hasOnlyWireKeys(markup, ["inline_keyboard"]) ||
+            !Array.isArray(markup.inline_keyboard) ||
+            markup.inline_keyboard.length > 32 ||
+            markup.inline_keyboard.some((row) => !Array.isArray(row) ||
+                !row.length ||
+                row.length > 8 ||
+                row.some((button) => !isRecord(button) ||
+                    !hasOnlyWireKeys(button, ["text", "callback_data"]) ||
+                    !nonempty(button.text) ||
+                    !nonempty(button.callback_data, 64) ||
+                    Buffer.byteLength(button.callback_data, "utf8") > 64)))
+            return undefined;
+        replyMarkup = {
+            inline_keyboard: markup.inline_keyboard.map((row) => row.map((button) => ({
+                text: button.text,
+                callback_data: button.callback_data,
+            }))),
+        };
+    }
+    const common = {
+        text: effect.text,
+        ...(effect.parseMode === "HTML" ? { parseMode: "HTML" } : {}),
+        ...(replyMarkup ? { replyMarkup } : {}),
+    };
+    return effect.kind === "send-text"
+        ? {
+            ...common,
+            kind: "send-text",
+            ...(effect.replyToMessageId !== undefined
+                ? { replyToMessageId: effect.replyToMessageId }
+                : {}),
+        }
+        : { ...common, kind: "edit-text", messageId: effect.messageId };
+}
+function parseSelectedMenuDeliveryEnvelope(value, requestId) {
+    const recipient = value.recipient, executor = value.executor, effect = parseTelegramBusSelectedMenuTextEffect(value.effect);
+    if (!hasOnlyWireKeys(value, [
+        "kind",
+        "requestId",
+        "auth",
+        "instanceId",
+        "registrationGeneration",
+        "operationId",
+        "recipient",
+        "executor",
+        "operatorUserId",
+        "effect",
+        "sentAtMs",
+    ]) ||
+        !nonempty(requestId) ||
+        !nonempty(value.instanceId) ||
+        !nonempty(value.registrationGeneration) ||
+        !nonempty(value.operationId) ||
+        !isRecord(recipient) ||
+        !hasOnlyWireKeys(recipient, [
+            "sessionId",
+            "sessionGeneration",
+            "processId",
+            "processBirthId",
+            "profileKey",
+            "journalBindingKey",
+            "target",
+        ]) ||
+        !nonempty(recipient.sessionId) ||
+        !nonnegative(recipient.sessionGeneration) ||
+        !positive(recipient.processId) ||
+        !nonempty(recipient.processBirthId) ||
+        !nonempty(recipient.profileKey, 1024) ||
+        !nonempty(recipient.journalBindingKey, 8192) ||
+        recipient.profileKey === recipient.journalBindingKey ||
+        !isRecord(recipient.target) ||
+        !hasOnlyWireKeys(recipient.target, ["chatId", "threadId"]) ||
+        !positive(recipient.target.chatId) ||
+        !positive(recipient.target.threadId) ||
+        !positive(value.operatorUserId) ||
+        value.operatorUserId !== recipient.target.chatId ||
+        !isRecord(executor) ||
+        !hasOnlyWireKeys(executor, ["instanceId", "leaderEpoch"]) ||
+        !nonempty(executor.instanceId) ||
+        !nonempty(executor.leaderEpoch) ||
+        !effect ||
+        typeof value.sentAtMs !== "number" ||
+        !Number.isFinite(value.sentAtMs) ||
+        value.sentAtMs < 0 ||
+        (value.auth !== undefined && typeof value.auth !== "string"))
+        return undefined;
+    return {
+        kind: "follower.deliverSelectedMenu",
+        requestId,
+        instanceId: value.instanceId,
+        registrationGeneration: value.registrationGeneration,
+        operationId: value.operationId,
+        recipient: {
+            sessionId: recipient.sessionId,
+            sessionGeneration: recipient.sessionGeneration,
+            processId: recipient.processId,
+            processBirthId: recipient.processBirthId,
+            profileKey: recipient.profileKey,
+            journalBindingKey: recipient.journalBindingKey,
+            target: {
+                chatId: recipient.target.chatId,
+                threadId: recipient.target.threadId,
+            },
+        },
+        executor: {
+            instanceId: executor.instanceId,
+            leaderEpoch: executor.leaderEpoch,
+        },
+        operatorUserId: value.operatorUserId,
+        effect,
+        sentAtMs: value.sentAtMs,
+    };
+}
+function parseCallApiEnvelope(value, requestId) {
+    return typeof value.instanceId === "string" &&
+        typeof value.method === "string" &&
+        Array.isArray(value.args) &&
+        typeof value.sentAtMs === "number"
+        ? {
+            kind: "follower.callApi",
+            requestId,
+            instanceId: value.instanceId,
+            ...(typeof value.registrationGeneration === "string"
+                ? { registrationGeneration: value.registrationGeneration }
+                : {}),
+            method: value.method,
+            args: value.args,
+            sentAtMs: value.sentAtMs,
+        }
+        : undefined;
+}
+function parseAckEnvelope(value, requestId) {
+    if (typeof value.ok !== "boolean")
+        return undefined;
+    const envelope = {
+        kind: "bus.ack",
+        requestId,
+        ok: value.ok,
+        message: typeof value.message === "string" ? value.message : undefined,
+    };
+    if (Object.hasOwn(value, "result"))
+        envelope.result = value.result;
+    const protocol = parseTelegramBusProtocolIdentity(value.protocol);
+    if (protocol)
+        envelope.protocol = protocol;
+    if (isRecord(value.error)) {
+        const code = value.error.code;
+        if (code === "commit-unknown" ||
+            code === "request-id-collision" ||
+            code === "ledger-overloaded" ||
+            code === "incompatible-protocol" ||
+            code === "stale-target" ||
+            code === "workspace-binding-unavailable") {
+            const chatId = value.error.chatId;
+            const threadId = value.error.threadId;
+            if (code === "stale-target" &&
+                (!Number.isSafeInteger(chatId) || !Number.isSafeInteger(threadId))) {
+                return undefined;
+            }
+            envelope.error = {
+                code,
+                ...(typeof value.error.method === "string"
+                    ? { method: value.error.method }
+                    : {}),
+                ...(typeof chatId === "number" ? { chatId } : {}),
+                ...(typeof threadId === "number" ? { threadId } : {}),
+            };
+        }
+    }
+    return envelope;
+}
+function parseTelegramBusProtocolIdentity(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (!Number.isSafeInteger(value.protocolVersion) ||
+        value.protocolVersion <= 0 ||
+        typeof value.runtimeBuild !== "string" ||
+        !value.runtimeBuild.trim() ||
+        value.runtimeBuild !== value.runtimeBuild.trim() ||
+        value.runtimeBuild.length > 128 ||
+        !Array.isArray(value.capabilities) ||
+        value.capabilities.length > 32 ||
+        value.capabilities.some((capability) => typeof capability !== "string" ||
+            capability.length > 128 ||
+            !/^[a-z0-9][a-z0-9._-]*$/u.test(capability))) {
+        return undefined;
+    }
+    const capabilities = value.capabilities;
+    if (capabilities.some((capability, index) => index > 0 && capability <= capabilities[index - 1])) {
+        return undefined;
+    }
+    return {
+        protocolVersion: value.protocolVersion,
+        runtimeBuild: value.runtimeBuild,
+        capabilities: [...capabilities],
+    };
+}
+function parseRegistration(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (typeof value.instanceId !== "string")
+        return undefined;
+    if (typeof value.connectedAtMs !== "number")
+        return undefined;
+    const target = parseTarget(value.target);
+    if (value.target !== undefined && !target)
+        return undefined;
+    const registration = {
+        instanceId: value.instanceId,
+        connectedAtMs: value.connectedAtMs,
+    };
+    if (typeof value.previousInstanceId === "string") {
+        registration.previousInstanceId = value.previousInstanceId;
+    }
+    if (typeof value.profileKey === "string")
+        registration.profileKey = value.profileKey;
+    if (typeof value.threadName === "string")
+        registration.threadName = value.threadName;
+    if (typeof value.slot === "string" && /^[A-Z]$/.test(value.slot)) {
+        registration.slot = value.slot;
+    }
+    if (typeof value.cwd === "string")
+        registration.cwd = value.cwd;
+    if (value.sessionId !== undefined) {
+        if (typeof value.sessionId !== "string" ||
+            !value.sessionId ||
+            value.sessionId !== value.sessionId.trim() ||
+            Buffer.byteLength(value.sessionId, "utf8") > 256)
+            return undefined;
+        registration.sessionId = value.sessionId;
+    }
+    if (typeof value.pid === "number")
+        registration.pid = value.pid;
+    if (typeof value.busSocketPath === "string") {
+        registration.busSocketPath = value.busSocketPath;
+    }
+    if (typeof value.registrationGeneration === "string") {
+        registration.registrationGeneration = value.registrationGeneration;
+    }
+    if (Number.isSafeInteger(value.sessionGeneration) &&
+        value.sessionGeneration > 0) {
+        registration.sessionGeneration = value.sessionGeneration;
+    }
+    if (typeof value.processBirthId === "string" && value.processBirthId) {
+        registration.processBirthId = value.processBirthId;
+    }
+    const protocol = parseTelegramBusProtocolIdentity(value.protocol);
+    if (protocol)
+        registration.protocol = protocol;
+    if (target)
+        registration.target = target;
+    return registration;
+}
+function parseThreadTarget(value) {
+    const target = parseTarget(value);
+    return target && typeof target.threadId === "number"
+        ? { chatId: target.chatId, threadId: target.threadId }
+        : undefined;
+}