@ouro.bot/cli 0.1.0-alpha.74 → 0.1.0-alpha.740

package/dist/senses/telegram-approval-runtime.js

@@ -0,0 +1,526 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.telegramApprovalCommitBarrierHooks = telegramApprovalCommitBarrierHooks;
+exports.telegramApprovalDecisionBarrierHooks = telegramApprovalDecisionBarrierHooks;
+exports.approvalContinuationRunAgentOptions = approvalContinuationRunAgentOptions;
+exports.executeApprovedTelegramTool = executeApprovedTelegramTool;
+exports.createTelegramApprovalRuntime = createTelegramApprovalRuntime;
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const approval_files_1 = require("../heart/approval-files");
+const approval_store_1 = require("../heart/approval-store");
+const tool_approval_1 = require("../heart/tool-approval");
+const core_1 = require("../heart/core");
+const identity_1 = require("../heart/identity");
+const sanctuary_acceptance_marker_1 = require("../heart/daemon/sanctuary-acceptance-marker");
+const telegram_1 = require("./telegram");
+const context_1 = require("../mind/context");
+const session_transaction_1 = require("../mind/session-transaction");
+const tools_1 = require("../repertoire/tools");
+const runtime_1 = require("../nerves/runtime");
+const telegram_client_1 = require("./telegram-client");
+function telegramApprovalCommitBarrierHooks(effectBarrier) {
+    return {
+        afterJournalPrepare: effectBarrier,
+        afterTokenPersist: effectBarrier,
+        afterCheckpointWrite: effectBarrier,
+    };
+}
+function telegramApprovalDecisionBarrierHooks(effectBarrier) {
+    return {
+        afterClaim: effectBarrier,
+        afterAttempt: effectBarrier,
+        afterHandler: effectBarrier,
+    };
+}
+function approvalContinuationRunAgentOptions(toolContext, approvalCoordinator) {
+    return { toolContext: toolContext, approvalCoordinator };
+}
+async function executeApprovedTelegramTool(name, args, execute, scenarioHandleDigest, approvalId, effectBarrier = () => undefined) {
+    if (name === "unraid_restart_container")
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.telegram_approved_restart_start",
+            message: "approved Sanctuary restart execution started",
+            meta: { ...(scenarioHandleDigest ? { scenarioHandleDigest } : {}), ...(approvalId ? { approvalId } : {}) },
+        });
+    try {
+        effectBarrier();
+        const result = await execute(name, args);
+        if (name !== "unraid_restart_container")
+            return result;
+        let parsed;
+        try {
+            parsed = JSON.parse(result);
+        }
+        catch {
+            throw new tool_approval_1.ApprovalExecutionFailedError("approved restart returned an invalid result");
+        }
+        if (!parsed || typeof parsed !== "object" || !("ok" in parsed)) {
+            throw new tool_approval_1.ApprovalExecutionFailedError("approved restart returned an invalid result");
+        }
+        if (parsed.ok !== true) {
+            const error = parsed.error;
+            const message = error && typeof error === "object" && typeof error.message === "string"
+                ? error.message.slice(0, 240)
+                : "approved restart failed";
+            throw new tool_approval_1.ApprovalExecutionFailedError(message);
+        }
+        const data = parsed.data;
+        const container = data && typeof data === "object" ? data.container : null;
+        const validSuccess = data !== null
+            && typeof data === "object"
+            && container !== null
+            && typeof container === "object"
+            && typeof container.id === "string"
+            && container.id.length > 0
+            && typeof container.name === "string"
+            && container.name.length > 0
+            && typeof data.beforeState === "string"
+            && typeof data.afterState === "string"
+            && data.observedRestart === true
+            && data.degraded === false;
+        if (!validSuccess) {
+            throw new tool_approval_1.ApprovalExecutionFailedError("approved restart returned an invalid result");
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.telegram_approved_restart_end",
+            message: "approved Sanctuary restart execution completed",
+            meta: { ...(scenarioHandleDigest ? { scenarioHandleDigest } : {}), ...(approvalId ? { approvalId } : {}), observedRestart: true },
+        });
+        return result;
+    }
+    catch (error) {
+        if (name === "unraid_restart_container")
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "senses",
+                event: "senses.telegram_approved_restart_error",
+                message: "approved Sanctuary restart execution failed",
+                meta: { ...(scenarioHandleDigest ? { scenarioHandleDigest } : {}), ...(approvalId ? { approvalId } : {}), reason: error instanceof Error ? error.message.slice(0, 240) : "unknown" },
+            });
+        throw error;
+    }
+}
+function opaqueTelegramMessageBinding(subject, messageId) {
+    return `tgm_${(0, node_crypto_1.createHmac)("sha256", subject).update(`message:${messageId}`, "utf8").digest("base64url")}`;
+}
+function createTelegramApprovalRuntime(options) {
+    const effectBarrier = options.effectBarrier ?? (() => undefined);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.telegram_approval_runtime_create",
+        message: "creating durable Telegram approval runtime",
+        meta: { agentName: options.agentName },
+    });
+    const now = options.dependencies?.now ?? Date.now;
+    const acceptanceMarker = options.dependencies?.acceptanceMarker ?? (() => (0, sanctuary_acceptance_marker_1.readSanctuaryAcceptanceMarker)(options.agentName));
+    const provider = options.dependencies?.runProvider ?? core_1.runAgent;
+    const resolveTool = options.dependencies?.resolveTool ?? tools_1.resolveToolDefinition;
+    const executeTool = options.dependencies?.executeTool ?? tools_1.execTool;
+    const stateRoot = path.join(options.dependencies?.agentRoot ?? (0, identity_1.getAgentRoot)(options.agentName), "state", "approvals");
+    const store = (0, approval_store_1.openApprovalStore)({ databasePath: path.join(stateRoot, "approvals.sqlite"), now: () => new Date(now()) });
+    const checkpoints = new approval_files_1.FileApprovalCheckpointStore(path.join(stateRoot, "checkpoints.json"));
+    const tokens = new approval_files_1.FileApprovalTokenStore(path.join(stateRoot, "tokens.json"));
+    const pendingStore = new telegram_client_1.FileTelegramPendingApprovalStore(path.join(stateRoot, "telegram-pending.json"));
+    let transport;
+    const commitAcceptanceEvidence = options.dependencies?.commitAcceptanceEvidence ?? (async (event, meta) => {
+        if (event === "telegram.callback_settled") {
+            await (0, runtime_1.emitNervesEventDurable)({
+                component: "senses",
+                event: "telegram.callback_settled",
+                message: "Telegram approval acceptance evidence durably recorded",
+                meta,
+            });
+        }
+        else if (event === "telegram.callback_recovery_settled") {
+            await (0, runtime_1.emitNervesEventDurable)({
+                component: "senses",
+                event: "telegram.callback_recovery_settled",
+                message: "Telegram approval acceptance evidence durably recorded",
+                meta,
+            });
+        }
+        else {
+            throw new Error("Telegram durable acceptance settlement event is unsupported");
+        }
+    });
+    const coordinator = (context) => ({
+        propose: async (request) => {
+            if (request.toolCall.type !== "function")
+                throw new Error("approval requires a function tool call");
+            effectBarrier();
+            const scenarioHandleDigest = acceptanceMarker()?.scenarioHandleDigest;
+            const committed = (0, tool_approval_1.commitApprovalProposal)({
+                approvalStore: store,
+                checkpointStore: checkpoints,
+                tokenStore: tokens,
+                proposal: {
+                    toolCallId: request.toolCall.id,
+                    toolName: request.toolCall.function.name,
+                    arguments: request.arguments,
+                    schemaDigest: request.schemaDigest,
+                    toolDigest: request.toolDigest,
+                    policyDigest: request.policyDigest,
+                    policyId: request.policyId,
+                    sessionKey: `telegram:${options.subject}`,
+                    sessionPath: context.sessionPath,
+                    baseSessionRevision: context.baseSessionRevision,
+                    checkpointDigest: "0".repeat(64),
+                    requesterId: options.subject,
+                    transport: "telegram",
+                    transportUserId: options.subject,
+                    transportChatId: options.subject,
+                    expiresAt: new Date(now() + 300_000).toISOString(),
+                    frozenAssistantMessage: request.frozenAssistantMessage,
+                    ...(scenarioHandleDigest ? { scenarioHandleDigest } : {}),
+                },
+                preCallMessages: request.preCallMessages,
+                hooks: telegramApprovalCommitBarrierHooks(effectBarrier),
+            });
+            const prompt = `Approve ${request.toolCall.function.name} with exact arguments ${JSON.stringify(request.arguments)}?`;
+            effectBarrier();
+            const actionDigest = (0, node_crypto_1.createHash)("sha256").update(JSON.stringify({ toolName: committed.record.toolName, argumentDigest: committed.record.argumentDigest })).digest("hex");
+            const targetDigest = (0, node_crypto_1.createHash)("sha256").update(JSON.stringify({ container: committed.record.arguments.container })).digest("hex");
+            const sent = await transport.sendApproval({
+                approvalId: committed.record.approvalId,
+                decisionToken: committed.decisionToken,
+                prompt,
+                ...(scenarioHandleDigest ? { acceptanceBinding: {
+                        scenarioHandleDigest,
+                        actionDigest,
+                        targetDigest,
+                        checkpointDigest: committed.record.checkpointDigest,
+                        suspendedSessionRevisionDigest: (0, node_crypto_1.createHash)("sha256").update(committed.record.suspendedSessionRevision, "utf8").digest("hex"),
+                    } } : {}),
+            });
+            effectBarrier();
+            store.bindPrompt({
+                approvalId: committed.record.approvalId,
+                transport: "telegram",
+                transportChatId: options.subject,
+                transportMessageId: opaqueTelegramMessageBinding(options.subject, sent.messageId),
+                expiresAt: new Date(sent.expiresAt).toISOString(),
+            });
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.telegram_approval_proposed",
+                message: "Telegram approval proposal was durably bound",
+                meta: { ...(scenarioHandleDigest ? { scenarioHandleDigest } : {}), toolName: request.toolCall.function.name },
+            });
+            return {
+                approvalId: committed.record.approvalId,
+                checkpointDigest: committed.record.checkpointDigest,
+                suspendedSessionRevision: committed.record.suspendedSessionRevision,
+            };
+        },
+    });
+    const terminalOutcome = (record) => {
+        const accepted = record.state === "succeeded";
+        return {
+            accepted,
+            terminalText: accepted
+                ? "✅ Approved — action completed"
+                : record.state === "denied"
+                    ? "❌ Denied — no action taken"
+                    : record.state === "attempted_indeterminate"
+                        ? "⚠️ Action outcome is indeterminate after restart — it was not retried"
+                        : "⚠️ Approval did not complete",
+        };
+    };
+    const continueTerminalRecord = (record, acceptanceBinding) => {
+        return (0, session_transaction_1.withSessionTurnLease)(record.sessionPath, async (lease) => {
+            const checkpoint = checkpoints.read(record.approvalId);
+            if (!checkpoint)
+                return { accepted: false, terminalText: "⚠️ Approval checkpoint is unavailable" };
+            const continuationOwnerId = `telegram-continuation-${(0, node_crypto_1.randomUUID)()}`;
+            let continuationEpoch = 0;
+            const continuationCoordinator = {
+                propose: (request) => coordinator({
+                    sessionPath: record.sessionPath,
+                    baseSessionRevision: (0, session_transaction_1.readSessionTransaction)(record.sessionPath, lease).revision,
+                }).propose(request),
+            };
+            effectBarrier();
+            await (0, core_1.resumeApprovalContinuation)({
+                record,
+                checkpoint,
+                currentSessionRevision: (0, session_transaction_1.readSessionTransaction)(record.sessionPath, lease).revision,
+                sessionMessages: checkpoint.preCallMessages,
+                callbacks: {},
+                channel: "telegram",
+                claimContinuation: () => {
+                    effectBarrier();
+                    const claim = store.claimContinuation({ approvalId: record.approvalId, ownerId: continuationOwnerId });
+                    continuationEpoch = claim.record.continuationEpoch;
+                    return claim;
+                },
+                markContinuationMaterialized: () => { effectBarrier(); store.markContinuationMaterialized({ approvalId: record.approvalId, ownerId: continuationOwnerId, epoch: continuationEpoch }); },
+                markContinuationAttempted: () => { effectBarrier(); store.markContinuationAttempted({ approvalId: record.approvalId, ownerId: continuationOwnerId, epoch: continuationEpoch }); },
+                completeContinuation: () => { effectBarrier(); store.completeContinuation({ approvalId: record.approvalId, ownerId: continuationOwnerId, epoch: continuationEpoch }); },
+                runAgent: provider,
+                runAgentOptions: approvalContinuationRunAgentOptions(options.toolContext, continuationCoordinator),
+                persist: (messages, result) => { effectBarrier(); (0, context_1.saveSession)(record.sessionPath, messages, result?.usage, undefined, lease); },
+                deliver: async (text) => {
+                    effectBarrier();
+                    const messageIds = await (0, telegram_client_1.sendTelegramText)(options.api, options.authorizedChatId, text);
+                    effectBarrier();
+                    if (acceptanceBinding) {
+                        const unsigned = {
+                            approvalId: record.approvalId,
+                            ...acceptanceBinding,
+                            deliveredAt: now(),
+                            resultDigest: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify({ state: record.state, result: record.result })).digest("hex"),
+                            deliveryDigest: (0, node_crypto_1.createHash)("sha256").update(text, "utf8").digest("hex"),
+                            deliveryMessageIdDigest: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(messageIds ?? [])).digest("hex"),
+                        };
+                        (0, runtime_1.emitNervesEvent)({
+                            component: "senses",
+                            event: "senses.telegram_approval_continuation_delivered",
+                            message: "Telegram approval continuation result was delivered",
+                            meta: { ...unsigned, evidenceMac: (0, telegram_1.sanctuaryTelegramApprovalEvidenceMac)(options.identityKey, "senses.telegram_approval_continuation_delivered", unsigned) },
+                        });
+                    }
+                },
+            });
+            return terminalOutcome(record);
+        });
+    };
+    transport = (0, telegram_client_1.createTelegramApprovalTransport)({
+        api: options.api,
+        expectedUserId: options.authorizedUserId,
+        expectedChatId: options.authorizedChatId,
+        pendingStore,
+        createOpaqueHandle: () => (0, node_crypto_1.randomBytes)(12).toString("base64url"),
+        acceptanceEventMeta: () => {
+            const scenarioHandleDigest = acceptanceMarker()?.scenarioHandleDigest;
+            const meta = scenarioHandleDigest ? { scenarioHandleDigest } : {};
+            return meta;
+        },
+        effectBarrier,
+        signAcceptanceEvidence: (event, meta) => (0, telegram_1.sanctuaryTelegramApprovalEvidenceMac)(options.identityKey, event, meta),
+        commitAcceptanceEvidence,
+        onSettlementComplete: async (approvalId) => { tokens.remove(approvalId); },
+        acceptanceMessageIdDigest: (messageId) => (0, node_crypto_1.createHash)("sha256").update(opaqueTelegramMessageBinding(options.subject, messageId), "utf8").digest("hex"),
+        now,
+        resolveDecisionToken: async (approvalId) => tokens.get(approvalId) ?? "",
+        onExpire: async (approvalId) => {
+            effectBarrier();
+            store.expire({ approvalId });
+            effectBarrier();
+            tokens.remove(approvalId);
+        },
+        onDecision: async (decision) => {
+            effectBarrier();
+            const decisionScenarioDigest = acceptanceMarker()?.scenarioHandleDigest;
+            const existing = store.read(decision.approvalId);
+            if (!existing)
+                return { accepted: false, terminalText: "⚠️ Approval is no longer valid" };
+            let record;
+            if (existing.state === "claimed") {
+                effectBarrier();
+                record = (0, tool_approval_1.recoverClaimedApproval)({ approvalStore: store, approvalId: existing.approvalId, reason: "decision interrupted before action attempt; action was not executed" });
+            }
+            else if (existing.state === "attempted") {
+                effectBarrier();
+                record = (0, tool_approval_1.recoverAttemptedApproval)({ approvalStore: store, approvalId: existing.approvalId });
+            }
+            else if (existing.state === "proposed") {
+                const ownerId = `telegram-decision-${(0, node_crypto_1.randomUUID)()}`;
+                record = await (0, session_transaction_1.withSessionTurnLease)(existing.sessionPath, async (lease) => (0, tool_approval_1.executeApprovalDecision)({
+                    approvalStore: store,
+                    checkpointStore: checkpoints,
+                    decision: {
+                        ...decision,
+                        requesterId: options.subject,
+                        transportUserId: options.subject,
+                        transportChatId: options.subject,
+                        transportMessageId: opaqueTelegramMessageBinding(options.subject, decision.transportMessageId),
+                        sessionKey: existing.sessionKey,
+                    },
+                    ownerId,
+                    currentSessionRevision: (0, session_transaction_1.readSessionTransaction)(existing.sessionPath, lease).revision,
+                    resolveTool,
+                    liveGuard: async () => ({ ok: true }),
+                    liveRisk: async () => ({ ok: true }),
+                    hooks: telegramApprovalDecisionBarrierHooks(effectBarrier),
+                    execute: (name, args) => {
+                        const execute = () => executeApprovedTelegramTool(name, args, (toolName, toolArgs) => executeTool(toolName, toolArgs, options.toolContext), decisionScenarioDigest, existing.approvalId, effectBarrier);
+                        return decisionScenarioDigest
+                            ? (0, sanctuary_acceptance_marker_1.runWithSanctuaryAcceptanceApproval)({ approvalId: existing.approvalId, argumentDigest: existing.argumentDigest }, execute)
+                            : execute();
+                    },
+                }));
+            }
+            else if (["succeeded", "failed", "attempted_indeterminate", "denied", "expired", "drifted", "session_head_changed", "abandoned_before_attempt"].includes(existing.state)) {
+                record = existing;
+            }
+            else {
+                return { accepted: false, terminalText: "⚠️ Approval is not recoverable" };
+            }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.telegram_approval_terminal",
+                message: "Telegram approval reached a terminal decision state",
+                meta: { state: record.state, ...(decisionScenarioDigest ? { scenarioHandleDigest: decisionScenarioDigest } : {}) },
+            });
+            return continueTerminalRecord(record, decision.acceptanceBinding);
+        },
+    });
+    const recover = async () => {
+        let failureCount = 0;
+        let fencedFailure;
+        for (const pending of transport.listPendingDeliveries()) {
+            let persistedState;
+            try {
+                persistedState = (0, telegram_client_1.classifyTelegramPersistedApprovalState)(pending);
+            }
+            catch (error) {
+                failureCount += 1;
+                fencedFailure ??= error;
+                continue;
+            }
+            const mustFailClosed = persistedState === "decision_attempt" || persistedState === "action_terminal";
+            try {
+                const existing = store.read(pending.approvalId);
+                if (!existing) {
+                    if (mustFailClosed)
+                        throw new Error("Telegram fenced approval journal is unavailable");
+                    const orphanRecovery = await transport.terminalizeOrphaned(pending.approvalId, "⚠️ Approval record is unavailable — no action was taken");
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "senses",
+                        event: "senses.telegram_approval_orphan_recovered",
+                        message: "orphaned Telegram approval transport state was removed",
+                        meta: {
+                            agentName: options.agentName,
+                            recovery: "missing_journal",
+                            terminalEditSucceeded: orphanRecovery.terminalEditSucceeded,
+                        },
+                    });
+                    continue;
+                }
+                if (mustFailClosed) {
+                    await transport.recoverDecisionAttempt(pending.approvalId);
+                    continue;
+                }
+                if (persistedState === "expiry_observed") {
+                    await transport.reconcileExpired();
+                    continue;
+                }
+                if (persistedState === "delivery_interruption") {
+                    await transport.terminalizeRecovered(pending.approvalId, pending.terminal.terminalText);
+                    continue;
+                }
+                const deliveryState = pending.deliveryState ?? "bound";
+                if (existing.state === "awaiting_prompt_binding" && deliveryState !== "bound") {
+                    effectBarrier();
+                    const record = store.abandonPromptBinding({
+                        approvalId: existing.approvalId,
+                        reason: deliveryState === "pending"
+                            ? "approval prompt was interrupted before delivery; action was not executed"
+                            : "approval prompt delivery was indeterminate; action was not executed",
+                    });
+                    const outcome = await continueTerminalRecord(record);
+                    await transport.terminalizeRecovered(record.approvalId, outcome.terminalText);
+                    continue;
+                }
+                if (existing.state === "awaiting_prompt_binding" && deliveryState === "bound" && pending.messageId) {
+                    effectBarrier();
+                    store.bindPrompt({
+                        approvalId: existing.approvalId,
+                        transport: "telegram",
+                        transportChatId: options.subject,
+                        transportMessageId: opaqueTelegramMessageBinding(options.subject, pending.messageId),
+                    });
+                    continue;
+                }
+                if (existing.state === "proposed" || existing.state === "preparing" || existing.state === "awaiting_prompt_binding")
+                    continue;
+                if (existing.state === "expired" && !pending.terminal) {
+                    await transport.reconcileExpired();
+                    continue;
+                }
+                let record = existing;
+                if (record.state === "claimed") {
+                    effectBarrier();
+                    record = (0, tool_approval_1.recoverClaimedApproval)({ approvalStore: store, approvalId: record.approvalId, reason: "decision interrupted before action attempt; action was not executed" });
+                }
+                else if (record.state === "attempted") {
+                    effectBarrier();
+                    record = (0, tool_approval_1.recoverAttemptedApproval)({ approvalStore: store, approvalId: record.approvalId });
+                }
+                const outcome = await continueTerminalRecord(record);
+                await transport.terminalizeRecovered(record.approvalId, outcome.terminalText);
+            }
+            catch (error) {
+                failureCount += 1;
+                if (mustFailClosed)
+                    fencedFailure ??= error;
+            }
+        }
+        if (failureCount > 0) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "senses",
+                event: "senses.telegram_approval_recovery_error",
+                message: "Telegram approval startup recovery completed with isolated failures",
+                meta: { failureCount },
+            });
+        }
+        if (fencedFailure !== undefined)
+            throw fencedFailure;
+    };
+    const legacySubjects = () => (store.listTelegramIdentitySubjects?.() ?? [])
+        .filter((candidate) => candidate !== options.subject);
+    const migrateIdentity = (subjects) => {
+        for (const legacySubject of subjects) {
+            effectBarrier();
+            store.migrateTelegramIdentity?.({
+                legacyUserId: legacySubject,
+                legacyChatId: legacySubject,
+                subject: options.subject,
+            });
+        }
+        effectBarrier();
+        store.migrateTelegramIdentity?.({
+            legacyUserId: options.authorizedUserId,
+            legacyChatId: options.authorizedChatId,
+            subject: options.subject,
+        });
+    };
+    return { transport, coordinator, legacySubjects, migrateIdentity, recover, close: () => store.close() };
+}