@ouro.bot/cli 0.1.0-alpha.800 → 0.1.0-alpha.802

package/changelog.json

@@ -1,6 +1,18 @@
 {
   "_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.802",
+      "changes": [
+        "Prefer validated completion text for settled replies and bind delivery causality only when the newest validated current-turn session event matches, preventing stale or duplicate Telegram answers."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.801",
+      "changes": [
+        "Keep shared-turn empty-response diagnostics internal on Telegram so tool-only investigation steps do not appear as user-visible Butler messages."
+      ]
+    },
     {
       "version": "0.1.0-alpha.800",
       "changes": [

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

@@ -1,5 +1,5 @@
 {
-  "runtimeVersion": "0.1.0-alpha.800",
+  "runtimeVersion": "0.1.0-alpha.802",
   "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>ouro-butler</Name>
-  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.800</Repository>
+  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.802</Repository>
   <Registry>https://github.com/ourostack/ouroboros/pkgs/container/ouroboros-butler</Registry>
   <Network>host</Network>
   <Shell>sh</Shell>

package/dist/heart/session-events.js

@@ -52,6 +52,7 @@ exports.stampIngressTime = stampIngressTime;
 exports.getIngressTime = getIngressTime;
 exports.stampIngressRelations = stampIngressRelations;
 exports.getIngressRelations = getIngressRelations;
+exports.projectedSessionEventIds = projectedSessionEventIds;
 exports.projectProviderMessages = projectProviderMessages;
 exports.annotateMessageTimestamps = annotateMessageTimestamps;
 exports.bestEventTimestamp = bestEventTimestamp;
@@ -936,10 +937,13 @@ function buildEventFromMessage(message, sequence, recordedAt, captureKind, sourc
         },
     };
 }
-function projectProviderMessages(envelope) {
-    const eventIds = envelope.projection.eventIds.length > 0
+function projectedSessionEventIds(envelope) {
+    return envelope.projection.eventIds.length > 0
         ? envelope.projection.eventIds
         : envelope.events.map((event) => event.id);
+}
+function projectProviderMessages(envelope) {
+    const eventIds = projectedSessionEventIds(envelope);
     const byId = new Map(envelope.events.map((event) => [event.id, event]));
     return eventIds
         .map((id) => byId.get(id))
@@ -958,9 +962,7 @@ function projectProviderMessages(envelope) {
  * System and tool messages are untouched.
  */
 function annotateMessageTimestamps(envelope, messages, nowMs = Date.now()) {
-    const eventIds = envelope.projection.eventIds.length > 0
-        ? envelope.projection.eventIds
-        : envelope.events.map((event) => event.id);
+    const eventIds = projectedSessionEventIds(envelope);
     const byId = new Map(envelope.events.map((event) => [event.id, event]));
     const events = eventIds
         .map((id) => byId.get(id))

package/dist/mind/context.js

@@ -349,6 +349,7 @@ function loadSession(filePath) {
         return {
             messages: (0, session_events_1.sanitizeProviderMessages)((0, session_events_1.projectProviderMessages)(envelope)),
             events: envelope.events,
+            projectionEventIds: [...(0, session_events_1.projectedSessionEventIds)(envelope)],
             structuredOutputs: envelope.structuredOutputs ?? [],
             lastUsage: envelope.lastUsage ?? undefined,
             state: denormalizeContinuityState(envelope.state),

package/dist/senses/shared-turn.js

@@ -177,70 +177,134 @@ function extractOutwardSenseDeliveryText(messages) {
         : assistantContentText(assistant.content);
 }
 function hasAcceptedOutwardSessionAck(events, assistantIndex, toolCallId, toolName) {
+    if (typeof toolCallId !== "string" || !toolCallId.trim())
+        return false;
     const expectedAck = OUTWARD_DELIVERY_TOOL_ACKS.get(toolName);
     for (let index = assistantIndex + 1; index < events.length; index++) {
         const candidate = events[index];
         if (candidate.role !== "tool")
             return false;
-        if (candidate.toolCallId === toolCallId && typeof candidate.content === "string" && candidate.content.trim() === expectedAck)
-            return true;
+        if (candidate.toolCallId !== toolCallId && candidate.relations?.toolCallId !== toolCallId)
+            continue;
+        return candidate.toolCallId === toolCallId
+            && candidate.relations?.toolCallId === toolCallId
+            && candidate.provenance?.captureKind === "live"
+            && Array.isArray(candidate.toolCalls)
+            && candidate.toolCalls.length === 0
+            && typeof candidate.content === "string"
+            && candidate.content === expectedAck;
     }
     return false;
 }
-function newOutwardCoordinates(events, existingEventIds, afterEventId) {
-    const boundaryIndex = events.findIndex((event) => event.id === afterEventId);
-    if (boundaryIndex < 0)
-        return [];
+function newOutwardCoordinates(events, existingEventIds, boundaryIndex) {
     return events.flatMap((event, eventIndex) => {
-        if (eventIndex <= boundaryIndex || existingEventIds.has(event.id) || event.role !== "assistant" || event.provenance?.captureKind === "synthetic")
+        if (eventIndex <= boundaryIndex || existingEventIds.has(event.id) || event.role !== "assistant" || event.provenance?.captureKind !== "live" || !Array.isArray(event.toolCalls))
             return [];
         const outwardTools = event.toolCalls.flatMap((call) => {
-            if (call.function.name !== "speak" && call.function.name !== "settle")
+            const toolName = call?.function?.name;
+            if (toolName !== "speak" && toolName !== "settle")
                 return [];
-            if (!hasAcceptedOutwardSessionAck(events, eventIndex, call.id, call.function.name))
+            if (!hasAcceptedOutwardSessionAck(events, eventIndex, call.id, toolName))
                 return [];
-            const text = stripThinkBlocks(parseToolStringArg(call, call.function.name, call.function.name === "speak" ? "message" : "answer") ?? "");
-            return text ? [{ kind: call.function.name, eventId: event.id, text }] : [];
+            const text = stripThinkBlocks(parseToolStringArg(call, toolName, toolName === "speak" ? "message" : "answer") ?? "");
+            return text ? [{ kind: toolName, eventId: event.id, eventIndex, text }] : [];
         });
         if (outwardTools.length > 0)
             return outwardTools;
         if (event.toolCalls.length > 0)
             return [];
         const text = stripThinkBlocks(typeof event.content === "string" ? event.content : "");
-        return text ? [{ kind: "text", eventId: event.id, text }] : [];
+        return text ? [{ kind: "text", eventId: event.id, eventIndex, text }] : [];
     });
 }
-function newestPlainAssistantText(messages) {
-    const message = messages.findLast((candidate) => candidate.role === "assistant"
-        && (!("tool_calls" in candidate) || !Array.isArray(candidate.tool_calls) || candidate.tool_calls.length === 0)
-        && typeof candidate.content === "string"
-        && candidate.content.trim().length > 0);
-    return message ? assistantContentText(message.content) : null;
-}
-function causalSessionEventIds(events, existingEventIds, attempts, afterEventId) {
-    if (!afterEventId)
+function alignedDeliveryCoordinates(view, attempts, finalAttemptIndex, finalCoordinate) {
+    if (!view)
         return attempts.flatMap((attempt) => attempt.delivered ? [null] : []);
-    const coordinates = newOutwardCoordinates(events, existingEventIds, afterEventId);
+    const terminalCoordinate = finalCoordinate ?? (finalAttemptIndex === undefined ? view.terminal : undefined);
+    const reservedAttemptIndex = terminalCoordinate
+        ? finalAttemptIndex !== undefined
+            ? (attempts[finalAttemptIndex]?.delivered && attempts[finalAttemptIndex]?.kind === terminalCoordinate.kind && attempts[finalAttemptIndex]?.text === terminalCoordinate.text ? finalAttemptIndex : -1)
+            : attempts.findLastIndex((attempt) => attempt.delivered && attempt.kind === terminalCoordinate.kind && attempt.text === terminalCoordinate.text)
+        : -1;
+    const availableCoordinates = terminalCoordinate ? view.coordinates.filter((coordinate) => coordinate !== terminalCoordinate) : view.coordinates;
     let nextCoordinate = 0;
-    return attempts.flatMap((attempt) => {
+    return attempts.flatMap((attempt, attemptIndex) => {
         if (!attempt.delivered)
             return [];
-        const coordinateIndex = coordinates.findIndex((coordinate, index) => index >= nextCoordinate && coordinate.kind === attempt.kind && coordinate.text === attempt.text);
+        if (attemptIndex === finalAttemptIndex)
+            return finalCoordinate && finalCoordinate.kind === attempt.kind && finalCoordinate.text === attempt.text ? [finalCoordinate] : [null];
+        if (attemptIndex === reservedAttemptIndex && terminalCoordinate)
+            return [terminalCoordinate];
+        const coordinateIndex = availableCoordinates.findIndex((coordinate, index) => index >= nextCoordinate && coordinate.kind === attempt.kind && coordinate.text === attempt.text);
         if (coordinateIndex < 0)
             return [null];
         nextCoordinate = coordinateIndex + 1;
-        return [coordinates[coordinateIndex].eventId];
+        return [availableCoordinates[coordinateIndex]];
     });
 }
+function causalSessionEventIds(view, attempts, finalAttemptIndex, finalCoordinate) {
+    return alignedDeliveryCoordinates(view, attempts, finalAttemptIndex, finalCoordinate).map((coordinate) => coordinate?.eventId ?? null);
+}
 function currentIngressEventId(events, existingEventIds, userMessage, precommittedIngress, ingressRelations) {
-    if (precommittedIngress)
-        return precommittedIngress.eventId;
     const reference = ingressRelations?.references[0];
-    return events.findLast((event) => (!existingEventIds.has(event.id)
-        && event.role === "user"
+    const carriesReference = (event, expected) => Array.isArray(event.relations?.references) && event.relations.references.includes(expected);
+    const matches = events.filter((event) => (event.role === "user"
         && event.content === userMessage
-        && event.provenance?.captureKind !== "synthetic"
-        && (!reference || event.relations?.references.includes(reference))))?.id;
+        && event.provenance?.captureKind === "live"
+        && (precommittedIngress
+            ? ((event.id === precommittedIngress.eventId && carriesReference(event, precommittedIngress.reference))
+                || (!existingEventIds.has(event.id) && carriesReference(event, precommittedIngress.reference)))
+            : !existingEventIds.has(event.id) && (!reference || carriesReference(event, reference)))));
+    return matches.length === 1 ? matches[0].id : undefined;
+}
+function rawSessionEvents(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return [];
+    const record = value;
+    return record.version === 2 && Array.isArray(record.events) ? record.events : [];
+}
+function exactProjectedIngressMessage(existing, messages, eventId) {
+    const eventsById = new Map(existing.events.map((event) => [event.id, event]));
+    if (eventsById.size !== existing.events.length)
+        return null;
+    const seenProjectionIds = new Set();
+    const projectedEvents = [];
+    for (const projectedId of existing.projectionEventIds) {
+        if (typeof projectedId !== "string" || !projectedId.trim() || seenProjectionIds.has(projectedId))
+            return null;
+        const event = eventsById.get(projectedId);
+        if (!event)
+            return null;
+        seenProjectionIds.add(projectedId);
+        projectedEvents.push(event);
+    }
+    if (existing.projectionEventIds.filter((projectedId) => projectedId === eventId).length !== 1)
+        return null;
+    const projectedUsers = projectedEvents.filter((event) => event.role === "user");
+    const providerUsers = messages.filter((message) => message.role === "user");
+    if (projectedUsers.at(-1)?.id !== eventId || projectedUsers.length !== providerUsers.length)
+        return null;
+    return providerUsers.at(-1);
+}
+function currentTurnEventView(events, existingEventIds, userMessage, precommittedIngress, ingressRelations) {
+    const eventIds = new Set();
+    let previousSequence = 0;
+    for (const event of events) {
+        if (!event || typeof event !== "object" || typeof event.id !== "string" || !event.id.trim() || eventIds.has(event.id) || !Number.isSafeInteger(event.sequence) || event.sequence <= previousSequence)
+            return null;
+        eventIds.add(event.id);
+        previousSequence = event.sequence;
+    }
+    const ingressEventId = currentIngressEventId(events, existingEventIds, userMessage, precommittedIngress, ingressRelations);
+    if (!ingressEventId)
+        return null;
+    const ingressIndex = events.findIndex((event) => event.id === ingressEventId);
+    if (events.some((event, eventIndex) => eventIndex > ingressIndex && existingEventIds.has(event.id)))
+        return null;
+    const coordinates = newOutwardCoordinates(events, existingEventIds, ingressIndex);
+    const newestAssistantIndex = events.findLastIndex((event, eventIndex) => eventIndex > ingressIndex && event.role === "assistant");
+    const terminal = coordinates.findLast((coordinate) => coordinate.eventIndex === newestAssistantIndex);
+    return { coordinates, ...(terminal ? { terminal } : {}) };
 }
 function getSenseSessionPath(agentName, friendId, channel, sessionKey, agentRootOverride) {
     return path.join(agentRootOverride ?? (0, identity_1.getAgentRoot)(agentName), "state", "sessions", friendId, channel, `${(0, config_1.sanitizeKey)(sessionKey)}.json`);
@@ -309,11 +373,13 @@ async function runSenseTurn(options) {
     return runWithLease(sessPath, async (sessionTurnLease) => {
         const baseSessionRevision = (0, session_transaction_1.readSessionTransaction)(sessPath, sessionTurnLease).revision;
         const existing = (0, context_1.loadSession)(sessPath);
+        const precommittedIngressEvent = options.precommittedIngress
+            ? existing?.events?.find((candidate) => candidate.id === options.precommittedIngress.eventId)
+            : undefined;
         if (options.precommittedIngress) {
-            const event = existing?.events?.find((candidate) => candidate.id === options.precommittedIngress.eventId);
             const latestUserEvent = existing?.events?.filter((candidate) => candidate.role === "user").at(-1);
-            if (!event || event !== latestUserEvent || event.role !== "user" || event.content !== userMessage
-                || !event.relations.references.includes(options.precommittedIngress.reference)) {
+            if (!precommittedIngressEvent || precommittedIngressEvent !== latestUserEvent || precommittedIngressEvent.role !== "user" || precommittedIngressEvent.content !== userMessage
+                || !precommittedIngressEvent.relations.references.includes(options.precommittedIngress.reference)) {
                 throw new Error("shared turn precommitted ingress is missing, mismatched, or no longer current");
             }
         }
@@ -323,7 +389,16 @@ async function runSenseTurn(options) {
         const sessionMessages = existing?.messages && existing.messages.length > 0
             ? existing.messages
             : [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(await (0, prompt_1.buildSystem)(channel, {}, undefined)) }];
-        const preTurnMessageCount = sessionMessages.length;
+        if (precommittedIngressEvent) {
+            const projectedIngress = exactProjectedIngressMessage(existing, sessionMessages, precommittedIngressEvent.id);
+            if (!projectedIngress || projectedIngress.role !== "user" || projectedIngress.content !== userMessage)
+                throw new Error("shared turn precommitted ingress is absent from the provider projection");
+            (0, session_events_1.stampIngressRelations)(projectedIngress, {
+                replyToEventId: precommittedIngressEvent.relations.replyToEventId,
+                threadRootEventId: precommittedIngressEvent.relations.threadRootEventId,
+                references: precommittedIngressEvent.relations.references,
+            });
+        }
         // Pending dir
         const pendingDir = (0, pending_1.getPendingDir)(agentName, friendId, channel, sessionKey);
         // Accumulate outward text through the same callback boundary used by chat
@@ -352,9 +427,10 @@ async function runSenseTurn(options) {
             const text = stripThinkBlocks(pendingResponseText);
             pendingResponseText = "";
             if (!text)
-                return;
+                return undefined;
             const delivery = { kind, text };
             const attempt = { kind, text, delivered: false };
+            const attemptIndex = deliveryAttempts.length;
             deliveryAttempts.push(attempt);
             try {
                 await options.deliverySink?.onDelivery(delivery);
@@ -376,6 +452,7 @@ async function runSenseTurn(options) {
                     throw error;
                 commitResponseText(text);
             }
+            return attemptIndex;
         };
         /* v8 ignore start — callback stubs are exercised through the pipeline integration */
         const callbacks = {
@@ -393,7 +470,7 @@ async function runSenseTurn(options) {
             },
             onError: () => { },
             onClearText: () => { pendingResponseText = ""; },
-            flushNow: () => deliverPending("speak", { throwOnError: true }),
+            flushNow: async () => { await deliverPending("speak", { throwOnError: true }); },
         };
         /* v8 ignore stop */
         // Run the pipeline
@@ -469,27 +546,28 @@ async function runSenseTurn(options) {
             };
         }
         const persistedEvents = persistPromise ? await persistPromise : [];
-        const ingressEventId = currentIngressEventId(persistedEvents, existingEventIds, userMessage, options.precommittedIngress, options.ingressRelations);
-        const finalDeliveryKind = terminalDeliveryKind;
+        const terminalEvents = persistedEvents.length > 0
+            ? persistedEvents
+            : rawSessionEvents((0, session_transaction_1.readSessionTransaction)(sessPath, sessionTurnLease).value);
+        const eventView = currentTurnEventView(terminalEvents, existingEventIds, userMessage, options.precommittedIngress, options.ingressRelations);
+        let finalDeliveryKind = terminalDeliveryKind;
         const acceptedTerminalOutcome = turnResult.turnOutcome === "settled" || turnResult.turnOutcome === "blocked";
         const failoverText = turnResult.turnOutcome === "errored" ? turnResult.failoverMessage?.trim() : undefined;
         const expectsOutwardResponse = acceptedTerminalOutcome || turnResult.turnOutcome === "command" || Boolean(failoverText);
-        const hadPendingCallbackText = stripThinkBlocks(pendingResponseText).length > 0;
-        let recoveredTerminalEventId;
+        let finalCausalCoordinate;
         if (acceptedTerminalOutcome) {
-            const completionText = turnResult.completion?.answer.trim();
-            const currentTurnMessages = Array.isArray(turnResult.messages) ? turnResult.messages.slice(preTurnMessageCount) : [];
-            const plainTerminalText = newestPlainAssistantText(currentTurnMessages);
-            const acknowledgedDeliveryText = finalDeliveryKind === "settle"
-                ? extractOutwardSenseDeliveryText(currentTurnMessages)
-                : null;
-            const authoritativeText = completionText || acknowledgedDeliveryText || plainTerminalText;
-            if (authoritativeText)
-                pendingResponseText = authoritativeText;
-            else
-                pendingResponseText = "";
-            if (!hadPendingCallbackText && plainTerminalText)
-                recoveredTerminalEventId = causalSessionEventIds(persistedEvents, existingEventIds, [{ kind: "text", text: stripThinkBlocks(plainTerminalText), delivered: true }], ingressEventId)[0] ?? undefined;
+            const completionText = stripThinkBlocks(turnResult.completion?.answer ?? "");
+            let authoritativeText = completionText;
+            if (!authoritativeText && eventView?.terminal) {
+                authoritativeText = eventView.terminal.text;
+                finalDeliveryKind = eventView.terminal.kind;
+            }
+            if (eventView?.terminal?.kind === finalDeliveryKind && eventView.terminal.text === authoritativeText)
+                finalCausalCoordinate = eventView.terminal;
+            const terminalAlreadyDelivered = finalCausalCoordinate
+                ? alignedDeliveryCoordinates(eventView, deliveryAttempts).includes(finalCausalCoordinate)
+                : false;
+            pendingResponseText = authoritativeText && !terminalAlreadyDelivered ? authoritativeText : "";
         }
         else if (turnResult.turnOutcome === "command") {
             // Slash-command text is emitted directly by the pipeline and has no assistant event.
@@ -500,28 +578,20 @@ async function runSenseTurn(options) {
         else {
             pendingResponseText = "";
         }
-        await deliverPending(finalDeliveryKind, { throwOnError: false });
+        const finalDeliveryAttemptIndex = await deliverPending(finalDeliveryKind, { throwOnError: false });
         const ponderDeferred = false;
         // Build response
         let finalResponse;
-        let responseCausalSessionEventId = recoveredTerminalEventId;
+        const finalDeliveryAttempt = finalDeliveryAttemptIndex === undefined ? undefined : deliveryAttempts[finalDeliveryAttemptIndex];
+        const responseDeliveryFailure = finalDeliveryAttempt && !finalDeliveryAttempt.delivered ? deliveryFailures.at(-1) : undefined;
+        const responseCausalSessionEventId = finalDeliveryAttempt && !finalDeliveryAttempt.delivered ? finalCausalCoordinate?.eventId : undefined;
         if (committedResponseText.length === 0) {
             if (!expectsOutwardResponse) {
                 finalResponse = "";
             }
             else {
-                // The terminal turn had no committed text — check its session transcript for the delivered answer.
-                const postTurnSession = (0, context_1.loadSession)(sessPath);
                 const emptyFallback = options.emptyResponseFallback?.();
-                if (postTurnSession?.messages) {
-                    const recovered = extractOutwardSenseDeliveryText(postTurnSession.messages.slice(preTurnMessageCount));
-                    finalResponse = recovered ?? emptyFallback ?? (hadReasoningChunk ? "" : "(agent responded but response was empty)");
-                    if (recovered)
-                        responseCausalSessionEventId = causalSessionEventIds(persistedEvents, existingEventIds, [{ kind: finalDeliveryKind, text: stripThinkBlocks(recovered), delivered: true }], ingressEventId)[0] ?? undefined;
-                }
-                else {
-                    finalResponse = emptyFallback ?? (hadReasoningChunk ? "" : "(agent responded but response was empty)");
-                }
+                finalResponse = emptyFallback ?? (hadReasoningChunk ? "" : "(agent responded but response was empty)");
             }
         }
         else {
@@ -561,10 +631,11 @@ async function runSenseTurn(options) {
             ponderDeferred,
             deliveries,
             deliveryFailures,
+            ...(responseDeliveryFailure ? { responseDeliveryFailure } : {}),
             providerInvocationCount,
             toolInvocationCount,
             sessionPath: sessPath,
-            ...(deliveries.length > 0 ? { causalSessionEventIds: causalSessionEventIds(persistedEvents, existingEventIds, deliveryAttempts, ingressEventId) } : {}),
+            ...(deliveries.length > 0 ? { causalSessionEventIds: causalSessionEventIds(eventView, deliveryAttempts, finalDeliveryAttemptIndex, finalCausalCoordinate) } : {}),
             ...(responseCausalSessionEventId ? { responseCausalSessionEventId } : {}),
         };
     });

package/dist/senses/telegram.js

@@ -90,6 +90,16 @@ const pending_1 = require("../mind/pending");
 const relationship_authorization_1 = require("../repertoire/relationship-authorization");
 const telegram_admission_1 = require("./telegram-admission");
 const telegram_effect_adapter_1 = require("./telegram-effect-adapter");
+const EMPTY_SHARED_TURN_DIAGNOSTIC = "(agent responded but response was empty)";
+function hasUserVisibleTurnResponse(response) {
+    const text = response.trim();
+    return text.length > 0 && text !== EMPTY_SHARED_TURN_DIAGNOSTIC;
+}
+function responseFallbackAfterDeliveries(result, successfulDeliveryCount) {
+    const failedTerminal = result.responseDeliveryFailure?.text ?? (result.responseCausalSessionEventId ? result.deliveryFailures.at(-1)?.text : undefined);
+    const response = failedTerminal ?? (successfulDeliveryCount === 0 && result.deliveryFailures.length === 0 ? result.response : "");
+    return hasUserVisibleTurnResponse(response) ? response : null;
+}
 function createFullVisibilityProgress() {
     const progress = {};
     return { progress, emptyResponseFallback: () => progress.fallback?.() };
@@ -1181,10 +1191,15 @@ function createTelegramSenseApp(options) {
             emptyResponseFallback: fullVisibility.emptyResponseFallback,
             deliverySink: { onDelivery: (delivery) => deliver(delivery.text, delivery.kind === "settle") },
         });
-        if (effects.length === 0 && result.response.trim())
-            await deliver(result.response, true);
+        let responseFallbackArtifactId;
+        const responseFallback = responseFallbackAfterDeliveries(result, effects.length);
+        if (responseFallback) {
+            await deliver(responseFallback, true);
+            responseFallbackArtifactId = effects.at(-1)?.id;
+        }
         const causalEventIds = Object.fromEntries(effects.flatMap((artifact, index) => {
-            const eventId = result.causalSessionEventIds?.[index] ?? (effects.length === 1 ? result.responseCausalSessionEventId : undefined);
+            const eventId = result.causalSessionEventIds?.[index]
+                ?? (artifact.id === responseFallbackArtifactId ? result.responseCausalSessionEventId : undefined);
             return eventId ? [[artifact.id, eventId]] : [];
         }));
         await recordAcceptedEffects(sessionPath, effects, undefined, causalEventIds);
@@ -1317,7 +1332,6 @@ function createTelegramSenseApp(options) {
             meta: lifecycleMeta("senses.telegram_turn_start", { agentName: options.agentName, subject, ...acceptanceMeta, ...lifecycleCoordinates }, lifecycleStartedAt),
         });
         acceptanceAuditBarrier();
-        let deliveryCount = 0;
         const deliveredMessageIds = [];
         const deliveredChunks = [];
         let receiptStatus = "success";
@@ -1381,7 +1395,6 @@ function createTelegramSenseApp(options) {
                         }
                         else {
                             turnEffects.push(await deliverButlerEffect(delivery.text, `turn:${subject}:${message.updateId}:delivery:${deliveryOrdinal++}`, undefined, (messageId, chunk) => { deliveredMessageIds.push(messageId); deliveredChunks.push(chunk); }, exactDownloadCreditQuestion));
-                            deliveryCount += 1;
                         }
                     },
                 },
@@ -1413,12 +1426,14 @@ function createTelegramSenseApp(options) {
                     throw new Error("Canonical Sanctuary query did not produce exactly one matching grounded settle");
                 const canonical = (0, sanctuary_grounding_1.renderSanctuaryGroundedResponse)(grounding.toolName, grounding.facts);
                 turnEffects.push(await deliverButlerEffect(canonical, `turn:${subject}:${message.updateId}:delivery:${deliveryOrdinal++}`, undefined, (messageId, chunk) => { deliveredMessageIds.push(messageId); deliveredChunks.push(chunk); }));
-                deliveryCount = 1;
             }
-            else if (deliveryCount === 0 && result.response.trim()) {
-                const artifact = await deliverButlerEffect(result.response, `turn:${subject}:${message.updateId}:delivery:${deliveryOrdinal++}`, undefined, (messageId, chunk) => { deliveredMessageIds.push(messageId); deliveredChunks.push(chunk); }, exactDownloadCreditQuestion);
-                turnEffects.push(artifact);
-                responseFallbackArtifactId = artifact.id;
+            else {
+                const responseFallback = responseFallbackAfterDeliveries(result, turnEffects.length);
+                if (responseFallback) {
+                    const artifact = await deliverButlerEffect(responseFallback, `turn:${subject}:${message.updateId}:delivery:${deliveryOrdinal++}`, undefined, (messageId, chunk) => { deliveredMessageIds.push(messageId); deliveredChunks.push(chunk); }, exactDownloadCreditQuestion);
+                    turnEffects.push(artifact);
+                    responseFallbackArtifactId = artifact.id;
+                }
             }
             if (result.sessionPath) {
                 const causalEventIds = Object.fromEntries((groundingIntentTool ? [] : turnEffects).flatMap((artifact, index) => {
@@ -1435,7 +1450,7 @@ function createTelegramSenseApp(options) {
                 component: "senses",
                 event: "senses.telegram_turn_end",
                 message: "Telegram authorized turn completed",
-                meta: lifecycleMeta("senses.telegram_turn_end", { agentName: options.agentName, subject, deliveryCount: Math.max(deliveryCount, result.response.trim() ? 1 : 0), ...acceptanceMeta, ...lifecycleCoordinates, ...(acceptanceMarker ? { outcome: "success", errorDigest: null } : {}) }, Math.max(Date.now(), lifecycleStartedAt + 1)),
+                meta: lifecycleMeta("senses.telegram_turn_end", { agentName: options.agentName, subject, deliveryCount: turnEffects.length, ...acceptanceMeta, ...lifecycleCoordinates, ...(acceptanceMarker ? { outcome: "success", errorDigest: null } : {}) }, Math.max(Date.now(), lifecycleStartedAt + 1)),
             });
         }
         catch (error) {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.800",
+  "version": "0.1.0-alpha.802",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.800",
+      "version": "0.1.0-alpha.802",
       "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.800",
+  "version": "0.1.0-alpha.802",
   "engines": {
     "node": ">=22"
   },