@segmentstream/agent 0.27.0 → 0.28.0

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

@@ -29,10 +29,6 @@ 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;
@@ -44,11 +40,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 +58,19 @@ export interface GroupPolicy {
     readonly sources: Readonly<Record<string, string>>;
 }
 export declare function smartPolicy(input?: SmartPolicyInput, base?: SmartPolicy): SmartPolicy;
+/**
+ * Settings of the former conversation state machine (timers and per-state thresholds). They are
+ * still accepted so that existing configurations deploy, and are ignored: the classifier reads the
+ * chat's recent messages instead.
+ */
+export declare const IGNORED_GROUP_SETTINGS: {
+    readonly engagement: readonly ["idleMinutes", "humanExchangeMinutes", "humanQuestionMinutes", "inferredMaxMinutes"];
+    readonly thresholds: readonly ["continuation", "inferredContinuation", "contested", "ambient", "humanExchange"];
+};
+/** 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,7 +59,7 @@ function smartPolicy(input = {}, base) {
 				openQuestionMinutes: engaged ? 30 : "unlimited",
 				addresseeGate: engaged
 			} : {},
-			...input.engagement,
+			...withoutIgnored(input.engagement, IGNORED_GROUP_SETTINGS.engagement),
 			burst: {
 				quietSeconds: 6,
 				maxSeconds: 15,
@@ -76,25 +72,44 @@ function smartPolicy(input = {}, base) {
 			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"
+	]
+};
+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 +137,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 +159,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 +179,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-CMmCRD8l.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-CMmCRD8l.mjs";
 import { GET } from "eve/channels";
 const HEALTH_ROUTE = "/eve/v1/telegram/health";
 function healthRoute(input) {

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

@@ -9,7 +9,7 @@ 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 { conversationAddressing } from "../group-routing/addressing.mjs";
 import { questionInvitation } from "../group-routing/engagement.mjs";
 import { routeMessage } from "../group-routing/router.mjs";
 import { debounceBurst, routingBurst } from "../group-routing/burst.mjs";
@@ -515,15 +515,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);

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-CMmCRD8l.mjs";
 var AttachmentLifecycleNotPermitted = class extends Error {
 	code = "attachment_lifecycle_not_permitted";
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segmentstream/agent",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "description": "Mount a SegmentStream workspace's agent on eve: the ontology as tools, acting as the member who writes, and Telegram through the workspace's connection.",
   "license": "Apache-2.0",
   "author": "SegmentStream",

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

@@ -1,46 +0,0 @@
-import type { GroupPolicy } from "./policy.js";
-import type { GroupMessageSignals } from "./signals.js";
-import type { RecentMessage } from "./messages.js";
-export type ConversationPath = "A" | "H" | "C" | "Ci" | "C2" | "B" | "X";
-export interface ConversationState {
-    status: "active" | "closed" | "none";
-    opened_by: "explicit" | "agent_initiated" | "inferred" | null;
-    opened_at?: string;
-    last_exchange_at?: string;
-    last_p_at?: string;
-    contested: boolean;
-    closed_reason?: "turned_to_human" | "idle" | "ended" | "inferred_expired";
-}
-export interface ConversationAnalysis {
-    readonly path: ConversationPath;
-    readonly conversation: ConversationState;
-    readonly human_targets: ReadonlyArray<string>;
-    readonly human_exchange: {
-        readonly active: boolean;
-        readonly with: ReadonlyArray<string>;
-        readonly evidence: ReadonlyArray<string>;
-    };
-    readonly other_live_agent_conversations: ReadonlyArray<string>;
-    readonly pending_question_live: boolean;
-}
-/** Workspace names are data. Only leading/trailing vocatives count as an address. */
-export declare function vocatives(text: string): ReadonlyArray<string>;
-export interface AddressEvidence {
-    readonly agent_named: boolean;
-    readonly reply_to_agent: boolean;
-    readonly human_targets: ReadonlyArray<string>;
-    readonly soft_target?: string;
-}
-export declare function conversationAddressing(signals: GroupMessageSignals, recent: ReadonlyArray<RecentMessage>, policy: GroupPolicy, agentNames?: ReadonlyArray<string>): AddressEvidence;
-export declare function recordedMessageSignals(m: RecentMessage, current: GroupMessageSignals): GroupMessageSignals;
-/** Restore bounded state from received messages and confirmed delivery facts, including unpaired humans. */
-export declare function conversationState(input: {
-    readonly signals: GroupMessageSignals;
-    readonly recent: ReadonlyArray<RecentMessage>;
-    readonly policy: GroupPolicy;
-    readonly agentNames?: ReadonlyArray<string>;
-    readonly pendingQuestionAt?: string;
-    /** Dequeued inputs use the current turn boundary without changing provider timestamps. */
-    readonly asOf?: string;
-}): ConversationAnalysis;
-export declare const conversationThreshold: (path: ConversationPath, policy: GroupPolicy) => number;

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

@@ -1,269 +0,0 @@
-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 norm = (s) => s.normalize("NFKC").toLowerCase().replace(/^@/, "");
-const stamp = (s) => Date.parse(/[zZ]|[+-]\d\d:\d\d$/.test(s) ? s : s + "Z");
-function vocatives(text) {
-	return [/^[\s«"“'([]*(@?[\p{L}\p{N}_-]{2,})(?=[\s,!:;?.»"”')\]]|$)/u.exec(text)?.[1], /,\s*([\p{L}\p{N}_-]{2,})\s*[?!.)»"”]*\s*$/u.exec(text)?.[1]].filter((s) => s !== void 0).map(norm);
-}
-function identities(participants, recent) {
-	const names = new Map();
-	for (const [id, p] of Object.entries(participants)) for (const a of [id, ...p.aliases]) names.set(norm(a), id);
-	for (const m of recent) {
-		if (own(m)) continue;
-		const id = names.get(norm(m.authorId ?? m.username ?? m.author)) ?? m.authorId ?? m.username ?? m.author;
-		for (const a of [
-			m.authorId,
-			m.username,
-			m.author,
-			m.author.split(/\s/u)[0]
-		]) if (a) names.set(norm(a), id);
-	}
-	return (name) => names.get(norm(name)) ?? norm(name);
-}
-function conversationAddressing(signals, recent, policy, agentNames = []) {
-	const canonical = identities(policy.participants, recent);
-	const sender = canonical(signals.sender.externalId);
-	const agents = new Set([...agentNames, ...policy.smart.engagement.agentAliases].map(norm));
-	const names = vocatives(signals.derived?.transcript ?? signals.message.text);
-	const mentions = [...signals.addressing.mentions, ...Array.from(signals.message.text.matchAll(/(?:^|[^\p{L}\p{N}_])@([A-Za-z0-9_]+)/gu), (m) => ({
-		username: m[1],
-		kind: "unknown"
-	}))];
-	const punctuated = /^[\s«"“'([]*(@?[\p{L}\p{N}_-]{2,})\s*(?:[,!:?]|$)/u.exec(signals.derived?.transcript ?? signals.message.text)?.[1];
-	const trailing = /,\s*([\p{L}\p{N}_-]{2,})\s*[?!.)»"”]*\s*$/u.exec(signals.derived?.transcript ?? signals.message.text)?.[1];
-	const named = signals.addressing.agentMentioned || signals.addressing.command || [punctuated, trailing].some((n) => n !== void 0 && agents.has(norm(n))) || mentions.some((m) => m.kind === "bot" || agents.has(norm(m.username ?? m.externalId ?? "")));
-	const humans = new Set();
-	const terminalMention = /@([A-Za-z0-9_]+)\s*[.!?]*\s*$/u.exec(signals.message.text)?.[1];
-	const replyToAgent = signals.addressing.replyTo?.author === "agent" || signals.addressing.threadWithAgent === true;
-	let soft;
-	for (const m of mentions) if (m.kind !== "bot" && !agents.has(norm(m.username ?? m.externalId ?? ""))) {
-		const target = canonical(m.externalId ?? m.username ?? "unknown");
-		if (replyToAgent && m.type !== "text_mention" && m.username !== void 0 && !names.some((name) => canonical(name) === target) && (terminalMention === void 0 || canonical(terminalMention) !== target)) soft = target;
-		else humans.add(target);
-	}
-	const known = new Set([...Object.keys(policy.participants), ...recent.filter((m) => !own(m)).map((m) => canonical(m.authorId ?? m.username ?? m.author))]);
-	for (const name of names) {
-		const id = canonical(name);
-		if (known.has(id) && id !== sender && !agents.has(name)) humans.add(id);
-	}
-	const reply = signals.addressing.replyTo;
-	if (reply && reply.author !== "agent" && !reply.self) {
-		const parent = recent.find((m) => m.messageId === reply.messageId);
-		const id = canonical(reply.authorExternalId ?? reply.authorUsername ?? parent?.authorId ?? parent?.username ?? reply.authorName ?? "unknown");
-		if (id !== sender) {
-			const upload = reply.hasAttachments || (parent?.attachmentKinds?.length ?? 0) > 0;
-			const parentTargetsSender = parent !== void 0 && ((parent.taggedUsers ?? []).some((m) => canonical(m.id ?? m.username ?? "") === sender) || vocatives(parent.text).some((n) => canonical(n) === sender));
-			if (upload && !parentTargetsSender && reply.author !== "other_bot") soft = id;
-			else humans.add(id);
-		}
-	}
-	return {
-		agent_named: named,
-		reply_to_agent: replyToAgent,
-		human_targets: [...humans],
-		...soft ? { soft_target: soft } : {}
-	};
-}
-function recordedMessageSignals(m, current) {
-	return {
-		...current,
-		derived: void 0,
-		sender: {
-			externalId: m.authorId ?? m.username ?? m.author,
-			username: m.username,
-			displayName: m.author,
-			kind: m.kind ?? "human"
-		},
-		message: {
-			...current.message,
-			id: m.messageId ?? "",
-			at: m.at,
-			text: m.text,
-			attachments: [],
-			hasCaption: m.hasCaption ?? false
-		},
-		addressing: {
-			agentMentioned: m.invitation === "mention" || (m.taggedUsers?.some((t) => t.kind === "bot") ?? false),
-			command: m.invitation === "command",
-			threadWithAgent: m.invitation === "thread-with-agent",
-			mentions: (m.taggedUsers ?? []).map((t) => ({
-				type: t.type,
-				externalId: t.id,
-				username: t.username,
-				kind: t.kind
-			})),
-			...m.replyTo ? { replyTo: {
-				messageId: m.replyTo.messageId,
-				author: m.replyTo.kind === "bot" ? "agent" : m.replyTo.kind,
-				authorExternalId: m.replyTo.id,
-				authorUsername: m.replyTo.username
-			} } : {}
-		}
-	};
-}
-function conversationState(input) {
-	const { signals, policy } = input;
-	const now = stamp(input.asOf ?? signals.message.at);
-	const settings = policy.smart.engagement;
-	const recent = input.recent.filter((m) => m.messageId !== signals.message.id && stamp(m.at) <= now).slice().sort((a, b) => stamp(a.at) - stamp(b.at));
-	const current = {
-		author: signals.sender.displayName ?? signals.sender.externalId,
-		authorId: signals.sender.externalId,
-		username: signals.sender.username,
-		at: signals.message.at,
-		text: signals.derived?.transcript ?? signals.message.text,
-		messageId: signals.message.id,
-		kind: signals.sender.kind
-	};
-	const canonical = identities(policy.participants, [...recent, current]);
-	const states = new Map();
-	const edges = [];
-	let lastAgent = -Infinity;
-	const humanSinceAgent = [];
-	const open = (person, by, at) => states.set(person, {
-		status: "active",
-		opened_by: by,
-		opened_at: at,
-		last_exchange_at: at,
-		last_p_at: by === "agent_initiated" ? void 0 : at,
-		contested: false
-	});
-	const expire = (state, t) => {
-		if (state?.status !== "active") return;
-		if (t - stamp(state.last_exchange_at) > settings.idleMinutes * 6e4) {
-			state.status = "closed";
-			state.closed_reason = "idle";
-		} else if (state.opened_by === "inferred" && t - stamp(state.opened_at) > settings.inferredMaxMinutes * 6e4) {
-			state.status = "closed";
-			state.closed_reason = "inferred_expired";
-		}
-	};
-	const human = (m, s, isCurrent) => {
-		const t = stamp(isCurrent ? input.asOf ?? m.at : m.at), person = canonical(s.sender.externalId);
-		const evidence = conversationAddressing(s, recent, policy, input.agentNames);
-		for (const target of evidence.human_targets) {
-			edges.push({
-				at: t,
-				from: person,
-				to: target
-			});
-			const targetState = states.get(target);
-			if (targetState?.status === "active") targetState.contested = true;
-		}
-		if (evidence.soft_target) edges.push({
-			at: t,
-			from: person,
-			to: evidence.soft_target
-		});
-		for (const [other, state] of states) {
-			expire(state, t);
-			if (other !== person && state.status === "active" && evidence.human_targets.length === 0 && !evidence.agent_named && t > stamp(state.last_p_at ?? state.opened_at)) state.contested = true;
-		}
-		let state = states.get(person);
-		expire(state, t);
-		const wasActive = state?.status === "active";
-		const explicit = evidence.agent_named || evidence.reply_to_agent && evidence.human_targets.length === 0 && evidence.soft_target === void 0;
-		let path;
-		if (explicit) {
-			path = "A";
-			open(person, "explicit", m.at);
-			state = states.get(person);
-		} else if (evidence.human_targets.length) {
-			path = "H";
-			if (state?.status === "active") {
-				state.status = "closed";
-				state.closed_reason = "turned_to_human";
-			}
-		} else if (state?.status === "active") path = state.contested || evidence.soft_target ? "C2" : state.opened_by === "inferred" ? "Ci" : "C";
-		else path = "B";
-		const humanEdges = edges.filter((e) => t - e.at >= 0 && t - e.at <= settings.humanExchangeMinutes * 6e4 && (e.from === person || e.to === person));
-		const questions = edges.filter((e) => e.to === person && t - e.at <= settings.humanQuestionMinutes * 6e4 && lastAgent < e.at);
-		const others = [...states].filter(([p, c]) => p !== person && c.status === "active" && t - stamp(c.last_p_at ?? c.opened_at) <= 12e4).map(([p]) => p);
-		const sequence = [...humanSinceAgent.filter((x) => t - x.at <= settings.humanExchangeMinutes * 6e4).map((x) => x.who), person];
-		const switches = sequence.slice(1).filter((p, i) => p !== sequence[i] && (p === person || sequence[i] === person)).length;
-		const exchange = humanEdges.length > 0 || questions.length > 0 || switches >= 2 || others.length > 0;
-		if (path === "B" && exchange) path = "X";
-		if (!isCurrent) {
-			if (m.conversationEnded && state) {
-				state.status = "closed";
-				state.closed_reason = "ended";
-			}
-			if (state?.status === "active" && [
-				"A",
-				"C",
-				"Ci",
-				"C2"
-			].includes(path)) state.last_p_at = m.at;
-			humanSinceAgent.push({
-				at: t,
-				who: person
-			});
-		}
-		return {
-			path,
-			conversation: { ...state ?? {
-				status: "none",
-				opened_by: null,
-				contested: false
-			} },
-			human_targets: evidence.human_targets,
-			human_exchange: {
-				active: state?.status !== "active" && exchange,
-				with: [...new Set([...humanEdges, ...questions].flatMap((e) => [e.from, e.to]).filter((p) => p !== person))],
-				evidence: [
-					...humanEdges.length ? ["recent_human_address"] : [],
-					...questions.length ? ["human_question"] : [],
-					...switches >= 2 ? ["human_alternation"] : [],
-					...others.length ? ["other_live_agent_conversation"] : []
-				]
-			},
-			other_live_agent_conversations: others,
-			pending_question_live: wasActive && state?.status === "active" && evidence.human_targets.length === 0 && input.pendingQuestionAt !== void 0 && t - stamp(input.pendingQuestionAt) >= 0 && (settings.openQuestionMinutes === "unlimited" || t - stamp(input.pendingQuestionAt) <= settings.openQuestionMinutes * 6e4)
-		};
-	};
-	for (const m of recent) {
-		if (!own(m)) {
-			if (m.kind === "bot" || m.kind === "other_bot") continue;
-			human(m, recordedMessageSignals(m, signals), false);
-			continue;
-		}
-		if (m.confirmation) continue;
-		lastAgent = stamp(m.at);
-		humanSinceAgent.length = 0;
-		const parent = recent.find((p) => !own(p) && p.messageId === m.replyTo?.messageId);
-		const targets = new Set([...m.addressedTo.map((p) => canonical(p.id ?? p.username ?? p.author)), ...parent ? [canonical(parent.authorId ?? parent.username ?? parent.author)] : []]);
-		const named = conversationAddressing(recordedMessageSignals({
-			...m,
-			role: void 0
-		}, signals), recent, policy, input.agentNames).human_targets;
-		for (const target of named) targets.add(target);
-		for (const target of targets) {
-			const state = states.get(target);
-			expire(state, stamp(m.at));
-			if (state?.status === "active") state.last_exchange_at = m.at;
-			else open(target, parent || m.inReplyTo ? "inferred" : "agent_initiated", m.at);
-		}
-	}
-	return human(current, input.asOf === void 0 ? signals : {
-		...signals,
-		message: {
-			...signals.message,
-			at: input.asOf
-		}
-	}, true);
-}
-const conversationThreshold = (path, policy) => ({
-	A: 0,
-	H: 1,
-	C: policy.smart.thresholds.continuation,
-	Ci: policy.smart.thresholds.inferredContinuation,
-	C2: policy.smart.thresholds.contested,
-	B: policy.smart.thresholds.ambient,
-	X: policy.smart.thresholds.humanExchange
-})[path];
-export { conversationAddressing, conversationState, conversationThreshold, recordedMessageSignals, vocatives };