@segmentstream/agent 0.6.13 → 0.7.0

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

@@ -5,17 +5,20 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { memberIdOf, telegramPrincipal } from "./principal.mjs";
-import { chatPostOperationId, isChatPost } from "../chat-post-confirmation.mjs";
+import { humanText } from "../confirmation-description.mjs";
 import { renderConfirmation, withConfirmationText } from "./confirmation-text.mjs";
+import { chatPostOperationId, isChatPost } from "../chat-post-confirmation.mjs";
 import { chatPostCard, chatPostCardStatus, chatPostReceipt, withChatPostCard } from "./chat-post-card.mjs";
 import { confirmations } from "../confirmations.mjs";
 import { conversationEvent } from "../conversations.mjs";
-import { n as currentInboundRequest, p as reportTelegramError } from "../../../_chunks/inbound-request-CysnjMdw.mjs";
-import { answerMarker, isPendingQuestion, pendingQuestions, questionKey } from "../questions.mjs";
+import { n as currentInboundRequest, p as reportTelegramError } from "../../../_chunks/inbound-request-BwBvXk0A.mjs";
 import { formatAddress, scopedAddress } from "./sessions.mjs";
+import { agentMessage, observedChatKey, withConfirmationPrompt } from "./observed.mjs";
+import { postDeferredCard } from "./deferred-confirmations.mjs";
+import { answerMarker, isPendingQuestion, pendingQuestions, questionKey } from "../questions.mjs";
 import { telegramTextLinks } from "@segmentstream-cloud/ontology/telegram";
-import { registerTelegramFreeformPrompt, renderTelegramInputRequest } from "eve/channels/telegram";
 import { createHash } from "node:crypto";
+import { registerTelegramFreeformPrompt, renderTelegramInputRequest } from "eve/channels/telegram";
 const PREFIX = "ss-confirm:";
 function shortHash(value) {
 	return createHash("sha256").update(value).digest("hex").slice(0, 20);
@@ -31,7 +34,7 @@ function openConfirmations(events) {
 	const open = new Map();
 	for (const event of events) {
 		const data = object(event.data);
-		if (event.type === "context.cleared") open.clear();
+		if (event.type === "context.cleared" || event.type === "session.started") open.clear();
 		if (event.type === "input.requested" && Array.isArray(data.requests)) for (const item of data.requests) {
 			const request = object(item);
 			const action = object(request.action);
@@ -47,10 +50,55 @@ function openConfirmations(events) {
 			const id = object(item).requestId;
 			if (typeof id === "string") open.delete(id);
 		}
+		if (event.type === "action.result") {
+			for (const [key, prompt] of open) if (prompt.callId === object(data.result).callId) open.delete(key);
+		}
 	}
 	return [...open.values()];
 }
+function routingConfirmationState(events, prompt, at) {
+	if (prompt.state !== void 0 && prompt.state !== "pending" && prompt.state !== "approved") return prompt.state;
+	let state = prompt.state ?? "pending";
+	let callId;
+	for (const event of prompt.mode === "deferred" ? [] : events) {
+		const data = object(event.data);
+		if ((event.type === "context.cleared" || event.type === "session.started") && Date.parse(event.meta.at) >= Date.parse(prompt.at)) state = "expired";
+		if (event.type === "input.requested" && Array.isArray(data.requests)) {
+			for (const request of data.requests) if (object(request).requestId === prompt.requestId) {
+				callId = String(object(object(request).action).callId);
+				state = prompt.state ?? "pending";
+			}
+		}
+		if (event.type === "input.resolved" && Array.isArray(data.resolutions)) {
+			for (const resolution of data.resolutions) if (object(resolution).requestId === prompt.requestId) state = object(resolution).outcome === "approved" ? "approved" : "cancelled";
+		}
+		if (event.type === "action.result" && callId !== void 0 && object(data.result).callId === callId) state = data.status === "completed" ? "completed" : "failed";
+	}
+	if (state === "pending" && Date.parse(at) - Date.parse(prompt.at) >= 6e5) return "expired";
+	return state;
+}
+function routingConfirmations(events, recent, at) {
+	return openConfirmations(events).filter((prompt) => {
+		const age = Date.parse(at) - prompt.at;
+		const delivered = recent.findLast((message) => "role" in message && message.confirmation?.requestId === prompt.requestId);
+		const state = delivered !== void 0 && "role" in delivered ? delivered.confirmation?.state : void 0;
+		return age >= 0 && age < 6e5 && (state === void 0 || state === "pending");
+	}).slice(-5).map((prompt) => {
+		const delivered = recent.findLast((message) => "role" in message && message.confirmation?.requestId === prompt.requestId);
+		const summary = delivered !== void 0 && "role" in delivered ? delivered.confirmation : void 0;
+		return {
+			state: "pending",
+			action: summary?.action ?? "the requested action",
+			requestedBy: summary?.requestedBy ?? null,
+			at: summary?.at ?? new Date(prompt.at).toISOString()
+		};
+	});
+}
 function questionFromHistory(events, owner) {
+	const pending = questionsFromHistory(events);
+	return owner === void 0 ? pending.at(-1) : pending.find((question) => questionKey(question) === questionKey(owner));
+}
+function questionsFromHistory(events) {
 	const pending = new Map();
 	for (const event of events) {
 		const data = object(event.data);
@@ -64,7 +112,7 @@ function questionFromHistory(events, owner) {
 			for (const [key, question] of pending) if (data.message.startsWith(answerMarker(question.id))) pending.delete(key);
 		}
 	}
-	return owner === void 0 ? [...pending.values()].at(-1) : pending.get(questionKey(owner));
+	return [...pending.values()];
 }
 function questionAddress(owner) {
 	return formatAddress({
@@ -136,7 +184,31 @@ async function handleConfirmationCallback(input) {
 	}, edit ? "The chat post was cancelled for editing. Ask the member what to change using questions_ask, then make a NEW chat_post_message call and confirmation. Never reuse the cancelled call." : void 0);
 	await notice(expired ? "⌛" : void 0);
 }
-function telegramConfirmationEvents(archive) {
+function messagePrompt(message) {
+	return message.prompt ?? {
+		requestId: message.requestId,
+		action: "the requested action",
+		requestedBy: null,
+		at: new Date().toISOString()
+	};
+}
+function telegramConfirmationEvents(archive, observed, deferredOptions) {
+	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 }
+		});
+	};
 	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;
@@ -184,6 +256,7 @@ function telegramConfirmationEvents(archive) {
 						text: rendered.text,
 						reply_markup: rendered.replyMarkup
 					});
+					remember(channel, ctx, sent.id, rendered.text);
 					if (rendered.freeformRequestId !== void 0) registerTelegramFreeformPrompt(channel.state, {
 						messageId: sent.id,
 						requestId: request.requestId
@@ -228,7 +301,30 @@ function telegramConfirmationEvents(archive) {
 						}
 					]] }
 				});
-				const sent = await (exactPost ? withChatPostCard(text, send, copy.previewLinks) : withConfirmationText(text, send));
+				const prompt = {
+					requestId: request.requestId,
+					state: "pending",
+					sessionId: ctx.session.id,
+					address: channel.continuation?.token ?? formatAddress({
+						chatId: channel.telegram.chatId,
+						messageThreadId: String(channel.telegram.messageThreadId ?? ""),
+						conversationId: channel.telegram.conversationId ?? ""
+					}),
+					action: humanText(description?.action) ?? "the requested action",
+					requestedBy: humanText(ctx.session.auth.current?.attributes.memberName) ?? null,
+					at: new Date().toISOString(),
+					...ctx.session.auth.current?.subject === void 0 ? {} : { requester: {
+						id: ctx.session.auth.current.subject,
+						author: humanText(ctx.session.auth.current.attributes.memberName) ?? "the requester"
+					} }
+				};
+				const sent = await withConfirmationPrompt(prompt, () => exactPost ? withChatPostCard(text, send, copy.previewLinks) : withConfirmationText(text, send));
+				remember(channel, ctx, sent.id, text, prompt);
+				channel.continuation?.alias(formatAddress({
+					chatId: channel.telegram.chatId,
+					messageThreadId: String(channel.telegram.messageThreadId ?? ""),
+					conversationId: ""
+				}));
 				const state = channel.state;
 				state.confirmationMessages = {
 					...state.confirmationMessages,
@@ -238,6 +334,7 @@ function telegramConfirmationEvents(archive) {
 						text,
 						copy,
 						exactPost,
+						prompt,
 						previewLinks: copy.previewLinks
 					}
 				};
@@ -271,7 +368,13 @@ function telegramConfirmationEvents(archive) {
 					replyMarkup: { inline_keyboard: [] },
 					text
 				});
-				await (message.exactPost ? withChatPostCard(text, edit, [...message.previewLinks ?? [], ...telegramTextLinks(status)]) : withConfirmationText(text, edit));
+				const prompt = {
+					...messagePrompt(message),
+					state: resolution.outcome === "approved" ? "approved" : reason === "expired" ? "expired" : "cancelled"
+				};
+				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, text, resolution.outcome === "approved" ? "requested" : "cancelled", ctx);
 				if (resolution.outcome !== "approved") {
 					delete state.confirmationMessages?.[callId];
@@ -287,6 +390,13 @@ function telegramConfirmationEvents(archive) {
 		},
 		async "action.result"(data, channel, ctx) {
 			const state = channel.state;
+			if (data.result.kind === "tool-result" && deferredOptions !== void 0 && archive !== void 0) {
+				const output = object(data.result.output);
+				if (output.status === "awaiting_confirmation" && typeof output.confirmation === "string") {
+					await postDeferredCard(output.confirmation, channel, ctx, deferredOptions, archive, observed);
+					return;
+				}
+			}
 			if (data.result.kind === "tool-result") {
 				const question = object(data.result.output).pendingQuestion;
 				if (data.result.toolName.endsWith("__questions_ask") && isPendingQuestion(question)) {
@@ -313,13 +423,14 @@ function telegramConfirmationEvents(archive) {
 						conversationId: ""
 					}));
 					channel.continuation?.alias(questionAddress(saved));
-					await channel.telegram.post({
+					const sent = 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.result.callId];
@@ -331,22 +442,32 @@ function telegramConfirmationEvents(archive) {
 				const errorId = failed ? reportTelegramError("confirmed_chat_post_failed", data, { callId: data.result.callId }) : void 0;
 				const status = receipt ?? (failed ? `${copy.failed} ${errorId}\n⚠️ ❓` : "⚠️ ❓");
 				const text = chatPostCardStatus(message.text, status);
-				await withChatPostCard(text, () => channel.telegram.editMessageText({
+				const prompt = {
+					...messagePrompt(message),
+					state: failed ? "failed" : "completed"
+				};
+				await withConfirmationPrompt(prompt, () => withChatPostCard(text, () => channel.telegram.editMessageText({
 					messageId: message.messageId,
 					replyMarkup: { inline_keyboard: [] },
 					text
-				}), [...message.previewLinks ?? [], ...telegramTextLinks(status)]);
+				}), [...message.previewLinks ?? [], ...telegramTextLinks(status)]));
+				remember(channel, ctx, message.messageId, text, prompt);
 				await record(data.result.callId, "receipt", text, failed ? "failed" : object(data.result.kind === "tool-result" ? data.result.output : void 0).status === "sent" ? "completed" : "unknown", ctx);
 			} else {
 				const copy = message.copy ?? renderConfirmation();
 				const errorId = failed ? reportTelegramError("confirmed_action_failed", data, { callId: data.result.callId }) : void 0;
 				const status = failed ? `${copy.failed} ${errorId}` : copy.completed;
 				const text = `${message.text}\n\n${status}`;
-				await withConfirmationText(text, () => channel.telegram.editMessageText({
+				const prompt = {
+					...messagePrompt(message),
+					state: failed ? "failed" : "completed"
+				};
+				await withConfirmationPrompt(prompt, () => withConfirmationText(text, () => channel.telegram.editMessageText({
 					messageId: message.messageId,
 					replyMarkup: { inline_keyboard: [] },
 					text
-				}));
+				})));
+				remember(channel, ctx, message.messageId, text, prompt);
 			}
 			delete state.confirmationMessages?.[data.result.callId];
 		},
@@ -368,4 +489,4 @@ function telegramConfirmationEvents(archive) {
 	};
 }
 const confirmationEvents = telegramConfirmationEvents();
-export { confirmationCallback, confirmationEvents, handleConfirmationCallback, questionAddress, questionFromHistory, telegramConfirmationEvents };
+export { confirmationCallback, confirmationEvents, handleConfirmationCallback, questionAddress, questionFromHistory, questionsFromHistory, routingConfirmationState, routingConfirmations, telegramConfirmationEvents };

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

@@ -2,7 +2,10 @@ 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. */
+export declare const REVISION_CLAIM_TTL_MS: number;
 /** Runs after webhook verification, before eve drops bot/channel/service updates. */
 export declare function captureTelegramWebhook(input: {
     readonly request: Request;
@@ -14,8 +17,14 @@ export declare function captureTelegramWebhook(input: {
 }): Promise<Response>;
 /** Additive inbound hook: the router keeps ownership of the reply policy. */
 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">): void;
+export declare function recordRouteDecision(route: "reply" | "observe", addressed: boolean | AddressingReason | undefined, policy: string, audit?: Pick<RouteDecision, "reason" | "note" | "diagnostics">): void;
 export declare function captureRouteDecider(decide: RouteDecider): RouteDecider;
+/** 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>;
+}): Promise<void>;
 /** Captures message sends and button/status edits, including pairing and proactive replies. */
 export declare function captureTelegramFetch(fetchImpl: typeof fetch, archive: Conversations, identities: () => AgentIdentities): typeof fetch;
 /** Reuses the request's verified lookup; it never survives into another inbound request. */

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

@@ -4,16 +4,18 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
-import { collapseConversationEvents, conversationEvent } from "../conversations.mjs";
-import { observedChatKey } from "./observed.mjs";
-import { n as currentInboundRequest, s as currentThreadId } from "../../../_chunks/inbound-request-CysnjMdw.mjs";
-import { reportMembership } from "./membership.mjs";
+import { conversationEvent } from "../conversations.mjs";
+import { n as currentInboundRequest, s as currentThreadId } from "../../../_chunks/inbound-request-BwBvXk0A.mjs";
 import { contentShape, messageContent } from "./content.mjs";
-import { parseTelegramUpdate } from "eve/channels/telegram";
+import { currentConfirmationPrompt, messageMetadata, observedChatKey } from "./observed.mjs";
+import { archivedRoutingMessages } from "./routing-context.mjs";
+import { reportMembership } from "./membership.mjs";
 import { createHash, randomUUID } from "node:crypto";
+import { parseTelegramUpdate } from "eve/channels/telegram";
 const captures = new WeakMap();
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 const id = (value) => typeof value === "number" || typeof value === "string" ? String(value) : null;
+const REVISION_CLAIM_TTL_MS = 12e4;
 function attachmentRefs(message) {
 	const files = message.attachments.map((file) => ({
 		id: file.fileId,
@@ -44,6 +46,16 @@ function attachmentRefs(message) {
 	}
 	return files;
 }
+function attachmentIdentity(files) {
+	return JSON.stringify(files.map((file) => [file.kind, file.uniqueId ?? file.id]));
+}
+function eventRouting(event) {
+	try {
+		return record(record(JSON.parse(event.argsSummary ?? "{}")).routing);
+	} catch {
+		return {};
+	}
+}
 async function participants(message, identities, resolved) {
 	if (message.chat.type !== "private" || message.from === void 0 || message.from.isBot) return [];
 	try {
@@ -85,6 +97,7 @@ async function captureTelegramWebhook(input) {
 	const time = edited === void 0 ? message.raw.date : message.raw.edit_date ?? message.raw.date;
 	const sentAt = typeof time === "number" ? time * 1e3 : Date.now();
 	const senderChat = record(message.raw.sender_chat);
+	const attachments = attachmentRefs(message);
 	let lookup;
 	const event = conversationEvent({
 		eventId: [
@@ -99,7 +112,13 @@ async function captureTelegramWebhook(input) {
 		threadId: message.messageThreadId === void 0 ? null : String(message.messageThreadId),
 		kind: "inbound",
 		text: content.text || null,
-		argsSummary: JSON.stringify(contentShape(message.raw, content)),
+		argsSummary: JSON.stringify({
+			...contentShape(message.raw, content),
+			routing: {
+				...messageMetadata(message),
+				...attachments.length === 0 ? {} : { originalText: content.text }
+			}
+		}),
 		messageId: message.messageId,
 		replyToMessageId: message.replyToMessage?.messageId ?? null,
 		senderId: id(senderChat.id) ?? message.from?.id ?? null,
@@ -108,15 +127,33 @@ async function captureTelegramWebhook(input) {
 		participantIds: await participants(message, input.identities, (result) => {
 			lookup = result;
 		}),
-		attachments: attachmentRefs(message),
+		attachments,
 		at: new Date(sentAt).toISOString()
 	});
 	await input.archive.append(event);
 	const capture = {
 		event,
 		message,
+		archive: input.archive,
 		...lookup === void 0 ? {} : { lookup }
 	};
+	const revisionId = edited === void 0 ? void 0 : `telegram:${message.chat.id}:${message.messageId}:routing:${createHash("sha256").update(JSON.stringify({
+		at: event.at,
+		content,
+		...event.attachments.length === 0 ? {} : { attachments: attachmentIdentity(event.attachments) }
+	})).digest("hex")}`;
+	const revisionEvents = [];
+	let revisionClaim;
+	const finishRevision = async (status) => {
+		if (revisionClaim === void 0) return;
+		await input.archive.append({
+			...revisionClaim,
+			eventId: status === "completed" ? `${revisionId}:completed` : `${revisionClaim.eventId}:failed`,
+			at: new Date(Date.now()).toISOString(),
+			status,
+			reason: status === "completed" ? "routing_completed" : "routing_failed"
+		});
+	};
 	const inbound = currentInboundRequest();
 	if (inbound !== void 0) captures.set(inbound, capture);
 	const chat = observedChatKey({
@@ -132,37 +169,88 @@ async function captureTelegramWebhook(input) {
 		includeDecisions: true,
 		...lookup?.status === "paired" ? { participantId: lookup.member.id } : {}
 	});
-	const routing = automated ? [] : (await input.archive.context({
+	const messageHistory = automated ? [] : (await input.archive.context({
 		provider: "telegram",
 		chatId: message.chat.id,
 		messageId: message.messageId,
 		includeDecisions: true,
 		limit: 100,
 		...lookup?.status === "paired" ? { participantId: lookup.member.id } : {}
-	})).events.filter((earlier) => earlier.kind === "decision" && earlier.senderId === event.senderId);
+	})).events;
+	const routing = messageHistory.filter((earlier) => earlier.kind === "decision" && earlier.senderId === event.senderId);
 	const previousClaim = routing.find((earlier) => earlier.reason === "turn_claimed");
 	const admitted = routing.some((earlier) => earlier.reason === "turn_admitted");
 	const released = previousClaim !== void 0 && routing.some((earlier) => earlier.eventId === `${previousClaim.eventId}:released`);
 	const dispatched = routing.some((earlier) => earlier.reason === "turn_dispatch_started");
 	const reserved = previousClaim !== void 0 && !released && Date.now() - Date.parse(previousClaim.at) < 6e5;
 	const alreadyHandled = admitted || dispatched || reserved;
-	if (!automated && edited === void 0 && !alreadyHandled) for (const earlier of (input.observed.recent(chat).length === 0 ? collapseConversationEvents(history?.events ?? []) : []).filter((item) => item.kind === "inbound" && item.eventId !== event.eventId && !history?.events.some((decision) => decision.kind === "decision" && decision.messageId === item.messageId && decision.reason === "turn_admitted")).slice(0, 30).reverse()) input.observed.add(chat, {
-		author: earlier.senderName ?? earlier.senderId ?? "automated post",
-		text: earlier.text ?? "[attachment or service message]",
-		at: earlier.at,
-		...earlier.messageId === null ? {} : { messageId: earlier.messageId },
-		...earlier.senderId === null ? {} : { authorId: earlier.senderId }
-	});
-	else if (automated || edited !== void 0) {
+	const rememberRevision = (events) => {
+		if (revisionId !== void 0) revisionEvents.push(...events.filter((item) => item.eventId === revisionId || item.eventId.startsWith(`${revisionId}:`)));
+	};
+	const historyEvents = [...messageHistory];
+	rememberRevision(historyEvents);
+	const previousRevision = (earlier) => earlier.kind === "inbound" && earlier.messageId === message.messageId && earlier.senderId === event.senderId && earlier.eventId !== event.eventId && !(edited !== void 0 && earlier.eventId.includes(":edit:") && earlier.at === event.at && (eventRouting(earlier).originalText ?? earlier.text) === content.text && attachmentIdentity(earlier.attachments) === attachmentIdentity(event.attachments));
+	const previous = messageHistory.find(previousRevision);
+	const unchangedAttachments = previous !== void 0 && attachmentIdentity(previous.attachments) === attachmentIdentity(event.attachments);
+	const previousRouting = previous === void 0 ? {} : eventRouting(previous);
+	const originalEvent = previous === void 0 ? void 0 : historyEvents.find((item) => item.eventId === previous.eventId.split(":content:")[0]);
+	if (inbound !== void 0) {
+		inbound.previousText = typeof previousRouting.originalText === "string" ? previousRouting.originalText : originalEvent?.text ?? previous?.text ?? void 0;
+		inbound.attachmentsChanged = previous === void 0 ? event.attachments.length > 0 : !unchangedAttachments;
+		if (unchangedAttachments && event.attachments.length > 0) {
+			const decoded = Array.isArray(previousRouting.decoded) ? previousRouting.decoded : [];
+			const media = typeof previousRouting.media === "string" ? previousRouting.media : void 0;
+			const metadata = record(JSON.parse(capture.event.argsSummary ?? "{}"));
+			capture.event = {
+				...capture.event,
+				argsSummary: JSON.stringify({
+					...metadata,
+					routing: {
+						...record(metadata.routing),
+						membership: previousRouting.membership
+					}
+				})
+			};
+			inbound.previousContent = {
+				decoded,
+				...media === void 0 ? {} : { media }
+			};
+			const transcripts = decoded.flatMap((item) => [
+				"voice",
+				"audio",
+				"video_note"
+			].includes(item.attachment_kind) && item.processed && typeof item.content === "string" ? [item.content] : []);
+			await recordInboundContent({
+				text: [content.text, ...transcripts].filter(Boolean).join("\n\n"),
+				decoded,
+				...media === void 0 ? {} : { media }
+			});
+		}
+	}
+	if (!automated) for (const earlier of input.observed.recent(chat).length === 0 ? archivedRoutingMessages((history?.events ?? []).filter((item) => item.eventId !== event.eventId)) : []) 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 ?? ""
 		});
-		input.observed.add(chat, {
+		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
+			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";
@@ -174,6 +262,27 @@ async function captureTelegramWebhook(input) {
 	}
 	if (inbound !== void 0) {
 		inbound.edited = edited !== void 0;
+		if (revisionId !== void 0) inbound.claimRevision = async () => {
+			if (revisionEvents.some((item) => item.eventId === `${revisionId}:completed`)) return false;
+			const claims = revisionEvents.filter((item) => item.reason === "routing_claimed");
+			const latest = claims[0];
+			if (latest !== void 0 && !revisionEvents.some((item) => item.eventId === `${latest.eventId}:failed`) && Date.now() - Date.parse(latest.at) < 12e4) return false;
+			const attempt = claims.length === 0 ? void 0 : Math.max(...claims.map((item) => Number(item.eventId.slice(revisionId.length).replace(":retry:", "")))) + 1;
+			const claim = {
+				...event,
+				eventId: attempt === void 0 ? revisionId : `${revisionId}:retry:${attempt}`,
+				at: new Date(Date.now()).toISOString(),
+				kind: "decision",
+				decision: "silent",
+				reason: "routing_claimed",
+				status: "requested",
+				text: null,
+				attachments: []
+			};
+			const inserted = await input.archive.append(claim);
+			if (inserted !== false) revisionClaim = claim;
+			return inserted !== false;
+		};
 		const nextClaim = previousClaim === void 0 ? void 0 : createHash("sha256").update(previousClaim.eventId).digest("hex");
 		const claimId = previousClaim === void 0 ? `telegram:${message.chat.id}:${message.messageId}:turn` : `telegram:${message.chat.id}:${message.messageId}:turn:${nextClaim}`;
 		let claimed = false;
@@ -232,6 +341,7 @@ async function captureTelegramWebhook(input) {
 				reason: "inbound_handler_failed",
 				attachments: []
 			});
+			await finishRevision("failed");
 		} catch (storageError) {
 			console.error("[segmentstream] recording inbound failure failed", {
 				storageError,
@@ -245,12 +355,16 @@ async function captureTelegramWebhook(input) {
 		...event,
 		eventId: `${event.eventId}:decision`,
 		kind: "decision",
-		argsSummary: null,
+		argsSummary: JSON.stringify({
+			...capture.diagnostics === void 0 ? {} : { decision: capture.diagnostics },
+			routing: { membership: capture.lookup === void 0 ? "unknown" : capture.lookup.status === "paired" ? "linked" : "unlinked" }
+		}),
 		text: capture.note ?? (edited !== void 0 ? "Message edit recorded as context; no agent turn started." : null),
 		decision: capture.decision ?? "silent",
 		reason: capture.reason ?? (message.raw.left_chat_member ? "member_departure" : message.raw.migrate_to_chat_id || message.raw.migrate_from_chat_id ? "chat_migration" : "unpaired_refused_or_empty_message"),
 		attachments: []
 	});
+	await finishRevision(capture.reason === "inbound_message_failed" || capture.reason === "decision_model_failed" || capture.reason === "decision_model_timeout" ? "failed" : "completed");
 	return response;
 }
 function recordGateDecision(reason, decision = "silent") {
@@ -269,6 +383,7 @@ function recordRouteDecision(route, addressed, policy, audit) {
 		capture.decision = route === "reply" ? "reply" : "silent";
 		capture.reason ??= audit?.reason ?? (typeof addressed === "string" ? addressed : addressed ? "addressed_message" : policy === "mention" ? "mention_policy" : `decision_model_${route}`);
 		capture.note = audit?.note.slice(0, 500);
+		capture.diagnostics = audit?.diagnostics;
 	}
 }
 function captureRouteDecider(decide) {
@@ -283,6 +398,34 @@ function captureRouteDecider(decide) {
 		}
 	};
 }
+async function recordInboundContent(content) {
+	const inbound = currentInboundRequest();
+	const capture = inbound === void 0 ? void 0 : captures.get(inbound);
+	if (capture?.archive === void 0) return;
+	const metadata = record(JSON.parse(capture.event.argsSummary ?? "{}"));
+	const membership = capture.lookup === void 0 ? record(metadata.routing).membership : capture.lookup.status === "paired" ? "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 contentHash = createHash("sha256").update(JSON.stringify({
+		...content,
+		membership
+	})).digest("hex").slice(0, 16);
+	const event = {
+		...capture.event,
+		eventId: `${capture.event.eventId}:content:${contentHash}`,
+		text: content.text,
+		argsSummary: JSON.stringify({
+			...metadata,
+			routing: {
+				...record(metadata.routing),
+				membership,
+				media: content.media?.slice(0, 8e3),
+				decoded: content.decoded
+			}
+		})
+	};
+	await capture.archive.append(event);
+	capture.event = event;
+}
 function captureTelegramFetch(fetchImpl, archive, identities) {
 	return async (input, init) => {
 		const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
@@ -316,6 +459,15 @@ function captureTelegramFetch(fetchImpl, archive, identities) {
 			senderIsBot: true,
 			senderId: "agent",
 			senderName: "agent",
+			argsSummary: JSON.stringify({ routing: {
+				...currentConfirmationPrompt() === void 0 ? {} : { confirmation: currentConfirmationPrompt() },
+				...capture?.event.chatId === chatId && capture.event.senderId !== null ? { inReplyTo: {
+					id: capture.event.senderId,
+					author: capture.event.senderName ?? capture.event.senderId,
+					...capture.message.from?.username === void 0 ? {} : { username: capture.message.from.username }
+				} } : {},
+				...currentConfirmationPrompt()?.requester === void 0 ? {} : { inReplyTo: currentConfirmationPrompt()?.requester }
+			} }),
 			participantIds,
 			threadId: id(body.message_thread_id) ?? currentThreadId() ?? null,
 			replyToMessageId: id(body.reply_to_message_id) ?? id(record(body.reply_parameters).message_id),
@@ -358,7 +510,10 @@ function conversationIdentities(identities) {
 		lookup: async (account) => {
 			const inbound = currentInboundRequest();
 			const capture = inbound === void 0 ? void 0 : captures.get(inbound);
-			return account.provider === "telegram" && capture?.message.from?.id === account.externalId && capture.lookup !== void 0 ? capture.lookup : identities.lookup(account);
+			if (account.provider === "telegram" && capture?.message.from?.id === account.externalId && capture.lookup !== void 0) return capture.lookup;
+			const lookup = await identities.lookup(account);
+			if (account.provider === "telegram" && capture?.message.from?.id === account.externalId) capture.lookup = lookup;
+			return lookup;
 		}
 	};
 }
@@ -394,4 +549,4 @@ function telegramConversationCapture(input) {
 		}
 	};
 }
-export { captureRouteDecider, captureTelegramFetch, captureTelegramWebhook, conversationIdentities, recordGateDecision, recordRouteDecision, telegramConversationCapture };
+export { REVISION_CLAIM_TTL_MS, captureRouteDecider, captureTelegramFetch, captureTelegramWebhook, conversationIdentities, recordGateDecision, recordInboundContent, recordRouteDecision, telegramConversationCapture };

package/dist/extension/lib/telegram/customer-text.mjs

@@ -5,5 +5,5 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { isTechnicalText } from "../customer-text-safety.mjs";
-import { a as TelegramDeliveryError, c as customerCopy, d as failureText, f as formattingRefused, h as withDeliveryLocale, l as customerMessage, m as safeTelegramFetch, o as currentLocale, p as reportTelegramError, s as currentThreadId, u as customerText } from "../../../_chunks/inbound-request-CysnjMdw.mjs";
+import { a as TelegramDeliveryError, c as customerCopy, d as failureText, f as formattingRefused, h as withDeliveryLocale, l as customerMessage, m as safeTelegramFetch, o as currentLocale, p as reportTelegramError, s as currentThreadId, u as customerText } from "../../../_chunks/inbound-request-BwBvXk0A.mjs";
 export { TelegramDeliveryError, currentLocale, currentThreadId, customerCopy, customerMessage, customerText, failureText, formattingRefused, isTechnicalText, reportTelegramError, safeTelegramFetch, withDeliveryLocale };

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

@@ -0,0 +1,26 @@
+import type { TelegramCallbackQuery, TelegramContext, TelegramHandle, TelegramEventContext } from "eve/channels/telegram";
+import type { SessionContext } from "eve/context";
+import { type DeferredConfirmation, type DeferredOptions } from "../deferred-confirmations.js";
+import { type Conversations } from "../conversations.js";
+import type { AgentIdentities } from "../identities.js";
+import { type ObservedMessages } from "./observed.js";
+export declare const isDeferredCallback: (data?: string) => boolean;
+export declare const deferredCallback: (record: DeferredConfirmation, choice: "y" | "n" | "e") => string;
+export declare function archiveDeferred(record: DeferredConfirmation, phase: string, archive: Conversations): Promise<void>;
+/** Called at the durable tool-result boundary. Pending cards never become eve input requests. */
+export declare function postDeferredCard(id: string, channel: TelegramEventContext, ctx: SessionContext, options: DeferredOptions, archive: Conversations, observed?: ObservedMessages): Promise<void>;
+/** Every callback re-resolves the live identity. The database arbitrates concurrent presses. */
+export declare function handleDeferredCallback(input: {
+    readonly context: TelegramContext;
+    readonly query: TelegramCallbackQuery;
+    readonly identities: AgentIdentities;
+    readonly archive: Conversations;
+    readonly options: DeferredOptions;
+    readonly observed?: ObservedMessages;
+}): Promise<void>;
+/** A database-clock expiry claim is shared by webhooks and the minute schedule. */
+export declare function expireDeferredRecord(record: DeferredConfirmation, context: {
+    readonly telegram: Pick<TelegramHandle, "editMessageText">;
+}, options: DeferredOptions, archive: Conversations, notify: NonNullable<import("./inbound-request.js").InboundRequest["confirmationEvent"]>, observed?: ObservedMessages): Promise<void>;
+/** Webhooks also reconcile expiry if the host's minute scheduler is delayed. */
+export declare function expireDeferredCards(context: TelegramContext, options: DeferredOptions, archive: Conversations, observed?: ObservedMessages): Promise<void>;