@segmentstream/agent 0.8.23 → 0.9.0

package/dist/extension/lib/group-routing/signals.d.ts

@@ -0,0 +1,110 @@
+/** Channels report facts; unavailable signals must never be guessed. */
+export interface AgentIdentity {
+    readonly id: string;
+    readonly username: string | undefined;
+    readonly displayName?: string;
+    readonly firstName?: string;
+}
+export interface GroupMessageSignals {
+    readonly provider: string;
+    readonly conversation: {
+        readonly externalId: string;
+        readonly kind: "direct" | "group" | "channel";
+        readonly scope?: string;
+        readonly title?: string;
+    };
+    readonly message: {
+        readonly id: string;
+        readonly at: string;
+        readonly text: string;
+        readonly edited?: {
+            readonly originalAt: string;
+            readonly editedAt: string;
+        };
+        readonly attachments: ReadonlyArray<{
+            readonly kind: string;
+            readonly filename?: string;
+            readonly mediaType?: string;
+            readonly size?: number;
+        }>;
+        readonly hasCaption: boolean;
+    };
+    readonly sender: {
+        readonly externalId: string;
+        readonly username?: string;
+        readonly displayName?: string;
+        readonly kind: "human" | "bot" | "other_bot" | "unknown";
+        readonly member?: {
+            readonly id: string;
+            readonly name: string | null;
+            readonly roles: ReadonlyArray<string>;
+        };
+    };
+    readonly addressing: {
+        readonly agentMentioned: boolean;
+        readonly command: boolean;
+        readonly replyTo?: {
+            readonly messageId: string;
+            readonly author: "agent" | "human" | "other_bot" | "unknown";
+            readonly authorExternalId?: string;
+            readonly authorUsername?: string;
+            readonly authorName?: string;
+            readonly hasAttachments?: boolean;
+            readonly self?: boolean;
+        };
+        readonly mentions: ReadonlyArray<{
+            readonly externalId?: string;
+            readonly username?: string;
+            readonly kind: "human" | "bot" | "other_bot" | "unknown";
+        }>;
+        readonly threadWithAgent: boolean | "unavailable";
+        /** False when a channel does not admit ambient channel messages. */
+        readonly eligible?: boolean;
+    };
+    readonly derived?: {
+        readonly transcript?: string;
+        readonly attachmentDescription?: string;
+    };
+}
+export interface AgentMessageSignals {
+    readonly provider: string;
+    readonly conversation: GroupMessageSignals["conversation"];
+    readonly message: GroupMessageSignals["message"];
+    readonly replyToMessageId?: string;
+}
+export interface GroupChannelAdapter<Message, Delivery, Principal> {
+    readonly provider: string;
+    signals(message: Message, bot: AgentIdentity | undefined): GroupMessageSignals;
+    outbound(delivery: Delivery): AgentMessageSignals;
+    address(signals: GroupMessageSignals, scope: "chat" | "thread"): string;
+    principal(signals: GroupMessageSignals): Principal;
+}
+export declare function conversationKey(signals: Pick<GroupMessageSignals, "provider" | "conversation">): string;
+export interface MessageAudience {
+    readonly originalText: string;
+    readonly botTagged: boolean;
+    readonly mentions: ReadonlyArray<{
+        readonly kind: "bot" | "human" | "other_bot" | "unknown";
+        readonly id?: string;
+        readonly username?: string;
+        readonly name?: string;
+        readonly type: "mention" | "text_mention";
+        readonly text: string;
+    }>;
+    readonly replyTo: null | {
+        readonly kind: "bot" | "human" | "other_bot" | "unknown";
+        readonly id?: string;
+        readonly username?: string;
+        readonly name?: string;
+        readonly messageId: string;
+        readonly text: string;
+        readonly hasAttachments?: boolean;
+        readonly filename?: string;
+        readonly self?: boolean;
+    };
+}
+export declare function signalAudience(signals: GroupMessageSignals): MessageAudience;
+export type AddressingReason = "private" | "mention" | "reply-to-bot" | "command" | "pending-question" | "thread-with-agent";
+export declare function addressingReason(signals: GroupMessageSignals): AddressingReason | undefined;
+/** Explicit recipients win; quoting an upload or one's own message remains inference evidence. */
+export declare function otherRecipient(audience: MessageAudience | undefined): string | undefined;

package/dist/extension/lib/group-routing/signals.mjs

@@ -0,0 +1,47 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+const __filename = __eveFileURLToPath(import.meta.url);
+__eveDirname(__filename);
+__eveCreateRequire(import.meta.url);
+function conversationKey(signals) {
+	const scope = signals.conversation.scope === void 0 ? "" : `/${signals.conversation.scope}`;
+	return `${signals.provider}:${signals.conversation.externalId}${scope}`;
+}
+function signalAudience(signals) {
+	const reply = signals.addressing.replyTo;
+	return {
+		originalText: signals.message.text,
+		botTagged: signals.addressing.agentMentioned,
+		mentions: signals.addressing.mentions.map((m) => ({
+			kind: m.kind,
+			id: m.externalId,
+			username: m.username,
+			type: "mention",
+			text: m.username === void 0 ? "" : `@${m.username}`
+		})),
+		replyTo: reply === void 0 ? null : {
+			kind: reply.author === "agent" ? "bot" : reply.author,
+			id: reply.authorExternalId,
+			username: reply.authorUsername,
+			name: reply.authorName,
+			messageId: reply.messageId,
+			text: "",
+			hasAttachments: reply.hasAttachments,
+			self: reply.self
+		}
+	};
+}
+function addressingReason(signals) {
+	if (signals.conversation.kind === "direct") return "private";
+	if (signals.addressing.command) return "command";
+	if (signals.addressing.agentMentioned) return "mention";
+	if (signals.addressing.replyTo?.author === "agent") return "reply-to-bot";
+	return signals.addressing.threadWithAgent === true ? "thread-with-agent" : void 0;
+}
+function otherRecipient(audience) {
+	if (audience === void 0 || audience.botTagged) return;
+	if (audience.mentions.some((item) => item.kind !== "bot")) return "Message tags another recipient; this agent was not addressed.";
+	if (audience.replyTo?.kind === "other_bot" || audience.replyTo?.kind === "human" && !audience.replyTo.hasAttachments && !audience.replyTo.self) return "Reply targets another person or bot; this agent was not addressed.";
+}
+export { addressingReason, conversationKey, otherRecipient, signalAudience };

package/dist/extension/lib/identities.d.ts

@@ -1,3 +1,4 @@
+import { type ChatOverrideInput } from "@segmentstream-cloud/ontology/groups";
 import type { AdmissionLimitsInput } from "../config.js";
 import type { RuntimeToken } from "./runtime-token.js";
 /**
@@ -68,6 +69,8 @@ export interface ChatAccount {
 }
 /** A group chat in the ontology's `agent_chat` registry, with what members said it is for. */
 export interface AgentChat {
+    readonly routing?: ChatOverrideInput;
+    readonly scope?: string;
     readonly id: string;
     readonly title: string;
     readonly purpose: string | null;

package/dist/extension/lib/identities.mjs

@@ -5,6 +5,7 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { redactDiagnostic } from "./diagnostics.mjs";
+import { groupPolicyIssues } from "@segmentstream-cloud/ontology/groups";
 var AgentIdentityError = class extends Error {
 	name = "AgentIdentityError";
 	code;
@@ -93,11 +94,22 @@ function agentChat(value) {
 		code: "invalid_response",
 		message: "The ontology service answered the chat report with an invalid body."
 	});
+	const override = {
+		...isRecord(value.routing) ? value.routing : {},
+		...isRecord(value.participants) ? { participants: value.participants } : {}
+	};
+	const valid = groupPolicyIssues(override, true).length === 0;
+	if (!valid) console.error("[segmentstream] invalid chat routing override", {
+		chatId: value.id,
+		issues: groupPolicyIssues(override, true)
+	});
 	return {
 		id: value.id,
 		title: value.title,
 		purpose: value.purpose,
-		whenToUse: value.whenToUse
+		whenToUse: value.whenToUse,
+		...typeof value.scope === "string" ? { scope: value.scope } : {},
+		...valid && Object.keys(override).length > 0 ? { routing: override } : {}
 	};
 }
 async function refusal(response, call) {

package/dist/extension/lib/ontology-connection.mjs

@@ -6,9 +6,9 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { appOrigin } from "./environment.mjs";
 import { identityProviderOf, memberIdOf } from "./telegram/principal.mjs";
+import { runtimeToken, tokenExpiry } from "./runtime-token.mjs";
 import { CHAT_POST_ENVELOPE, chatPostDigest, chatPostOperationId, isChatPost } from "./chat-post-confirmation.mjs";
 import { actionApproval, confirmations } from "./confirmations.mjs";
-import { runtimeToken, tokenExpiry } from "./runtime-token.mjs";
 import { ontologyTools } from "./ontology-tools.mjs";
 import { defineMcpClientConnection } from "eve/connections";
 const ACT_AS_HEADER = "X-SegmentStream-Act-As";

package/dist/extension/lib/ontology-tools.mjs

@@ -6,10 +6,10 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { appOrigin } from "./environment.mjs";
 import { identityProviderOf, memberIdOf } from "./telegram/principal.mjs";
+import { runtimeToken } from "./runtime-token.mjs";
 import { redactDiagnostic } from "./diagnostics.mjs";
 import { describeConfirmation, object } from "./confirmation-description.mjs";
 import { describeChatPost, isChatPost, supportsChatPost } from "./chat-post-confirmation.mjs";
-import { runtimeToken } from "./runtime-token.mjs";
 import { randomUUID } from "node:crypto";
 var OntologyToolRejected = class extends Error {
 	code = "ontology_tool_rejected";

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

@@ -1,3 +1,4 @@
+import type { GroupPolicy } from "../group-routing/policy.js";
 import { type AttachmentDescriber } from "./attachment-description.js";
 import { type TelegramChannel } from "eve/channels/telegram";
 import type { ChatModelChoice, AdmissionSettings, SessionSettings, TelegramSettings } from "../../config.js";
@@ -21,6 +22,7 @@ import { type Transcriber } from "./voice.js";
 export interface TelegramAdapterOptions {
     /** The mounted `channels.telegram`, or `null` when the workspace has no Telegram channel. */
     readonly settings: () => TelegramSettings | null;
+    readonly groups?: () => GroupPolicy;
     readonly models: () => {
         readonly stt: string | false;
         readonly decision: string;

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

@@ -8,13 +8,16 @@ import { manifestOf } from "../../config.mjs";
 import { appOrigin, channelsEnabled, proxyEnvironment, runtimeIdentityEnvironment, webhookSecret } from "../environment.mjs";
 import { conversationLanguage, telegramPrincipal } from "./principal.mjs";
 import { chooseModel } from "../../model.mjs";
-import { t as agentBuild } from "../../../_chunks/build-metadata-26dmE9nn.mjs";
+import { groupRoutingHealth } from "../group-routing/health.mjs";
+import { decisionRouter } from "../group-routing/router.mjs";
+import { runtimeToken } from "../runtime-token.mjs";
+import { groupSettings } from "../group-routing/settings.mjs";
+import { conversations } from "../conversations.mjs";
+import { t as agentBuild } from "../../../_chunks/build-metadata-DuHeGf1m.mjs";
 import { confirmationLocale } from "./confirmation-text.mjs";
 import { telegramSendScope } from "./send-queue.mjs";
 import { d as failureText, h as withDeliveryLocale, i as withReplacedText, m as safeTelegramFetch, n as currentInboundRequest, p as reportTelegramError, r as runInboundRequest, t as InboundRequest } from "../../../_chunks/inbound-request-B8Eyjz1O.mjs";
-import { runtimeToken } from "../runtime-token.mjs";
 import { attachmentLifecycle } from "./lifecycle.mjs";
-import { conversations } from "../conversations.mjs";
 import { scopedAddress, sessionPolicy } from "./sessions.mjs";
 import { observedMessages } from "./observed.mjs";
 import { expireDeferredCards, handleDeferredCallback, isDeferredCallback } from "./deferred-confirmations.mjs";
@@ -23,7 +26,6 @@ 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 { decisionRouter } from "./router.mjs";
 import { replyDelivery } from "./silent.mjs";
 import { handleConfirmationCallback, telegramConfirmationEvents } from "./confirmations.mjs";
 import { captureRouteDecider, captureTelegramFetch, conversationIdentities, recordGateDecision, telegramConversationCapture } from "./conversations.mjs";
@@ -68,7 +70,12 @@ const eveInteractions = async (sessionId) => {
 function segmentstreamTelegram(options) {
 	const environment = options.environment ?? process.env;
 	const token = options.token ?? runtimeToken;
-	const observed = options.observed ?? observedMessages();
+	const readGroups = groupSettings({
+		environment,
+		token,
+		fetch: options.fetch
+	});
+	const observed = options.observed ?? observedMessages(60);
 	const readHistory = options.history ?? eveHistory;
 	const readInteractions = options.history ?? eveInteractions;
 	const capabilities = options.modelCapabilities ?? gatewayMediaCapabilities(options.fetch);
@@ -166,6 +173,10 @@ function segmentstreamTelegram(options) {
 					request: currentInboundRequest(),
 					dependencies: {
 						policy: settings().policy,
+						decisionModel: options.models().decision,
+						groups: options.groups?.(),
+						cloudGroups: options.groups === void 0 ? void 0 : readGroups,
+						signalSettings: settings().groups,
 						recoverHeldApprovals: options.confirmationMode?.() === "deferred",
 						...settings().attachmentLifecycle === void 0 ? {} : { lifecycle: (principal, memberId, message) => attachmentLifecycle({
 							configuration: settings().attachmentLifecycle,
@@ -403,6 +414,7 @@ function segmentstreamTelegram(options) {
 			capture
 		})), healthRoute({
 			chats,
+			...options.groups === void 0 ? {} : { routing: groupRoutingHealth },
 			enabled: () => channelsEnabled(environment),
 			configured: () => options.settings() !== null,
 			verify: () => verify ??= runtimeTokenVerifier(runtimeIdentityEnvironment(environment)),

package/dist/extension/lib/telegram/attachments-send.mjs

@@ -6,11 +6,11 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { appOrigin, channelsEnabled, proxyEnvironment } from "../environment.mjs";
 import "./principal.mjs";
+import { runtimeToken } from "../runtime-token.mjs";
 import { redactDiagnostic } from "../diagnostics.mjs";
 import { confirmationLocale } from "./confirmation-text.mjs";
 import { inTelegramSendQueue, telegramSendScope } from "./send-queue.mjs";
 import { c as customerCopy, f as formattingRefused, l as customerMessage, p as reportTelegramError } from "../../../_chunks/inbound-request-B8Eyjz1O.mjs";
-import { runtimeToken } from "../runtime-token.mjs";
 import { MAXIMUM_PROXY_BODY_BYTES, connectionProxy } from "../connection-proxy.mjs";
 import { ACT_AS_HEADER } from "../ontology-connection.mjs";
 import { AttachmentError, CONVERSATION_HEADER, SESSION_HEADER } from "../attachments.mjs";

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

@@ -1,30 +1,7 @@
 import type { TelegramMessage } from "eve/channels/telegram";
 import type { BotIdentity } from "./router.js";
-type TargetKind = "bot" | "human" | "other_bot" | "unknown";
-interface Recipient {
-    readonly kind: TargetKind;
-    readonly id?: string;
-    readonly username?: string;
-    readonly name?: string;
-}
-export interface MessageAudience {
-    readonly originalText: string;
-    readonly botTagged: boolean;
-    readonly mentions: ReadonlyArray<Recipient & {
-        readonly type: "mention" | "text_mention";
-        readonly text: string;
-    }>;
-    readonly replyTo: (Recipient & {
-        readonly messageId: string;
-        readonly text: string;
-        /** A reply can quote evidence instead of addressing its uploader. */
-        readonly hasAttachments?: boolean;
-        readonly filename?: string;
-        readonly self?: boolean;
-    }) | null;
-}
+export type { MessageAudience } from "../group-routing/signals.js";
+import type { MessageAudience } from "../group-routing/signals.js";
 /** Current-message entities only; mentions inside a quoted/code range are not addressees. */
 export declare function messageAudience(message: TelegramMessage, bot: BotIdentity | undefined): MessageAudience;
-/** Explicit recipients win; quoting an upload or one's own message goes to smart inference. */
-export declare function otherRecipient(audience: MessageAudience | undefined): string | undefined;
-export {};
+export { otherRecipient } from "../group-routing/signals.js";

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

@@ -4,6 +4,7 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
+import { otherRecipient } from "../group-routing/signals.mjs";
 import { messageContent, telegramRecord } from "./content.mjs";
 function recipient(user, bot) {
 	const id = typeof user.id === "string" || typeof user.id === "number" ? String(user.id) : void 0;
@@ -85,9 +86,4 @@ function messageAudience(message, bot) {
 		replyTo
 	};
 }
-function otherRecipient(audience) {
-	if (audience === void 0 || audience.botTagged) return;
-	if (audience.mentions.some((item) => item.kind !== "bot")) return "Message tags another recipient; this bot was not addressed.";
-	if (audience.replyTo?.kind === "other_bot" || audience.replyTo?.kind === "human" && !audience.replyTo.hasAttachments && !audience.replyTo.self) return "Reply targets another person or bot; this bot was not addressed.";
-}
 export { messageAudience, otherRecipient };

package/dist/extension/lib/telegram/confirmation-expiry.mjs

@@ -5,11 +5,11 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { proxyEnvironment } from "../environment.mjs";
+import { runtimeToken } from "../runtime-token.mjs";
+import { conversations } from "../conversations.mjs";
 import { telegramSendScope } from "./send-queue.mjs";
 import { m as safeTelegramFetch, p as reportTelegramError } from "../../../_chunks/inbound-request-B8Eyjz1O.mjs";
-import { runtimeToken } from "../runtime-token.mjs";
 import { deferredConfirmations } from "../deferred-confirmations.mjs";
-import { conversations } from "../conversations.mjs";
 import { expireDeferredRecord } from "./deferred-confirmations.mjs";
 import { connectionProxy } from "../connection-proxy.mjs";
 import { TELEGRAM_PLACEHOLDER_TOKEN, TELEGRAM_PROXY_ORIGIN, telegramProxyFetch } from "./proxy-fetch.mjs";

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

@@ -5,15 +5,15 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { memberIdOf, telegramPrincipal } from "./principal.mjs";
+import { agentMessage, observedChatKey, withConfirmationPrompt } from "../group-routing/observed.mjs";
+import { conversationEvent } from "../conversations.mjs";
 import { humanText } from "../confirmation-description.mjs";
 import { renderConfirmation, withConfirmationText } from "./confirmation-text.mjs";
 import { chatPostCard, chatPostCardStatus, chatPostReceipt, withChatPostCard } from "./chat-post-card.mjs";
 import { n as currentInboundRequest, p as reportTelegramError } from "../../../_chunks/inbound-request-B8Eyjz1O.mjs";
 import { chatPostOperationId, isChatPost } from "../chat-post-confirmation.mjs";
 import { confirmations } from "../confirmations.mjs";
-import { conversationEvent } from "../conversations.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";

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

@@ -17,7 +17,7 @@ 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" | "diagnostics">): 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;
 /** Update the existing inbound event after STT/description, under the same text retention policy. */
 export declare function recordInboundContent(content: {

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

@@ -4,11 +4,12 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
-import { n as currentInboundRequest, p as reportTelegramError, s as currentThreadId } from "../../../_chunks/inbound-request-B8Eyjz1O.mjs";
+import { currentConfirmationPrompt, observedChatKey } from "../group-routing/observed.mjs";
 import { conversationEvent } from "../conversations.mjs";
+import { archivedRoutingMessages } from "../group-routing/routing-context.mjs";
+import { n as currentInboundRequest, p as reportTelegramError, s as currentThreadId } from "../../../_chunks/inbound-request-B8Eyjz1O.mjs";
 import { contentShape, messageContent } from "./content.mjs";
-import { currentConfirmationPrompt, messageMetadata, observedChatKey } from "./observed.mjs";
-import { archivedRoutingMessages } from "./routing-context.mjs";
+import { messageMetadata } from "./observed.mjs";
 import { reportMembership } from "./membership.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import { parseTelegramUpdate } from "eve/channels/telegram";
@@ -233,7 +234,7 @@ async function captureTelegramWebhook(input) {
 			});
 		}
 	}
-	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);
+	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({
@@ -382,6 +383,8 @@ async function captureTelegramWebhook(input) {
 		kind: "decision",
 		argsSummary: JSON.stringify({
 			...capture.diagnostics === void 0 ? {} : { decision: capture.diagnostics },
+			...capture.router === void 0 ? {} : { router: capture.router },
+			...capture.shadow === void 0 ? {} : { shadow: capture.shadow },
 			routing: { membership: capture.lookup === void 0 ? "unknown" : capture.lookup.status === "paired" || capture.lookup.status === "existing" || capture.lookup.status === "created" ? "linked" : "unlinked" }
 		}),
 		text: capture.note ?? (edited !== void 0 ? "Message edit recorded as context; no agent turn started." : null),
@@ -409,7 +412,10 @@ 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.routeReason = audit?.reason;
 		capture.diagnostics = audit?.diagnostics;
+		capture.router = audit?.router;
+		capture.shadow = audit?.shadow;
 	}
 }
 function captureRouteDecider(decide) {
@@ -493,6 +499,13 @@ function captureTelegramFetch(fetchImpl, archive, identities) {
 					...typeof body.parse_mode === "string" ? { parse_mode: body.parse_mode } : {}
 				},
 				routing: {
+					...capture?.routeReason !== void 0 && [
+						"mention",
+						"command",
+						"reply-to-bot",
+						"thread-with-agent",
+						"pending-question"
+					].includes(capture.routeReason) ? { invitation: capture.routeReason } : {},
 					...currentConfirmationPrompt() === void 0 ? {} : { confirmation: currentConfirmationPrompt() },
 					...capture?.event.chatId === chatId && capture.event.senderId !== null ? { inReplyTo: {
 						id: capture.event.senderId,

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

@@ -5,6 +5,8 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { telegramPrincipal } from "./principal.mjs";
+import { agentMessage, observedChatKey, withConfirmationPrompt } from "../group-routing/observed.mjs";
+import { conversationEvent } from "../conversations.mjs";
 import { humanText } from "../confirmation-description.mjs";
 import { renderConfirmation, withConfirmationText } from "./confirmation-text.mjs";
 import { chatPostCard, chatPostCardStatus, chatPostReceipt, withChatPostCard } from "./chat-post-card.mjs";
@@ -13,9 +15,7 @@ import { CONFIRMATION_TTL_MS, inputHash } from "../confirmations.mjs";
 import { OntologyToolRejected } from "../ontology-tools.mjs";
 import { confirmationOutcome } from "../confirmation-outcome.mjs";
 import { deferredConfirmations, deferredKey, runDeferredAction } from "../deferred-confirmations.mjs";
-import { conversationEvent } from "../conversations.mjs";
 import { formatAddress } from "./sessions.mjs";
-import { agentMessage, observedChatKey, withConfirmationPrompt } from "./observed.mjs";
 import { telegramTextLinks } from "@segmentstream-cloud/ontology/telegram";
 const PREFIX = "ss-confirm:d:";
 const isDeferredCallback = (data) => data?.startsWith(PREFIX) === true;

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

@@ -6,6 +6,7 @@ export declare const HEALTH_ROUTE = "/eve/v1/telegram/health";
 /** Runtime-only, per-instance health. It never exposes credentials or private provider bodies. */
 export declare function healthRoute(input: {
     readonly chats: AgentChats;
+    readonly routing?: () => unknown;
     readonly enabled: () => boolean;
     readonly configured: () => boolean;
     readonly verify: () => RuntimeTokenVerifier;

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

@@ -4,7 +4,7 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
-import { t as agentBuild } from "../../../_chunks/build-metadata-26dmE9nn.mjs";
+import { t as agentBuild } from "../../../_chunks/build-metadata-DuHeGf1m.mjs";
 import { runtimeRequestFailure } from "./runtime-request.mjs";
 import { GET } from "eve/channels";
 const HEALTH_ROUTE = "/eve/v1/telegram/health";
@@ -16,6 +16,7 @@ function healthRoute(input) {
 		return Response.json({
 			status: registry.degraded ? "degraded" : "ok",
 			registry,
+			...input.routing === void 0 ? {} : { routing: input.routing() },
 			runtime: agentBuild(),
 			...input.configuration === void 0 ? {} : { configuration: input.configuration() }
 		}, {

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

@@ -1,3 +1,6 @@
+import type { CloudGroupSettings } from "../group-routing/settings.js";
+import { type GroupPolicy } from "../group-routing/policy.js";
+import type { TelegramSettings } from "../../config.js";
 import { attachmentLifecycle } from "./lifecycle.js";
 import type { TelegramContext, TelegramInboundResult, TelegramMessage } from "eve/channels/telegram";
 import type { AdmissionSettings, SessionSettings, TelegramPolicy } from "../../config.js";
@@ -39,6 +42,10 @@ import type { PdfTextExtractor } from "./pdf-text.js";
  */
 export interface InboundDependencies {
     readonly policy: TelegramPolicy;
+    readonly decisionModel?: string;
+    readonly groups?: GroupPolicy;
+    readonly cloudGroups?: () => Promise<CloudGroupSettings | undefined>;
+    readonly signalSettings?: TelegramSettings["groups"];
     /** Recover old held sessions only when the workspace has chosen non-blocking confirmations. */
     readonly recoverHeldApprovals?: boolean;
     readonly lifecycle?: (principal: import("eve/context").SessionAuthContext, memberId: string, message: TelegramMessage) => ReturnType<typeof attachmentLifecycle>;