@segmentstream/agent 0.8.24 → 0.9.0

package/dist/_chunks/{build-metadata-BrXE_Dxu.mjs → build-metadata-DuHeGf1m.mjs}

@@ -4,7 +4,7 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
-var version = "0.8.24";
+var version = "0.9.0";
 function agentBuild(environment = process.env) {
 	return {
 		agent: version,

package/dist/_chunks/content-CvFsrmSD.mjs

@@ -0,0 +1,102 @@
+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);
+const CONTENT_CAPS = {
+	args: 16384,
+	result: 32768,
+	error: 4096
+};
+const sensitive = /token|password|passwd|secret|authorization|cookie|credential|api.?key|private.?key|session|iban|card|cvv|ssn|email|phone|address|birth|document.?text|raw.?content|body|bytes|base64/i;
+const encoder = new TextEncoder();
+function luhn(value) {
+	const digits = value.replace(/\D/g, "");
+	if (digits.length < 13 || digits.length > 19) return false;
+	let sum = 0;
+	let double = false;
+	for (let i = digits.length - 1; i >= 0; i--) {
+		let n = Number(digits[i]);
+		if (double && (n *= 2) > 9) n -= 9;
+		sum += n;
+		double = !double;
+	}
+	return sum % 10 === 0;
+}
+function redactText(value) {
+	return value.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g, "[binary data]").replace(/-----BEGIN [^-\r\n]+-----[\s\S]*?(?:-----END [^-\r\n]+-----|$)/g, "[redacted PEM]").replace(/data:[^\s"']+/gi, "[binary data]").replace(/\b(?:Bearer|Basic)\s+[A-Za-z0-9+/_=.:~\-]+/gi, "[redacted authorization]").replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g, "[redacted JWT]").replace(/\b(?:ssw_|sscli_|sk[-_]|rk[-_])[A-Za-z0-9._~\-]+/gi, "[redacted key]").replace(/\b([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi, "$1[redacted]@").replace(/([?&](?:[^=&#\s]*(?:token|password|secret|key|signature|credential|session|auth|cookie)[^=&#\s]*|sig)=)[^&#\s"']*/gi, "$1[redacted]").replace(/((?:["']?)(?:[\w-]*(?:token|password|passwd|secret|authorization|cookie|credential|api.?key|private.?key|session|iban|card|cvv|ssn)[\w-]*)(?:["']?)\s*[:=]\s*)(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^\s,;})]+)/gi, "$1[redacted]").replace(/\b[A-Z]{2}\d{2}(?:[ -]?[A-Z0-9]){11,30}\b/gi, "[redacted IBAN]").replace(/\b\d(?:[ -]?\d){12,18}\b/g, (candidate) => luhn(candidate) ? "[redacted card]" : candidate).replace(/[A-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[A-Z0-9](?:[A-Z0-9.-]*[A-Z0-9])?\.[A-Z]{2,}/gi, "[email]").replace(/\b\d{3}-\d{2}-\d{4}\b/g, "[redacted SSN]").replace(/\b[A-Za-z0-9+/]{128,}={0,2}/g, "[binary data]");
+}
+const documentField = /^(?:text|content|body|csv|tsv|file[_-]?body|email[_-]?body)$/i;
+const omittedDocument = "[omitted: unstructured document content]";
+function redactContent(value) {
+	const seen = new WeakSet();
+	let nodes = 0;
+	const visit = (item, depth, field) => {
+		if (++nodes > 5e3 || depth > 12) return "[omitted: content complexity]";
+		if (typeof item === "string") {
+			try {
+				const embedded = JSON.parse(item);
+				if (embedded !== null && typeof embedded === "object") return JSON.stringify(visit(embedded, depth + 1, field));
+			} catch {}
+			if (documentField.test(field ?? "")) return omittedDocument;
+			return redactText(item);
+		}
+		if (typeof item === "bigint") return item.toString();
+		if (item === null || typeof item !== "object") return item;
+		if (ArrayBuffer.isView(item) || item instanceof ArrayBuffer) return "[binary data]";
+		if (seen.has(item)) return "[omitted: circular]";
+		seen.add(item);
+		if (Array.isArray(item)) {
+			const entries = item.slice(0, 200).map((entry) => visit(entry, depth + 1, field));
+			if (item.length > 200) entries.push("[omitted: array entries]");
+			return entries;
+		}
+		const entries = Object.entries(item);
+		return Object.fromEntries([...entries.slice(0, 200).map(([key, entry]) => [redactText(key), sensitive.test(key) && !documentField.test(key) ? "[redacted]" : visit(entry, depth + 1, key)]), ...entries.length > 200 ? [["_omitted", "[omitted: object entries]"]] : []]);
+	};
+	return visit(value, 0);
+}
+function contentText(value, cap) {
+	if (value == null) return null;
+	let parsed = value;
+	if (typeof value === "string") try {
+		parsed = JSON.parse(value);
+	} catch {}
+	const redacted = redactContent(parsed);
+	const text = typeof redacted === "string" ? redacted : JSON.stringify(redacted) ?? "[omitted]";
+	if (encoder.encode(text).length <= cap) return text;
+	let preview = text;
+	while (true) {
+		const result = JSON.stringify({
+			truncated: true,
+			preview
+		});
+		const bytes = encoder.encode(result).length;
+		if (bytes <= cap) return result;
+		const available = Math.max(0, encoder.encode(preview).length - (bytes - cap) - 4);
+		preview = new TextDecoder().decode(encoder.encode(preview).slice(0, available), { stream: true });
+	}
+}
+function redactRouterPayload(value) {
+	const seen = new WeakSet();
+	let nodes = 0;
+	const visit = (item, depth) => {
+		if (++nodes > 5e3 || depth > 16) return "[omitted: routing complexity]";
+		if (typeof item === "string") {
+			try {
+				const embedded = JSON.parse(item);
+				if (embedded !== null && typeof embedded === "object") return JSON.stringify(visit(embedded, depth + 1));
+			} catch {}
+			return redactText(item);
+		}
+		if (item === null || typeof item !== "object") return item;
+		if (ArrayBuffer.isView(item) || item instanceof ArrayBuffer) return "[binary data]";
+		if (seen.has(item)) return "[omitted: circular]";
+		seen.add(item);
+		if (Array.isArray(item)) return item.slice(0, 200).map((entry) => visit(entry, depth + 1));
+		return Object.fromEntries(Object.entries(item).slice(0, 200).map(([key, entry]) => [key, /token|password|secret|authorization|cookie|credential|api.?key|bytes|base64/i.test(key) ? "[redacted]" : visit(entry, depth + 1)]));
+	};
+	return visit(value, 0);
+}
+export { contentText as n, redactRouterPayload as r, CONTENT_CAPS as t };

package/dist/extension/channels/telegram.mjs

@@ -9,6 +9,7 @@ import { segmentstreamTelegram } from "../lib/telegram/adapter.mjs";
 import { decide } from "eve/ai";
 var telegram_default = segmentstreamTelegram({
 	settings: () => segmentstream.config.channels.telegram,
+	groups: () => segmentstream.config.groups,
 	models: () => segmentstream.config.models,
 	confirmationMode: () => segmentstream.config.confirmations.mode,
 	sessions: () => segmentstream.config.sessions,

package/dist/extension/config.d.ts

@@ -1,3 +1,5 @@
+import { type GroupPolicyInput } from "@segmentstream-cloud/ontology/groups";
+import { type GroupPolicy } from "./lib/group-routing/policy.js";
 import type { AttachmentLifecycle } from "./lib/telegram/lifecycle.js";
 import { type TelegramLinkPreviews } from "@segmentstream-cloud/ontology/telegram";
 export declare const TELEGRAM_POLICIES: readonly ["mention", "smart"];
@@ -51,6 +53,7 @@ export interface AdmissionSettings {
  * the values validation allows.
  */
 export interface SegmentStreamAgentConfigInput {
+    readonly groups?: GroupPolicyInput;
     readonly firstContact?: FirstContactSettings;
     readonly limits?: AdmissionLimitsInput;
     readonly replies?: AdmissionReplies;
@@ -58,8 +61,13 @@ export interface SegmentStreamAgentConfigInput {
         readonly telegram?: {
             /** The Connect key whose credential is the bot token, such as `telegram`. */
             readonly connection: string;
-            /** `smart` (default) or `mention`. */
+            /** @deprecated Use groups.mode; conflicting values are rejected. */
             readonly policy?: string;
+            readonly groups?: {
+                readonly replyEdgeIsAddress?: boolean;
+                readonly topicScope?: boolean;
+                readonly commandsAddress?: boolean;
+            };
             /** External links only (default), Telegram's native first link, or no previews. */
             readonly linkPreviews?: string;
             /** Additional exact HTTP(S) origins belonging to this workspace. */
@@ -86,7 +94,7 @@ export interface SegmentStreamAgentConfigInput {
         readonly imageDescription?: string | boolean;
         /** @deprecated Compatibility alias for imageDescription; the canonical key takes precedence. */
         readonly attachments?: string | boolean;
-        /** The Gateway decision model of the inbound router. */
+        /** @deprecated Use groups.smart.model; conflicting values are rejected. */
         readonly decision?: string;
     };
     readonly ontology?: {
@@ -115,6 +123,11 @@ export interface SegmentStreamAgentConfigInput {
     };
 }
 export interface TelegramSettings {
+    readonly groups?: {
+        readonly replyEdgeIsAddress?: boolean;
+        readonly topicScope?: boolean;
+        readonly commandsAddress?: boolean;
+    };
     readonly connection: string;
     readonly policy: TelegramPolicy;
     readonly linkPreviews?: TelegramLinkPreviews;
@@ -146,6 +159,7 @@ export interface SessionSettings {
 }
 /** The validated configuration with defaults applied. It stays JSON-serializable. */
 export interface SegmentStreamAgentConfig extends AdmissionSettings {
+    readonly groups: GroupPolicy;
     readonly channels: {
         readonly telegram: TelegramSettings | null;
     };

package/dist/extension/config.mjs

@@ -4,6 +4,10 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
+import { effectiveGroupPolicy, groupPolicy } from "./lib/group-routing/policy.mjs";
+import { readFileSync, realpathSync } from "node:fs";
+import { isAbsolute, relative, resolve } from "node:path";
+import { expandGroupFiles, groupPolicyIssues } from "@segmentstream-cloud/ontology/groups";
 import { TELEGRAM_LINK_PREVIEWS, isHttpOrigin } from "@segmentstream-cloud/ontology/telegram";
 const CONNECTION_KEY = /^[a-z][a-z0-9_]{0,63}$/;
 const TELEGRAM_POLICIES = ["mention", "smart"];
@@ -65,6 +69,7 @@ function telegramSettings(value, issues) {
 		allowed: [
 			"connection",
 			"policy",
+			"groups",
 			"linkPreviews",
 			"additionalOwnOrigins",
 			"attachmentLifecycle"
@@ -72,6 +77,24 @@ function telegramSettings(value, issues) {
 		issues
 	});
 	if (telegram === void 0) return null;
+	const signalSettings = section({
+		value: telegram.groups,
+		path: [...path, "groups"],
+		allowed: [
+			"replyEdgeIsAddress",
+			"topicScope",
+			"commandsAddress"
+		],
+		issues
+	});
+	for (const [key, value] of Object.entries(signalSettings ?? {})) if (typeof value !== "boolean") issues.push({
+		message: "must be a boolean",
+		path: [
+			...path,
+			"groups",
+			key
+		]
+	});
 	const connection = telegram.connection;
 	const policy = telegram.policy ?? "smart";
 	if (typeof connection !== "string" || !CONNECTION_KEY.test(connection)) issues.push({
@@ -117,6 +140,7 @@ function telegramSettings(value, issues) {
 	return typeof connection === "string" && isTelegramPolicy(policy) ? {
 		connection,
 		policy,
+		...signalSettings === void 0 ? {} : { groups: signalSettings },
 		linkPreviews,
 		additionalOwnOrigins,
 		...lifecycle === void 0 ? {} : { attachmentLifecycle: {
@@ -345,6 +369,7 @@ function validateConfig(input) {
 		path: [],
 		allowed: [
 			"channels",
+			"groups",
 			"models",
 			"ontology",
 			"sessions",
@@ -390,6 +415,66 @@ function validateConfig(input) {
 		path: ["confirmations", "mode"]
 	});
 	const telegram = telegramSettings(channels?.telegram, issues);
+	for (const issue of groupPolicyIssues(root?.groups)) issues.push({
+		...issue,
+		path: ["groups", ...issue.path]
+	});
+	let authoredGroups = root?.groups;
+	if (authoredGroups !== void 0 && groupPolicyIssues(authoredGroups).length === 0) try {
+		authoredGroups = expandGroupFiles(authoredGroups, (path) => {
+			const root = realpathSync(process.cwd());
+			const file = realpathSync(resolve(root, path));
+			const local = relative(root, file);
+			if (local.startsWith("..") || isAbsolute(local)) throw new Error("Group instruction file is outside agent/.");
+			return readFileSync(file, "utf8");
+		});
+	} catch (cause) {
+		issues.push({
+			path: [
+				"groups",
+				"smart",
+				"instructions"
+			],
+			message: cause instanceof Error ? cause.message : "instruction file could not be read"
+		});
+	}
+	const legacyMode = isRecord(channels?.telegram) ? channels.telegram.policy : void 0;
+	if (authoredGroups?.mode !== void 0 && legacyMode !== void 0 && authoredGroups.mode !== legacyMode) issues.push({
+		path: ["groups", "mode"],
+		message: "conflicts with channels.telegram.policy"
+	});
+	if (authoredGroups?.smart?.model !== void 0 && models?.decision !== void 0 && authoredGroups.smart.model !== models.decision) issues.push({
+		path: [
+			"groups",
+			"smart",
+			"model"
+		],
+		message: "conflicts with models.decision"
+	});
+	let groups = groupPolicy();
+	try {
+		groups = groupPolicy(issues.length === 0 ? authoredGroups : void 0, {
+			mode: typeof legacyMode === "string" ? legacyMode : void 0,
+			model: typeof models?.decision === "string" ? models.decision : void 0
+		});
+	} catch (cause) {
+		issues.push({
+			path: ["groups"],
+			message: cause instanceof Error ? cause.message : "invalid inherited group policy"
+		});
+	}
+	if (issues.length === 0) for (const key of Object.keys(groups.chats)) try {
+		effectiveGroupPolicy(groups, key);
+	} catch (cause) {
+		issues.push({
+			path: [
+				"groups",
+				"chats",
+				key
+			],
+			message: cause instanceof Error ? cause.message : "invalid inherited group policy"
+		});
+	}
 	const chat = chatModelChoice(models?.chat, issues);
 	const stt = models?.stt === false ? false : modelId({
 		value: models?.stt,
@@ -397,7 +482,7 @@ function validateConfig(input) {
 		path: ["models", "stt"],
 		issues
 	});
-	const decision = modelId({
+	modelId({
 		value: models?.decision,
 		fallback: DEFAULT_DECISION_MODEL,
 		path: ["models", "decision"],
@@ -426,11 +511,15 @@ function validateConfig(input) {
 	});
 	if (issues.length > 0) return { issues };
 	return { value: {
-		channels: { telegram },
+		groups,
+		channels: { telegram: telegram === null ? null : {
+			...telegram,
+			policy: groups.mode
+		} },
 		models: {
 			chat,
 			stt,
-			decision,
+			decision: groups.smart.model,
 			imageDescription,
 			attachments
 		},

package/dist/extension/extension.d.ts

@@ -17,3 +17,10 @@ export declare const segmentstream: import("eve/extension").ExtensionHandle<{
 export default segmentstream;
 export { DEFAULT_DECISION_MODEL, DEFAULT_STT_MODEL, DEFAULT_ADMISSION_LIMITS, SegmentStreamAgentConfigError, manifestOf, type ChatModelChoice, type AdmissionLimits, type AdmissionLimitsInput, type AdmissionSettings, type AdmissionReplies, type FirstContactSettings, type LocalizedText, type SegmentStreamAgentConfig, type SegmentStreamAgentConfigInput, type SessionScope, type SessionSettings, type TelegramPolicy, type TelegramSettings, } from "./config.js";
 export { chooseModel, model, type DynamicModel, type ModelChoice } from "./model.js";
+export { groupPolicy, effectiveGroupPolicy, DEFAULT_GROUP_POLICY, type GroupPolicy, type GroupPolicyInput, type SmartPolicyInput, type ChatOverrideInput, } from "./lib/group-routing/policy.js";
+export { addressingReason as groupAddressingReason, conversationKey, type GroupMessageSignals, type AgentMessageSignals, type GroupChannelAdapter, } from "./lib/group-routing/signals.js";
+export { routeMessage as routeGroupMessage, decisionRouter as groupDecisionRouter, } from "./lib/group-routing/router.js";
+export { groupSettings as readGroupSettings, type CloudGroupSettings, } from "./lib/group-routing/settings.js";
+export { observedMessages as groupObservedMessages, agentMessage as groupAgentMessage, type RecentMessage, type AgentMessage, type ObservedMessage, } from "./lib/group-routing/observed.js";
+export { archivedRoutingMessages } from "./lib/group-routing/routing-context.js";
+export { replayRouterPayload } from "./lib/group-routing/replay.js";

package/dist/extension/extension.mjs

@@ -4,12 +4,19 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
+import { DEFAULT_GROUP_POLICY, effectiveGroupPolicy, groupPolicy } from "./lib/group-routing/policy.mjs";
 import { DEFAULT_ADMISSION_LIMITS, DEFAULT_DECISION_MODEL, DEFAULT_STT_MODEL, SegmentStreamAgentConfigError, configSchema, manifestOf } from "./config.mjs";
 import { chooseModel, model } from "./model.mjs";
+import { addressingReason, conversationKey } from "./lib/group-routing/signals.mjs";
+import { decisionRouter, routeMessage } from "./lib/group-routing/router.mjs";
+import { groupSettings } from "./lib/group-routing/settings.mjs";
+import { agentMessage, observedMessages } from "./lib/group-routing/observed.mjs";
+import { archivedRoutingMessages } from "./lib/group-routing/routing-context.mjs";
+import { replayRouterPayload } from "./lib/group-routing/replay.mjs";
 import { defineExtension } from "eve/extension";
 const extension = defineExtension({ config: configSchema });
 const segmentstream = Object.assign(extension, {
 	model: (choice) => model(choice ?? (() => extension.config.models.chat)),
 	manifestOf
 });
-export { DEFAULT_ADMISSION_LIMITS, DEFAULT_DECISION_MODEL, DEFAULT_STT_MODEL, SegmentStreamAgentConfigError, chooseModel, segmentstream as default, segmentstream, manifestOf, model };
+export { DEFAULT_ADMISSION_LIMITS, DEFAULT_DECISION_MODEL, DEFAULT_GROUP_POLICY, DEFAULT_STT_MODEL, SegmentStreamAgentConfigError, archivedRoutingMessages, chooseModel, conversationKey, segmentstream as default, segmentstream, effectiveGroupPolicy, addressingReason as groupAddressingReason, agentMessage as groupAgentMessage, decisionRouter as groupDecisionRouter, observedMessages as groupObservedMessages, groupPolicy, manifestOf, model, groupSettings as readGroupSettings, replayRouterPayload, routeMessage as routeGroupMessage };

package/dist/extension/hooks/conversations.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 { n as conversationRecorder } from "../../_chunks/conversation-runtime-ovs8IhXJ.mjs";
+import { conversationRecorder } from "../lib/conversation-runtime.mjs";
 import { defineHook } from "eve/hooks";
 var conversations_default = defineHook({ events: { "*": conversationRecorder() } });
 export { conversations_default as default };

package/dist/extension/instructions/conversations.mjs

@@ -5,7 +5,7 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { conversations, storedConversationContext } from "../lib/conversations.mjs";
-import { t as conversationCoordinates } from "../../_chunks/conversation-runtime-ovs8IhXJ.mjs";
+import { conversationCoordinates } from "../lib/conversation-runtime.mjs";
 import { defineDynamic, defineInstructions } from "eve/instructions";
 const archive = conversations();
 var conversations_default = defineDynamic({ events: { "turn.started": async (_event, context) => {

package/dist/extension/lib/build-metadata.mjs

@@ -4,5 +4,5 @@ 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-BrXE_Dxu.mjs";
+import { t as agentBuild } from "../../_chunks/build-metadata-DuHeGf1m.mjs";
 export { agentBuild };

package/dist/extension/lib/conversation-runtime.mjs

@@ -4,5 +4,136 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
-import { n as conversationRecorder, t as conversationCoordinates } from "../../_chunks/conversation-runtime-ovs8IhXJ.mjs";
+import { memberIdOf } from "./telegram/principal.mjs";
+import { n as contentText, t as CONTENT_CAPS } from "../../_chunks/content-CvFsrmSD.mjs";
+import { conversationEvent, conversations, summarizeArguments } from "./conversations.mjs";
+import { parseAddress } from "./telegram/sessions.mjs";
+import { completionKind } from "./telegram/silent.mjs";
+function conversationCoordinates(context) {
+	const principal = context.session.auth.current;
+	const telegram = principal?.authenticator === "segmentstream-telegram" || context.channel.kind?.includes("telegram");
+	const address = context.channel.continuationToken;
+	const attributes = principal?.attributes;
+	const fields = address?.split(":");
+	const localAddress = telegram && fields?.length === 4 ? fields.slice(1).join(":") : address;
+	const parsed = telegram && localAddress !== void 0 && /^-?\d+:\d*:\d*$/u.test(localAddress) ? parseAddress(localAddress) : void 0;
+	const attributeChatId = typeof attributes?.chatId === "string" && (!telegram || /^-?\d+$/u.test(attributes.chatId)) ? attributes.chatId : void 0;
+	const chatId = telegram ? parsed?.chatId ?? attributeChatId : attributeChatId !== void 0 ? attributeChatId : address;
+	if (!chatId) return;
+	const memberId = memberIdOf(principal);
+	const chatType = attributes?.chatType;
+	return {
+		provider: telegram ? "telegram" : context.channel.kind ?? "eve",
+		chatId,
+		chatType: chatType === "group" || chatType === "supergroup" || chatType === void 0 && telegram && chatId.startsWith("-") ? "group" : chatType === "channel" ? "channel" : "private",
+		threadId: !telegram ? null : parsed !== void 0 ? parsed.messageThreadId || null : typeof attributes?.messageThreadId === "string" ? attributes.messageThreadId : null,
+		participantIds: memberId === void 0 ? [] : [memberId],
+		senderId: principal?.subject ?? null
+	};
+}
+function conversationRecorder(archive = conversations()) {
+	return async (event, context) => {
+		const coordinates = conversationCoordinates(context);
+		if (coordinates === void 0) return;
+		const base = {
+			...coordinates,
+			sessionId: context.session.id,
+			turnId: event.data !== void 0 && "turnId" in event.data ? event.data.turnId : context.session.turn.id,
+			at: event.meta.at
+		};
+		const eventId = `eve:${context.session.id}:${event.meta.id}`;
+		if (event.type === "actions.requested") for (const action of event.data.actions) {
+			const name = "toolName" in action ? action.toolName : action.name;
+			await archive.append(conversationEvent({
+				...base,
+				eventId: `${eventId}:${action.callId}`,
+				kind: "tool_call",
+				toolCallId: action.callId,
+				toolName: name,
+				argsSummary: summarizeArguments(action.input),
+				argsText: contentText(action.input, CONTENT_CAPS.args),
+				status: "requested"
+			}));
+		}
+		else if (event.type === "action.result") {
+			const result = event.data.result;
+			const name = "toolName" in result ? result.toolName : "name" in result ? result.name : result.subagentName;
+			await archive.append(conversationEvent({
+				...base,
+				eventId,
+				kind: "tool_result",
+				toolCallId: result.callId,
+				toolName: name,
+				status: event.data.status,
+				resultText: contentText("output" in result ? result.output : null, CONTENT_CAPS.result),
+				errorText: contentText(event.data.error?.message ?? (event.data.status === "failed" ? resultErrorMessage(result.output) : null), CONTENT_CAPS.error)
+			}));
+		} else if (event.type === "task.started" || event.type === "task.settled") await archive.append(conversationEvent({
+			...base,
+			eventId,
+			kind: event.type === "task.started" ? "tool_call" : "tool_result",
+			toolCallId: event.data.callId,
+			toolName: event.data.name ?? "task",
+			argsSummary: "{}",
+			...event.type === "task.settled" ? {
+				resultText: contentText(event.data.output, CONTENT_CAPS.result),
+				errorText: contentText(event.data.error?.message, CONTENT_CAPS.error)
+			} : {},
+			status: event.type === "task.started" ? "requested" : event.data.status === "cancelled" ? "cancelled" : event.data.status === "failed" ? "failed" : "completed"
+		}));
+		else if (event.type === "turn.failed" || event.type === "step.failed") await archive.append(conversationEvent({
+			...base,
+			turnId: event.data.turnId,
+			eventId,
+			kind: "decision",
+			decision: "silent",
+			reason: event.type,
+			status: "failed",
+			errorText: contentText(event.data.message, CONTENT_CAPS.error)
+		}));
+		else if (event.type === "message.completed" && event.data.finishReason !== "tool-calls") {
+			const kind = completionKind(event.data.message, event.data.finishReason);
+			const silent = kind !== "reply";
+			const note = kind === "silent_marker" ? "Model returned an explicit silence marker; no message delivery." : kind === "empty" ? "Model completed without final text; no message delivery." : kind === "whitespace" ? "Model returned only whitespace; no message delivery." : "Model produced a reply; transport delivery is recorded separately.";
+			await archive.append(conversationEvent({
+				...base,
+				eventId,
+				kind: "decision",
+				decision: silent ? "silent" : "reply",
+				reason: kind === "reply" ? "model_reply" : `model_${kind}_output`,
+				text: note,
+				argsSummary: JSON.stringify({
+					outputKind: kind,
+					outputCharacters: event.data.message?.length ?? 0,
+					finishReason: event.data.finishReason
+				})
+			}));
+			if (coordinates.provider !== "telegram" && !silent) await archive.append(conversationEvent({
+				...base,
+				eventId: `${eventId}:outbound`,
+				kind: "outbound",
+				text: event.data.message,
+				senderId: "agent",
+				senderIsBot: true,
+				status: "completed"
+			}));
+		} else if (event.type === "message.received" && coordinates.provider !== "telegram") await archive.append(conversationEvent({
+			...base,
+			eventId,
+			kind: "inbound",
+			text: event.data.message,
+			attachments: (event.data.parts ?? []).filter((part) => part.type === "file").map((part, index) => ({
+				id: `${eventId}:file:${index}`,
+				kind: "file",
+				...part.filename ? { filename: part.filename } : {},
+				contentType: part.mediaType
+			}))
+		}));
+	};
+}
+function resultErrorMessage(output) {
+	if (typeof output === "string") return output;
+	if (output !== null && typeof output === "object" && "message" in output && typeof output.message === "string") return output.message;
+	return null;
+}
 export { conversationCoordinates, conversationRecorder };

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

@@ -6,11 +6,11 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { appOrigin } from "./environment.mjs";
 import { memberIdOf } from "./telegram/principal.mjs";
+import { runtimeToken } from "./runtime-token.mjs";
 import { redactDiagnostic } from "./diagnostics.mjs";
 import { humanText, object } from "./confirmation-description.mjs";
 import { chatPostDigest, chatPostOperationId, isChatPost } from "./chat-post-confirmation.mjs";
 import { actionApproval, inputHash } from "./confirmations.mjs";
-import { runtimeToken } from "./runtime-token.mjs";
 import { ontologyTools } from "./ontology-tools.mjs";
 import { createHash } from "node:crypto";
 const deferredKey = (id) => createHash("sha256").update(id).digest("hex").slice(0, 20);

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

@@ -0,0 +1,18 @@
+import type { GroupPolicy, Participants } from "./policy.js";
+import type { GroupMessageSignals } from "./signals.js";
+import type { RecentMessage } from "./observed.js";
+export interface Engagement {
+    readonly memberId: string;
+    readonly since: string;
+    readonly lastAgentReplyAt: string;
+    readonly anchorMessageId?: string;
+    readonly source: string;
+    readonly strength: "explicit" | "model";
+}
+/** Compare workspace-provided names, never infer translations or personal aliases. */
+export declare function humanAddressee(signals: GroupMessageSignals, recent: ReadonlyArray<RecentMessage>, participants: Participants): string | undefined;
+/** A participant's own human reply edge followed by that human's response is a human thread. */
+export declare function humanThread(signals: GroupMessageSignals, recent: ReadonlyArray<RecentMessage>, minutes: number): boolean;
+/** Recover from delivered replies and their inbound anchors; model replies remain weak. */
+export declare function restoreEngagement(signals: GroupMessageSignals, recent: ReadonlyArray<RecentMessage>, policy: GroupPolicy): Engagement | undefined;
+export declare function questionInvitation(at: string | undefined, now: string, minutes: number | "unlimited"): boolean;

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

@@ -0,0 +1,65 @@
+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);
+const own = (m) => "role" in m && m.role === "agent";
+const normalize = (text) => text.normalize("NFKC").toLocaleLowerCase().replace(/^@/, "");
+function humanAddressee(signals, recent, participants) {
+	const first = /^[\s«"“'([]*([\p{L}\p{N}_-]{3,})(?=[\s,!:;?.»"”')\]]|$)/u.exec(signals.message.text)?.[1];
+	if (first === void 0) return;
+	const name = normalize(first);
+	for (const [id, participant] of Object.entries(participants)) {
+		if (id === signals.sender.externalId || id === signals.sender.member?.id || normalize(id) === normalize(signals.sender.username ?? "")) continue;
+		if ([id, ...participant.aliases].some((alias) => normalize(alias) === name)) return id;
+	}
+	for (const member of recent) {
+		if (own(member) || member.kind === "bot" || member.kind === "other_bot" || member.authorId === signals.sender.externalId) continue;
+		if ([member.username, member.author.split(/\s+/u)[0]].some((alias) => alias !== void 0 && normalize(alias) === name)) return member.authorId ?? member.username ?? member.author;
+	}
+}
+function humanThread(signals, recent, minutes) {
+	const now = Date.parse(signals.message.at);
+	const edge = recent.filter((m) => now >= Date.parse(m.at) && now - Date.parse(m.at) <= minutes * 6e4).findLast((m) => !own(m) && m.authorId === signals.sender.externalId && (m.replyTo?.kind === "human" || m.invitation !== void 0));
+	return edge?.replyTo?.kind === "human" && edge.replyTo.id !== void 0 && edge.replyTo.id !== signals.sender.externalId;
+}
+function restoreEngagement(signals, recent, policy) {
+	let state;
+	for (let i = 0; i < recent.length; i++) {
+		const message = recent[i];
+		if (!own(message)) {
+			if (message.authorId === signals.sender.externalId && (message.replyTo?.kind === "human" && message.replyTo.id !== message.authorId || message.taggedUsers?.some((target) => target.kind !== "bot") || humanAddressee({
+				...signals,
+				message: {
+					...signals.message,
+					text: message.text
+				}
+			}, recent, policy.participants) !== void 0)) state = void 0;
+			continue;
+		}
+		if (message.confirmation !== void 0 || !message.addressedTo.some((target) => target.id === signals.sender.externalId || target.username !== void 0 && normalize(target.username) === normalize(signals.sender.username ?? ""))) continue;
+		const anchor = recent.slice(0, i).findLast((entry) => !own(entry) && entry.authorId === signals.sender.externalId && (message.replyTo === void 0 || entry.messageId === message.replyTo.messageId));
+		const invitation = message.invitation ?? anchor?.invitation ?? (anchor?.replyTo?.kind === "bot" ? "reply-to-bot" : anchor?.taggedUsers?.some((target) => target.kind === "bot") ? "mention" : void 0);
+		const continuous = state?.strength === "explicit" && Date.parse(message.at) - Date.parse(state.lastAgentReplyAt) <= policy.smart.engagement.conversationMinutes * 6e4;
+		state = invitation === void 0 && continuous ? {
+			...state,
+			lastAgentReplyAt: message.at
+		} : {
+			memberId: signals.sender.member?.id ?? signals.sender.externalId,
+			since: anchor?.at ?? message.at,
+			lastAgentReplyAt: message.at,
+			anchorMessageId: anchor?.messageId,
+			source: invitation ?? "model",
+			strength: invitation === void 0 ? "model" : "explicit"
+		};
+	}
+	const age = Date.parse(signals.message.at) - Date.parse(state?.lastAgentReplyAt ?? "");
+	return state !== void 0 && age >= 0 && age <= policy.smart.engagement.conversationMinutes * 6e4 ? state : void 0;
+}
+function questionInvitation(at, now, minutes) {
+	if (minutes === "unlimited") return true;
+	const age = Date.parse(now) - Date.parse(at ?? "");
+	return minutes > 0 && age >= 0 && age <= minutes * 6e4;
+}
+export { humanAddressee, humanThread, questionInvitation, restoreEngagement };

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

@@ -0,0 +1,11 @@
+import type { Route } from "./router.js";
+/** Aggregate facts only: no chat, member or message identifiers enter process health. */
+export declare function recordRoutingMetric(provider: string, route: Route, reason: string, latencyMs?: number): void;
+export declare function groupRoutingHealth(): {
+    provider: string;
+    route: Route;
+    reason: string;
+    count: number;
+    modelCalls: number;
+    averageLatencyMs: number | null;
+}[];