@segmentstream/agent 0.26.1 → 0.27.0

package/dist/extension/lib/telegram/adapter.mjs

@@ -13,7 +13,7 @@ import { n as conversationLanguage, o as telegramPrincipal } from "../../../_chu
 import { object } from "../confirmation-description.mjs";
 import { confirmationLocale } from "./confirmation-text.mjs";
 import { telegramSendScope } from "./send-queue.mjs";
-import { conversations } from "../conversations.mjs";
+import { conversations, topicContext } from "../conversations.mjs";
 import { withDeliveryDiagnostics } from "./delivery-diagnostics.mjs";
 import { d as failureText, h as withDeliveryLocale, i as withReplacedText, m as safeTelegramFetch, n as currentInboundRequest, o as currentLocale, p as reportTelegramError, r as runInboundRequest, t as InboundRequest } from "../../../_chunks/inbound-request-D1r0FkDI.mjs";
 import { chooseModel } from "../../model.mjs";
@@ -21,22 +21,21 @@ import { groupRoutingHealth } from "../group-routing/health.mjs";
 import { decisionRouter } from "../group-routing/router.mjs";
 import { archivedRoutingMessages } from "../group-routing/routing-context.mjs";
 import { dispatchStructuredMessage, structuredMessage } from "./structured.mjs";
-import { scopedAddress, sessionPolicy } from "./sessions.mjs";
+import { scopedAddress } from "./sessions.mjs";
 import { handleWorkspaceCallback, isWorkspaceCallback } from "./callbacks.mjs";
-import { t as agentBuild } from "../../../_chunks/build-metadata-D_Gqlb5f.mjs";
+import { t as agentBuild } from "../../../_chunks/build-metadata-R_ssK2uR.mjs";
 import { attachmentLifecycle } from "./lifecycle.mjs";
 import { gatewayImageDescriber } from "./images.mjs";
 import { gatewayAttachmentDescriber } from "./attachment-description.mjs";
 import { MAXIMUM_DOWNLOAD_BYTES, connectionProxy } from "../connection-proxy.mjs";
 import { agentAttachments, parseAttachmentUrl } from "../attachments.mjs";
 import { agentIdentities } from "../identities.mjs";
-import { observedMessages } from "./observed.mjs";
-import { interimTexts, replyDelivery } from "./silent.mjs";
-import { handleConfirmationCallback, telegramConfirmationEvents } from "./confirmations.mjs";
 import { captureRouteDecider, captureTelegramFetch, conversationIdentities, recordGateDecision, telegramConversationCapture } from "./conversations.mjs";
 import { botIdentityCache } from "./bot.mjs";
+import { handleConfirmationCallback, telegramConfirmationEvents } from "./confirmations.mjs";
 import { gatewayMediaCapabilities, planMedia } from "./media-policy.mjs";
 import { agentChats } from "./chats.mjs";
+import { interimTexts, replyDelivery } from "./silent.mjs";
 import { downloadTelegramFile, gatewayTranscriber } from "./voice.mjs";
 import { handleInboundMessage } from "./inbound.mjs";
 import { recoverableSessions } from "./session-recovery.mjs";
@@ -78,7 +77,6 @@ const eveInteractions = async (sessionId) => {
 function segmentstreamTelegram(options) {
 	const environment = options.environment ?? process.env;
 	const token = options.token ?? runtimeToken;
-	const observed = options.observed ?? observedMessages(60);
 	const readHistory = options.history ?? eveHistory;
 	const readInteractions = options.history ?? eveInteractions;
 	const capabilities = options.modelCapabilities ?? gatewayMediaCapabilities(options.fetch);
@@ -87,10 +85,6 @@ function segmentstreamTelegram(options) {
 		token,
 		fetch: options.fetch
 	});
-	const policy = sessionPolicy({
-		settings: options.sessions,
-		read: readHistory
-	});
 	const bot = botIdentityCache();
 	const proxies = new Map();
 	const interimDelivered = interimTexts();
@@ -127,7 +121,6 @@ function segmentstreamTelegram(options) {
 	const capture = telegramConversationCapture({
 		archive,
 		identities: pairing,
-		observed,
 		chats,
 		structured: (raw) => {
 			const inbound = settings().inbound;
@@ -172,7 +165,7 @@ function segmentstreamTelegram(options) {
 		archive,
 		identities: pairing
 	});
-	const approvalEvents = telegramConfirmationEvents(archive, observed, () => options.sessions().scope);
+	const approvalEvents = telegramConfirmationEvents(archive, () => options.sessions().scope);
 	const channel = telegramChannel({
 		turnPolicy: "queue",
 		api: {
@@ -203,10 +196,10 @@ function segmentstreamTelegram(options) {
 						policy: settings().policy,
 						decisionModel: options.models().decision,
 						groups: options.groups?.(),
-						recentConversation: async (chatId, threadId) => archivedRoutingMessages((await archive.context({
+						recentConversation: async (chatId, threadId) => archivedRoutingMessages((await topicContext(archive, {
 							provider: "telegram",
 							chatId,
-							...threadId === void 0 ? {} : { threadId },
+							threadId: threadId ?? null,
 							limit: 200,
 							includeDecisions: true
 						})).events, 100),
@@ -236,7 +229,6 @@ function segmentstreamTelegram(options) {
 						}) },
 						sessions: options.sessions,
 						admission: options.admission ?? (() => manifestOf({})),
-						sessionPolicy: policy,
 						sttModel: options.models().stt,
 						attachmentsModel: options.models().imageDescription ?? options.models().attachments ?? "google/gemini-2.5-flash-lite",
 						describeAttachment: options.describeAttachment ?? gatewayAttachmentDescriber,
@@ -285,7 +277,6 @@ function segmentstreamTelegram(options) {
 							...options
 						}),
 						attachments: attachments(),
-						observed,
 						readHistory,
 						history: readInteractions,
 						chats,
@@ -425,7 +416,7 @@ function segmentstreamTelegram(options) {
 					await channel.telegram.post(failureText(reference));
 					return;
 				}
-				await replyDelivery(observed, () => telegramSendScope(environment, settings().connection), {
+				await replyDelivery(() => telegramSendScope(environment, settings().connection), {
 					enabled: () => settings().interimMessages === true,
 					delivered: interimDelivered
 				})(event, context);

package/dist/extension/lib/telegram/confirmations.d.ts

@@ -1,13 +1,13 @@
 import type { ChannelEvents } from "eve/channels";
 import type { TelegramCallbackQuery, TelegramChannelEvents, TelegramContext, TelegramEventContext } from "eve/channels/telegram";
-import { type ObservedMessages, type PendingConfirmation, type RecentMessage } from "./observed.js";
+import { type ConfirmationPrompt, type PendingConfirmation, type RecentMessage } from "../group-routing/messages.js";
 import { type Conversations } from "../conversations.js";
 import type { AgentIdentities } from "../identities.js";
 import { type PendingQuestion } from "../questions.js";
 import { type HistoryReader, type RecordedEvent } from "./sessions.js";
 export declare function confirmationCallback(requestId: string, memberId: string, decision: "approve" | "cancel" | "edit"): string;
 /** Terminal facts override stale presentation, including when a Telegram edit failed. */
-export declare function routingConfirmationState(events: readonly RecordedEvent[], prompt: import("./observed.js").ConfirmationPrompt, at: string): NonNullable<PendingConfirmation["state"]>;
+export declare function routingConfirmationState(events: readonly RecordedEvent[], prompt: ConfirmationPrompt, at: string): NonNullable<PendingConfirmation["state"]>;
 /** Read-only projection of the same durable approval lifecycle used by the callback gate. */
 export declare function routingConfirmations(events: readonly RecordedEvent[], recent: readonly RecentMessage[], at: string): ReadonlyArray<PendingConfirmation>;
 export declare function questionFromHistory(events: readonly RecordedEvent[], owner?: Pick<PendingQuestion, "memberId" | "chatId" | "messageThreadId">): PendingQuestion | undefined;
@@ -23,5 +23,5 @@ export declare function handleConfirmationCallback(input: {
     readonly scope: "chat" | "thread";
     readonly now?: number;
 }): Promise<void>;
-export declare function telegramConfirmationEvents(archive?: Conversations, observed?: ObservedMessages, scope?: () => "chat" | "thread"): TelegramChannelEvents & Pick<ChannelEvents<TelegramEventContext>, "context.settled">;
+export declare function telegramConfirmationEvents(archive?: Conversations, scope?: () => "chat" | "thread"): TelegramChannelEvents & Pick<ChannelEvents<TelegramEventContext>, "context.settled">;
 export declare const confirmationEvents: TelegramChannelEvents & Pick<ChannelEvents<TelegramEventContext>, "context.settled">;

package/dist/extension/lib/telegram/confirmations.mjs

@@ -11,7 +11,7 @@ import { renderConfirmation, withConfirmationText } from "./confirmation-text.mj
 import { chatPostCard, chatPostCardStatus, chatPostReceipt, withChatPostCard } from "./chat-post-card.mjs";
 import { conversationEvent } from "../conversations.mjs";
 import { n as currentInboundRequest, p as reportTelegramError } from "../../../_chunks/inbound-request-D1r0FkDI.mjs";
-import { agentMessage, observedChatKey, withConfirmationPrompt } from "../group-routing/observed.mjs";
+import { withConfirmationPrompt } from "../group-routing/messages.mjs";
 import { chatPostOperationId, isChatPost } from "../chat-post-confirmation.mjs";
 import { confirmations } from "../confirmations.mjs";
 import { formatAddress, scopedAddress } from "./sessions.mjs";
@@ -201,23 +201,7 @@ function messagePrompt(message) {
 		at: new Date().toISOString()
 	};
 }
-function telegramConfirmationEvents(archive, observed, scope) {
-	const remember = (channel, ctx, messageId, text, confirmation) => {
-		const principal = ctx.session.auth.current;
-		const name = humanText(principal?.attributes.memberName);
-		observed?.remember(observedChatKey(channel.telegram), {
-			...agentMessage({
-				text,
-				at: new Date().toISOString(),
-				messageId,
-				...principal?.subject === void 0 || name === void 0 ? {} : { inReplyTo: {
-					id: principal.subject,
-					author: name
-				} }
-			}),
-			...confirmation === void 0 ? {} : { confirmation }
-		});
-	};
+function telegramConfirmationEvents(archive, scope) {
 	const record = async (callId, phase, text, status, ctx) => {
 		const saved = confirmations.get()[callId];
 		if (archive === void 0 || saved?.description?.chatPost === void 0 || saved.source === void 0) return;
@@ -275,7 +259,6 @@ function telegramConfirmationEvents(archive, observed, scope) {
 						selective: true
 					}
 				}));
-				remember(channel, ctx, sent.id, text);
 				channel.state.pendingFreeformReplies = {
 					...channel.state.pendingFreeformReplies,
 					[sent.id]: requestId
@@ -341,7 +324,6 @@ function telegramConfirmationEvents(archive, observed, scope) {
 				} }
 			};
 			const sent = await withConfirmationPrompt(prompt, () => exactPost ? withChatPostCard(text, send, copy.previewLinks) : withConfirmationText(text, send));
-			remember(channel, ctx, sent.id, text, prompt);
 			if (aliasesPendingTopic(scope?.(), channel.continuation?.token)) channel.continuation?.alias(formatAddress({
 				chatId: channel.telegram.chatId,
 				messageThreadId: String(channel.telegram.messageThreadId ?? ""),
@@ -405,7 +387,6 @@ function telegramConfirmationEvents(archive, observed, scope) {
 			};
 			message.prompt = prompt;
 			await withConfirmationPrompt(prompt, () => message.exactPost ? withChatPostCard(text, edit, [...message.previewLinks ?? [], ...telegramTextLinks(status)]) : withConfirmationText(text, edit));
-			remember(channel, ctx, message.messageId, text, prompt);
 			await record(callId, reason ?? (resolution.outcome === "accepted" ? "approved" : resolution.outcome === "declined" ? "cancelled" : "ignored"), text, resolution.outcome === "accepted" ? "requested" : "cancelled", ctx);
 			if (resolution.outcome !== "accepted") {
 				delete state.confirmationMessages?.[callId];
@@ -451,14 +432,13 @@ function telegramConfirmationEvents(archive, observed, scope) {
 						}));
 						channel.continuation?.alias(questionAddress(saved));
 					}
-					const sent = await channel.telegram.post({
+					await channel.telegram.post({
 						text: question.question,
 						reply_markup: {
 							force_reply: true,
 							selective: true
 						}
 					});
-					remember(channel, ctx, sent.id, question.question);
 				}
 			}
 			const message = state.confirmationMessages?.[data.callId];
@@ -479,7 +459,6 @@ function telegramConfirmationEvents(archive, observed, scope) {
 					replyMarkup: { inline_keyboard: [] },
 					text
 				}), [...message.previewLinks ?? [], ...telegramTextLinks(status)]));
-				remember(channel, ctx, message.messageId, text, prompt);
 				await record(data.callId, "receipt", text, failed ? "failed" : object(action?.kind === "tool" ? data.output : void 0).status === "sent" ? "completed" : "unknown", ctx);
 			} else {
 				const copy = message.copy ?? renderConfirmation();
@@ -495,7 +474,6 @@ function telegramConfirmationEvents(archive, observed, scope) {
 					replyMarkup: { inline_keyboard: [] },
 					text
 				})));
-				remember(channel, ctx, message.messageId, text, prompt);
 			}
 			delete state.confirmationMessages?.[data.callId];
 		},

package/dist/extension/lib/telegram/conversations.d.ts

@@ -2,7 +2,6 @@ import type { StructuredMessage } from "./structured.js";
 import type { AgentIdentities } from "../identities.js";
 import { type Conversations } from "../conversations.js";
 import type { AgentChats } from "./chats.js";
-import type { ObservedMessages } from "./observed.js";
 import type { DecodedAttachment } from "./attachment-description.js";
 import type { AddressingReason, RouteDecider, RouteDecision } from "./router.js";
 /** A crashed routing attempt can be reclaimed; the per-message turn claim still fences dispatch. */
@@ -14,7 +13,6 @@ export declare function captureTelegramWebhook(input: {
     readonly request: Request;
     readonly archive: Conversations;
     readonly identities: AgentIdentities;
-    readonly observed: ObservedMessages;
     readonly chats?: AgentChats;
     readonly next: (request?: Request) => Promise<Response>;
 }): Promise<Response>;
@@ -22,11 +20,25 @@ export declare function captureTelegramWebhook(input: {
 export declare function recordGateDecision(reason: string, decision?: "reply" | "silent"): void;
 export declare function recordRouteDecision(route: "reply" | "observe", addressed: boolean | AddressingReason | undefined, policy: string, audit?: Pick<RouteDecision, "reason" | "note" | "diagnostics" | "router" | "shadow">): void;
 export declare function captureRouteDecider(decide: RouteDecider): RouteDecider;
+/** A stored attachment of an archived message: what a later turn needs to read or show it. */
+export interface ArchivedFile {
+    readonly id: string;
+    readonly filename: string;
+    readonly contentType: string;
+    readonly size: number;
+    readonly expiresAt: string;
+    /** Whether it can reach a model as a native image. */
+    readonly image?: true;
+}
 /** Update the existing inbound event after STT/description, under the same text retention policy. */
 export declare function recordInboundContent(content: {
     readonly text: string;
     readonly media?: string;
     readonly decoded?: ReadonlyArray<DecodedAttachment>;
+    /** How the chat context names a linked member: their name and roles, then their handle. */
+    readonly author?: string;
+    /** The message's stored attachments, by reference: never bytes or download grants. */
+    readonly files?: ReadonlyArray<ArchivedFile>;
 }): Promise<void>;
 /**
  * Records eve's unrecoverable session failure from the channel. The channel receives it even when
@@ -54,7 +66,6 @@ export declare function telegramConversationCapture(input: {
     readonly structured?: (raw: Readonly<Record<string, unknown>>) => StructuredMessage | undefined;
     readonly archive: Conversations;
     readonly identities: () => AgentIdentities;
-    readonly observed: ObservedMessages;
     readonly chats: AgentChats;
     readonly verify: (request: Request) => boolean;
 }): (request: Request, next: (request?: Request) => Promise<Response>) => Promise<Response>;

package/dist/extension/lib/telegram/conversations.mjs

@@ -6,12 +6,12 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { n as contentText, t as CONTENT_CAPS } from "../../../_chunks/content-cDtVnr8Y.mjs";
 import { conversationEvent, sessionFailureEventId } from "../conversations.mjs";
+import { currentDeliveryScope } from "./delivery-diagnostics.mjs";
 import { n as currentInboundRequest, p as reportTelegramError, s as currentThreadId } from "../../../_chunks/inbound-request-D1r0FkDI.mjs";
-import { currentConfirmationPrompt, observedChatKey } from "../group-routing/observed.mjs";
-import { archivedRoutingMessages } from "../group-routing/routing-context.mjs";
+import { currentConfirmationPrompt } from "../group-routing/messages.mjs";
 import { parseArchivedMessage } from "./archive-message.mjs";
 import { contentShape, messageContent } from "./content.mjs";
-import { messageMetadata } from "./observed.mjs";
+import { messageMetadata } from "./message-metadata.mjs";
 import { reportMembership } from "./membership.mjs";
 import { createHash, randomUUID } from "node:crypto";
 const captures = new WeakMap();
@@ -177,20 +177,8 @@ async function captureTelegramWebhook(input) {
 	};
 	const inbound = currentInboundRequest();
 	if (inbound !== void 0) captures.set(inbound, capture);
-	const chat = observedChatKey({
-		chatId: message.chat.id,
-		...message.messageThreadId === void 0 ? {} : { messageThreadId: message.messageThreadId }
-	});
 	const automated = message.from === void 0 || message.from.isBot || message.chat.type === "channel";
 	if (automated || edited !== void 0 || message.raw.left_chat_member || message.raw.migrate_to_chat_id || message.raw.migrate_from_chat_id) await capture.persist();
-	const history = automated ? void 0 : await input.archive.context({
-		provider: "telegram",
-		chatId: message.chat.id,
-		...event.threadId === null ? {} : { threadId: event.threadId },
-		limit: 100,
-		includeDecisions: true,
-		...lookup?.status === "paired" ? { participantId: lookup.member.id } : {}
-	});
 	const messageHistory = automated ? [] : (await input.archive.context({
 		provider: "telegram",
 		chatId: message.chat.id,
@@ -265,35 +253,16 @@ async function captureTelegramWebhook(input) {
 			await recordInboundContent({
 				text: [content.text, ...transcripts].filter(Boolean).join("\n\n"),
 				decoded,
-				...media === void 0 ? {} : { media }
+				...media === void 0 ? {} : { media },
+				...Array.isArray(previousRouting.files) ? { files: previousRouting.files } : {}
 			});
 		}
 	}
-	if (!automated) for (const earlier of input.observed.recent(chat).length === 0 ? archivedRoutingMessages((history?.events ?? []).filter((item) => item.eventId !== event.eventId), 60) : []) if ("role" in earlier || history?.events.some((decision) => decision.kind === "decision" && decision.messageId === earlier.messageId && decision.reason === "turn_admitted")) input.observed.remember(chat, earlier);
-	else input.observed.add(chat, earlier);
 	if (automated || edited !== void 0) {
 		if (message.chat.type === "group" || message.chat.type === "supergroup") await input.chats?.seen({
 			chatId: message.chat.id,
 			title: message.chat.title ?? ""
 		});
-		const remembered = input.observed.recent(chat).findLast((entry) => entry.messageId === message.messageId);
-		const retained = alreadyHandled && edited === void 0 ? remembered : void 0;
-		const retainedContent = archivedRoutingMessages([{
-			...capture.event,
-			sequence: "1",
-			storedAt: event.at
-		}])[0];
-		input.observed.add(chat, retained ?? (retainedContent === void 0 ? void 0 : {
-			...retainedContent,
-			...unchangedAttachments && remembered?.images !== void 0 ? { images: remembered.images } : {}
-		}) ?? {
-			...messageMetadata(message),
-			author: event.senderName ?? event.senderId ?? "automated post",
-			text: event.text ?? "[attachment or service message]",
-			at: event.at,
-			messageId: message.messageId,
-			...event.senderId === null ? {} : { authorId: event.senderId }
-		});
 		capture.decision = "silent";
 		capture.reason = automated ? "automated_or_channel_message" : alreadyHandled ? "message_already_handled" : "message_edit";
 		if (alreadyHandled) capture.note = "This message already started a turn; edits and retries do not repeat its task.";
@@ -495,7 +464,9 @@ async function recordInboundContent(content) {
 	await capture.persist();
 	const metadata = record(JSON.parse(capture.event.argsSummary ?? "{}"));
 	const membership = capture.lookup === void 0 ? record(metadata.routing).membership : capture.lookup.status === "paired" || capture.lookup.status === "existing" || capture.lookup.status === "created" ? "linked" : "unlinked";
-	if (content.text === capture.event.text && content.media === record(metadata.routing).media && membership === record(metadata.routing).membership && JSON.stringify(content.decoded) === JSON.stringify(record(metadata.routing).decoded)) return;
+	const author = content.author ?? record(metadata.routing).author;
+	const files = content.files ?? record(metadata.routing).files;
+	if (content.text === capture.event.text && content.media === record(metadata.routing).media && membership === record(metadata.routing).membership && author === record(metadata.routing).author && JSON.stringify(files) === JSON.stringify(record(metadata.routing).files) && JSON.stringify(content.decoded) === JSON.stringify(record(metadata.routing).decoded)) return;
 	const contentHash = createHash("sha256").update(JSON.stringify({
 		...content,
 		membership
@@ -509,6 +480,8 @@ async function recordInboundContent(content) {
 			routing: {
 				...record(metadata.routing),
 				membership,
+				...typeof author === "string" ? { author: author.slice(0, 500) } : {},
+				...Array.isArray(files) && files.length > 0 ? { files: files.slice(0, 10) } : {},
 				media: content.media?.slice(0, 8e3),
 				decoded: content.decoded
 			}
@@ -582,6 +555,8 @@ function captureTelegramFetch(fetchImpl, archive, identities) {
 		const chatId = id(body.chat_id);
 		if (chatId === null) return fetchImpl(input, init);
 		const { capture, chatType, participantIds } = await outboundAudience(chatId, identities);
+		const delivery = currentDeliveryScope();
+		const own = delivery?.chatId === chatId && delivery.sessionId !== null;
 		const event = conversationEvent({
 			eventId: `telegram:${edit ? "edit" : "send"}:${randomUUID()}`,
 			provider: "telegram",
@@ -620,6 +595,10 @@ function captureTelegramFetch(fetchImpl, archive, identities) {
 			participantIds,
 			threadId: id(body.message_thread_id) ?? currentThreadId() ?? null,
 			replyToMessageId: id(body.reply_to_message_id) ?? id(record(body.reply_parameters).message_id),
+			...own ? {
+				sessionId: delivery.sessionId,
+				turnId: delivery.turnId
+			} : {},
 			status: "requested"
 		});
 		await archive.append(event);

package/dist/extension/lib/telegram/delivery-diagnostics.d.ts

@@ -5,8 +5,11 @@ interface Diagnostic {
     readonly error: unknown;
     readonly metadata: Record<string, unknown>;
 }
+type DeliveryScope = Pick<ConversationEvent, "chatId" | "chatType" | "threadId" | "sessionId" | "turnId">;
 /** Receives the same credential-redacted payload as operator logs, never raw provider errors. */
 export declare function retainDeliveryDiagnostic(diagnostic: Diagnostic): void;
+/** The session and turn a channel callback delivers for, so its sends are archived as its own. */
+export declare function currentDeliveryScope(): DeliveryScope | undefined;
 /** Await archive writes inside the channel callback, including failed or restored callbacks. */
-export declare function withDeliveryDiagnostics<T>(archive: Conversations, scope: Pick<ConversationEvent, "chatId" | "chatType" | "threadId" | "sessionId" | "turnId">, run: () => T | Promise<T>): Promise<T>;
+export declare function withDeliveryDiagnostics<T>(archive: Conversations, scope: DeliveryScope, run: () => T | Promise<T>): Promise<T>;
 export {};

package/dist/extension/lib/telegram/delivery-diagnostics.mjs

@@ -10,11 +10,17 @@ import { conversationEvent } from "../conversations.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
 const pending = new AsyncLocalStorage();
 function retainDeliveryDiagnostic(diagnostic) {
-	pending.getStore()?.push(diagnostic);
+	pending.getStore()?.diagnostics.push(diagnostic);
+}
+function currentDeliveryScope() {
+	return pending.getStore()?.scope;
 }
 async function withDeliveryDiagnostics(archive, scope, run) {
 	const diagnostics = [];
-	return pending.run(diagnostics, async () => {
+	return pending.run({
+		diagnostics,
+		scope
+	}, async () => {
 		try {
 			return await run();
 		} finally {
@@ -43,4 +49,4 @@ async function withDeliveryDiagnostics(archive, scope, run) {
 		}
 	});
 }
-export { retainDeliveryDiagnostic, withDeliveryDiagnostics };
+export { currentDeliveryScope, retainDeliveryDiagnostic, withDeliveryDiagnostics };

package/dist/extension/lib/telegram/health.mjs

@@ -5,7 +5,7 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { runtimeRequestFailure } from "./runtime-request.mjs";
-import { t as agentBuild } from "../../../_chunks/build-metadata-D_Gqlb5f.mjs";
+import { t as agentBuild } from "../../../_chunks/build-metadata-R_ssK2uR.mjs";
 import { GET } from "eve/channels";
 const HEALTH_ROUTE = "/eve/v1/telegram/health";
 function healthRoute(input) {

package/dist/extension/lib/telegram/inbound.d.ts

@@ -1,5 +1,5 @@
 import { type StructuredInbound, type StructuredMessage, type StructuredResult } from "./structured.js";
-import type { RecentMessage } from "../group-routing/observed.js";
+import type { RecentMessage } from "../group-routing/messages.js";
 import { type GroupPolicy } from "../group-routing/policy.js";
 import type { TelegramSettings } from "../../config.js";
 import { attachmentLifecycle } from "./lifecycle.js";
@@ -12,9 +12,8 @@ import { type AgentChats } from "./chats.js";
 import type { InboundRequest } from "./inbound-request.js";
 import type { ImageDescriber } from "./images.js";
 import type { MediaPlan } from "./media-policy.js";
-import { type ObservedMessages } from "./observed.js";
 import { type RouteDecider } from "./router.js";
-import { type HistoryReader, type SessionPolicy } from "./sessions.js";
+import { type HistoryReader } from "./sessions.js";
 import { type Transcriber } from "./voice.js";
 import { type AttachmentDescriber } from "./attachment-description.js";
 import type { PdfTextExtractor } from "./pdf-text.js";
@@ -30,16 +29,18 @@ import type { PdfTextExtractor } from "./pdf-text.js";
  * 2. Voice becomes text, so the router and the agent read what was said.
  * 3. The router answers or observes. Group files follow the same addressing rules as text;
  *    captionless uploads use smart routing and recent agent requests. Files are stored after the
- *    registry knows the sender. Observing starts no session or typing indication;
- *    the ring carries the stored files' references (or storage failures) into the next reply.
- * 4. The session policy runs on the session an answered message continues: an idle one is cleared, the
- *    first message after the day's compaction time compacts it.
+ *    registry knows the sender. Observing starts no session or typing indication; the
+ *    conversation archive keeps the message and its stored files' references for routing, the
+ *    next turn's chat context and the native images that turn carries.
+ * 4. An answered message continues the session its address names under the configured scope; eve
+ *    compacts and expires sessions itself.
  * 5. An answered message reads the stored attachments in place of the Telegram files.
- * 6. An answered message dispatches as the paired member, with the ring, the registry's `<chat>`
- *    block, a `<speaker>` block naming the member, their roles and the message they replied to and
- *    an `<attachments>` block naming its stored files ahead of it as context. An answered group
- *    message waits for its chat's report first, so that a chat new to the process already carries
- *    its `<chat>` block.
+ * 6. An answered message dispatches as the paired member, with only its own facts as context: a
+ *    `<speaker>` block naming the member, their roles and the message they replied to, its
+ *    `<message_audience>` and an `<attachments>` block naming its stored files. The chat around
+ *    it, observed messages and the registry's `<chat>` guidance, reaches the session once through
+ *    its chat context (`lib/chat-context.ts`). An answered group message waits for its chat's
+ *    report first, so that a chat new to the process already carries its guidance.
  */
 export interface InboundDependencies {
     readonly structured?: {
@@ -49,12 +50,12 @@ export interface InboundDependencies {
     readonly policy: TelegramPolicy;
     readonly decisionModel?: string;
     readonly groups?: GroupPolicy;
+    /** The chat's or forum topic's recent messages from the conversation archive, oldest first. */
     readonly recentConversation?: (chatId: string, threadId?: string) => Promise<ReadonlyArray<RecentMessage>>;
     readonly signalSettings?: TelegramSettings["groups"];
     readonly lifecycle?: (principal: import("eve/context").SessionAuthContext, memberId: string, message: TelegramMessage) => ReturnType<typeof attachmentLifecycle>;
     readonly admission: () => AdmissionSettings;
     readonly sessions: () => SessionSettings;
-    readonly sessionPolicy: SessionPolicy;
     readonly sttModel: string | false;
     readonly attachmentsModel: string | false;
     readonly describeAttachment: AttachmentDescriber;
@@ -73,7 +74,6 @@ export interface InboundDependencies {
     }) => Promise<Uint8Array>;
     /** The attachment store; without it, files reach the turn as eve's Telegram file parts. */
     readonly attachments?: AgentAttachments;
-    readonly observed: ObservedMessages;
     /** Recent session events for smart routing. */
     readonly readHistory: HistoryReader;
     readonly chats: AgentChats;