@rivus/gateway 0.18.0 → 0.18.1

package/dist/bootstrap/pi-feishu.js

@@ -1,10 +1,11 @@
 import { S as deepFreeze$1, _ as loadMergedLocalEnvFile, a as createRivusModelManagementSocketServer, d as gatewayPackageDirectory, h as loadRivusDeploymentManifest, i as RIVUS_RELEASE_DESCRIPTOR, n as disposeRuntimeCacheEntries, o as createRivusModelManagementFailure, p as gatewaySkillsDirectory, r as invokeRuntimeControl, t as createRuntimeCache, v as resolveFeishuEndpointCredentials } from "../chunks/runtime-cache.js";
 import { t as createBackgroundSessionToolContracts } from "../chunks/background-session-authority.js";
+import { a as openTerminalBindingsStore, c as classifyFeishuCardOwnership, d as parseFeishuTerminalMessage, i as openTerminalMessageClaims, l as createFeishuTerminalDelivery, n as embeddedHerdrRouteSchema, o as terminalAgentSchema, s as createHerdrSocketClient, t as createHerdrFeishuBridgeRuntime, u as parseFeishuTerminalAction } from "../chunks/herdr-feishu-runtime.js";
 import { createRandomId, createSha256Digest, createStableId } from "@rivus/platform/identity";
 import { ATTACHMENT_RECOVERY_COMMAND, AgentEventHandlerFailed, AgentEventSinkFailed, AgentLoopFailed, AgentRunCancelled, ModelChangeBoundaryDeadlineError, RivusToolInputRejected, ToolExecutorInputRejected, ToolInvocationDenied, createAgentHarness, createAgentsMdInstructionsSource, createInvocationAuthority, createJsonlAgentEventLog, createLangfuseAgentTelemetry, createMemoryService, createProjectMemoryPromptPreparer, createRecoveryAction, createRivusMemoryToolDescriptor, createRunAdmission, createTelemetryContentRedactor, createToolBroker, createToolInputDigest, createWorkspaceInstructionsResolver, createWorkspaceRootHandle, normalizeAgentInvocation, openJsonlAgentMemoryRepository, openJsonlToolOperationLedger, remainingUntil, resolveInvocationAuthority, resolveLangfuseTelemetryConfig, restoreAgentHistory } from "@rivus/runtime";
 import { homedir, tmpdir } from "node:os";
 import { delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { Cause, Deferred, Effect, Exit, Fiber, Result, Semaphore } from "effect";
+import { Cause, Deferred, Effect, Exit, Fiber, Result, Schema, Semaphore } from "effect";
 import { access, appendFile, chmod, constants, lstat, mkdir, open, readFile, readdir, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
 import { appendJsonlRecord, isRecord, loadJsonlSnapshotStore, readPersistenceFile, writeAtomicTextFile, writePersistenceFile } from "@rivus/platform/persistence";
@@ -12909,6 +12910,982 @@ function settleCleanup(steps) {
 	});
 }
 //#endregion
+//#region src/adapters/feishu/inbound-delivery/jsonl-inbound-delivery-store.ts
+function openJsonlInboundDeliveryStore(options) {
+	const codecOptions = {
+		...options.acceptLegacySameAttemptClaims === void 0 ? {} : { acceptLegacySameAttemptClaims: options.acceptLegacySameAttemptClaims },
+		label: options.label ?? "Inbound Delivery",
+		payload: options.payload
+	};
+	return Effect.gen(function* () {
+		const raw = yield* Effect.tryPromise({
+			try: () => readPersistenceFile(options.filePath),
+			catch: (cause) => cause
+		});
+		return createInMemoryDurableQueueStore({
+			initial: yield* Effect.try({
+				try: () => decodeInboundDeliverySnapshots(raw, codecOptions),
+				catch: (cause) => cause
+			}),
+			persist: (delivery) => appendInboundDeliverySnapshot(options.filePath, delivery)
+		});
+	});
+}
+function decodeInboundDeliverySnapshots(raw, options) {
+	if (raw === void 0) return [];
+	const latest = /* @__PURE__ */ new Map();
+	for (const [index, line] of raw.split("\n").entries()) {
+		if (line.trim().length === 0) continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(line);
+		} catch {
+			throw new Error(`invalid ${options.label} snapshot at line ${index + 1}`);
+		}
+		if (!isEnvelope(parsed)) throw new Error(`invalid ${options.label} snapshot at line ${index + 1}`);
+		let delivery;
+		try {
+			delivery = decodeDelivery(parsed.delivery, options.payload);
+		} catch {
+			throw new Error(`invalid ${options.label} snapshot at line ${index + 1}`);
+		}
+		const previous = latest.get(delivery.id);
+		if (delivery.revision !== (previous?.revision ?? 0) + 1) throw new Error(`invalid ${options.label} revision at line ${index + 1}`);
+		try {
+			if (previous) {
+				if (!isValidPersistedTransition(previous, delivery, options.acceptLegacySameAttemptClaims ?? false)) throw new Error("transition");
+			} else assertNewInboundDelivery(delivery);
+		} catch {
+			throw new Error(`invalid ${options.label} transition at line ${index + 1}`);
+		}
+		latest.set(delivery.id, delivery);
+	}
+	return [...latest.values()];
+}
+function encodeInboundDeliverySnapshot(delivery) {
+	const snapshot = readInboundDeliverySnapshot(delivery);
+	const persisted = {
+		acceptedAt: snapshot.acceptedAt,
+		attempts: snapshot.attempts,
+		id: snapshot.id,
+		laneKey: snapshot.laneKey,
+		...snapshot.metadata === void 0 ? {} : { options: snapshot.metadata },
+		payload: snapshot.payload,
+		...snapshot.recovery === void 0 ? {} : { recovery: snapshot.recovery },
+		revision: snapshot.revision,
+		state: snapshot.state
+	};
+	return JSON.stringify({
+		delivery: persisted,
+		version: 1
+	});
+}
+function decodeDelivery(value, payloadCodec) {
+	if (!isRecord(value) || typeof value.acceptedAt !== "string" || typeof value.attempts !== "number" || typeof value.id !== "string" || typeof value.laneKey !== "string" || typeof value.revision !== "number") throw new Error("invalid Inbound Delivery snapshot");
+	const metadata = payloadCodec.decodeMetadata(value.options);
+	return readInboundDeliverySnapshot({
+		acceptedAt: value.acceptedAt,
+		attempts: value.attempts,
+		id: value.id,
+		laneKey: value.laneKey,
+		...metadata === void 0 ? {} : { metadata },
+		payload: payloadCodec.decodePayload(value.payload),
+		...value.recovery === void 0 ? {} : { recovery: value.recovery },
+		revision: value.revision,
+		state: value.state
+	});
+}
+function isEnvelope(value) {
+	return isRecord(value) && value.version === 1 && "delivery" in value;
+}
+function isValidPersistedTransition(previous, next, acceptLegacySameAttemptClaims) {
+	if (isValidInboundDeliveryTransition(previous, next)) return true;
+	if (!acceptLegacySameAttemptClaims || previous.state.status !== "pending" || next.state.status !== "leased" || next.attempts !== previous.attempts) return false;
+	return isValidInboundDeliveryTransition(previous, {
+		...next,
+		attempts: next.attempts + 1
+	});
+}
+function appendInboundDeliverySnapshot(filePath, delivery) {
+	return Effect.tryPromise({
+		try: async () => {
+			await mkdir(dirname(filePath), { recursive: true });
+			await appendFile(filePath, `${encodeInboundDeliverySnapshot(delivery)}\n`, "utf8");
+		},
+		catch: (cause) => cause
+	});
+}
+//#endregion
+//#region src/adapters/feishu/routing/feishu-conversation-router.ts
+const CAPACITY_REFUSAL = "队列已满，请用新消息重发；本条未提交。";
+const UNSUPPORTED_TYPE_REFUSAL = "会话模式暂不支持该消息类型。";
+/**
+* Single-entry Feishu conversation router: every message and callback is fenced
+* by the durable owner ledger before any destination runs, and the mode capture
+* plus owner admission share one bridge admission turn.
+*/
+function createFeishuConversationRouter(options) {
+	const mode = options.bridge.conversation?.mode;
+	const allowed = (identity) => options.actors.includes(identity.actorId) && options.chats.includes(identity.chatId);
+	const freeze = (reason, messageId) => Effect.sync(() => {
+		mode?.freeze();
+		options.onObservation?.({
+			...messageId === void 0 ? {} : { messageId },
+			type: "route_frozen"
+		});
+		console.error(`Herdr route frozen: ${reason}`);
+	});
+	const freezeVerdict = (reason, messageId) => Effect.gen(function* () {
+		yield* freeze(reason, messageId);
+		return { kind: "frozen" };
+	});
+	/**
+	* Refusals for owner uncertainty use a stable internal claim key: claiming the
+	* original id would fabricate a Herdr fence that conflicts with a durable Pi
+	* owner after restart, so the original owner identity stays untouched.
+	*/
+	const refusalClaimId = (identity) => `route-refusal:${JSON.stringify([options.appId, identity.messageId])}`;
+	const refusalMessage = (identity) => ({
+		id: refusalClaimId(identity),
+		actorId: identity.actorId,
+		chatId: identity.chatId,
+		sentAt: identity.sentAt,
+		text: ""
+	});
+	/** One admission turn: legacy fences → owner lookup → capture → durable owner → admit captured. */
+	const admitSequence = (input) => Effect.gen(function* () {
+		const { identity } = input;
+		const legacy = yield* options.legacyOwnerOf(identity.messageId);
+		if (legacy === "conflict") return yield* freezeVerdict("legacy Pi inbox and Herdr claim conflict", identity.messageId);
+		const lookup = yield* Effect.result(options.ledger.lookup(identity.messageId));
+		if (Result.isFailure(lookup)) return yield* freezeVerdict("owner ledger lookup failed", identity.messageId);
+		if (lookup.success.kind === "opaque-fence") return yield* freezeVerdict("owner record is an opaque fence", identity.messageId);
+		if (lookup.success.kind === "record") {
+			const record = lookup.success.record;
+			if (record.actorId !== identity.actorId || record.chatId !== identity.chatId) return yield* freezeVerdict("owner record does not match the incoming message source", identity.messageId);
+			if (legacy === "pi" && record.decision === "herdr" || legacy === "herdr" && record.decision === "pi") return yield* freezeVerdict("historical fence and owner record disagree", identity.messageId);
+			options.onObservation?.({
+				messageId: identity.messageId,
+				type: "route_skipped"
+			});
+			return record.decision === "pi" ? { kind: "pi" } : { kind: "skip" };
+		}
+		if (legacy === "herdr") {
+			options.onObservation?.({
+				messageId: identity.messageId,
+				type: "route_skipped"
+			});
+			return { kind: "skip" };
+		}
+		let captured;
+		let unsupportedType = false;
+		if (input.parsed) captured = options.bridge.captureInAdmission(input.parsed);
+		else if (legacy === "none" && mode?.isFrozen() && allowed(identity)) return { kind: "frozen" };
+		else if (legacy === "none" && mode?.stateOf(identity.actorId, identity.chatId)) unsupportedType = true;
+		const decision = legacy === "pi" || !unsupportedType && (captured === void 0 || captured.route.kind === "pass-through") ? "pi" : "herdr";
+		const record = {
+			appId: options.appId,
+			messageId: identity.messageId,
+			decision,
+			actorId: identity.actorId,
+			chatId: identity.chatId,
+			at: Date.now(),
+			...decision === "herdr" && captured?.route.kind === "locked-send" ? { target: captured.route.agent } : {}
+		};
+		const admitted = yield* Effect.result(options.ledger.admit(record));
+		if (Result.isFailure(admitted)) return yield* freezeVerdict("owner admission failed", identity.messageId);
+		if (admitted.success.kind === "existing-opaque") return yield* freezeVerdict("owner admission found an opaque fence", identity.messageId);
+		if (admitted.success.kind === "existing") {
+			const existing = admitted.success.record;
+			if (legacy === "pi" && existing.decision === "herdr") return yield* freezeVerdict("historical fence and owner record disagree", identity.messageId);
+			options.onObservation?.({
+				messageId: identity.messageId,
+				type: "route_skipped"
+			});
+			return existing.decision === "pi" ? { kind: "pi" } : { kind: "skip" };
+		}
+		if (decision === "pi") return { kind: "pi" };
+		if (unsupportedType || captured === void 0) return {
+			kind: "unsupported-type",
+			chatId: identity.chatId
+		};
+		const outcome = yield* Effect.result(options.bridge.admitCapturedInAdmission(captured));
+		if (Result.isFailure(outcome)) return yield* freezeVerdict("herdr event admission failed", identity.messageId);
+		return {
+			kind: "herdr",
+			entry: {
+				message: captured.message,
+				outcome: outcome.success
+			}
+		};
+	});
+	/**
+	* Runs the sequence inside one admission turn and publishes the shared freeze
+	* for every full cause BEFORE the permit is released, so already queued work
+	* and later captures observe the exact flag.
+	*/
+	const admitInAdmission = (input) => options.bridge.withAdmission(Effect.gen(function* () {
+		const exit = yield* Effect.exit(admitSequence(input));
+		if (Exit.isFailure(exit)) return yield* freezeVerdict("admission sequence failed", input.identity.messageId);
+		return exit.value;
+	}));
+	/**
+	* Owner uncertainty freezes; the visible refusal is admitted in a separate,
+	* non-nested turn via the bridge's own frozen-refusal capture, so freshness,
+	* authorization and the event claim stay with existing semantics. Delivery
+	* happens only outside admission through the tracked reply lane. A failing
+	* refusal claim keeps the freeze and reports a diagnostic: there is no
+	* direct undeduped chat fallback and no destination retry.
+	*/
+	const deliverOwnerUncertainRefusal = async (identity) => {
+		let outcome;
+		try {
+			outcome = await Effect.runPromise(options.bridge.withAdmission(Effect.gen(function* () {
+				const captured = options.bridge.captureInAdmission(refusalMessage(identity));
+				return yield* options.bridge.admitCapturedInAdmission(captured);
+			})));
+		} catch {
+			outcome = void 0;
+		}
+		if (outcome !== void 0 && outcome.kind === "done" && outcome.result.kind === "reply") {
+			await options.target.reply(identity.chatId, outcome.result.reply.text);
+			return true;
+		}
+		options.onObservation?.({
+			messageId: identity.messageId,
+			type: "refusal_undelivered"
+		});
+		console.error(`Herdr owner-uncertain refusal not delivered for ${identity.messageId}`);
+		return false;
+	};
+	const route = async (identity, parsed) => {
+		let verdict;
+		try {
+			verdict = await Effect.runPromise(admitInAdmission({
+				identity,
+				parsed
+			}));
+		} catch {
+			verdict = { kind: "frozen" };
+		}
+		switch (verdict.kind) {
+			case "pi": return { kind: "pi" };
+			case "skip": return { kind: "skip" };
+			case "frozen":
+				await deliverOwnerUncertainRefusal(identity);
+				return { kind: "frozen" };
+			case "unsupported-type":
+				await options.target.reply(verdict.chatId, UNSUPPORTED_TYPE_REFUSAL);
+				return { kind: "consumed" };
+			case "herdr":
+				if (!await options.target.execute(verdict.entry)) await options.target.reply(verdict.entry.message.chatId, CAPACITY_REFUSAL);
+				return { kind: "consumed" };
+		}
+	};
+	const routeAwaited = async (identity, parsed) => {
+		if (options.target.runAdmission === void 0) return route(identity, parsed);
+		const admission = await options.target.runAdmission(() => route(identity, parsed));
+		if (admission.kind === "stopped") throw new Error("Herdr intake is stopped; event not admitted");
+		return admission.value;
+	};
+	const acceptedResult = (messageId) => ({
+		accepted: true,
+		messageId,
+		pending: 0
+	});
+	const skippedResult = (messageId) => ({
+		accepted: false,
+		messageId,
+		pending: 0,
+		reason: "duplicate"
+	});
+	const refusedResult = (messageId) => ({
+		accepted: false,
+		messageId,
+		pending: 0,
+		reason: "ignored"
+	});
+	const deadCardResponse = () => ({ toast: {
+		content: "This card cannot be handled; run /herdr again for a fresh one.",
+		i18n: {
+			en_us: "This card cannot be handled; run /herdr again for a fresh one.",
+			zh_cn: "此卡片已失效或无法识别；请重新执行 /herdr 获取新卡片。"
+		},
+		type: "error"
+	} });
+	const notReceivedCardResponse = () => ({ toast: {
+		content: "The intake is full; this click was not received. Try again in a moment.",
+		i18n: {
+			en_us: "The intake is full; this click was not received. Try again in a moment.",
+			zh_cn: "处理通道已满，本次点击未接收；请稍后重试。"
+		},
+		type: "error"
+	} });
+	const frozenCardResponse = () => ({ toast: {
+		content: "Routing is paused; this click was not executed.",
+		i18n: {
+			en_us: "Routing is paused; this click was not executed.",
+			zh_cn: "会话路由已暂停；本次点击未执行。"
+		},
+		type: "warning"
+	} });
+	const receivedCardResponse = () => ({ toast: {
+		content: "Received; the result arrives as a chat reply.",
+		i18n: {
+			en_us: "Received; the result arrives as a chat reply.",
+			zh_cn: "已接收，结果将以会话回复送达。"
+		},
+		type: "info"
+	} });
+	const duplicateCardResponse = () => ({ toast: {
+		content: "Already handled",
+		i18n: {
+			en_us: "Already handled",
+			zh_cn: "该操作已处理过"
+		},
+		type: "info"
+	} });
+	const piCardErrorResponse = () => ({ toast: {
+		content: "Card action failed",
+		i18n: {
+			en_us: "Card action failed",
+			zh_cn: "卡片操作失败"
+		},
+		type: "error"
+	} });
+	return {
+		/**
+		* Message entry for the merged dispatcher table. Decides ownership before
+		* any destination; the original Pi handler runs only for Pi-owned events.
+		*/
+		routeMessage: (piReceive) => async (payload) => {
+			const normalized = normalizeReceiveMessagePayload(payload);
+			if (!shouldAcceptFeishuEndpointMessage(normalized, options.groupPolicy, options.botOpenId)) return piReceive(payload);
+			const identity = readMessageIdentity(normalized.event);
+			if (!identity) return piReceive(payload);
+			const parsed = parseFeishuTerminalMessage(normalized.event);
+			switch ((await routeAwaited(identity, parsed)).kind) {
+				case "pi": return piReceive(payload);
+				case "skip": return skippedResult(identity.messageId);
+				case "frozen": return refusedResult(identity.messageId);
+				case "consumed": return acceptedResult(identity.messageId);
+			}
+		},
+		/**
+		* Card callback entry: ownership comes only from explicit markers. Pi cards
+		* always reach the original handler, in every mode and while frozen.
+		*/
+		routeCardAction: (piCardAction) => async (event) => {
+			const ownership = classifyFeishuCardOwnership(event);
+			if (ownership === "pi") {
+				if (!piCardAction) return piCardErrorResponse();
+				return piCardAction(event);
+			}
+			if (ownership !== "herdr") return deadCardResponse();
+			const message = parseFeishuTerminalAction(event, {});
+			if (!message) return deadCardResponse();
+			const identity = {
+				actorId: message.actorId,
+				chatId: message.chatId,
+				messageId: message.id,
+				messageType: "text",
+				sentAt: message.sentAt
+			};
+			if (options.target.scheduleAdmission !== void 0) {
+				const scheduled = await options.target.scheduleAdmission(() => route(identity, message).then(() => void 0));
+				if (scheduled === "accepted") return receivedCardResponse();
+				if (scheduled === "full") return notReceivedCardResponse();
+				return frozenCardResponse();
+			}
+			switch ((await route(identity, message)).kind) {
+				case "pi": return piCardAction ? piCardAction(event) : piCardErrorResponse();
+				case "skip": return duplicateCardResponse();
+				case "frozen": return frozenCardResponse();
+				case "consumed": return receivedCardResponse();
+			}
+		},
+		/** Bot menu events are Herdr-owned by their configured event_key. */
+		routeMenuEvent: async (event, menuChats) => {
+			const message = parseFeishuTerminalAction(event, menuChats);
+			if (!message) return;
+			await routeAwaited({
+				actorId: message.actorId,
+				chatId: message.chatId,
+				messageId: message.id,
+				messageType: "text",
+				sentAt: message.sentAt
+			}, message);
+		}
+	};
+}
+/**
+* Wraps the endpoint's real event dispatcher: Pi handlers stay under their own
+* keys, the three routed keys are replaced once, every other key is preserved,
+* and the underlying `register` return value reaches the WebSocket start
+* unchanged.
+*/
+function createRoutedFeishuEventDispatcher(inner, route, menuChats) {
+	return { register: (handlers) => {
+		const merged = {
+			...handlers,
+			"im.message.receive_v1": (payload) => route.message(handlers["im.message.receive_v1"])(payload),
+			"card.action.trigger": (payload) => route.card(handlers["card.action.trigger"])(payload),
+			"application.bot.menu_v6": (payload) => route.menu(payload, menuChats)
+		};
+		return inner.register(merged);
+	} };
+}
+/** Normalized event shape: {message, sender} at the top level. */
+const messageIdentitySchema = Schema.Struct({
+	message: Schema.optional(Schema.Struct({
+		chat_id: Schema.optional(Schema.String),
+		message_id: Schema.optional(Schema.String),
+		message_type: Schema.optional(Schema.String),
+		create_time: Schema.optional(Schema.String)
+	})),
+	sender: Schema.optional(Schema.Struct({ sender_id: Schema.optional(Schema.Struct({ open_id: Schema.optional(Schema.String) })) }))
+});
+const decodeMessageIdentity = Schema.decodeUnknownSync(messageIdentitySchema);
+/** Builds the gateway owner record identity from a normalized event payload. */
+function readMessageIdentity(event) {
+	let decoded;
+	try {
+		decoded = decodeMessageIdentity(event);
+	} catch {
+		return;
+	}
+	const message = decoded.message;
+	const messageId = message?.message_id;
+	const chatId = message?.chat_id;
+	const actorId = decoded.sender?.sender_id?.open_id;
+	if (!messageId || !chatId || !actorId) return;
+	return {
+		actorId,
+		chatId,
+		messageId,
+		messageType: message?.message_type ?? "",
+		sentAt: Number(message?.create_time)
+	};
+}
+//#endregion
+//#region src/adapters/outbound/persistence/message-gateway/file-route-admission-ledger.ts
+const admissionRecordSchema = Schema.Struct({
+	version: Schema.Literal(1),
+	appId: Schema.String,
+	messageId: Schema.String,
+	decision: Schema.Literals(["pi", "herdr"]),
+	actorId: Schema.String,
+	chatId: Schema.String,
+	at: Schema.Number,
+	target: Schema.optional(terminalAgentSchema)
+});
+const decodeAdmissionRecord = Schema.decodeUnknownSync(admissionRecordSchema);
+const isErrnoCode$1 = Schema.Struct({ code: Schema.String });
+/** Admissions and state directories reject any group/other permission or symlink. */
+function assertPrivateDirectory$1(info, label) {
+	if (info.isSymbolicLink() || !info.isDirectory()) throw new Error(`${label} is not a regular directory`);
+	if (info.uid !== process.getuid?.() || (info.mode & 63) !== 0) throw new Error(`Unsafe ${label} permissions or owner`);
+}
+function assertPrivateOwnerFile(info) {
+	if (info.isSymbolicLink() || !info.isFile()) throw new Error("Route admission owner is not a regular file");
+	if (info.uid !== process.getuid?.() || (info.mode & 127) !== 0) throw new Error("Unsafe route admission owner permissions or owner");
+}
+/**
+* Create the final-level admissions child inside an already-provisioned state
+* root (the shared claims opener owns the root) and sync the root entry durably.
+* A missing root is a startup failure with guidance — never an ancestor walk.
+*/
+async function createPrivateChildDirectory(path, mode, label, stateRoot) {
+	try {
+		await mkdir(path, {
+			recursive: false,
+			mode
+		});
+	} catch (error) {
+		if (Schema.is(isErrnoCode$1)(error) && error.code === "ENOENT") throw new Error(`Cannot create ${label}: the state directory ${stateRoot} does not exist; open the shared claims store first`);
+		if (!(Schema.is(isErrnoCode$1)(error) && error.code === "EEXIST")) throw error;
+	}
+	assertPrivateDirectory$1(await lstat(path), label);
+}
+async function syncDirectoryEntry(path) {
+	const handle = await open(path, "r");
+	try {
+		await handle.sync();
+	} finally {
+		await handle.close();
+	}
+}
+async function syncStateDirectory(path, label) {
+	try {
+		await syncDirectoryEntry(path);
+	} catch (error) {
+		throw new Error(`Cannot sync ${label}`, { cause: error });
+	}
+}
+/**
+* File-backed cross-route admission ledger (one irrevocable owner file per
+* appId/messageId).
+*
+* Lock ownership: the caller must already hold the shared state-directory lifetime
+* lock (`openTerminalMessageClaims`) for this directory and keep it for the
+* store's lifetime; this factory never acquires or releases a lock itself and
+* never opens a connection. Crash recovery is manual: lock files and
+* owner files are preserved; a lock is removed only after its owner is verified
+* stopped, never by PID/age-based theft.
+*/
+async function openFileRouteAdmissionLedger(directory, appId) {
+	const admissionsDirectory = join(directory, "route-admissions");
+	await createPrivateChildDirectory(admissionsDirectory, 448, "route admission directory", directory);
+	await syncStateDirectory(directory, "state directory");
+	const ownerPath = (messageId) => join(admissionsDirectory, `${createHash("sha256").update(JSON.stringify([appId, messageId])).digest("hex")}.json`);
+	const syncAdmissionsDirectory = async () => {
+		const handle = await open(admissionsDirectory, "r");
+		try {
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+	};
+	const safeStatOwner = async (messageId) => {
+		const path = ownerPath(messageId);
+		assertPrivateOwnerFile(await lstat(path));
+		return path;
+	};
+	const decodeOwner = (raw, messageId) => {
+		let parsed;
+		try {
+			parsed = JSON.parse(raw);
+		} catch {
+			return { kind: "opaque-fence" };
+		}
+		let record;
+		try {
+			const validated = decodeAdmissionRecord(parsed);
+			record = {
+				appId: validated.appId,
+				messageId: validated.messageId,
+				decision: validated.decision,
+				actorId: validated.actorId,
+				chatId: validated.chatId,
+				at: validated.at,
+				...validated.target === void 0 ? {} : { target: validated.target }
+			};
+		} catch {
+			return { kind: "opaque-fence" };
+		}
+		if (record.appId !== appId || record.messageId !== messageId) throw new Error("Route admission owner belongs to another app or event");
+		return {
+			kind: "record",
+			record
+		};
+	};
+	/**
+	* One safe flow for lookup and EEXIST: an existing owner is stat-validated
+	* first (unsafe files fail before being read or synced); only a valid complete
+	* record is re-synchronized (owner file, admissions directory, closes) before
+	* it is returned, because visibility alone is not durable proof. Partial or
+	* corrupt owners return their opaque fence immediately; failures propagate —
+	* once an owner has been observed by lstat, even ENOENT on the read or during
+	* recovery is a failure, never a downgrade to missing.
+	*/
+	/** Shared read/decode/fsync/finally-close plus admissions-dir resync for an already stat-validated owner. */
+	const readAndSyncOwner = async (validatedPath, messageId) => {
+		const lookup = decodeOwner(await readFile(validatedPath, "utf8"), messageId);
+		if (lookup.kind !== "record") return lookup;
+		const handle = await open(validatedPath, "r+");
+		try {
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+		await syncAdmissionsDirectory();
+		return lookup;
+	};
+	const loadExisting = async (messageId) => {
+		const path = await safeStatOwner(messageId);
+		return readAndSyncOwner(path, messageId);
+	};
+	return {
+		lookup: (messageId) => Effect.uninterruptible(Effect.tryPromise({
+			try: async () => {
+				let path;
+				try {
+					path = await safeStatOwner(messageId);
+				} catch (error) {
+					if (Schema.is(isErrnoCode$1)(error) && error.code === "ENOENT") return { kind: "missing" };
+					throw error;
+				}
+				return await readAndSyncOwner(path, messageId);
+			},
+			catch: (error) => error
+		})),
+		admit: (input) => Effect.uninterruptible(Effect.tryPromise({
+			try: async () => {
+				const record = decodeAdmissionRecord({
+					...input,
+					version: 1
+				});
+				if (record.appId !== appId) throw new Error("Route admission record belongs to another app");
+				if (record.decision === "pi" && record.target !== void 0) throw new Error("A pi route admission never carries a Herdr target");
+				const path = ownerPath(record.messageId);
+				let handle;
+				try {
+					handle = await open(path, "wx", 384);
+				} catch (error) {
+					if (Schema.is(isErrnoCode$1)(error) && error.code === "EEXIST") {
+						const lookup = await loadExisting(record.messageId);
+						return lookup.kind === "record" ? {
+							kind: "existing",
+							record: lookup.record
+						} : { kind: "existing-opaque" };
+					}
+					throw error;
+				}
+				try {
+					await handle.writeFile(JSON.stringify({
+						...record,
+						version: 1
+					}), "utf8");
+					await handle.sync();
+					await syncAdmissionsDirectory();
+				} catch (error) {
+					await handle.close().catch(() => void 0);
+					throw error;
+				}
+				await handle.close();
+				return {
+					kind: "created",
+					record
+				};
+			},
+			catch: (error) => error
+		}))
+	};
+}
+//#endregion
+//#region src/adapters/outbound/persistence/terminal-session/terminal-conversation-states.ts
+const modeStateSchema = Schema.Union([Schema.Struct({
+	kind: Schema.Literal("selection"),
+	actorId: Schema.String,
+	chatId: Schema.String,
+	since: Schema.Number
+}), Schema.Struct({
+	kind: Schema.Literal("locked"),
+	actorId: Schema.String,
+	chatId: Schema.String,
+	since: Schema.Number,
+	handle: Schema.String,
+	agent: terminalAgentSchema,
+	stale: Schema.Boolean
+})]);
+const snapshotSchema = Schema.Struct({
+	version: Schema.Literal(1),
+	appId: Schema.String,
+	states: Schema.Array(modeStateSchema)
+});
+const decodeSnapshot = Schema.decodeUnknownSync(snapshotSchema);
+const isErrnoCode = Schema.Struct({ code: Schema.String });
+function assertStateCollection(states) {
+	if (states.length > 64) throw new Error("Conversation state snapshot exceeds capacity");
+	if (new Set(states.map((state) => `${state.actorId}\u0000${state.chatId}`)).size !== states.length) throw new Error("Conversation state snapshot contains duplicate conversations");
+}
+function assertPrivateDirectory(info) {
+	if (info.isSymbolicLink() || !info.isDirectory()) throw new Error("Conversation state directory is not a regular directory");
+	if (info.uid !== process.getuid?.() || (info.mode & 63) !== 0) throw new Error("Unsafe conversation state directory permissions or owner");
+}
+function assertPrivateFile(info, label) {
+	if (info.isSymbolicLink() || !info.isFile()) throw new Error(`${label} is not a regular file`);
+	if (info.uid !== process.getuid?.() || (info.mode & 127) !== 0) throw new Error(`Unsafe ${label} permissions or owner`);
+}
+/**
+* Versioned per-app conversation mode snapshot (selection/locked states) with a
+* durable initialization marker.
+*
+* Lock ownership: the caller must already hold the shared state-directory lifetime
+* lock (`openTerminalMessageClaims`) for this directory and keep it for the
+* store's lifetime; this factory never acquires a lock, releases one, or opens a
+* connection. Crash recovery is manual: an interrupted
+* initialization or a snapshot missing after initialization refuses startup
+* (fail closed) instead of erasing modes; an operator removes a stale lock only
+* after the previous owner is verified stopped.
+*/
+async function openTerminalConversationStates(directory, appId) {
+	assertPrivateDirectory(await lstat(directory));
+	const digest = createHash("sha256").update(appId).digest("hex");
+	const snapshotPath = join(directory, `conversation-states-${digest}.json`);
+	const markerPath = join(directory, `.conversation-states-initialized-${digest}`);
+	const safeFile = async (path, label) => {
+		const info = await lstat(path);
+		if (!info.isFile()) throw new Error(`${label} is not a regular file`);
+		assertPrivateFile(info, label);
+	};
+	const readStates = async () => {
+		await safeFile(snapshotPath, "Conversation state snapshot");
+		let snapshot;
+		try {
+			snapshot = decodeSnapshot(JSON.parse(await readFile(snapshotPath, "utf8")));
+		} catch (error) {
+			throw new Error("Cannot restore conversation states", { cause: error });
+		}
+		if (snapshot.appId !== appId) throw new Error("Conversation state snapshot belongs to another app");
+		const states = snapshot.states;
+		assertStateCollection(states);
+		return states;
+	};
+	const durableSyncDirectory = async () => {
+		const handle = await open(directory, "r");
+		try {
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+	};
+	const createMarker = async () => {
+		const marker = await open(markerPath, "wx", 384);
+		try {
+			await marker.writeFile(JSON.stringify({
+				version: 1,
+				appId
+			}));
+			await marker.sync();
+			await durableSyncDirectory();
+			await marker.close();
+		} catch (error) {
+			await marker.close().catch(() => void 0);
+			throw error;
+		}
+	};
+	const markerStat = await lstat(markerPath).catch((error) => {
+		if (Schema.is(isErrnoCode)(error) && error.code === "ENOENT") return;
+		throw error;
+	});
+	if (markerStat !== void 0) {
+		if (!markerStat.isFile()) throw new Error("Conversation state initialization marker is not a regular file");
+		assertPrivateFile(markerStat, "Conversation state initialization marker");
+	}
+	const snapshotStat = await lstat(snapshotPath).catch((error) => {
+		if (Schema.is(isErrnoCode)(error) && error.code === "ENOENT") return;
+		throw error;
+	});
+	let initial;
+	if (markerStat === void 0 && snapshotStat === void 0) {
+		await createMarker();
+		initial = [];
+		await writeAtomicTextFile(snapshotPath, JSON.stringify({
+			version: 1,
+			appId,
+			states: []
+		}), {
+			mode: 384,
+			durable: true
+		});
+	} else {
+		if (markerStat === void 0) throw new Error("Conversation state initialization is ambiguous; refusing startup");
+		if (snapshotStat === void 0) throw new Error("Conversation state snapshot is missing after initialization");
+		initial = await readStates();
+		await writeAtomicTextFile(snapshotPath, JSON.stringify({
+			version: 1,
+			appId,
+			states: initial
+		}), {
+			mode: 384,
+			durable: true
+		});
+	}
+	return {
+		initial,
+		save: (states) => Effect.uninterruptible(Effect.tryPromise({
+			try: async () => {
+				assertStateCollection(states);
+				const validated = decodeSnapshot({
+					version: 1,
+					appId,
+					states
+				});
+				await writeAtomicTextFile(snapshotPath, JSON.stringify({
+					version: 1,
+					appId,
+					states: validated.states
+				}), {
+					mode: 384,
+					durable: true
+				});
+			},
+			catch: (error) => error
+		}))
+	};
+}
+//#endregion
+//#region src/bootstrap/feishu/embedded-herdr-route.ts
+const herdrRouteConfigSchema = embeddedHerdrRouteSchema;
+/**
+* Parses RIVUS_HERDR_ROUTE_CONFIG and fails the assembly unless exactly one
+* enabled endpoint resolves to the configured appId. A missing variable keeps
+* the deployment entirely on the Pi path.
+*/
+async function resolveHerdrRouteConfig(env, manifest) {
+	const configPath = env.RIVUS_HERDR_ROUTE_CONFIG?.trim();
+	if (!configPath) return;
+	if (!isAbsolute(configPath)) throw new Error(`RIVUS_HERDR_ROUTE_CONFIG must be an absolute path: ${configPath}`);
+	let config;
+	try {
+		const raw = await readFile(configPath, "utf8");
+		config = Schema.decodeUnknownSync(herdrRouteConfigSchema)(JSON.parse(raw));
+	} catch (error) {
+		throw new Error(`Invalid RIVUS_HERDR_ROUTE_CONFIG at ${configPath}`, { cause: error });
+	}
+	if ((config.sessions?.length ?? 0) > 0 === (config.discoverSessionsIn !== void 0)) throw new Error("RIVUS_HERDR_ROUTE_CONFIG requires exactly one of sessions or discoverSessionsIn");
+	for (const [actor, chat] of Object.entries(config.menuChats ?? {})) if (!config.allowedActors.includes(actor) || !config.allowedChats.includes(chat)) throw new Error("Herdr route menu destinations must be allowlisted");
+	const matched = manifest.endpoints.filter((endpoint) => {
+		if (!endpoint.enabled) return false;
+		try {
+			return resolveFeishuEndpointCredentials(endpoint.credentialRef, env).appId === config.appId;
+		} catch {
+			return false;
+		}
+	});
+	if (matched.length !== 1) throw new Error(`RIVUS_HERDR_ROUTE_CONFIG appId must match exactly one enabled endpoint (matched ${matched.length})`);
+	return {
+		appId: config.appId,
+		endpointId: matched[0].id,
+		allowedActors: config.allowedActors,
+		allowedChats: config.allowedChats,
+		stateDirectory: config.stateDirectory,
+		writable: config.writable === true,
+		...config.sessions === void 0 ? {} : { sessions: config.sessions },
+		...config.discoverSessionsIn === void 0 ? {} : { discoverSessionsIn: config.discoverSessionsIn },
+		...config.menuChats === void 0 ? {} : { menuChats: config.menuChats },
+		...config.fontFiles === void 0 ? {} : { fontFiles: config.fontFiles }
+	};
+}
+/**
+* Startup-built pre-upgrade Pi fence: the same inbox file decoded with the same
+* codec the live store uses, reduced to received ids of any status. Corruption
+* fails the endpoint assembly before any WebSocket starts.
+*/
+async function buildLegacyPiInboxIndex(filePath) {
+	const deliveries = decodeInboundDeliverySnapshots(await readPersistenceFile(filePath), {
+		acceptLegacySameAttemptClaims: true,
+		label: "Feishu inbox",
+		payload: feishuInboundDeliveryPayloadCodec
+	});
+	return new Set(deliveries.map((delivery) => delivery.id));
+}
+/**
+* Opens every embedded Herdr store (claims lock, bindings, mode snapshot,
+* owner ledger) plus the connection-less runtime and router. The opener
+* Promise is allocated lazily inside the Effect and joined on interruption:
+* a cancelled hand still waits for the stores it may have acquired and
+* releases them instead of leaving an ownerless lock holder behind.
+*/
+function openEmbeddedHerdrRoute(input) {
+	return Effect.suspend(() => {
+		const opener = buildEmbeddedHerdrRoute(input);
+		return Effect.onInterrupt(Effect.tryPromise({
+			catch: (error) => error,
+			try: () => opener
+		}), () => Effect.promise(() => opener.then((opened) => opened.runtime.stop().then(() => void 0, () => void 0), () => void 0)));
+	});
+}
+async function buildEmbeddedHerdrRoute(input) {
+	const { herdr } = input;
+	return (async () => {
+		const legacyPiIds = await buildLegacyPiInboxIndex(join(input.endpointStateDirectory, "feishu-inbox.jsonl"));
+		const claims = await openTerminalMessageClaims(herdr.stateDirectory, herdr.appId);
+		const closeClaims = () => claims.close().catch(() => void 0);
+		let bindings;
+		let states;
+		let ledger;
+		let stopState;
+		let runtime;
+		let router;
+		try {
+			bindings = await openTerminalBindingsStore(herdr.stateDirectory, herdr.appId);
+			states = await openTerminalConversationStates(herdr.stateDirectory, herdr.appId);
+			ledger = await openFileRouteAdmissionLedger(herdr.stateDirectory, herdr.appId);
+			stopState = { stopped: false };
+			runtime = createHerdrFeishuBridgeRuntime({
+				sessions: createHerdrSocketClient(herdr.sessions ?? [], 5e3, herdr.discoverSessionsIn),
+				actors: herdr.allowedActors,
+				chats: herdr.allowedChats,
+				writable: herdr.writable,
+				claim: claims.claim,
+				bindings,
+				conversation: {
+					epoch: randomUUID(),
+					states
+				},
+				delivery: createFeishuTerminalDelivery(new Lark.Client({
+					appId: herdr.appId,
+					appSecret: input.appSecret,
+					domain: input.baseUrl,
+					loggerLevel: Lark.LoggerLevel.error
+				}), { isStopped: () => stopState.stopped }),
+				...herdr.fontFiles === void 0 ? {} : { fontFiles: herdr.fontFiles },
+				stopState,
+				closeStores: () => claims.close()
+			});
+			router = createFeishuConversationRouter({
+				appId: herdr.appId,
+				bridge: runtime.bridge,
+				ledger,
+				actors: herdr.allowedActors,
+				chats: herdr.allowedChats,
+				legacyOwnerOf: (messageId) => Effect.gen(function* () {
+					const claimed = yield* claims.hasClaim(messageId);
+					const pi = legacyPiIds.has(messageId);
+					if (pi && claimed) return "conflict";
+					if (pi) return "pi";
+					return claimed ? "herdr" : "none";
+				}),
+				groupPolicy: input.groupPolicy,
+				botOpenId: input.botOpenId,
+				target: runtime
+			});
+		} catch (error) {
+			await closeClaims();
+			throw error;
+		}
+		return {
+			runtime,
+			routedDispatcher: () => createRoutedFeishuEventDispatcher(new Lark.EventDispatcher({}), {
+				message: router.routeMessage,
+				card: router.routeCardAction,
+				menu: router.routeMenuEvent
+			}, herdr.menuChats ?? {})
+		};
+	})();
+}
+function wrapEmbeddedHerdrEndpointLifecycle(endpoint, runtime) {
+	return {
+		running: () => endpoint.running(),
+		start: () => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+			yield* Effect.tryPromise({
+				catch: (error) => error,
+				try: () => runtime.start()
+			});
+			const startExit = yield* Effect.exit(restore(Effect.suspend(() => endpoint.start())));
+			if (Exit.isFailure(startExit)) {
+				yield* Effect.exit(Effect.tryPromise({
+					catch: () => void 0,
+					try: () => runtime.stop()
+				}));
+				return yield* Effect.failCause(startExit.cause);
+			}
+		})),
+		stop: () => Effect.uninterruptible(Effect.gen(function* () {
+			yield* Effect.sync(() => runtime.stopIntake());
+			const endpointExit = yield* Effect.exit(endpoint.stop());
+			const drainExit = yield* Effect.exit(Effect.tryPromise({
+				catch: (error) => error,
+				try: () => runtime.completeStop()
+			}));
+			if (Exit.isFailure(endpointExit)) return yield* Effect.failCause(endpointExit.cause);
+			if (Exit.isFailure(drainExit)) return yield* Effect.failCause(drainExit.cause);
+		}))
+	};
+}
+//#endregion
 //#region src/adapters/feishu/run-presentation/feishu-presentation-preparation.ts
 function createFeishuPresentationPreparation(options) {
 	return (run) => Effect.gen(function* () {
@@ -15146,112 +16123,6 @@ function append(filePath, record) {
 	});
 }
 //#endregion
-//#region src/adapters/feishu/inbound-delivery/jsonl-inbound-delivery-store.ts
-function openJsonlInboundDeliveryStore(options) {
-	const codecOptions = {
-		...options.acceptLegacySameAttemptClaims === void 0 ? {} : { acceptLegacySameAttemptClaims: options.acceptLegacySameAttemptClaims },
-		label: options.label ?? "Inbound Delivery",
-		payload: options.payload
-	};
-	return Effect.gen(function* () {
-		const raw = yield* Effect.tryPromise({
-			try: () => readPersistenceFile(options.filePath),
-			catch: (cause) => cause
-		});
-		return createInMemoryDurableQueueStore({
-			initial: yield* Effect.try({
-				try: () => decodeInboundDeliverySnapshots(raw, codecOptions),
-				catch: (cause) => cause
-			}),
-			persist: (delivery) => appendInboundDeliverySnapshot(options.filePath, delivery)
-		});
-	});
-}
-function decodeInboundDeliverySnapshots(raw, options) {
-	if (raw === void 0) return [];
-	const latest = /* @__PURE__ */ new Map();
-	for (const [index, line] of raw.split("\n").entries()) {
-		if (line.trim().length === 0) continue;
-		let parsed;
-		try {
-			parsed = JSON.parse(line);
-		} catch {
-			throw new Error(`invalid ${options.label} snapshot at line ${index + 1}`);
-		}
-		if (!isEnvelope(parsed)) throw new Error(`invalid ${options.label} snapshot at line ${index + 1}`);
-		let delivery;
-		try {
-			delivery = decodeDelivery(parsed.delivery, options.payload);
-		} catch {
-			throw new Error(`invalid ${options.label} snapshot at line ${index + 1}`);
-		}
-		const previous = latest.get(delivery.id);
-		if (delivery.revision !== (previous?.revision ?? 0) + 1) throw new Error(`invalid ${options.label} revision at line ${index + 1}`);
-		try {
-			if (previous) {
-				if (!isValidPersistedTransition(previous, delivery, options.acceptLegacySameAttemptClaims ?? false)) throw new Error("transition");
-			} else assertNewInboundDelivery(delivery);
-		} catch {
-			throw new Error(`invalid ${options.label} transition at line ${index + 1}`);
-		}
-		latest.set(delivery.id, delivery);
-	}
-	return [...latest.values()];
-}
-function encodeInboundDeliverySnapshot(delivery) {
-	const snapshot = readInboundDeliverySnapshot(delivery);
-	const persisted = {
-		acceptedAt: snapshot.acceptedAt,
-		attempts: snapshot.attempts,
-		id: snapshot.id,
-		laneKey: snapshot.laneKey,
-		...snapshot.metadata === void 0 ? {} : { options: snapshot.metadata },
-		payload: snapshot.payload,
-		...snapshot.recovery === void 0 ? {} : { recovery: snapshot.recovery },
-		revision: snapshot.revision,
-		state: snapshot.state
-	};
-	return JSON.stringify({
-		delivery: persisted,
-		version: 1
-	});
-}
-function decodeDelivery(value, payloadCodec) {
-	if (!isRecord(value) || typeof value.acceptedAt !== "string" || typeof value.attempts !== "number" || typeof value.id !== "string" || typeof value.laneKey !== "string" || typeof value.revision !== "number") throw new Error("invalid Inbound Delivery snapshot");
-	const metadata = payloadCodec.decodeMetadata(value.options);
-	return readInboundDeliverySnapshot({
-		acceptedAt: value.acceptedAt,
-		attempts: value.attempts,
-		id: value.id,
-		laneKey: value.laneKey,
-		...metadata === void 0 ? {} : { metadata },
-		payload: payloadCodec.decodePayload(value.payload),
-		...value.recovery === void 0 ? {} : { recovery: value.recovery },
-		revision: value.revision,
-		state: value.state
-	});
-}
-function isEnvelope(value) {
-	return isRecord(value) && value.version === 1 && "delivery" in value;
-}
-function isValidPersistedTransition(previous, next, acceptLegacySameAttemptClaims) {
-	if (isValidInboundDeliveryTransition(previous, next)) return true;
-	if (!acceptLegacySameAttemptClaims || previous.state.status !== "pending" || next.state.status !== "leased" || next.attempts !== previous.attempts) return false;
-	return isValidInboundDeliveryTransition(previous, {
-		...next,
-		attempts: next.attempts + 1
-	});
-}
-function appendInboundDeliverySnapshot(filePath, delivery) {
-	return Effect.tryPromise({
-		try: async () => {
-			await mkdir(dirname(filePath), { recursive: true });
-			await appendFile(filePath, `${encodeInboundDeliverySnapshot(delivery)}\n`, "utf8");
-		},
-		catch: (cause) => cause
-	});
-}
-//#endregion
 //#region src/adapters/feishu/conversation-session/json-feishu-session-store.ts
 function openJsonFeishuSessionStore(options) {
 	return Effect.tryPromise({
@@ -17017,6 +17888,7 @@ async function createRivusDeploymentAdapters(context) {
 			manifest
 		};
 	})));
+	const herdrRoute = await resolveHerdrRouteConfig(context.env, manifest);
 	const memoryTenantId = context.env.RIVUS_MEMORY_TENANT_ID?.trim() || "local";
 	const request = createJsonFetchRequest();
 	const attachmentCapabilities = /* @__PURE__ */ new Map();
@@ -17323,6 +18195,15 @@ async function createRivusDeploymentAdapters(context) {
 					config
 				});
 				const prepareCardTarget = (run) => cardRollover.prepareRun(run);
+				const herdr = herdrRoute !== void 0 && input.endpointId === herdrRoute.endpointId ? herdrRoute : void 0;
+				const embedded = herdr ? yield* openEmbeddedHerdrRoute({
+					herdr,
+					appSecret: credentials.appSecret,
+					baseUrl: input.definition.baseUrl,
+					endpointStateDirectory: endpointState,
+					groupPolicy: input.definition.groupPolicy,
+					botOpenId
+				}) : void 0;
 				const endpoint = createFeishuDeploymentEndpoint({
 					agentId: input.agentId,
 					acknowledgeSteering: (messageId) => reactions.add(messageId),
@@ -17333,7 +18214,7 @@ async function createRivusDeploymentAdapters(context) {
 					finalizeRun: (runId) => cardRollover.rollover.releaseRun(runId),
 					cancel: input.cancel,
 					endpointId: input.endpointId,
-					eventDispatcher: createLazyFeishuWebSocketEventDispatcher(() => new Lark.EventDispatcher({})),
+					eventDispatcher: embedded ? createLazyFeishuWebSocketEventDispatcher(embedded.routedDispatcher) : createLazyFeishuWebSocketEventDispatcher(() => new Lark.EventDispatcher({})),
 					groupPolicy: input.definition.groupPolicy,
 					handle: input.handle,
 					inboxStore: inbox,
@@ -17361,7 +18242,8 @@ async function createRivusDeploymentAdapters(context) {
 					workerConcurrency: 4
 				});
 				interactionRegistry.register(input.endpointId, interactions);
-				return endpoint;
+				if (embedded === void 0) return endpoint;
+				return wrapEmbeddedHerdrEndpointLifecycle(endpoint, embedded.runtime);
 			}).pipe(Effect.catchDefect((error) => Effect.fail(error))),
 			createRuntime: (input) => Effect.gen(function* () {
 				const instanceState = join(STATE_DIR, "instances", input.instanceId);