@ouro.bot/cli 0.1.0-alpha.790 → 0.1.0-alpha.792

package/changelog.json

@@ -1,6 +1,26 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+      {
+        "version": "0.1.0-alpha.792",
+        "changes": [
+          "Catch asynchronous bundle watcher errors so transient pending-message processing files on live filesystems cannot tombstone the daemon or interrupt private-runtime wakes.",
+          "Warm runtime credentials before private-runtime bootstrap so Telegram-capable workers start with runtime config instead of racing the managed Telegram sense.",
+          "Treat simple Sanctuary library visibility asks like 'see the lib' as catalog reads, and block replies that send Ari to inspect Jellyfin, Unmanic, dashboards, or logs while safe evidence tools are available.",
+          "Degrade optional Unmanic file-size metrics, including failed detail reads, without hiding available media catalog evidence."
+        ]
+      },
+      {
+        "version": "0.1.0-alpha.791",
+        "changes": [
+          "Promote operator CLI pending messages into the active inner-turn user message so private-runtime wakes answer the text that woke them instead of stale heartbeat context.",
+          "Keep non-operator pending work in the background pending section so automated noise does not become the live user ask.",
+          "Deliver private-runtime Telegram surface and send_message returns through the existing Telegram effect journal instead of queuing ghost messages for the next chat.",
+          "Canonicalize Telegram session filename keys before live delivery so production sanitized session paths still authorize against the real Telegram binding.",
+          "Prefer the authoritative settle tool answer over incidental streamed prose for shared-turn delivery, preventing concatenated Telegram replies.",
+          "Expire stale generic Telegram outreach from the pending queue while preserving request-bound returns and trust/admission notices."
+        ]
+      },
     {
       "version": "0.1.0-alpha.790",
       "changes": [

package/deploy/unraid/sanctuary.ouro/bundle-meta.json

@@ -1,5 +1,5 @@
 {
-  "runtimeVersion": "0.1.0-alpha.790",
+  "runtimeVersion": "0.1.0-alpha.792",
   "bundleSchemaVersion": 3,
   "lastUpdated": "2026-09-03T00:00:00.000Z"
 }

package/deploy/unraid/sanctuary.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <Container version="2">
   <Name>Mendelow Cloud Butler</Name>
-  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.790</Repository>
+  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.792</Repository>
   <Registry>https://github.com/ourostack/ouroboros/pkgs/container/ouroboros-butler</Registry>
   <Network>host</Network>
   <Shell>sh</Shell>

package/dist/heart/agent-entry.js

@@ -172,7 +172,7 @@ Promise.resolve().then(() => __importStar(require("./runtime-credentials"))).the
         drainBufferedRuntimeCredentialBootstrap(applyRuntimeCredentialBootstrapMessage);
     }
     if (!readRuntimeCredentialConfig(agentName).ok) {
-        void refreshRuntimeCredentialConfig(agentName, { preserveCachedOnFailure: true }).catch(() => undefined);
+        await refreshRuntimeCredentialConfig(agentName, { preserveCachedOnFailure: true }).catch(() => undefined);
     }
     const providerPool = readProviderCredentialPool(agentName);
     const providerTargets = await selectedProviderTargets(agentName);

package/dist/heart/config.js

@@ -57,6 +57,7 @@ exports.getSyncConfig = getSyncConfig;
 exports.getOpenAIEmbeddingsApiKey = getOpenAIEmbeddingsApiKey;
 exports.getLogsDir = getLogsDir;
 exports.sanitizeKey = sanitizeKey;
+exports.canonicalizeTelegramSessionKey = canonicalizeTelegramSessionKey;
 exports.slugify = slugify;
 exports.resolveSessionPath = resolveSessionPath;
 exports.sessionPath = sessionPath;
@@ -351,6 +352,19 @@ function getLogsDir() {
 function sanitizeKey(key) {
     return key.replace(/[/:]/g, "_");
 }
+function canonicalizeTelegramSessionKey(key) {
+    if (key.startsWith("telegram:"))
+        return key;
+    if (!key.startsWith("telegram_"))
+        return key;
+    const suffix = key.slice("telegram_".length);
+    if (suffix.startsWith("tg_"))
+        return `telegram:${suffix}`;
+    const numericSession = suffix.match(/^([0-9]+)_(-?[0-9]+)$/u);
+    if (numericSession)
+        return `telegram:${numericSession[1]}:${numericSession[2]}`;
+    return key;
+}
 function slugify(value) {
     return value
         .trim()

package/dist/heart/daemon/daemon-entry.js

@@ -591,6 +591,7 @@ async function prepareProviderRuntime() {
     const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
     const readiness = await Promise.all(managedAgents.map(async (agent) => {
         try {
+            await (0, runtime_credentials_1.refreshRuntimeCredentialConfig)(agent, { preserveCachedOnFailure: true });
             const result = await (0, agent_config_check_1.checkAgentConfigWithProviderHealth)(agent, bundlesRoot);
             if (result.ok)
                 return null;

package/dist/heart/mailbox/mailbox-http-transport.js

@@ -92,7 +92,20 @@ function createBundleWatcher(bundlesRoot, onChange, deps = DEFAULT_BUNDLE_WATCHE
     }
     try {
         if (deps.existsSync(bundlesRoot)) {
-            watchers.push(deps.watch(bundlesRoot, { recursive: true }, debouncedOnChange));
+            const watcher = deps.watch(bundlesRoot, { recursive: true }, debouncedOnChange);
+            watcher.on?.("error", () => {
+                try {
+                    watcher.close();
+                }
+                catch {
+                    // Already closed.
+                }
+                const index = watchers.indexOf(watcher);
+                if (index >= 0)
+                    watchers.splice(index, 1);
+                debouncedOnChange();
+            });
+            watchers.push(watcher);
         }
     }
     catch {

package/dist/repertoire/tools-session.js

@@ -39,6 +39,7 @@ exports.formatButlerOperationalVisibility = formatButlerOperationalVisibility;
 exports.renderInnerProgressStatus = renderInnerProgressStatus;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
 const config_1 = require("../heart/config");
 const identity_1 = require("../heart/identity");
 const session_events_1 = require("../heart/session-events");
@@ -1050,6 +1051,17 @@ exports.sessionToolDefinitions = [
                             detail: "live delivery unavailable right now; queued for the next active turn",
                         };
                     },
+                    telegram: async (request) => {
+                        const key = (0, config_1.canonicalizeTelegramSessionKey)(request.key);
+                        const hash = (0, crypto_1.createHash)("sha256").update(`${request.friendId}\0${key}\0${request.content}`).digest("hex");
+                        const { sendTelegramAwaitFollowUp } = await Promise.resolve().then(() => __importStar(require("../senses/telegram")));
+                        return sendTelegramAwaitFollowUp(agentName, {
+                            ...request,
+                            key,
+                            requestId: request.requestId ?? `send-message:${hash}`,
+                            deliveryId: request.deliveryId ?? `send-message:${hash}`,
+                        });
+                    },
                     voice: async (request) => deliverVoiceChannelMessage(request, agentName, voiceInitialAudio),
                 },
             });

package/dist/repertoire/tools-surface.js

@@ -35,6 +35,8 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.surfaceToolDefinition = exports.surfaceToolDef = void 0;
 const fs = __importStar(require("fs"));
+const crypto_1 = require("crypto");
+const config_1 = require("../heart/config");
 const identity_1 = require("../heart/identity");
 const surface_tool_1 = require("../senses/surface-tool");
 const obligations_1 = require("../arc/obligations");
@@ -173,6 +175,38 @@ exports.surfaceToolDefinition = {
                 const agentRoot = (0, identity_1.getAgentRoot)();
                 const sessionsDir = path.join(agentRoot, "state", "sessions");
                 const friendsDir = path.join(agentRoot, "friends");
+                const queueToSession = async (target, detail) => {
+                    const { queuePendingMessage, getPendingDir } = await Promise.resolve().then(() => __importStar(require("../mind/pending")));
+                    const pendingDir = getPendingDir(agentName, target.friendId, target.channel, target.key);
+                    queuePendingMessage(pendingDir, {
+                        from: agentName,
+                        friendId: target.friendId,
+                        channel: target.channel,
+                        key: target.key,
+                        content,
+                        timestamp: Date.now(),
+                    });
+                    return { status: "queued", detail };
+                };
+                const deliverTelegramOrQueue = async (target, detail) => {
+                    const telegramKey = (0, config_1.canonicalizeTelegramSessionKey)(target.key);
+                    const hash = (0, crypto_1.createHash)("sha256").update(`${target.friendId}\0${telegramKey}\0${content}`).digest("hex");
+                    const requestId = queueItem?.obligationId ?? `surface:${hash}`;
+                    const deliveryId = queueItem?.obligationId ? `surface:${queueItem.obligationId}:${hash}` : `surface:${hash}`;
+                    const { sendTelegramAwaitFollowUp } = await Promise.resolve().then(() => __importStar(require("../senses/telegram")));
+                    const delivered = await sendTelegramAwaitFollowUp(agentName, {
+                        friendId: target.friendId,
+                        channel: "telegram",
+                        key: telegramKey,
+                        content,
+                        requestId,
+                        deliveryId,
+                        intent: "generic_outreach",
+                    });
+                    return delivered.status === "delivered_now"
+                        ? { status: "delivered", detail: "sent to Telegram now" }
+                        : queueToSession(target, detail);
+                };
                 // Resolve friend name → UUID if needed (agents may pass name instead of UUID)
                 let resolvedFriendId = friendId;
                 if (!fs.existsSync(path.join(sessionsDir, friendId))) {
@@ -213,17 +247,10 @@ exports.surfaceToolDefinition = {
                             && activity.channel !== "inner"
                             && bridge.attachedSessions.some((s) => s.friendId === activity.friendId && s.channel === activity.channel && s.key === activity.key));
                         if (bridgeTarget) {
-                            const { queuePendingMessage, getPendingDir } = await Promise.resolve().then(() => __importStar(require("../mind/pending")));
-                            const pendingDir = getPendingDir(agentName, bridgeTarget.friendId, bridgeTarget.channel, bridgeTarget.key);
-                            queuePendingMessage(pendingDir, {
-                                from: agentName,
-                                friendId: bridgeTarget.friendId,
-                                channel: bridgeTarget.channel,
-                                key: bridgeTarget.key,
-                                content,
-                                timestamp: Date.now(),
-                            });
-                            return { status: "queued", detail: `for next interaction via ${bridgeTarget.channel}` };
+                            const detail = `for next interaction via ${bridgeTarget.channel}`;
+                            return bridgeTarget.channel === "telegram"
+                                ? deliverTelegramOrQueue(bridgeTarget, detail)
+                                : queueToSession(bridgeTarget, detail);
                         }
                     }
                 }
@@ -232,17 +259,11 @@ exports.surfaceToolDefinition = {
                 // address before considering fresher sessions for the same friend,
                 // especially MCP sessions where check_response drains this path.
                 if (queueItem?.channel && queueItem.key && queueItem.channel !== "inner") {
-                    const { queuePendingMessage, getPendingDir } = await Promise.resolve().then(() => __importStar(require("../mind/pending")));
-                    const pendingDir = getPendingDir(agentName, friendId, queueItem.channel, queueItem.key);
-                    queuePendingMessage(pendingDir, {
-                        from: agentName,
-                        friendId,
-                        channel: queueItem.channel,
-                        key: queueItem.key,
-                        content,
-                        timestamp: Date.now(),
-                    });
-                    return { status: "queued", detail: `for originating ${queueItem.channel} session` };
+                    const target = { friendId, channel: queueItem.channel, key: queueItem.key };
+                    const detail = `for originating ${queueItem.channel} session`;
+                    return queueItem.channel === "telegram"
+                        ? deliverTelegramOrQueue(target, detail)
+                        : queueToSession(target, detail);
                 }
                 // Priority 2: Try proactive delivery first, then queue to freshest session
                 const allFriendSessions = (0, session_activity_1.listSessionActivity)({ sessionsDir, friendsDir, agentName, activeThresholdMs: Number.MAX_SAFE_INTEGER })
@@ -250,17 +271,10 @@ exports.surfaceToolDefinition = {
                 // Priority 2: Queue to freshest non-private-runtime session
                 const freshest = allFriendSessions[0];
                 if (freshest) {
-                    const { queuePendingMessage, getPendingDir } = await Promise.resolve().then(() => __importStar(require("../mind/pending")));
-                    const pendingDir = getPendingDir(agentName, freshest.friendId, freshest.channel, freshest.key);
-                    queuePendingMessage(pendingDir, {
-                        from: agentName,
-                        friendId: freshest.friendId,
-                        channel: freshest.channel,
-                        key: freshest.key,
-                        content,
-                        timestamp: Date.now(),
-                    });
-                    return { status: "queued", detail: `for next interaction via ${freshest.channel}` };
+                    const detail = `for next interaction via ${freshest.channel}`;
+                    return freshest.channel === "telegram"
+                        ? deliverTelegramOrQueue(freshest, detail)
+                        : queueToSession(freshest, detail);
                 }
                 // Priority 3: Deferred — no active session found
                 const { getDeferredReturnDir } = await Promise.resolve().then(() => __importStar(require("../mind/pending")));

package/dist/senses/pipeline.js

@@ -74,10 +74,21 @@ const flight_recorder_1 = require("../arc/flight-recorder");
 const context_loss_sentinel_1 = require("../heart/context-loss-sentinel");
 const cares_1 = require("../arc/cares");
 const VOICE_PENDING_MAX_AGE_MS = 15 * 60 * 1_000;
-function pendingExpirationReason(channel, message, now) {
+const TELEGRAM_GENERIC_OUTREACH_PENDING_MAX_AGE_MS = 15 * 60 * 1_000;
+function pendingExpirationReason(channel, message, now, agentName) {
     /* v8 ignore start -- pending expiry edge permutations are covered by the stale voice queue tests; this helper keeps defensive non-voice fallbacks @preserve */
     if (Number.isFinite(message.expiresAt) && Number(message.expiresAt) <= now)
         return "explicit_expiry";
+    if (channel === "telegram"
+        && agentName
+        && message.from === agentName
+        && !message.delegatedFrom
+        && !message.obligationId
+        && !message.requestId
+        && Number.isFinite(message.timestamp)
+        && now - message.timestamp > TELEGRAM_GENERIC_OUTREACH_PENDING_MAX_AGE_MS) {
+        return "telegram_generic_outreach_freshness_window";
+    }
     if (channel !== "voice")
         return null;
     if (!Number.isFinite(message.timestamp))
@@ -139,10 +150,18 @@ function filterDeliverablePendingMessages(input) {
     if (input.messages.length === 0)
         return input.messages;
     const now = input.now ?? Date.now();
+    const agentName = (() => {
+        try {
+            return (0, identity_1.getAgentName)();
+        }
+        catch {
+            return undefined;
+        }
+    })();
     const deliverable = [];
     const expired = [];
     for (const message of input.messages) {
-        const reason = pendingExpirationReason(input.channel, message, now);
+        const reason = pendingExpirationReason(input.channel, message, now, agentName);
         if (reason) {
             expired.push({ message, reason });
         }
@@ -786,6 +805,14 @@ async function handleInboundTurn(input) {
             channel: input.channel,
             messages: [...deferredReturns, ...sessionPending],
         });
+        const promotedPendingUserMessages = input.channel === "inner"
+            ? pending
+                .filter((message) => message.from === "ouro-cli" && message.content.trim().length > 0)
+                .map((message) => ({ role: "user", content: message.content }))
+            : [];
+        const backgroundPendingMessages = promotedPendingUserMessages.length > 0
+            ? pending.filter((message) => message.from !== "ouro-cli")
+            : pending;
         // Assemble messages: session messages + pending + inbound user messages
         // NOTE: live world-state checkpoint and pending messages are rendered via buildSystem (system prompt sections)
         const extraPrefixSections = input.onPendingDrained?.(pending) ?? [];
@@ -794,11 +821,11 @@ async function handleInboundTurn(input) {
             input.messages[0] = prependTurnSections(input.messages[0], extraPrefixSections);
         }
         // Append user messages from the inbound turn
-        for (const msg of input.messages) {
+        for (const msg of [...input.messages, ...promotedPendingUserMessages]) {
             (0, session_events_1.stampIngressTime)(msg);
             sessionMessages.push(msg);
         }
-        const currentUserMessages = input.messages.filter((message) => message.role === "user");
+        const currentUserMessages = [...input.messages, ...promotedPendingUserMessages].filter((message) => message.role === "user");
         const orientationFrame = input.runAgentOptions?.orientationFrame
             ?? (currentUserMessages.length > 0
                 ? (0, orientation_frame_1.buildOrientationFrame)({
@@ -891,8 +918,10 @@ async function handleInboundTurn(input) {
         }
         // Step 5: runAgent
         const existingToolContext = input.runAgentOptions?.toolContext;
-        const currentUserMessage = existingToolContext?.currentUserMessage
-            ?? latestUserAuthoredText(input.messages, input.continuityIngressTexts);
+        const promotedCurrentUserMessage = latestUserAuthoredText(promotedPendingUserMessages, undefined);
+        const currentUserMessage = promotedCurrentUserMessage
+            ?? existingToolContext?.currentUserMessage
+            ?? latestUserAuthoredText([...input.messages, ...promotedPendingUserMessages], input.continuityIngressTexts);
         let runAgentOptions = {
             ...input.runAgentOptions,
             resumePriorWork,
@@ -902,7 +931,7 @@ async function handleInboundTurn(input) {
             activeWorkFrame,
             delegationDecision,
             startOfTurnPacket: renderedStartOfTurnPacket,
-            pendingMessages: pending.length > 0 ? pending.map((msg) => ({ from: msg.from, content: msg.content })) : undefined,
+            pendingMessages: backgroundPendingMessages.length > 0 ? backgroundPendingMessages.map((msg) => ({ from: msg.from, content: msg.content })) : undefined,
             currentSessionKey: currentSession.key,
             currentObligation,
             mustResolveBeforeHandoff,

package/dist/senses/sanctuary-media-catalog-contract.js

@@ -15,8 +15,8 @@ function sanctuaryMediaCatalogRequiredToolCalls(request, advertisedToolNames) {
     if (!advertisedToolNames.includes("sanctuary_search_media_catalog"))
         return undefined;
     const normalized = normalizedRequest(request);
-    const mentionsMedia = /\b(?:film|films|movie|movies|show|shows|tv|jellyfin|watch|shelf|stock|catalog|library)\b/u.test(normalized);
-    const asksCatalog = /\b(?:have|got|stock|catalog|library|favorite|favourite|recommend|suggest|pick|watch)\b/u.test(normalized);
+    const mentionsMedia = /\b(?:film|films|movie|movies|show|shows|tv|jellyfin|watch|shelf|stock|catalog|library|lib)\b/u.test(normalized);
+    const asksCatalog = /\b(?:have|got|stock|catalog|library|lib|favorite|favourite|recommend|suggest|pick|watch|see)\b/u.test(normalized);
     const titleInventoryQuestion = /\b(?:do|did|can)\s+(?:we|you)\s+(?:have|got|stock)\s+[a-z0-9'][a-z0-9' ]*\??$/u.test(normalized);
     if ((!mentionsMedia && !titleInventoryQuestion) || !asksCatalog)
         return undefined;
@@ -29,10 +29,13 @@ function sanctuaryMediaCatalogRequiredToolCalls(request, advertisedToolNames) {
     });
     return {
         names,
-        retryMessage: "Use sanctuary_search_media_catalog before answering. If asked for taste or a favorite, form a light recommendation from returned catalog evidence instead of claiming you cannot have preferences. Keep it honest: say you cannot watch, but you can pick from the household shelf.",
+        retryMessage: "Use sanctuary_search_media_catalog before answering. If a broader media-optimization read fails or degrades, treat that as a diagnostic note and still use the catalog tool for ordinary library visibility questions. If asked for taste or a favorite, form a light recommendation from returned catalog evidence instead of claiming you cannot have preferences. Keep it honest: say you cannot watch, but you can pick from the household shelf.",
         validateTerminalAnswer(answer) {
-            return /\b(?:just|only|actually|merely)\s+(?:a\s+)?(?:bot|ai|assistant)\b|\bi don'?t actually watch\b/iu.test(answer)
-                ? "Answer from the catalog evidence with a truthful but personable recommendation; do not retreat into 'I am just a bot' framing."
+            if (/\b(?:just|only|actually|merely)\s+(?:a\s+)?(?:bot|ai|assistant)\b|\bi don'?t actually watch\b/iu.test(answer)) {
+                return "Answer from the catalog evidence with a truthful but personable recommendation; do not retreat into 'I am just a bot' framing.";
+            }
+            return /\b(?:you'?d|you\s+would|you\s+need\s+to|please)\b.*\b(?:check|look at|poke|nudge)\b.*\b(?:log|logs|dashboard|jellyfin|unmanic)\b/iu.test(answer)
+                ? "Do not send Ari to check Jellyfin, Unmanic, dashboards, or logs for ordinary library visibility while safe catalog tools are available. Use the catalog evidence, or if the catalog read itself fails, say exactly what I could and could not verify."
                 : undefined;
         },
     };

package/dist/senses/sanctuary-media-optimization.js

@@ -314,9 +314,8 @@ function createSanctuaryMediaOptimizationClient(options) {
             };
         }
         catch (error) {
-            if (!(error instanceof ReadFailure) || error.code !== "invalid_response")
-                throw error;
-            history = { available: false, reason: "file_size_metrics panel returned invalid data" };
+            const code = error.code;
+            history = { available: false, reason: code === "invalid_response" ? "file_size_metrics panel returned invalid data" : "file_size_metrics panel is unavailable" };
         }
         return {
             data: {

package/dist/senses/sanctuary-storage-optimization-contract.js

@@ -27,6 +27,6 @@ function sanctuaryStorageOptimizationRequiredToolCalls(request, _advertisedToolN
     });
     return {
         names,
-        retryMessage: "Run both safe reads now, identify the largest measured evidence, report Unmanic and Jellyfin findings, and propose a sample encode without inventing future savings. Do not ask permission or send Ari to a shell or QDirStat while these typed reads are available.",
+        retryMessage: "Run both safe reads now, identify the largest measured evidence, report Unmanic and Jellyfin findings, and propose a sample encode without inventing future savings. If one read returns a degraded or partial result, continue with the other safe reads and bounded container/log tools before answering. Do not ask permission or send Ari to a shell, dashboard, logs, or QDirStat while these typed reads are available.",
     };
 }

package/dist/senses/shared-turn.js

@@ -418,7 +418,13 @@ async function runSenseTurn(options) {
             };
         }
         const persistedEvents = persistPromise ? await persistPromise : [];
-        await deliverPending(terminalDeliveryKind, { throwOnError: false });
+        const finalDeliveryKind = terminalDeliveryKind;
+        if (finalDeliveryKind === "settle" && Array.isArray(turnResult.messages)) {
+            const settledText = extractOutwardSenseDeliveryText(turnResult.messages);
+            if (settledText)
+                pendingResponseText = settledText;
+        }
+        await deliverPending(finalDeliveryKind, { throwOnError: false });
         const ponderDeferred = false;
         // Build response
         let finalResponse;

package/dist/senses/telegram.js

@@ -67,6 +67,7 @@ const sanctuary_runtime_1 = require("./sanctuary-runtime");
 const sanctuary_sab_1 = require("./sanctuary-sab");
 const sanctuary_download_credit_presentation_1 = require("./sanctuary-download-credit-presentation");
 const shared_turn_1 = require("./shared-turn");
+const config_1 = require("../heart/config");
 const telegram_client_1 = require("./telegram-client");
 const sanctuary_runtime_2 = require("./sanctuary-runtime");
 const sanctuary_full_visibility_contract_1 = require("./sanctuary-full-visibility-contract");
@@ -1015,19 +1016,20 @@ function createTelegramSenseApp(options) {
     const deliverAwaitFollowUp = async (request) => {
         if (!request.requestId)
             return { status: "blocked", detail: "Telegram follow-up is missing its request binding" };
+        const sessionKey = (0, config_1.canonicalizeTelegramSessionKey)(request.key);
         try {
-            const obligation = (0, obligations_1.findPendingObligationForRequest)(agentRoot, { requestId: request.requestId, owedTo: { friendId: request.friendId, channel: "telegram", key: request.key } });
+            const obligation = (0, obligations_1.findPendingObligationForRequest)(agentRoot, { requestId: request.requestId, owedTo: { friendId: request.friendId, channel: "telegram", key: sessionKey } });
             if (obligation && !obligation.returnReadyAt)
                 (0, obligations_1.markObligationReturnReady)(agentRoot, obligation.id, request.deliveryId ?? `telegram-return:${request.requestId}`);
             const expiry = request.deliveryId?.endsWith(":expired") === true;
             const artifact = await executeAuthorizedEffect({
                 idempotencyKey: `await-${expiry ? "expiry-" : ""}follow-up:${request.requestId}:${(0, node_crypto_1.createHash)("sha256").update(request.deliveryId ?? request.content).digest("hex")}`,
-                target: { kind: "approved_relationship", friendId: request.friendId, sessionKey: request.key, requestId: request.requestId },
+                target: { kind: "approved_relationship", friendId: request.friendId, sessionKey, requestId: request.requestId },
                 authorClass: "butler",
                 effect: { kind: "text", text: request.content },
                 ...(obligation ? { obligationReturnId: obligation.id } : {}),
             });
-            await recordAcceptedEffects((0, shared_turn_1.getSenseSessionPath)(options.agentName, request.friendId, "telegram", request.key, agentRoot), [artifact]);
+            await recordAcceptedEffects((0, shared_turn_1.getSenseSessionPath)(options.agentName, request.friendId, "telegram", sessionKey, agentRoot), [artifact]);
             return { status: "delivered_now", detail: "sent to the exact request-bound Telegram chat" };
         }
         catch (error) {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.790",
+  "version": "0.1.0-alpha.792",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.790",
+      "version": "0.1.0-alpha.792",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.78.0",
         "@azure/identity": "^4.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.790",
+  "version": "0.1.0-alpha.792",
   "engines": {
     "node": ">=22"
   },