@segmentstream/agent 0.26.1 → 0.28.0

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

@@ -32,192 +32,5 @@ function scopedAddress(address, scope) {
 		conversationId: ""
 	});
 }
-function localParts(timezone, date) {
-	const parts = new Intl.DateTimeFormat("en-US", {
-		timeZone: timezone,
-		hourCycle: "h23",
-		year: "numeric",
-		month: "2-digit",
-		day: "2-digit",
-		hour: "2-digit",
-		minute: "2-digit",
-		second: "2-digit"
-	}).formatToParts(date);
-	const value = (type) => Number(parts.find((part) => part.type === type)?.value ?? "0");
-	return {
-		year: value("year"),
-		month: value("month"),
-		day: value("day"),
-		hour: value("hour"),
-		minute: value("minute"),
-		second: value("second")
-	};
-}
-function offsetMinutes(timezone, date) {
-	const local = localParts(timezone, date);
-	const asUtc = Date.UTC(local.year, local.month - 1, local.day, local.hour, local.minute, local.second);
-	return Math.round((asUtc - date.getTime()) / 6e4);
-}
-function instantOf(timezone, local) {
-	const guess = Date.UTC(local.year, local.month - 1, local.day, local.hour, local.minute);
-	const first = new Date(guess - offsetMinutes(timezone, new Date(guess)) * 6e4);
-	const second = new Date(guess - offsetMinutes(timezone, first) * 6e4);
-	const back = localParts(timezone, second);
-	if (back.hour !== local.hour || back.minute !== local.minute) return first > second ? first : second;
-	return second;
-}
-function compactBoundary(now, compactAt, timezone) {
-	const [hour = 0, minute = 0] = compactAt.split(":").map(Number);
-	const today = localParts(timezone, now);
-	const candidate = instantOf(timezone, {
-		...today,
-		hour,
-		minute
-	});
-	if (candidate.getTime() <= now.getTime()) return candidate;
-	const yesterday = new Date(Date.UTC(today.year, today.month - 1, today.day - 1));
-	return instantOf(timezone, {
-		year: yesterday.getUTCFullYear(),
-		month: yesterday.getUTCMonth() + 1,
-		day: yesterday.getUTCDate(),
-		hour,
-		minute
-	});
-}
 const HISTORY_TAIL = 400;
-function historyOf(events) {
-	let lastAt = 0;
-	let resetAt = 0;
-	let earliest = 0;
-	let marked = false;
-	let turnsSinceReset = 0;
-	for (const event of events) {
-		const at = Date.parse(event.meta.at);
-		if (Number.isNaN(at)) continue;
-		lastAt = Math.max(lastAt, at);
-		earliest = earliest === 0 ? at : Math.min(earliest, at);
-		if (event.type === "session.started" || event.type === "context.settled" && typeof event.data === "object" && event.data !== null && "outcome" in event.data && event.data.outcome === "completed") {
-			resetAt = at;
-			marked = true;
-			turnsSinceReset = 0;
-		} else if (event.type === "turn.settled") turnsSinceReset += 1;
-	}
-	return {
-		lastAt,
-		resetAt: marked ? resetAt : earliest,
-		turnsSinceReset
-	};
-}
-const EVIDENCE_OVERLAP_MS = 6e4;
-function evidenceSince(events) {
-	const members = new Set();
-	let since;
-	for (const event of events) {
-		const data = typeof event.data === "object" && event.data !== null ? event.data : {};
-		if (event.type === "session.started" || event.type === "context.settled" && data.outcome === "completed") {
-			members.clear();
-			since = void 0;
-		}
-		if (event.type === "delivery.admitted" && typeof data.deliveryId === "string") {
-			const principal = data.principal;
-			const source = data.source;
-			if (typeof principal?.id === "string" && principal.id.startsWith("telegram:") && source?.scheduleId === void 0) members.add(data.deliveryId);
-		}
-		const at = Date.parse(event.meta.at);
-		if (event.type === "delivery.consumed" && members.has(String(data.deliveryId)) && Array.isArray(data.parts) && data.parts.length > 0 && !Number.isNaN(at)) since = at - EVIDENCE_OVERLAP_MS;
-	}
-	return since;
-}
-const MAXIMUM_REMEMBERED = 500;
-function sessionPolicy(input) {
-	const remembered = new Map();
-	const log = input.log ?? ((message, error) => console.warn(message, error));
-	function remember(address, history) {
-		remembered.delete(address);
-		remembered.set(address, history);
-		if (remembered.size > MAXIMUM_REMEMBERED) {
-			const oldest = remembered.keys().next();
-			if (oldest.done !== true) remembered.delete(oldest.value);
-		}
-	}
-	async function history(address, operations, fresh = false) {
-		const known = fresh ? void 0 : remembered.get(address);
-		if (known !== void 0) return known;
-		const session = await operations.resolveSession(address);
-		if (session === void 0) {
-			remembered.delete(address);
-			return;
-		}
-		const read = historyOf(await input.read(session.id));
-		remember(address, read);
-		return read;
-	}
-	function due(known, settings, now, activeAt) {
-		const idle = settings.idleResetHours;
-		const lastAt = Math.max(known.lastAt, activeAt);
-		if (idle !== false && now.getTime() - lastAt >= idle * 36e5) return "clear";
-		if (settings.compactAt !== false) {
-			const boundary = compactBoundary(now, settings.compactAt, settings.timezone).getTime();
-			if (known.resetAt < boundary && known.turnsSinceReset > 0) return "compact";
-		}
-		return "none";
-	}
-	return {
-		async apply({ address, operations, activeAt = 0, now = new Date() }) {
-			const settings = input.settings();
-			const cached = remembered.has(address);
-			let known;
-			try {
-				known = await history(address, operations);
-			} catch (error) {
-				log("The session policy could not read the session's history; delivering as is.", error);
-				return "none";
-			}
-			if (known === void 0) return "none";
-			let action = due(known, settings, now, activeAt);
-			if (action !== "none" && cached) {
-				try {
-					known = await history(address, operations, true);
-				} catch (error) {
-					log("The session policy could not re-read the session's history; delivering as is.", error);
-					return "none";
-				}
-				if (known === void 0) return "none";
-				action = due(known, settings, now, activeAt);
-			}
-			if (action === "clear") try {
-				if ((await (await operations.from(address).clear()).result()).outcome !== "applied") {
-					remembered.delete(address);
-					return "none";
-				}
-				remember(address, {
-					lastAt: known.lastAt,
-					resetAt: now.getTime(),
-					turnsSinceReset: 0
-				});
-				return "cleared";
-			} catch (error) {
-				log("The idle reset could not clear the session; delivering as is.", error);
-				return "none";
-			}
-			if (action === "compact") try {
-				await operations.from(address).compact();
-				remembered.delete(address);
-				return "compacted";
-			} catch (error) {
-				log("The daily compaction could not be queued; delivering as is.", error);
-			}
-			return "none";
-		},
-		delivered(address, now = new Date()) {
-			const known = remembered.get(address);
-			if (known === void 0) return;
-			remember(address, {
-				lastAt: now.getTime(),
-				resetAt: known.resetAt,
-				turnsSinceReset: known.turnsSinceReset + 1
-			});
-		}
-	};
-}
-export { HISTORY_TAIL, compactBoundary, evidenceSince, formatAddress, historyOf, messageAddress, parseAddress, scopedAddress, sessionPolicy };
+export { HISTORY_TAIL, formatAddress, messageAddress, parseAddress, scopedAddress };

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

@@ -5,7 +5,7 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { messageAudience } from "./audience.mjs";
-import { messageMetadata } from "./observed.mjs";
+import { messageMetadata } from "./message-metadata.mjs";
 function telegramSignals(message, bot, settings) {
 	const audience = messageAudience(message, bot);
 	const meta = messageMetadata(message, bot);

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

@@ -1,5 +1,4 @@
 import type { TelegramChannelEvents } from "eve/channels/telegram";
-import { type ObservedMessages } from "./observed.js";
 export declare function isSilentReply(text: string): boolean;
 /** Use the same classification for delivery and its archive decision. Never strip real prose. */
 export declare function completionKind(message: string | null | undefined, finishReason?: string): "reply" | "tool_calls" | "empty" | "whitespace" | "silent_marker";
@@ -25,11 +24,11 @@ export interface InterimMessages {
 /**
  * The channel's final reply: formatted and split before Eve's plain-text splitter, with one
  * queue slot for the whole reply. Explicit silence markers have no delivery. Tool-call steps have
- * none either unless `interim` is enabled: then their text is delivered exactly like a reply, but
- * not remembered for group routing, which counts only final replies, as its recovery from the
- * session stream does. A text already delivered as an interim message in the same turn, whether
- * a repeat or the final reply, is not delivered again.
+ * none either unless `interim` is enabled: then their text is delivered exactly like a reply. The
+ * conversation archive records every delivery for routing and chat context. A text already
+ * delivered as an interim message in the same turn, whether a repeat or the final reply, is not
+ * delivered again.
  */
-export declare function replyDelivery(observed?: ObservedMessages, scope?: () => string, interim?: InterimMessages): MessageCompleted;
+export declare function replyDelivery(scope?: () => string, interim?: InterimMessages): MessageCompleted;
 export declare const deliverUnlessSilent: MessageCompleted;
 export {};

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

@@ -4,12 +4,10 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
-import "../../../_chunks/principal-D99Lleae.mjs";
 import { confirmationLocale } from "./confirmation-text.mjs";
 import { splitTelegramText } from "./format.mjs";
 import { inTelegramSendQueue } from "./send-queue.mjs";
 import { a as TelegramDeliveryError, l as customerMessage, o as currentLocale, p as reportTelegramError } from "../../../_chunks/inbound-request-D1r0FkDI.mjs";
-import { agentMessage, observedChatKey } from "../group-routing/observed.mjs";
 const SILENT_MARKERS = new Set(["[silent]", "no_reply"]);
 function isSilentReply(text) {
 	return SILENT_MARKERS.has(text.trim().toLowerCase());
@@ -36,7 +34,7 @@ function interimTexts(limit = 256) {
 		}
 	};
 }
-function replyDelivery(observed, scope = () => "telegram", interim) {
+function replyDelivery(scope = () => "telegram", interim) {
 	return async (event, context) => {
 		if (event.data.kind !== "text" || event.data.interrupted) return;
 		const channel = context.channel;
@@ -49,13 +47,12 @@ function replyDelivery(observed, scope = () => "telegram", interim) {
 		const key = textValue.trim();
 		if (turn !== void 0 && interim.delivered.has(turn, key)) return;
 		const message = customerMessage(textValue, confirmationLocale(context.session?.auth.current ?? null, currentLocale()));
-		const principal = context.session?.auth.current;
-		const replyTo = principal?.attributes.replyToMessageId;
+		const replyTo = (context.session?.auth.current)?.attributes.replyToMessageId;
 		const replyParameters = typeof replyTo === "string" && /^[1-9]\d*$/u.test(replyTo) ? { reply_parameters: {
 			message_id: Number(replyTo),
 			allow_sending_without_reply: true
 		} } : {};
-		const deliveredIds = await inTelegramSendQueue(scope(), channel.telegram.chatId, async () => {
+		await inTelegramSendQueue(scope(), channel.telegram.chatId, async () => {
 			const messageIds = [];
 			try {
 				for (const part of splitTelegramText(message)) {
@@ -72,31 +69,7 @@ function replyDelivery(observed, scope = () => "telegram", interim) {
 			}
 			return messageIds;
 		});
-		const text = message.text;
-		if (isInterim) {
-			if (turn !== void 0) interim.delivered.add(turn, key);
-			return;
-		}
-		if (observed === void 0 || channel.telegram.chatType === "private") return;
-		const sender = principal?.authenticator === "segmentstream-telegram" ? principal.subject : void 0;
-		const username = principal?.attributes.username;
-		const name = principal?.attributes.memberName;
-		const author = typeof name === "string" ? name : typeof username === "string" ? `@${username}` : sender;
-		const inReplyTo = sender === void 0 || author === void 0 ? void 0 : {
-			id: sender,
-			author,
-			...typeof username === "string" ? { username } : {}
-		};
-		const chat = observedChatKey({
-			chatId: channel.telegram.chatId,
-			...channel.telegram.messageThreadId === void 0 ? {} : { messageThreadId: channel.telegram.messageThreadId }
-		});
-		observed.remember(chat, agentMessage({
-			text,
-			at: new Date().toISOString(),
-			messageId: String(deliveredIds.at(-1)),
-			...inReplyTo === void 0 ? {} : { inReplyTo }
-		}));
+		if (isInterim && turn !== void 0) interim.delivered.add(turn, key);
 	};
 }
 const deliverUnlessSilent = replyDelivery();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segmentstream/agent",
-  "version": "0.26.1",
+  "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 "./observed.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 };