@segmentstream/agent 0.27.0 → 0.29.0

package/dist/extension/lib/group-routing/conversation-router.mjs

@@ -4,8 +4,15 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
-import { ADDRESSEE_CRITERIA, ENDS_CONVERSATION_INSTRUCTIONS, NEEDS_RESPONSE_INSTRUCTIONS } from "./conversation-prompt.mjs";
-import { conversationState, conversationThreshold } from "./conversation.mjs";
+import { ADDRESSEE_CRITERIA, NEEDS_RESPONSE_INSTRUCTIONS } from "./conversation-prompt.mjs";
+const ADDRESSED_TO_AGENT = {
+	addressee: .5,
+	needsResponse: .5
+};
+const RECENT_CHARACTERS = 24e3;
+function addressedToAgent(answers) {
+	return answers !== void 0 && answers.addressee.choice === "agent" && (answers.addressee.probabilities?.agent ?? NaN) >= ADDRESSED_TO_AGENT.addressee && (answers.needs_response.probabilities?.true ?? NaN) >= ADDRESSED_TO_AGENT.needsResponse;
+}
 function conversationQuestions(instructions) {
 	return {
 		addressee: {
@@ -20,28 +27,38 @@ function conversationQuestions(instructions) {
 				true: "Asks for or needs an answer or action.",
 				false: "Acknowledgement, reaction, status, closing or remark."
 			}
-		},
-		ends_conversation: {
-			type: "boolean",
-			instructions: ENDS_CONVERSATION_INSTRUCTIONS,
-			criteria: {
-				true: "Ends or declines the agent's involvement.",
-				false: "Anything else."
-			}
 		}
 	};
 }
-function conversationModelState(question, analysis) {
+function conversationModelState(question) {
 	const groups = question.groups;
 	const now = Date.parse(question.processingAt ?? question.message.at);
 	const own = (m) => "role" in m && m.role === "agent";
-	const classifiedIds = new Set((question.messagesToClassify ?? [question.message]).map((m) => m.messageId));
-	const conversationStart = analysis.conversation.status === "active" && analysis.conversation.opened_at !== void 0 ? Date.parse(analysis.conversation.opened_at) : now - 9e5;
-	const recent = question.recent.filter((m) => !classifiedIds.has(m.messageId)).filter((m) => now - Date.parse(m.at) >= 0 && now - Date.parse(m.at) <= 9e5 && Date.parse(m.at) >= conversationStart).slice(-Math.min(20, groups.smart.context.messages));
-	const last = recent.findLast((m) => own(m) && "addressedTo" in m && m.addressedTo.some((p) => p.id === question.signals?.sender.externalId || p.username && p.username === question.signals?.sender.username));
-	const pending = analysis.pending_question_live ? question.pendingQuestions?.at(-1) : void 0;
+	const classified = question.messagesToClassify ?? [question.message];
+	const classifiedIds = new Set(classified.map((m) => m.messageId));
+	const format = (m, media) => JSON.stringify({
+		at: m.at,
+		id: m.messageId ?? null,
+		author: own(m) ? "THE AGENT" : m.author,
+		author_id: m.authorId ?? null,
+		text: m.text.slice(0, 1e3),
+		media: m.media?.slice(0, media),
+		reply_to: m.replyTo ?? null,
+		tags: m.taggedUsers ?? [],
+		attachments: m.attachmentKinds ?? []
+	});
+	const candidates = question.recent.filter((m) => !classifiedIds.has(m.messageId) && Date.parse(m.at) <= now).slice(-groups.smart.context.messages);
+	const lines = [];
+	let characters = 0;
+	for (const m of [...candidates].reverse()) {
+		const line = format(m, 500);
+		if (lines.length > 0 && characters + line.length > RECENT_CHARACTERS) break;
+		lines.unshift(line);
+		characters += line.length;
+	}
+	const recent = candidates.slice(candidates.length - lines.length);
 	const roster = new Map();
-	for (const m of [...recent, question.message]) {
+	for (const m of [...recent, ...classified]) {
 		if (own(m)) continue;
 		const id = m.authorId ?? m.username ?? m.author;
 		roster.set(id, {
@@ -52,16 +69,6 @@ function conversationModelState(question, analysis) {
 			kind: m.kind ?? "human"
 		});
 	}
-	const format = (m) => JSON.stringify({
-		at: m.at,
-		author: own(m) ? "THE AGENT" : m.author,
-		author_id: m.authorId ?? null,
-		text: m.text.slice(0, 1e3),
-		media: m.media?.slice(0, 2e3),
-		reply_to: m.replyTo ?? null,
-		tags: m.taggedUsers ?? [],
-		attachments: m.attachmentKinds ?? []
-	});
 	return {
 		agent: JSON.stringify({
 			names: [...new Set([
@@ -77,47 +84,14 @@ function conversationModelState(question, analysis) {
 			purpose: (groups.smart.context.includeChatGuidance ? question.chat ?? [] : []).join("\n").slice(0, 500)
 		}),
 		participants: groups.smart.context.includeParticipants ? [...roster.values()].map((p) => JSON.stringify(p)) : [],
-		route_context: JSON.stringify({
-			path: {
-				A: "explicit",
-				H: "human_target",
-				C: "continuation",
-				Ci: "inferred_continuation",
-				C2: "contested",
-				B: "ambient",
-				X: "human_exchange"
-			}[analysis.path],
-			conversation_with_sender: {
-				...analysis.conversation,
-				seconds_since_last_exchange: analysis.conversation.last_exchange_at ? Math.floor((now - Date.parse(analysis.conversation.last_exchange_at)) / 1e3) : null,
-				agent_last_message_to_sender: last ? {
-					text: last.text.slice(0, 600),
-					seconds_ago: Math.floor((now - Date.parse(last.at)) / 1e3)
-				} : null,
-				agent_open_question: pending ? {
-					text: pending.question.slice(0, 300),
-					seconds_ago: pending.at ? Math.floor((now - Date.parse(pending.at)) / 1e3) : null
-				} : null
-			},
-			human_exchange: analysis.human_exchange,
-			other_live_agent_conversations: analysis.other_live_agent_conversations
-		}),
-		recent_messages: recent.map(format),
-		messages_to_classify: (question.messagesToClassify ?? [question.message]).map(format)
+		recent_messages: lines,
+		messages_to_classify: classified.map((m) => format(m, 2e3))
 	};
 }
 function conversationDecisionRouter(decide) {
 	return async (question) => {
 		const policy = question.groups;
-		const analysis = question.conversation ?? conversationState({
-			signals: question.signals,
-			recent: question.recent,
-			policy,
-			agentNames: question.agentIdentity?.aliases,
-			pendingQuestionAt: question.pendingQuestions?.at(-1)?.at,
-			asOf: question.processingAt
-		});
-		const state = conversationModelState(question, analysis);
+		const state = conversationModelState(question);
 		const questions = conversationQuestions(policy.smart.instructions);
 		const started = performance.now();
 		const signal = AbortSignal.timeout(Math.ceil(policy.smart.timeoutSeconds * 1e3));
@@ -127,56 +101,38 @@ function conversationDecisionRouter(decide) {
 			questions,
 			signal
 		});
-		const normalize = (answer) => {
-			const p = answer.probabilities?.true ?? answer.probability ?? NaN;
-			return {
+		const p = raw.needs_response.probabilities?.true ?? raw.needs_response.probability ?? NaN;
+		const answers = {
+			...raw,
+			needs_response: {
 				choice: p >= .5,
 				probabilities: {
 					true: p,
 					false: 1 - p
 				}
-			};
-		};
-		const answers = {
-			...raw,
-			needs_response: normalize(raw.needs_response),
-			ends_conversation: normalize(raw.ends_conversation)
+			}
 		};
-		const p = answers.addressee.probabilities?.agent ?? NaN, needs = answers.needs_response.probabilities?.true ?? NaN, ends = answers.ends_conversation.probabilities?.true ?? NaN;
-		if ([
-			p,
-			needs,
-			ends
-		].some((x) => !Number.isFinite(x) || x < 0 || x > 1)) throw new Error("Conversation classifier probabilities unavailable.");
-		const threshold = conversationThreshold(analysis.path, policy);
-		const reply = answers.addressee.choice === "agent" && p >= threshold && needs >= (analysis.path === "B" || analysis.path === "X" ? .7 : .5) && ends < .7;
+		const agent = answers.addressee.probabilities?.agent ?? NaN;
+		if ([agent, p].some((x) => !Number.isFinite(x) || x < 0 || x > 1)) throw new Error("Conversation classifier probabilities unavailable.");
 		const diagnostics = {
 			model: policy.smart.model,
 			latencyMs: Math.round(performance.now() - started),
 			probabilities: {
-				reply: p,
-				observe: 1 - p
+				reply: agent,
+				observe: 1 - agent
 			},
 			addressing: answers
 		};
 		return {
-			route: reply ? "reply" : "observe",
+			route: addressedToAgent(answers) ? "reply" : "observe",
 			diagnostics,
 			router: {
 				state,
 				questions,
 				answer: answers,
-				path: analysis.path,
-				conversation: analysis.conversation,
-				human_exchange: analysis.human_exchange,
-				thresholds_applied: {
-					threshold,
-					needs_response: analysis.path === "B" || analysis.path === "X" ? .7 : .5,
-					ends_conversation: .7
-				},
-				conversation_ended: ends >= .7
+				thresholds_applied: ADDRESSED_TO_AGENT
 			}
 		};
 	};
 }
-export { conversationDecisionRouter, conversationModelState, conversationQuestions };
+export { ADDRESSED_TO_AGENT, addressedToAgent, conversationDecisionRouter, conversationModelState, conversationQuestions };

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

@@ -12,8 +12,6 @@ export interface ObservedMessage {
     /** How intake named the sender: a linked member's name and roles, then their handle. */
     readonly signedAuthor?: string;
     readonly invitation?: string;
-    /** Classifier rejection closes routing hints without cancelling the underlying task. */
-    readonly conversationEnded?: boolean;
     readonly text: string;
     readonly media?: string;
     /** Stored native images, by reference only: never image bytes or a sender's download grant. */

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

@@ -29,13 +29,7 @@ export interface SmartPolicy {
     readonly engagement: {
         readonly policy: "legacy" | "engaged" | "conversation";
         readonly agentAliases: ReadonlyArray<string>;
-        readonly idleMinutes: number;
-        readonly humanExchangeMinutes: number;
-        readonly humanQuestionMinutes: number;
-        readonly inferredMaxMinutes: number;
         readonly burst: {
-            readonly quietSeconds: number;
-            readonly maxSeconds: number;
             readonly gapSeconds: number;
         };
         readonly followUpMinutes: number;
@@ -44,11 +38,6 @@ export interface SmartPolicy {
         readonly addresseeGate: boolean;
     };
     readonly thresholds: {
-        readonly continuation: number;
-        readonly inferredContinuation: number;
-        readonly contested: number;
-        readonly ambient: number;
-        readonly humanExchange: number;
         readonly engaged: number;
         readonly neutral: number;
         readonly humanThread: number;
@@ -67,6 +56,21 @@ export interface GroupPolicy {
     readonly sources: Readonly<Record<string, string>>;
 }
 export declare function smartPolicy(input?: SmartPolicyInput, base?: SmartPolicy): SmartPolicy;
+/**
+ * Settings of former SDK mechanisms: the conversation state machine's timers and per-state
+ * thresholds, and the webhook's wait for the rest of a burst. They are still accepted so that
+ * existing configurations deploy, and are ignored: the classifier reads the chat's recent
+ * messages, and a member's next message joins their active turn through eve's steering.
+ */
+export declare const IGNORED_GROUP_SETTINGS: {
+    readonly engagement: readonly ["idleMinutes", "humanExchangeMinutes", "humanQuestionMinutes", "inferredMaxMinutes"];
+    readonly thresholds: readonly ["continuation", "inferredContinuation", "contested", "ambient", "humanExchange"];
+    readonly burst: readonly ["quietSeconds", "maxSeconds"];
+};
+/** Whether a settings path names an ignored setting, in the agent, a chat or the shadow policy. */
+export declare function ignoredGroupSetting(path: ReadonlyArray<string>): boolean;
+/** The dotted paths of ignored settings an authored `groups` value sets, for a deploy warning. */
+export declare function ignoredGroupSettings(value: unknown, prefix?: ReadonlyArray<string>): string[];
 export declare function groupPolicy(input?: GroupPolicyInput, aliases?: {
     readonly mode?: string;
     readonly model?: string;

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

@@ -48,10 +48,6 @@ function smartPolicy(input = {}, base) {
 		engagement: {
 			policy: selected,
 			agentAliases: [],
-			idleMinutes: 10,
-			humanExchangeMinutes: 5,
-			humanQuestionMinutes: 30,
-			inferredMaxMinutes: 30,
 			followUpMinutes: 30,
 			conversationMinutes: 10,
 			...base?.engagement,
@@ -63,38 +59,55 @@ function smartPolicy(input = {}, base) {
 				openQuestionMinutes: engaged ? 30 : "unlimited",
 				addresseeGate: engaged
 			} : {},
-			...input.engagement,
+			...withoutIgnored(input.engagement, IGNORED_GROUP_SETTINGS.engagement),
 			burst: {
-				quietSeconds: 6,
-				maxSeconds: 15,
 				gapSeconds: 30,
 				...base?.engagement.burst,
-				...input.engagement?.burst
+				...withoutIgnored(input.engagement?.burst, IGNORED_GROUP_SETTINGS.burst)
 			}
 		},
 		thresholds: {
 			engaged: .5,
 			neutral: conversation ? .9 : engaged ? .75 : .5,
 			humanThread: conversation ? .95 : engaged ? .9 : .5,
-			continuation: .5,
-			inferredContinuation: .7,
-			contested: .8,
-			ambient: .9,
-			humanExchange: .95,
 			...changed ? {} : base?.thresholds,
-			...input.thresholds,
-			...conversation ? {
-				continuation: input.thresholds?.continuation ?? input.thresholds?.engaged ?? (changed ? .5 : base?.thresholds.continuation) ?? .5,
-				ambient: input.thresholds?.ambient ?? input.thresholds?.neutral ?? (changed ? .9 : base?.thresholds.ambient) ?? .9,
-				humanExchange: input.thresholds?.humanExchange ?? input.thresholds?.humanThread ?? (changed ? .95 : base?.thresholds.humanExchange) ?? .95
-			} : {}
+			...withoutIgnored(input.thresholds, IGNORED_GROUP_SETTINGS.thresholds)
 		},
 		timeoutSeconds: input.timeoutSeconds ?? base?.timeoutSeconds ?? 15
 	};
-	if (policy.engagement.burst.quietSeconds > policy.engagement.burst.maxSeconds) throw new RangeError("Burst quietSeconds must not exceed maxSeconds after inheritance.");
-	if ((conversation ? policy.instructions.length + JSON.stringify(ADDRESSEE_CRITERIA).length + 260 + 185 : policy.instructions.length + policy.criteria.observe.length + policy.criteria.reply.length) > 8e3) throw new RangeError("Group instructions and criteria must fit 8000 characters after inheritance.");
+	if ((conversation ? policy.instructions.length + JSON.stringify(ADDRESSEE_CRITERIA).length + 260 : policy.instructions.length + policy.criteria.observe.length + policy.criteria.reply.length) > 8e3) throw new RangeError("Group instructions and criteria must fit 8000 characters after inheritance.");
 	return policy;
 }
+const IGNORED_GROUP_SETTINGS = {
+	engagement: [
+		"idleMinutes",
+		"humanExchangeMinutes",
+		"humanQuestionMinutes",
+		"inferredMaxMinutes"
+	],
+	thresholds: [
+		"continuation",
+		"inferredContinuation",
+		"contested",
+		"ambient",
+		"humanExchange"
+	],
+	burst: ["quietSeconds", "maxSeconds"]
+};
+function withoutIgnored(value, ignored) {
+	return Object.fromEntries(Object.entries(value ?? {}).filter(([key]) => !ignored.includes(key)));
+}
+const IGNORED_SUFFIXES = Object.entries(IGNORED_GROUP_SETTINGS).flatMap(([section, keys]) => keys.map((key) => `${section}.${key}`));
+function ignoredGroupSetting(path) {
+	return IGNORED_SUFFIXES.includes(path.slice(-2).join("."));
+}
+function ignoredGroupSettings(value, prefix = []) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return ignoredGroupSetting(prefix) ? [prefix.join(".")] : [];
+	return Object.entries(value).flatMap(([key, child]) => ignoredGroupSettings(child, [...prefix, key]));
+}
+function authored(value, source) {
+	return Object.fromEntries(Object.entries(sources(value, source)).filter(([path]) => !ignoredGroupSetting(path.split("."))));
+}
 function sources(value, source, prefix = "") {
 	return Object.fromEntries(Object.entries(value).flatMap(([key, value]) => {
 		const path = prefix ? `${prefix}.${key}` : key;
@@ -122,7 +135,7 @@ function groupPolicy(input = {}, aliases) {
 			}, "platform"),
 			...aliases?.mode ? { mode: "channels.telegram.policy" } : {},
 			...aliases?.model ? { "smart.model": "models.decision" } : {},
-			...sources(input, "agent")
+			...authored(input, "agent")
 		}
 	};
 }
@@ -144,11 +157,6 @@ function overlaySmartPolicy(input, base) {
 			addresseeGate: inherited("engagement.addresseeGate") ? defaults.engagement.addresseeGate : base.smart.engagement.addresseeGate
 		},
 		thresholds: {
-			continuation: inherited("thresholds.continuation") ? defaults.thresholds.continuation : base.smart.thresholds.continuation,
-			inferredContinuation: inherited("thresholds.inferredContinuation") ? defaults.thresholds.inferredContinuation : base.smart.thresholds.inferredContinuation,
-			contested: inherited("thresholds.contested") ? defaults.thresholds.contested : base.smart.thresholds.contested,
-			ambient: inherited("thresholds.ambient") ? defaults.thresholds.ambient : base.smart.thresholds.ambient,
-			humanExchange: inherited("thresholds.humanExchange") ? defaults.thresholds.humanExchange : base.smart.thresholds.humanExchange,
 			engaged: inherited("thresholds.engaged") ? defaults.thresholds.engaged : base.smart.thresholds.engaged,
 			neutral: inherited("thresholds.neutral") ? defaults.thresholds.neutral : base.smart.thresholds.neutral,
 			humanThread: inherited("thresholds.humanThread") ? defaults.thresholds.humanThread : base.smart.thresholds.humanThread
@@ -169,11 +177,11 @@ function effectiveGroupPolicy(base, key) {
 		},
 		sources: {
 			...result.sources,
-			...sources(layer, "agent.chat")
+			...authored(layer, "agent.chat")
 		}
 	};
 	const thresholds = result.smart.thresholds;
 	if (thresholds.engaged > thresholds.neutral || thresholds.neutral > thresholds.humanThread) throw new RangeError("Group thresholds must satisfy engaged <= neutral <= humanThread after inheritance.");
 	return result;
 }
-export { DEFAULT_CRITERIA, DEFAULT_GROUP_POLICY, ENGAGED_CRITERIA, ENGAGED_INSTRUCTIONS, LEGACY_INSTRUCTIONS, effectiveGroupPolicy, groupPolicy, overlaySmartPolicy, smartPolicy };
+export { DEFAULT_CRITERIA, DEFAULT_GROUP_POLICY, ENGAGED_CRITERIA, ENGAGED_INSTRUCTIONS, IGNORED_GROUP_SETTINGS, LEGACY_INSTRUCTIONS, effectiveGroupPolicy, groupPolicy, ignoredGroupSetting, ignoredGroupSettings, overlaySmartPolicy, smartPolicy };

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

@@ -1,4 +1,3 @@
-import { type ConversationAnalysis } from "./conversation.js";
 import { type AddressingAnswers } from "./conversation-router.js";
 import { type GroupPolicy } from "./policy.js";
 import type { ObservedMessage, PendingConfirmation, RecentMessage } from "./messages.js";
@@ -9,7 +8,6 @@ export type Route = "observe" | "reply";
 /** What the decision model sees. */
 export interface RouteQuestion {
     readonly groups?: GroupPolicy;
-    readonly conversation?: ConversationAnalysis;
     readonly burstId?: string;
     readonly processingAt?: string;
     readonly messagesToClassify?: ReadonlyArray<ObservedMessage>;

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

@@ -6,8 +6,8 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { DEFAULT_GROUP_POLICY, groupPolicy, overlaySmartPolicy } from "./policy.mjs";
 import { addressingReason, otherRecipient, signalAudience } from "./signals.mjs";
-import { conversationState, conversationThreshold } from "./conversation.mjs";
-import { conversationDecisionRouter } from "./conversation-router.mjs";
+import { conversationAddressing } from "./addressing.mjs";
+import { addressedToAgent, conversationDecisionRouter } from "./conversation-router.mjs";
 import { recordRoutingMetric } from "./health.mjs";
 import { humanAddressee, humanThread, questionInvitation, restoreEngagement } from "./engagement.mjs";
 import { boundedRouterPayload, policyHash } from "./record.mjs";
@@ -300,25 +300,11 @@ async function routeMessage(input) {
 			groups,
 			signals
 		};
-		const analysis = conversationState({
-			signals,
-			recent: question.recent,
-			policy: groups,
-			agentNames: [...question.agentIdentity?.aliases ?? [], ...question.agentIdentity?.username ? [question.agentIdentity.username] : []],
-			pendingQuestionAt: input.pendingQuestionAt,
-			asOf: question.processingAt
-		});
-		question = {
-			...question,
-			conversation: analysis
-		};
+		const evidence = conversationAddressing(signals, question.recent, groups, [...question.agentIdentity?.aliases ?? [], ...question.agentIdentity?.username ? [question.agentIdentity.username] : []]);
 		payload = {
 			...payload,
 			burst_id: question.burstId,
-			path: analysis.path,
-			conversation: analysis.conversation,
-			human_exchange: analysis.human_exchange,
-			pending_question_voided: input.pendingQuestionAt !== void 0 && !analysis.pending_question_live,
+			addressing_evidence: evidence,
 			question: {
 				recent: question.recent,
 				pendingQuestions: question.pendingQuestions,
@@ -328,30 +314,22 @@ async function routeMessage(input) {
 				messagesToClassify: question.messagesToClassify
 			}
 		};
-		if (analysis.path === "A") {
+		if (evidence.agent_named || evidence.reply_to_agent && evidence.human_targets.length === 0 && evidence.soft_target === void 0) {
 			if (input.beforeDecide && !await input.beforeDecide(true)) return complete("observe", "admission_refused", "Admission refused before direct turn.");
 			return complete("reply", addressed && addressed !== "pending-question" ? addressed : "mention", "Agent explicitly addressed.");
 		}
-		if (analysis.path === "H") return complete("observe", "human_addressee", "Message addresses another participant; conversation and question invitation closed.");
+		if (evidence.human_targets.length > 0) return complete("observe", "human_addressee", "Message replies to, tags or names another participant.");
 		if (signals.addressing.eligible === false) return complete("observe", "channel_ineligible", "Channel excludes ambient messages.");
 		if (groups.mode === "mention") return complete("observe", "mention_policy", "Mention policy observes unaddressed messages.");
 		if (input.beforeDecide && !await input.beforeDecide()) return complete("observe", "admission_refused", "Admission refused before inference.");
 		const result = await input.decide(question);
 		const diagnostics = typeof result === "string" ? void 0 : result.diagnostics;
-		const probabilities = diagnostics?.addressing;
-		const threshold = conversationThreshold(analysis.path, groups);
-		const valid = probabilities !== void 0 && probabilities.addressee.choice === "agent" && (probabilities.addressee.probabilities?.agent ?? NaN) >= threshold && (probabilities.needs_response.probabilities?.true ?? NaN) >= (analysis.path === "B" || analysis.path === "X" ? .7 : .5) && (probabilities.ends_conversation.probabilities?.true ?? NaN) < .7;
+		const valid = addressedToAgent(diagnostics?.addressing);
 		payload = {
 			...payload,
-			...typeof result === "string" ? {} : result.router,
-			thresholds_applied: {
-				threshold,
-				path: analysis.path,
-				needs_response: analysis.path === "B" || analysis.path === "X" ? .7 : .5,
-				ends_conversation: .7
-			}
+			...typeof result === "string" ? {} : result.router
 		};
-		return complete(valid ? "reply" : "observe", `decision_model_${valid ? "reply" : "observe"}`, "Conversation addressing probabilities evaluated.", "decision-model", diagnostics);
+		return complete(valid ? "reply" : "observe", `decision_model_${valid ? "reply" : "observe"}`, "Addressee read from the chat's recent messages.", "decision-model", diagnostics);
 	} catch (error) {
 		console.error("[segmentstream] conversation routing failed", { error });
 		return complete("observe", error instanceof Error && error.name === "TimeoutError" ? "decision_model_timeout" : "decision_model_failed", "Conversation routing unavailable; observe fallback.");

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

@@ -34,15 +34,6 @@ function archivedRoutingMessages(events, limit = 30) {
 		"thread-with-agent",
 		"pending-question"
 	].includes(event.reason ?? "")).map((event) => [event.messageId, event.reason]));
-	const ended = new Set(events.filter((event) => {
-		if (event.kind !== "decision" || event.messageId === null) return false;
-		try {
-			const data = JSON.parse(event.argsSummary ?? "{}");
-			return data.router?.conversation_ended === true || data.routing?.conversationEnded === true;
-		} catch {
-			return false;
-		}
-	}).map((event) => event.messageId));
 	const admitted = new Set(events.flatMap((event) => event.kind === "decision" && event.reason === "turn_admitted" && event.messageId !== null ? [event.messageId] : []));
 	const membership = new Map();
 	for (const event of [...events].reverse()) {
@@ -80,7 +71,6 @@ function archivedRoutingMessages(events, limit = 30) {
 			invitation: metadata.invitation ?? invitations.get(event.messageId ?? ""),
 			...event.kind === "inbound" && admitted.has(event.messageId ?? "") ? { admitted: true } : {},
 			...images.length === 0 ? {} : { images },
-			...ended.has(event.messageId) ? { conversationEnded: true } : {},
 			author: event.senderName ?? event.senderId ?? "unknown sender",
 			...typeof metadata.author === "string" && event.kind === "inbound" ? { signedAuthor: metadata.author } : {},
 			text,

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

@@ -23,7 +23,7 @@ import { archivedRoutingMessages } from "../group-routing/routing-context.mjs";
 import { dispatchStructuredMessage, structuredMessage } from "./structured.mjs";
 import { scopedAddress } from "./sessions.mjs";
 import { handleWorkspaceCallback, isWorkspaceCallback } from "./callbacks.mjs";
-import { t as agentBuild } from "../../../_chunks/build-metadata-R_ssK2uR.mjs";
+import { t as agentBuild } from "../../../_chunks/build-metadata-DZs-ivRD.mjs";
 import { attachmentLifecycle } from "./lifecycle.mjs";
 import { gatewayImageDescriber } from "./images.mjs";
 import { gatewayAttachmentDescriber } from "./attachment-description.mjs";

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

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

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

@@ -29,7 +29,7 @@ export declare class InboundRequest {
     readonly agentDescription: () => Promise<string>;
     readonly agentName: () => Promise<string>;
     readonly traceId: `${string}-${string}-${string}-${string}-${string}`;
-    /** Conversation policy coalesces only the active caller; Eve queues other callers. */
+    /** Conversation policy steers the active caller's turn; Eve queues other callers. */
     turnPolicy: "queue" | "steer";
     edited: boolean;
     triggeringMessageId: string | undefined;

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

@@ -9,10 +9,9 @@ import { admitMessage, localizedText } from "../admission.mjs";
 import { d as telegramRuntimeSource, n as conversationLanguage, o as telegramPrincipal, u as runtimeEnvelope } from "../../../_chunks/principal-D99Lleae.mjs";
 import { p as reportTelegramError } from "../../../_chunks/inbound-request-D1r0FkDI.mjs";
 import { addressingReason, conversationKey, otherRecipient } from "../group-routing/signals.mjs";
-import { conversationAddressing, conversationState } from "../group-routing/conversation.mjs";
 import { questionInvitation } from "../group-routing/engagement.mjs";
 import { routeMessage } from "../group-routing/router.mjs";
-import { debounceBurst, routingBurst } from "../group-routing/burst.mjs";
+import { routingBurst } from "../group-routing/burst.mjs";
 import { WorkspaceActionAlreadyDispatched } from "./workspace-action.mjs";
 import { structuredMessage } from "./structured.mjs";
 import { formatAddress, messageAddress, scopedAddress } from "./sessions.mjs";
@@ -495,11 +494,6 @@ async function handleInboundMessage(input) {
 		model: dependencies.decisionModel
 	}), conversationKey(policySignals));
 	const conversationPolicy = group && groups.smart.engagement.policy === "conversation";
-	const agentAliases = [...groups.smart.engagement.agentAliases, ...[
-		bot?.username,
-		bot?.firstName,
-		bot?.displayName
-	].filter((n) => !!n)];
 	let conversationRecent = conversationPolicy ? await recentConversation() : [];
 	if (conversationPolicy && input.request && input.request.lifecycleKey === void 0 && input.request.structuredContext === void 0) {
 		address = topicAddress;
@@ -515,15 +509,6 @@ async function handleInboundMessage(input) {
 	});
 	const questionAge = Date.parse(sentAt(sent)) - Date.parse(asked?.meta.at ?? "");
 	if (answering && addressed === void 0 && !questionInvitation(asked?.meta.at, sentAt(sent), groups.smart.engagement.openQuestionMinutes)) answering = false;
-	if (conversationPolicy && answering) {
-		if (!conversationState({
-			signals: policySignals,
-			recent: conversationRecent,
-			policy: groups,
-			agentNames: agentAliases,
-			pendingQuestionAt: asked?.meta.at
-		}).pending_question_live) answering = false;
-	}
 	const recipientAnswer = !conversationPolicy && answering && (groups.smart.engagement.policy === "engaged" || questionAge >= 0 && questionAge <= groups.smart.engagement.followUpMinutes * 6e4) && audience.replyTo?.kind === "bot" && isRecipientAnswer(audience);
 	if (!conversationPolicy && answering && pending !== void 0 && input.request !== void 0) {
 		address = pending.address || (questionSession === void 0 ? topicAddress : memberQuestionAddress);
@@ -635,7 +620,6 @@ async function handleInboundMessage(input) {
 		};
 		return question;
 	};
-	let burstId;
 	if (conversationPolicy && input.request?.lifecycleKey === void 0 && input.request?.structuredContext === void 0) {
 		if (voice !== void 0) await transcribeVoice(true);
 		const routingSignals = {
@@ -645,26 +629,7 @@ async function handleInboundMessage(input) {
 				text
 			}
 		};
-		const evidence = conversationAddressing(routingSignals, conversationRecent, groups, agentAliases);
-		if (!evidence.agent_named && !evidence.reply_to_agent && evidence.human_targets.length === 0) {
-			await recordContent({
-				text,
-				decoded
-			});
-			const refreshed = await debounceBurst({
-				signals: routingSignals,
-				policy: groups,
-				read: freshConversation
-			});
-			conversationRecent = refreshed.recent;
-			question = void 0;
-			if (refreshed.burst.superseded) {
-				recordGateDecision("burst_superseded");
-				return null;
-			}
-		}
 		const burst = routingBurst(routingSignals, conversationRecent, groups);
-		burstId = burst.id;
 		const q = await conversation();
 		question = {
 			...q,
@@ -1063,32 +1028,6 @@ async function handleInboundMessage(input) {
 			chatGuidance: guidance
 		}
 	};
-	if (conversationPolicy && input.request?.lifecycleKey === void 0 && input.request?.structuredContext === void 0) principal = {
-		...principal,
-		attributes: {
-			...principal.attributes,
-			groupRouting: JSON.stringify({
-				policy: {
-					...groups,
-					chats: {}
-				},
-				signals: {
-					...policySignals,
-					message: {
-						...policySignals.message,
-						text
-					}
-				},
-				agent: question?.agent.slice(0, 600) ?? "",
-				agentIdentity: question?.agentIdentity,
-				chat: question?.chat,
-				burst_id: burstId ?? routingBurst(policySignals, conversationRecent, groups).id,
-				message: question?.message,
-				pendingQuestions: question?.pendingQuestions,
-				pendingQuestionAt: asked?.meta.at
-			})
-		}
-	};
 	return {
 		auth: answering && pending !== void 0 ? {
 			...principal,

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

@@ -10,7 +10,7 @@ import { n as currentInboundRequest } from "../../../_chunks/inbound-request-D1r
 import { member } from "../actor.mjs";
 import { needsConfirmation } from "../confirmations.mjs";
 import { OntologyActionNotPermitted, actionToolName, ontologyTools } from "../ontology-tools.mjs";
-import { t as agentBuild } from "../../../_chunks/build-metadata-R_ssK2uR.mjs";
+import { t as agentBuild } from "../../../_chunks/build-metadata-DZs-ivRD.mjs";
 var AttachmentLifecycleNotPermitted = class extends Error {
 	code = "attachment_lifecycle_not_permitted";
 };