@rivus/gateway 0.17.0 → 0.18.1

package/dist/chunks/herdr-feishu-runtime.js

@@ -0,0 +1,1993 @@
+import { isAbsolute, join, resolve } from "node:path";
+import { Array as Array$1, Effect, Fiber, Result, Schema, Semaphore } from "effect";
+import { chmod, lstat, mkdir, open, readFile, readdir, unlink } from "node:fs/promises";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { createConnection } from "node:net";
+import { writeAtomicTextFile } from "@rivus/platform/persistence";
+import { stripVTControlCharacters } from "node:util";
+import { Worker } from "node:worker_threads";
+import { eastAsianWidth } from "get-east-asian-width";
+//#region src/core/application/terminal-session/conversation-mode.ts
+const stateKey = (actorId, chatId) => `${actorId}\u0000${chatId}`;
+/**
+* Conversation mode state machine (normal/selection/locked per authorized
+* actor+chat) with persist-before-publication and a global frozen flag: any
+* ambiguous snapshot save freezes all mode-dependent activity until a validated
+* restart, and an unrelated conversation's state is never overwritten afterwards.
+* Generations advance monotonically per conversation for the whole process and
+* are never recycled; the startup epoch invalidates every card issued by an
+* earlier run while persisted locks stay (revalidated before writes).
+*/
+function createConversationMode(options) {
+	let states = new Map(options.states.initial.map((state) => [stateKey(state.actorId, state.chatId), state]));
+	const generations = /* @__PURE__ */ new Map();
+	let frozen = false;
+	const serial = Semaphore.makeUnsafe(1);
+	const generationOf = (actorId, chatId) => generations.get(stateKey(actorId, chatId)) ?? 0;
+	const advanceGeneration = (actorId, chatId) => {
+		const next = generationOf(actorId, chatId) + 1;
+		generations.set(stateKey(actorId, chatId), next);
+		return next;
+	};
+	const persistAndPublish = (candidate) => Effect.gen(function* () {
+		yield* options.states.save([...candidate.values()]);
+		states = candidate;
+		return true;
+	}).pipe(Effect.catchCause(() => Effect.sync(() => {
+		frozen = true;
+		return false;
+	})));
+	const controlRegion = (decide) => serial.withPermits(1)(Effect.uninterruptible(Effect.gen(function* () {
+		if (frozen) return {
+			frozen: true,
+			value: void 0
+		};
+		const candidate = new Map(states);
+		const decision = yield* decide(candidate);
+		if (!decision.save) return {
+			frozen: false,
+			value: decision.value
+		};
+		return {
+			frozen: !(yield* persistAndPublish(candidate)),
+			value: decision.value
+		};
+	})));
+	return {
+		epoch: options.epoch,
+		stateOf: (actorId, chatId) => states.get(stateKey(actorId, chatId)),
+		generationOf,
+		isFrozen: () => frozen,
+		freeze: () => {
+			frozen = true;
+		},
+		capturedTarget: (actorId, chatId) => {
+			const state = states.get(stateKey(actorId, chatId));
+			return state?.kind === "locked" ? state.agent : void 0;
+		},
+		enterSelection: (actorId, chatId) => controlRegion((candidate) => {
+			const key = stateKey(actorId, chatId);
+			if (!candidate.has(key) && candidate.size >= 64) return Effect.succeed({
+				save: false,
+				value: "capacity"
+			});
+			advanceGeneration(actorId, chatId);
+			if (candidate.get(key) === void 0) candidate.set(key, {
+				kind: "selection",
+				actorId,
+				chatId,
+				since: options.now()
+			});
+			return Effect.succeed({
+				save: true,
+				value: "committed"
+			});
+		}).pipe(Effect.map(({ frozen: wasFrozen, value }) => wasFrozen ? "frozen" : value)),
+		refresh: (actorId, chatId) => controlRegion((_candidate) => {
+			advanceGeneration(actorId, chatId);
+			return Effect.succeed({
+				save: false,
+				value: "committed"
+			});
+		}).pipe(Effect.map(({ frozen: wasFrozen, value }) => wasFrozen ? "frozen" : value)),
+		exit: (actorId, chatId) => controlRegion((candidate) => {
+			advanceGeneration(actorId, chatId);
+			candidate.delete(stateKey(actorId, chatId));
+			return Effect.succeed({
+				save: true,
+				value: "committed"
+			});
+		}).pipe(Effect.map(({ frozen: wasFrozen, value }) => wasFrozen ? "frozen" : value)),
+		reserveSelection: (credential) => controlRegion((candidate) => {
+			if (credential.epoch !== options.epoch) return Effect.succeed({
+				save: false,
+				value: { kind: "stale" }
+			});
+			const key = stateKey(credential.actorId, credential.chatId);
+			if (!candidate.has(key) && candidate.size >= 64) return Effect.succeed({
+				save: false,
+				value: { kind: "capacity" }
+			});
+			if (credential.generation !== generationOf(credential.actorId, credential.chatId)) return Effect.succeed({
+				save: false,
+				value: { kind: "stale" }
+			});
+			const ticketGeneration = advanceGeneration(credential.actorId, credential.chatId);
+			return Effect.succeed({
+				save: false,
+				value: {
+					credential,
+					actorId: credential.actorId,
+					chatId: credential.chatId,
+					handle: credential.handle,
+					ticketGeneration
+				}
+			});
+		}).pipe(Effect.map(({ frozen: wasFrozen, value }) => wasFrozen ? { kind: "frozen" } : value)),
+		inspectSelection: (ticket) => Effect.gen(function* () {
+			const binding = yield* options.bindings.lookup(ticket.handle, {
+				actorId: ticket.actorId,
+				chatId: ticket.chatId
+			});
+			if (binding.kind !== "found") return yield* Effect.fail(/* @__PURE__ */ new Error("Selection binding is no longer available"));
+			return yield* options.sessions.inspect(binding.binding.agent);
+		}),
+		commitSelection: (ticket, agent) => controlRegion((candidate) => {
+			const key = stateKey(ticket.actorId, ticket.chatId);
+			if (generationOf(ticket.actorId, ticket.chatId) !== ticket.ticketGeneration) return Effect.succeed({
+				save: false,
+				value: { kind: "stale" }
+			});
+			if (agent.kind !== "agent") return Effect.succeed({
+				save: false,
+				value: {
+					kind: "not-selectable",
+					reason: "终端面板为只读，不能作为会话目标。"
+				}
+			});
+			if (!candidate.has(key) && candidate.size >= 64) return Effect.succeed({
+				save: false,
+				value: { kind: "capacity" }
+			});
+			candidate.set(key, {
+				kind: "locked",
+				actorId: ticket.actorId,
+				chatId: ticket.chatId,
+				since: options.now(),
+				handle: ticket.handle,
+				agent,
+				stale: false
+			});
+			advanceGeneration(ticket.actorId, ticket.chatId);
+			return Effect.succeed({
+				save: true,
+				value: "committed"
+			});
+		}).pipe(Effect.flatMap(({ frozen: wasFrozen, value }) => wasFrozen ? Effect.succeed({ kind: "frozen" }) : Effect.succeed(value))),
+		markLockedStale: (actorId, chatId, expected) => controlRegion((candidate) => {
+			const state = candidate.get(stateKey(actorId, chatId));
+			if (state?.kind !== "locked") return Effect.succeed({
+				save: false,
+				value: void 0
+			});
+			if (!(expected === void 0 || state.agent.identity === expected.identity && state.agent.pane === expected.pane && state.agent.session === expected.session)) return Effect.succeed({
+				save: false,
+				value: void 0
+			});
+			candidate.set(stateKey(actorId, chatId), {
+				...state,
+				stale: true
+			});
+			return Effect.succeed({
+				save: true,
+				value: void 0
+			});
+		}).pipe(Effect.asVoid)
+	};
+}
+//#endregion
+//#region src/core/application/terminal-session/terminal-session-bindings.ts
+var TerminalBindingPersistenceError = class extends Error {
+	constructor(cause) {
+		super("Terminal binding snapshot could not be saved", { cause });
+	}
+};
+function createTerminalSessionBindings(options) {
+	let bindings = new Map((options.store?.initial ?? []).map((entry) => [entry.handle, entry]));
+	const serial = Semaphore.makeUnsafe(1);
+	const commit = (candidate) => Effect.gen(function* () {
+		if (options.store) yield* options.store.save([...candidate.values()]).pipe(Effect.mapError((cause) => new TerminalBindingPersistenceError(cause)));
+		bindings = candidate;
+	});
+	const insert = (candidate, entry) => {
+		candidate.delete(entry.handle);
+		candidate.set(entry.handle, entry);
+		if (candidate.size > 1e3) candidate.delete(candidate.keys().next().value);
+		return entry;
+	};
+	const fresh = (candidate, message, agent, expires) => {
+		let handle = options.newHandle();
+		while (candidate.has(handle)) handle = options.newHandle();
+		return insert(candidate, {
+			handle,
+			actorId: message.actorId,
+			chatId: message.chatId,
+			agent,
+			...expires === void 0 ? {} : { expires }
+		});
+	};
+	return {
+		lookup: (handle, message) => serial.withPermits(1)(Effect.uninterruptible(Effect.gen(function* () {
+			const binding = bindings.get(handle);
+			if (!binding) return { kind: "missing" };
+			if (binding.actorId !== message.actorId || binding.chatId !== message.chatId) return { kind: "unauthorized" };
+			const candidate = new Map(bindings);
+			insert(candidate, binding);
+			yield* commit(candidate);
+			return {
+				kind: "found",
+				binding
+			};
+		}))),
+		selections: (message, agents) => serial.withPermits(1)(Effect.uninterruptible(Effect.gen(function* () {
+			const candidate = new Map(bindings);
+			const selected = agents.map((agent) => {
+				const existing = [...candidate.values()].find((entry) => entry.expires === void 0 && entry.actorId === message.actorId && entry.chatId === message.chatId && entry.agent.session === agent.session && entry.agent.pane === agent.pane && entry.agent.identity === agent.identity);
+				return existing ? insert(candidate, {
+					...existing,
+					agent
+				}) : fresh(candidate, message, agent);
+			});
+			if (agents.length) yield* commit(candidate);
+			return selected;
+		}))),
+		form: (message, agent, expires) => serial.withPermits(1)(Effect.uninterruptible(Effect.gen(function* () {
+			const candidate = new Map(bindings);
+			const binding = fresh(candidate, message, agent, expires);
+			yield* commit(candidate);
+			return binding;
+		})))
+	};
+}
+//#endregion
+//#region src/core/application/terminal-session/terminal-session-bridge.ts
+var TerminalTargetChangedError = class extends Error {
+	constructor() {
+		super("Herdr target changed; select the target again");
+	}
+};
+/** A final target check refused before the prompt RPC was invoked. */
+var TerminalPromptPreflightError = class extends Error {
+	constructor(text) {
+		super(text);
+	}
+};
+const terminalWriteRefusalText = {
+	"read-only": "Terminal input is disabled for this deployment.",
+	terminal: "目标为只读终端面板，不能接收指令。",
+	"not-ready": "目标尚未完成启动，暂不接收指令；请刷新状态。",
+	busy: "目标正在执行任务，暂不接收新指令。",
+	blocked: "目标正在等待处理（如审批或提问），不会代替你处理；未提交指令。",
+	"unknown-status": "目标状态未知，请刷新确认后再发送。"
+};
+/**
+* Shared gate for every Herdr write path (locked text, /herdr send, form submit).
+* Herdr reports the same input-awaiting agent as `done` before it is focused and
+* `idle` afterwards, so both statuses admit a ready agent; everything else refuses
+* with a specific reason and no PTY input. Availability and status are evaluated
+* before the deployment read-only flag so an offline, replaced or busy target keeps
+* reporting its own reason instead of a generic disabled notice.
+*/
+function evaluateTerminalWriteInput(agent, writable) {
+	const refused = (refusal) => ({
+		allowed: false,
+		refusal,
+		text: terminalWriteRefusalText[refusal]
+	});
+	if (agent.kind !== "agent") return refused("terminal");
+	if (!agent.ready) return refused("not-ready");
+	if (agent.status === "working") return refused("busy");
+	if (agent.status === "blocked") return refused("blocked");
+	if (agent.status !== "idle" && agent.status !== "done") return refused("unknown-status");
+	if (!writable) return refused("read-only");
+	return { allowed: true };
+}
+function createTerminalSessionBridge(options) {
+	if (!options.actors.length || !options.chats.length) throw new Error("Explicit actor and chat allowlists required");
+	const bindings = createTerminalSessionBindings({
+		newHandle: options.newHandle,
+		store: options.bindings
+	});
+	const mode = options.conversation ? createConversationMode({
+		epoch: options.conversation.epoch,
+		states: options.conversation.states,
+		bindings,
+		sessions: options.sessions,
+		now: options.now
+	}) : void 0;
+	const watches = /* @__PURE__ */ new Map();
+	const watchExitRevisions = /* @__PURE__ */ new Map();
+	const watchScopeKey = (message) => JSON.stringify([message.actorId, message.chatId]);
+	const watchExitRevisionOf = (message) => watchExitRevisions.get(watchScopeKey(message)) ?? 0;
+	const allowed = (actor, chat) => options.actors.includes(actor) && options.chats.includes(chat);
+	const reply = (message, text) => ({
+		chatId: message.chatId,
+		text
+	});
+	const watchKey = (message, agent) => JSON.stringify([
+		message.actorId,
+		message.chatId,
+		agent.session,
+		agent.pane,
+		agent.identity
+	]);
+	const isFresh = (message) => {
+		const age = options.now() - message.sentAt;
+		return Number.isFinite(age) && age >= -3e4 && age <= 12e4;
+	};
+	const frozenReply = (message) => reply(message, "会话状态暂不可用（保存未确认）；本条未处理，也未转发。");
+	const capacityReply = (message) => reply(message, "会话状态名额已满（64），请先 /exit 其他会话后再进入。");
+	const runCapturedSend = (message, agent, text) => Effect.gen(function* () {
+		const targetChanged = () => withAdmission(mode.markLockedStale(message.actorId, message.chatId, {
+			identity: agent.identity,
+			pane: agent.pane,
+			session: agent.session
+		})).pipe(Effect.as({
+			kind: "reply",
+			reply: reply(message, "原会话的目标已变化；未向替换目标提交。锁定保留，请重新 /herdr 选择。")
+		}));
+		if (mode?.isFrozen()) return {
+			kind: "reply",
+			reply: frozenReply(message)
+		};
+		const inspected = yield* options.sessions.inspect(agent).pipe(Effect.result);
+		if (Result.isFailure(inspected)) {
+			if (inspected.failure instanceof TerminalTargetChangedError) return yield* targetChanged();
+			return {
+				kind: "reply",
+				reply: reply(message, "目标暂不可用；未提交指令。可 /exit 后重新选择。")
+			};
+		}
+		const verdict = evaluateTerminalWriteInput(inspected.success, options.writable);
+		if (!verdict.allowed) return {
+			kind: "reply",
+			reply: reply(message, `Input rejected: ${verdict.text}`)
+		};
+		if (mode?.isFrozen()) return {
+			kind: "reply",
+			reply: frozenReply(message)
+		};
+		return yield* options.sessions.prompt(agent, text).pipe(Effect.map(() => ({
+			kind: "reply",
+			reply: reply(message, "指令已提交一次；尚未确认 agent 已处理或完成，请查看输出。")
+		})), Effect.catch((error) => error instanceof TerminalTargetChangedError ? targetChanged() : Effect.succeed({
+			kind: "reply",
+			reply: reply(message, error instanceof TerminalPromptPreflightError ? error.message : "提交结果不确定（uncertain），不会自动重试。请先查看输出，确认后再发送新指令。")
+		})));
+	});
+	const detail = (message, agent, handle, text) => ({
+		chatId: message.chatId,
+		text: `${agent.session} / ${agent.name} | ${agent.status}\n${text}`,
+		menu: {
+			kind: "detail",
+			agents: [{
+				...agent,
+				handle
+			}],
+			writable: options.writable,
+			notice: text
+		}
+	});
+	const refreshDetail = (message, agent, text) => Effect.gen(function* () {
+		const current = yield* options.sessions.inspect(agent);
+		const [selected] = yield* bindings.selections(message, [current]);
+		return detail(message, current, selected.handle, text);
+	});
+	const inventory = (message, command, argument = "", notice, issued) => Effect.gen(function* () {
+		const { agents, unavailableSessions } = yield* options.sessions.list();
+		const page = Math.max(0, Math.min(Math.floor(Number(argument) || 0), Math.max(0, Math.ceil(agents.length / 20) - 1)));
+		const visible = command === "menu" ? agents.slice(page * 20, (page + 1) * 20) : agents;
+		const choices = (yield* bindings.selections(message, visible)).map(({ agent, handle }) => ({
+			...agent,
+			handle,
+			...issued === void 0 ? {} : { selection: {
+				epoch: issued.epoch,
+				generation: issued.generation,
+				actorId: issued.actorId,
+				chatId: issued.chatId,
+				handle
+			} }
+		}));
+		const warning = unavailableSessions.length ? `\nUnavailable sessions: ${unavailableSessions.join(", ")}; inventory is incomplete.` : "";
+		const lines = choices.map((agent) => `${agent.handle} | ${agent.session} | ${agent.name} | ${agent.status}`);
+		return {
+			...reply(message, `${notice ? notice + "\n" : ""}${new Date(options.now()).toISOString()}\n${lines.join("\n") || "No panels"}${warning}`),
+			...command === "menu" ? { menu: {
+				kind: "list",
+				agents: choices,
+				unavailableSessions,
+				page,
+				pages: Math.max(1, Math.ceil(agents.length / 20)),
+				writable: options.writable,
+				...notice ? { notice } : {}
+			} } : {}
+		};
+	});
+	const persistenceFailure = (message) => reply(message, "会话控制状态无法保存；未签发新卡片，也未提交指令。请稍后重新操作。");
+	const unavailableInventory = (message) => ({
+		...reply(message, "会话列表暂不可用，请稍后刷新列表；未提交指令。"),
+		menu: {
+			kind: "recovery",
+			writable: false,
+			agents: []
+		}
+	});
+	const recovery = (message, binding, error) => {
+		if (error instanceof TerminalTargetChangedError) return inventory(message, "menu", "", "原会话的目标已变化（target changed）；未向替换目标提交指令。请从新列表明确选择会话。");
+		if (!binding) return Effect.succeed(unavailableInventory(message));
+		return bindings.selections(message, [binding.agent]).pipe(Effect.map(([selected]) => ({
+			...reply(message, "原会话离线或暂不可用；未提交指令。可刷新原会话重试，刷新不会重发旧指令。"),
+			menu: {
+				kind: "recovery",
+				writable: false,
+				agents: [{
+					...binding.agent,
+					status: "unavailable",
+					ready: false,
+					handle: selected.handle
+				}]
+			}
+		})));
+	};
+	const recover = (message, binding, error) => error instanceof TerminalBindingPersistenceError ? Effect.succeed(persistenceFailure(message)) : recovery(message, binding, error).pipe(Effect.catch((cause) => Effect.succeed(cause instanceof TerminalBindingPersistenceError ? persistenceFailure(message) : unavailableInventory(message))));
+	const form = (message, agent, draft) => Effect.gen(function* () {
+		const binding = yield* bindings.form(message, agent, options.now() + 6e5);
+		const notice = draft === void 0 ? void 0 : "此表单已过期；草稿已保留，请确认后再次点击发送。旧指令未提交。";
+		return {
+			...reply(message, notice ?? `${agent.name} | ${agent.status}`),
+			menu: {
+				kind: "form",
+				agents: [{
+					...agent,
+					handle: binding.handle
+				}],
+				writable: options.writable,
+				...draft === void 0 ? {} : {
+					draft,
+					notice
+				}
+			}
+		};
+	});
+	const writable = (agent) => evaluateTerminalWriteInput(agent, options.writable);
+	const execute = (message, admittedWatchRevision) => {
+		let binding;
+		let isWatch = false;
+		const isCurrent = () => !isWatch || watchExitRevisionOf(message) === admittedWatchRevision;
+		return Effect.gen(function* () {
+			const match = /^\/herdr(?:\s+(\S+))?(?:\s+([\s\S]*))?$/.exec(message.text.trimStart());
+			if (!match) return null;
+			const command = match[1] ?? "help";
+			const argument = match[2] ?? "";
+			isWatch = command === "watch";
+			if (!isCurrent()) return null;
+			if (command === "list" || command === "menu") return yield* inventory(message, command, argument);
+			if (command === "help") return reply(message, "从应用菜单打开会话列表，选择 agent 后填写指令并点击发送。卡片可直接查看输出、画面和关注状态。\n文字命令：/herdr menu、/herdr list、/herdr read HANDLE、/herdr screen HANDLE、/herdr send HANDLE -- TEXT、/herdr watch HANDLE、/herdr unwatch HANDLE");
+			const parts = ["send", "submit"].includes(command) ? /^(\S+)\s+--\s([\s\S]*)$/.exec(argument) : null;
+			const handle = parts?.[1] ?? argument.trim();
+			const found = yield* bindings.lookup(handle, message);
+			if (!isCurrent()) return null;
+			if (found.kind === "missing") return yield* inventory(message, "menu", "", "此卡片的目标记录不存在或已淘汰，请从新列表重新选择；旧指令未提交。");
+			if (found.kind === "unauthorized") return {
+				...reply(message, "此卡片不可用于当前操作者或聊天，请刷新列表重新选择。"),
+				menu: {
+					kind: "recovery",
+					writable: false,
+					agents: []
+				}
+			};
+			binding = found.binding;
+			if (command === "unwatch") {
+				const removed = watches.delete(watchKey(message, binding.agent));
+				const [selected] = yield* bindings.selections(message, [binding.agent]);
+				return detail(message, binding.agent, selected.handle, removed ? "已取消关注；agent 仍在运行。" : "当前没有关注此会话。");
+			}
+			if (command === "open" || command === "compose" || command === "refresh") {
+				const current = yield* options.sessions.inspect(binding.agent);
+				const verdict = writable(current);
+				if (verdict.allowed) return yield* form(message, current);
+				const [selected] = yield* bindings.selections(message, [current]);
+				return detail(message, current, selected.handle, `${verdict.text}请刷新状态后再试。`);
+			}
+			if (command === "read" || command === "screen") {
+				const read = yield* options.sessions.read(binding.agent, command === "screen");
+				const title = `${handle} | ${binding.agent.name}`;
+				const at = options.now();
+				return command === "screen" ? {
+					...reply(message, `${title} — terminal text rendering`),
+					screen: {
+						title,
+						at,
+						...read
+					}
+				} : reply(message, `${title} | ${new Date(at).toISOString()}${read.truncated || read.text.length > 12e3 ? " | truncated（已截断）" : ""}\n${read.text.slice(-12e3)}`);
+			}
+			if (command === "send" || command === "submit") {
+				if (command === "submit") {
+					if (binding.expires === void 0 || !(yield* options.claim({
+						...message,
+						id: `form:${handle}`
+					}))) return yield* refreshDetail(message, binding.agent, "此表单已提交或失效，请查看输出；新指令请重新打开输入框。");
+				} else if (binding.expires !== void 0) return yield* refreshDetail(message, binding.agent, "表单只能通过发送按钮提交一次；新指令请重新打开输入框。");
+				const text = parts?.[2];
+				if (!text?.trim() || text.length > (command === "submit" ? 1e3 : 8e3) || Array.from(text).some((char) => {
+					const code = char.charCodeAt(0);
+					return code < 32 && code !== 9 && code !== 10 || code === 127;
+				})) {
+					if (command === "submit") return yield* refreshDetail(message, binding.agent, "指令需为 1–1000 个字符，且不能包含终端控制字符；请点击“发下一条指令”重新填写。");
+					return reply(message, "Use /herdr send HANDLE -- TEXT (1–8000 characters, no terminal control characters).");
+				}
+				const current = yield* options.sessions.inspect(binding.agent);
+				const [selected] = yield* bindings.selections(message, [current]);
+				const verdict = writable(current);
+				if (!verdict.allowed) return detail(message, current, selected.handle, `Input rejected: ${verdict.text}`);
+				if (command === "submit" && binding.expires <= options.now()) return yield* form(message, current, text);
+				if (mode?.isFrozen()) return detail(message, current, selected.handle, frozenReply(message).text);
+				return yield* options.sessions.prompt(binding.agent, text).pipe(Effect.as(detail(message, current, selected.handle, "指令已提交一次；尚未确认 agent 已处理或完成，请查看输出。")), Effect.catch((error) => error instanceof TerminalTargetChangedError ? Effect.fail(error) : Effect.succeed(detail(message, current, selected.handle, error instanceof TerminalPromptPreflightError ? error.message : "提交结果不确定（uncertain），不会自动重试。请先查看输出，确认后再发送新指令。"))));
+			}
+			if (command === "watch") {
+				for (const [key, watch] of watches) if (watch.expires <= options.now()) watches.delete(key);
+				const key = watchKey(message, binding.agent);
+				if (!watches.has(key) && watches.size >= 8) return detail(message, binding.agent, handle, "已达到 8 个关注目标，请先取消其他关注。");
+				const current = yield* options.sessions.inspect(binding.agent);
+				if (!isCurrent()) return null;
+				const [selected] = yield* bindings.selections(message, [current]);
+				if (!isCurrent()) return null;
+				watches.set(key, {
+					chatId: message.chatId,
+					actorId: message.actorId,
+					binding: selected,
+					expires: options.now() + 6e5,
+					status: current.status
+				});
+				return detail(message, current, selected.handle, "已关注此会话 10 分钟；重复关注会续期，不增加名额。");
+			}
+			return reply(message, "Unknown command; use /herdr help.");
+		}).pipe(Effect.catch((error) => isCurrent() ? recover(message, binding, error) : Effect.succeed(null)), Effect.map((result) => isCurrent() ? result : null));
+	};
+	const admission = Semaphore.makeUnsafe(1);
+	const withAdmission = (work) => admission.withPermits(1)(work);
+	const inventoryWork = (message, run) => ({
+		kind: "inventory",
+		message,
+		run
+	});
+	const capturedSendWork = (message, run) => ({
+		kind: "captured-send",
+		message,
+		run
+	});
+	const commandWork = (message, run) => ({
+		kind: "command",
+		message,
+		run
+	});
+	/** Captures epoch/generation/actor/chat synchronously and returns the inventory work. */
+	const inventoryWorkWithCurrentSelection = (message, command, argument = "", notice) => inventoryWork(message, inventory(message, command, argument, notice, {
+		epoch: mode.epoch,
+		generation: mode.generationOf(message.actorId, message.chatId),
+		actorId: message.actorId,
+		chatId: message.chatId
+	}));
+	const inspectSelectionWork = (message, ticket) => ({
+		kind: "inspect-selection",
+		message,
+		ticket,
+		run: Effect.gen(function* () {
+			const inspected = yield* mode.inspectSelection(ticket).pipe(Effect.result);
+			if (Result.isFailure(inspected)) return {
+				kind: "reply",
+				reply: reply(message, "目标暂不可用或已替换，无法确认身份；未绑定。请刷新列表后重试。")
+			};
+			const committed = yield* withAdmission(mode.commitSelection(ticket, inspected.success));
+			if (committed !== "committed") {
+				const notice = committed.kind === "stale" ? "状态已变化，本次选择未生效。" : committed.kind === "capacity" ? "会话状态名额已满（64）。" : "会话状态暂不可用（保存未确认）。";
+				return {
+					kind: "reply",
+					reply: reply(message, notice)
+				};
+			}
+			return {
+				kind: "reply",
+				reply: detail(message, inspected.success, ticket.handle, "已锁定该会话；之后普通消息将直接发送给它（/exit 退出）。")
+			};
+		})
+	});
+	/** Internal Route decided in one admission turn, before any claim or commit. */
+	const captureInAdmission = (message) => {
+		const text = message.text.trim();
+		const isExit = /^\/exit\s*$/.test(text);
+		const isHerdrToken = /^\/herdr(?:\s|$)/.test(text);
+		if (!allowed(message.actorId, message.chatId)) return {
+			message,
+			route: { kind: isHerdrToken || isExit ? "denial" : "pass-through" }
+		};
+		if (mode?.isFrozen()) return {
+			message,
+			route: { kind: "frozen-refusal" }
+		};
+		const stateAtAdmission = mode?.stateOf(message.actorId, message.chatId);
+		if (isExit) {
+			if (!mode || !stateAtAdmission) return {
+				message,
+				route: { kind: "pass-through" }
+			};
+			if (!isFresh(message) || !text) return {
+				message,
+				route: { kind: "consumed" }
+			};
+			return {
+				message,
+				route: { kind: "exit" }
+			};
+		}
+		if (mode && stateAtAdmission && !isHerdrToken) {
+			if (!isFresh(message) || !message.text.trim()) return {
+				message,
+				route: { kind: "consumed" }
+			};
+			if (stateAtAdmission.kind === "selection") return {
+				message,
+				route: {
+					kind: "selection-refusal",
+					text: "请先选择目标（回复列表卡片或 /herdr use HANDLE）；本条未发送。"
+				}
+			};
+			if (message.text.length > 8e3 || Array.from(message.text).some((char) => {
+				const code = char.charCodeAt(0);
+				return code < 32 && code !== 9 && code !== 10 || code === 127;
+			})) return {
+				message,
+				route: {
+					kind: "selection-refusal",
+					text: "指令需为 1–8000 个字符，且不能包含终端控制字符；本条未发送。"
+				}
+			};
+			return {
+				message,
+				route: {
+					kind: "locked-send",
+					agent: { ...stateAtAdmission.agent },
+					sendText: message.text
+				}
+			};
+		}
+		if (!isHerdrToken) return {
+			message,
+			route: { kind: "pass-through" }
+		};
+		if (!isFresh(message)) return {
+			message,
+			route: { kind: "consumed" }
+		};
+		if (mode) {
+			const useMatch = /^\/herdr\s+(?:use|select)\s+([a-f0-9]{12})\s*$/.exec(text);
+			if (useMatch) {
+				const selectionHandle = useMatch[1];
+				const card = message.selection;
+				if (card && (card.actorId !== message.actorId || card.chatId !== message.chatId || card.handle !== selectionHandle)) return {
+					message,
+					route: {
+						kind: "selection-refusal",
+						text: "选择已过期（凭据与消息不一致），请重新 /herdr 后选择。"
+					}
+				};
+				const credential = card ?? {
+					epoch: mode.epoch,
+					generation: mode.generationOf(message.actorId, message.chatId),
+					actorId: message.actorId,
+					chatId: message.chatId,
+					handle: selectionHandle
+				};
+				return {
+					message,
+					route: {
+						kind: card ? "select-card" : "select-text",
+						credential
+					}
+				};
+			}
+			if (/^\/herdr$/.test(text)) return {
+				message,
+				route: { kind: "enter" }
+			};
+			const menuMatch = /^\/herdr\s+(menu|list)(?:\s+(\S+))?\s*$/.exec(text);
+			if (menuMatch) return {
+				message,
+				route: {
+					kind: "refresh",
+					command: menuMatch[1],
+					argument: menuMatch[2] ?? ""
+				}
+			};
+		}
+		return {
+			message,
+			route: { kind: "legacy" }
+		};
+	};
+	/**
+	* Must be called while holding an admission permit (the future Router composes
+	* its durable owner write between capture and this call, in the same turn).
+	* Claims the event id exactly once, then publishes the frozen refusal or
+	* commits the local control; returns the remote work to run outside.
+	*/
+	const admitCapturedInAdmission = (captured) => Effect.gen(function* () {
+		const { message, route } = captured;
+		if (route.kind === "pass-through" || route.kind === "consumed") return {
+			kind: "done",
+			result: { kind: route.kind }
+		};
+		if (!isFresh(message)) return {
+			kind: "done",
+			result: { kind: "consumed" }
+		};
+		if (!(yield* options.claim(message))) return {
+			kind: "done",
+			result: { kind: "consumed" }
+		};
+		switch (route.kind) {
+			case "denial": return {
+				kind: "done",
+				result: {
+					kind: "reply",
+					reply: reply(message, "此聊天未启用 Herdr 会话控制。")
+				}
+			};
+			case "frozen-refusal": return {
+				kind: "done",
+				result: {
+					kind: "reply",
+					reply: frozenReply(message)
+				}
+			};
+			case "selection-refusal": return {
+				kind: "done",
+				result: {
+					kind: "reply",
+					reply: reply(message, route.text)
+				}
+			};
+			case "exit": {
+				const outcome = yield* mode.exit(message.actorId, message.chatId);
+				if (outcome === "committed") {
+					watchExitRevisions.set(watchScopeKey(message), watchExitRevisionOf(message) + 1);
+					for (const [key, watch] of watches) if (watch.actorId === message.actorId && watch.chatId === message.chatId) watches.delete(key);
+				}
+				return {
+					kind: "done",
+					result: {
+						kind: "reply",
+						reply: outcome === "frozen" ? frozenReply(message) : reply(message, "已退出会话模式；消息恢复由 Rivus 处理。")
+					}
+				};
+			}
+			case "locked-send": return {
+				kind: "work",
+				work: capturedSendWork(message, runCapturedSend(message, route.agent, route.sendText))
+			};
+			case "select-card":
+			case "select-text": {
+				const reserved = yield* mode.reserveSelection(route.credential);
+				if ("kind" in reserved) {
+					const notice = reserved.kind === "stale" ? "选择已过期（状态已变化或服务重启），请重新 /herdr 后选择。" : reserved.kind === "capacity" ? "会话状态名额已满（64）。" : reserved.kind === "not-selectable" ? reserved.reason : "会话状态暂不可用（保存未确认）；本条未处理，也未转发。";
+					return {
+						kind: "done",
+						result: {
+							kind: "reply",
+							reply: reply(message, notice)
+						}
+					};
+				}
+				return {
+					kind: "work",
+					work: inspectSelectionWork(message, reserved)
+				};
+			}
+			case "enter": {
+				const outcome = yield* mode.enterSelection(message.actorId, message.chatId);
+				if (outcome === "frozen") return {
+					kind: "done",
+					result: {
+						kind: "reply",
+						reply: frozenReply(message)
+					}
+				};
+				if (outcome === "capacity") return {
+					kind: "done",
+					result: {
+						kind: "reply",
+						reply: capacityReply(message)
+					}
+				};
+				return {
+					kind: "work",
+					work: inventoryWorkWithCurrentSelection(message, "menu", "", "已进入会话选择模式；选择目标后，普通消息将直接发送给它（/exit 退出）。")
+				};
+			}
+			case "refresh":
+				if ((yield* mode.refresh(message.actorId, message.chatId)) === "frozen") return {
+					kind: "done",
+					result: {
+						kind: "reply",
+						reply: frozenReply(message)
+					}
+				};
+				return {
+					kind: "work",
+					work: inventoryWorkWithCurrentSelection(message, route.command, route.argument)
+				};
+			case "legacy": return {
+				kind: "work",
+				work: commandWork(message, execute(message, watchExitRevisionOf(message)))
+			};
+		}
+	});
+	/** Runs after the permit is released; a freeze that appeared after admission refuses here. */
+	const runAdmitted = (work) => Effect.suspend(() => {
+		if (mode?.isFrozen()) return Effect.succeed({
+			kind: "reply",
+			reply: reply(work.message, "会话状态暂不可用（保存未确认）；本条未处理，也未转发。")
+		});
+		switch (work.kind) {
+			case "inventory": return Effect.map(work.run, (replyResult) => ({
+				kind: "reply",
+				reply: replyResult
+			}));
+			case "inspect-selection": return work.run;
+			case "captured-send": return work.run;
+			case "command": return Effect.map(work.run, (replyResult) => replyResult === null ? { kind: "consumed" } : {
+				kind: "reply",
+				reply: replyResult
+			});
+		}
+	});
+	/** Single-shot composition for the compatibility handlers; Router composes the
+	* three explicit entries itself inside one withAdmission turn. */
+	const admit = (message) => withAdmission(Effect.gen(function* () {
+		const captured = captureInAdmission(message);
+		return yield* admitCapturedInAdmission(captured);
+	}));
+	const handleDetailed = (message) => Effect.gen(function* () {
+		const outcome = yield* admit(message);
+		if (outcome.kind === "done") return outcome.result;
+		return yield* runAdmitted(outcome.work);
+	});
+	return {
+		handle: (message) => Effect.map(handleDetailed(message), (detailed) => detailed.kind === "reply" ? detailed.reply : null),
+		handleDetailed,
+		submitCaptured: runCapturedSend,
+		admit,
+		withAdmission,
+		captureInAdmission,
+		admitCapturedInAdmission,
+		runAdmitted,
+		conversation: mode ? { mode } : void 0,
+		tick: () => Effect.gen(function* () {
+			const results = [];
+			for (const [key, watch] of watches) {
+				const isCurrent = () => watches.get(key) === watch && watch.expires > options.now() && allowed(watch.actorId, watch.chatId);
+				if (!isCurrent()) {
+					if (watches.get(key) === watch) watches.delete(key);
+					continue;
+				}
+				const current = yield* options.sessions.inspect(watch.binding.agent).pipe(Effect.map((agent) => ({
+					status: agent.status,
+					failed: false
+				})), Effect.catch((error) => Effect.succeed({
+					status: error instanceof TerminalTargetChangedError ? "target changed" : "unavailable",
+					failed: true,
+					error
+				})));
+				if (!isCurrent() || current.status === watch.status) continue;
+				const notification = yield* (current.failed ? recovery({
+					...watch,
+					id: "watch",
+					sentAt: options.now(),
+					text: ""
+				}, watch.binding, current.error) : bindings.selections(watch, [watch.binding.agent]).pipe(Effect.map(([selected]) => detail(watch, {
+					...watch.binding.agent,
+					status: current.status,
+					ready: false
+				}, selected.handle, `状态有变化 · ${new Date(options.now()).toISOString()}。这是观察结果，不代表任务成功；操作前请刷新状态。`)))).pipe(Effect.catch(() => Effect.succeed(void 0)));
+				if (!notification || !isCurrent()) continue;
+				results.push({
+					reply: notification,
+					isCurrent,
+					acknowledge: () => {
+						if (isCurrent()) watch.status = current.status;
+					}
+				});
+			}
+			return results;
+		})
+	};
+}
+//#endregion
+//#region src/adapters/feishu/terminal-session/feishu-terminal-session.ts
+function parseFeishuTerminalMessage(event) {
+	if (!event || typeof event !== "object") return null;
+	const value = event;
+	const message = value.message;
+	if (value.sender?.sender_type !== "user" || !value.sender.sender_id?.open_id || !message?.message_id || !message.chat_id || message.message_type !== "text") return null;
+	try {
+		const content = JSON.parse(message.content ?? "{}");
+		if (!content || typeof content !== "object" || !("text" in content) || typeof content.text !== "string") return null;
+		const sentAt = Number(message.create_time);
+		if (!Number.isFinite(sentAt)) return null;
+		return {
+			id: message.message_id,
+			actorId: value.sender.sender_id.open_id,
+			chatId: message.chat_id,
+			sentAt,
+			text: content.text.replace(/^@_user_\d+\s*/, "")
+		};
+	} catch {
+		return null;
+	}
+}
+async function deliverTerminalBridgeReply(reply, delivery, render) {
+	if (reply.menu && delivery.sendCard) return delivery.sendCard(reply.chatId, renderTerminalMenu({
+		...reply.menu,
+		...reply.menu.kind === "recovery" ? { notice: reply.text } : {}
+	}));
+	if (!reply.screen) return delivery.sendText(reply.chatId, reply.text);
+	try {
+		await delivery.sendImage(reply.chatId, await render(reply.screen));
+	} catch {
+		await delivery.sendText(reply.chatId, `${reply.text} | ${new Date(reply.screen.at).toISOString()}${reply.screen.truncated || reply.screen.text.length > 12e3 ? " | truncated（已截断）" : ""}\n图片暂不可用，以下是终端文字：\n${reply.screen.text.slice(-12e3)}`);
+	}
+}
+const V2_FORM_NAME = /^rivus_herdr_v2_submit_([a-f0-9]{12})$/;
+const HANDLE_PATTERN = /^[a-f0-9]{12}$/;
+/**
+* Issued selection credential carried verbatim from the rendered row; the
+* schema rejects malformed payloads instead of trusting typeof checks.
+*/
+const selectionCredentialSchema = Schema.Struct({
+	epoch: Schema.Trimmed.check(Schema.isNonEmpty()),
+	generation: Schema.Number.check(Schema.makeFilter((generation) => Number.isSafeInteger(generation) && generation >= 0)),
+	actorId: Schema.Trimmed.check(Schema.isNonEmpty()),
+	chatId: Schema.Trimmed.check(Schema.isNonEmpty()),
+	handle: Schema.String.check(Schema.makeFilter((handle) => HANDLE_PATTERN.test(handle)))
+});
+/** Flattened (or pre-flattened) card callback envelope as the SDK hands it to handlers. */
+const cardActionEventSchema = Schema.Struct({
+	event_id: Schema.optional(Schema.String),
+	create_time: Schema.optional(Schema.String),
+	operator: Schema.optional(Schema.Struct({
+		open_id: Schema.optional(Schema.String),
+		operator_id: Schema.optional(Schema.Struct({ open_id: Schema.optional(Schema.String) }))
+	})),
+	event_key: Schema.optional(Schema.String),
+	context: Schema.optional(Schema.Struct({ open_chat_id: Schema.optional(Schema.String) })),
+	action: Schema.optional(Schema.Struct({
+		tag: Schema.optional(Schema.String),
+		name: Schema.optional(Schema.String),
+		value: Schema.optional(Schema.Struct({
+			bridge: Schema.optional(Schema.Literal("herdr")),
+			rivus_action: Schema.optional(Schema.String),
+			command: Schema.optional(Schema.String),
+			handle: Schema.optional(Schema.String.check(Schema.makeFilter((handle) => HANDLE_PATTERN.test(handle)))),
+			page: Schema.optional(Schema.Number),
+			selection: Schema.optional(selectionCredentialSchema)
+		})),
+		form_value: Schema.optional(Schema.Struct({ prompt: Schema.optional(Schema.String) }))
+	}))
+});
+const decodeCardActionEvent = (event) => {
+	try {
+		return Schema.decodeUnknownSync(cardActionEventSchema)(event);
+	} catch {
+		return;
+	}
+};
+/** The wrapped v2 envelope shape: the card callback lives under `event`. */
+const eventEnvelopeSchema = Schema.Struct({ event: Schema.Record(Schema.String, Schema.Unknown) });
+const decodeEventEnvelope = Schema.decodeUnknownSync(eventEnvelopeSchema);
+/**
+* Card callbacks arrive either flattened by the SDK (action at top level) or
+* wrapped under `event` (Pi intake shape); both carry the same payload.
+*/
+const readCardEnvelope = (event) => {
+	const flat = decodeCardActionEvent(event);
+	if (flat !== void 0 && (flat.action !== void 0 || flat.event_key !== void 0 || flat.operator !== void 0)) return flat;
+	let inner;
+	try {
+		inner = decodeEventEnvelope(event).event;
+	} catch {
+		return flat;
+	}
+	return decodeCardActionEvent(inner);
+};
+const hasPiMarker = (value) => {
+	const rivusAction = value?.value?.rivus_action;
+	return rivusAction !== void 0 && rivusAction.length > 0;
+};
+/**
+* Classifies a raw card callback before any handler runs: Pi cards carry
+* `value.rivus_action`, Herdr cards carry `value.bridge === "herdr"` or the v2
+* form name (a submit button cannot carry a value, so its explicit v2 name is
+* the marker). Both markers must be refused by both sides; unmarked legacy
+* cards are invalid and get a refresh instruction.
+*/
+function classifyFeishuCardOwnership(event) {
+	const decoded = readCardEnvelope(event);
+	if (!decoded) return "unmarked";
+	const pi = hasPiMarker(decoded.action);
+	const herdr = decoded.action?.value?.bridge === "herdr" || V2_FORM_NAME.test(decoded.action?.name ?? "");
+	if (pi && herdr) return "conflict";
+	if (pi) return "pi";
+	return herdr ? "herdr" : "unmarked";
+}
+function parseFeishuTerminalAction(event, menuChats) {
+	const decoded = readCardEnvelope(event);
+	if (!decoded) return null;
+	const actorId = decoded.operator?.open_id ?? decoded.operator?.operator_id?.open_id;
+	if (!actorId || !decoded.event_id || !decoded.create_time) return null;
+	let text;
+	let chatId;
+	let selection;
+	if (decoded.event_key) {
+		if (!["herdr_list", "herdr_help"].includes(decoded.event_key)) return null;
+		chatId = menuChats[actorId];
+		text = decoded.event_key === "herdr_list" ? "/herdr menu" : "/herdr help";
+	} else {
+		chatId = decoded.context?.open_chat_id;
+		const action = decoded.action;
+		const form = V2_FORM_NAME.exec(action?.name ?? "");
+		if (form) {
+			if (hasPiMarker(action) || action?.form_value?.prompt === void 0) return null;
+			text = `/herdr submit ${form[1]} -- ${action.form_value.prompt}`;
+		} else {
+			if (action?.tag !== "button" || action.value?.bridge !== "herdr" || hasPiMarker(action)) return null;
+			const command = action.value.command;
+			if (command === "use" || command === "select") {
+				const handle = action.value.handle;
+				const credential = action.value.selection;
+				if (handle === void 0 || credential === void 0 || credential.handle !== handle) return null;
+				text = `/herdr use ${handle}`;
+				selection = credential;
+			} else if (command === "menu") {
+				const page = action.value.page ?? 0;
+				if (!Number.isSafeInteger(page) || page < 0) return null;
+				text = `/herdr menu ${page}`;
+			} else {
+				if (command === void 0 || ![
+					"open",
+					"refresh",
+					"compose",
+					"read",
+					"screen",
+					"watch",
+					"unwatch"
+				].includes(command)) return null;
+				const handle = action.value.handle;
+				if (handle === void 0) return null;
+				text = `/herdr ${command} ${handle}`;
+			}
+		}
+	}
+	const sentAt = Number(decoded.create_time) / (decoded.event_key ? 1 : 1e3);
+	if (!Number.isFinite(sentAt)) return null;
+	return chatId ? {
+		id: `action:${decoded.event_id}`,
+		actorId,
+		chatId,
+		sentAt,
+		text,
+		...selection === void 0 ? {} : { selection }
+	} : null;
+}
+function renderTerminalMenu(menu) {
+	const plain = (content) => ({
+		tag: "plain_text",
+		content
+	});
+	const button = (label, command, handle, page, selection) => ({
+		tag: "button",
+		text: plain(label),
+		type: "default",
+		behaviors: [{
+			type: "callback",
+			value: {
+				bridge: "herdr",
+				command,
+				handle,
+				page,
+				...selection === void 0 ? {} : { selection }
+			}
+		}]
+	});
+	const rowButton = (label, agent) => agent.selection === void 0 ? button(label, "open", agent.handle) : button(label, "use", agent.handle, void 0, agent.selection);
+	const status = (agent) => {
+		if (agent.status === "unavailable") return "离线／暂不可用";
+		if (agent.kind === "terminal") return "终端只读";
+		if (agent.ready && ["idle", "done"].includes(agent.status)) return "等待输入";
+		return {
+			working: "执行中",
+			blocked: "等待处理",
+			idle: "空闲，尚未确认可输入",
+			done: "运行已结束，请刷新确认",
+			unknown: "状态未知"
+		}[agent.status] ?? "暂不可输入";
+	};
+	const elements = [];
+	if (menu.notice) elements.push({
+		tag: "div",
+		text: plain(menu.notice)
+	});
+	if (menu.kind === "list") {
+		elements.push({
+			tag: "markdown",
+			content: `**选择会话** · 第 ${(menu.page ?? 0) + 1}/${menu.pages ?? 1} 页`
+		});
+		const groups = Array$1.groupBy(menu.agents, (agent) => `${agent.session} / ${agent.workspace ?? "会话"}`);
+		for (const [group, agents] of Object.entries(groups)) {
+			elements.push({
+				tag: "div",
+				text: plain(group)
+			});
+			for (const agent of agents) elements.push(rowButton(`${agent.pane} · ${agent.tab ? agent.tab + " / " : ""}${agent.title ?? agent.name} · ${status(agent)}`.slice(0, 100), agent));
+		}
+		if (menu.unavailableSessions?.length) elements.push({
+			tag: "div",
+			text: plain(`以下 session 无法读取，列表不完整：${menu.unavailableSessions.join(", ")}`)
+		});
+		if (!menu.agents.length) elements.push({
+			tag: "markdown",
+			content: "当前没有可用会话。"
+		});
+		if ((menu.page ?? 0) > 0) elements.push(button("上一页", "menu", void 0, menu.page - 1));
+		if ((menu.page ?? 0) + 1 < (menu.pages ?? 1)) elements.push(button("下一页", "menu", void 0, menu.page + 1));
+	} else if (menu.kind === "recovery") {
+		if (menu.agents[0]) elements.push(button("刷新原会话", "refresh", menu.agents[0].handle));
+	} else {
+		const agent = menu.agents[0];
+		elements.push({
+			tag: "div",
+			text: plain(`目标：${agent.session} / ${agent.name}\n状态：${status(agent)}`)
+		});
+		if (menu.kind === "form") {
+			elements.push({
+				tag: "form",
+				name: "herdr_prompt",
+				elements: [{
+					tag: "input",
+					name: "prompt",
+					required: true,
+					input_type: "multiline_text",
+					max_length: 1e3,
+					...menu.draft === void 0 ? {} : { default_value: menu.draft },
+					placeholder: plain("输入要交给此 agent 的指令"),
+					label: plain("指令内容")
+				}, {
+					tag: "button",
+					name: `rivus_herdr_v2_submit_${agent.handle}`,
+					text: plain("发送"),
+					type: "primary_filled",
+					form_action_type: "submit"
+				}]
+			});
+			elements.push({
+				tag: "markdown",
+				content: "每个表单只提交一次；提交后可通过“看输出”核对执行结果。"
+			});
+		} else {
+			const verdict = evaluateTerminalWriteInput(agent, menu.writable);
+			if (verdict.allowed) elements.push(button("发下一条指令", "compose", agent.handle));
+			else elements.push({
+				tag: "div",
+				text: plain(menu.writable && agent.kind === "agent" ? `${verdict.text}请查看输出，或刷新状态后再试。` : "此会话为只读模式。")
+			});
+		}
+		elements.push(button("关注状态", "watch", agent.handle), button("取消关注", "unwatch", agent.handle), button("看画面", "screen", agent.handle), button("看输出", "read", agent.handle), button("刷新当前会话", "refresh", agent.handle));
+	}
+	elements.push(button("刷新会话列表", "menu"));
+	return {
+		schema: "2.0",
+		config: {
+			width_mode: "default",
+			enable_forward: false
+		},
+		header: {
+			title: plain(menu.kind === "form" ? "向会话发送指令" : "Herdr 会话"),
+			template: "blue"
+		},
+		body: { elements }
+	};
+}
+function createFeishuTerminalDelivery(client, options) {
+	const refuseWhenStopped = () => {
+		if (options?.isStopped?.() === true) throw new Error("Herdr runtime is stopped; delivery refused");
+	};
+	return {
+		sendCard: async (chatId, card) => {
+			refuseWhenStopped();
+			if ((await client.im.message.create({
+				params: { receive_id_type: "chat_id" },
+				data: {
+					receive_id: chatId,
+					msg_type: "interactive",
+					content: JSON.stringify(card)
+				}
+			})).code !== 0) throw new Error("Feishu card delivery failed");
+		},
+		sendText: async (chatId, text) => {
+			refuseWhenStopped();
+			if ((await client.im.message.create({
+				params: { receive_id_type: "chat_id" },
+				data: {
+					receive_id: chatId,
+					msg_type: "text",
+					content: JSON.stringify({ text })
+				}
+			})).code !== 0) throw new Error("Feishu text delivery failed");
+		},
+		sendImage: async (chatId, bytes) => {
+			refuseWhenStopped();
+			const value = await client.im.image.create({ data: {
+				image_type: "message",
+				image: Buffer.from(bytes)
+			} });
+			const imageKey = value?.image_key ?? value?.data?.image_key;
+			if (!imageKey) throw new Error("Feishu image upload failed");
+			refuseWhenStopped();
+			if ((await client.im.message.create({
+				params: { receive_id_type: "chat_id" },
+				data: {
+					receive_id: chatId,
+					msg_type: "image",
+					content: JSON.stringify({ image_key: imageKey })
+				}
+			})).code !== 0) throw new Error("Feishu image delivery failed");
+		}
+	};
+}
+//#endregion
+//#region src/adapters/herdr/session/herdr-socket-request.ts
+const responseRecord = Schema.Record(Schema.String, Schema.Unknown);
+const isResponseRecord = Schema.is(responseRecord);
+const isString = Schema.is(Schema.String);
+function object(value) {
+	if (!isResponseRecord(value)) throw new Error("Invalid Herdr response");
+	return value;
+}
+function string(value) {
+	if (!isString(value)) throw new Error("Invalid Herdr response field");
+	return value;
+}
+function requestHerdrSocket(path, method, params, timeoutMs, signal) {
+	return new Promise((resolve, reject) => {
+		const id = randomUUID();
+		const socket = createConnection({ path });
+		let settled = false;
+		let bytes = 0;
+		let buffer = "";
+		const onError = (error) => finish(error);
+		socket.once("close", () => socket.removeListener("error", onError));
+		const finish = (error, result) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			signal.removeEventListener("abort", abort);
+			socket.removeAllListeners("connect");
+			socket.removeAllListeners("data");
+			socket.removeAllListeners("end");
+			socket.destroy();
+			if (error) reject(error);
+			else resolve(result);
+		};
+		const abort = () => finish(/* @__PURE__ */ new Error("Herdr request aborted; input may have been submitted"));
+		const timer = setTimeout(() => finish(/* @__PURE__ */ new Error("Herdr request timed out; input may have been submitted")), timeoutMs);
+		signal.addEventListener("abort", abort, { once: true });
+		socket.setEncoding("utf8");
+		socket.on("connect", () => socket.write(`${JSON.stringify({
+			id,
+			method,
+			params
+		})}\n`));
+		socket.on("error", onError);
+		socket.on("end", () => finish(/* @__PURE__ */ new Error("Herdr closed without a response; outcome unknown")));
+		socket.on("data", (chunk) => {
+			bytes += Buffer.byteLength(chunk);
+			if (bytes > 1048576) return finish(/* @__PURE__ */ new Error("Herdr response exceeds one MiB"));
+			buffer += chunk;
+			const newline = buffer.indexOf("\n");
+			if (newline < 0) return;
+			try {
+				const response = object(JSON.parse(buffer.slice(0, newline)));
+				if (response.id !== id) throw new Error("Herdr response identity mismatch");
+				if (response.error) throw new Error(`Herdr error: ${string(object(response.error).code)}`);
+				finish(void 0, object(response.result));
+			} catch (error) {
+				finish(error);
+			}
+		});
+		if (signal.aborted) abort();
+	});
+}
+//#endregion
+//#region src/adapters/herdr/session/herdr-socket-client.ts
+function createHerdrSocketClient(sessions, timeoutMs = 5e3, discoverSessionsIn) {
+	if (!sessions.length && !discoverSessionsIn || new Set(sessions.map((s) => s.name)).size !== sessions.length) throw new Error("Herdr requires unique configured session names");
+	if (discoverSessionsIn && !isAbsolute(discoverSessionsIn)) throw new Error("Herdr discovery root must be absolute");
+	let configs = new Map(sessions.map((session) => [session.name, session]));
+	const refresh = () => Effect.tryPromise({
+		try: async () => {
+			const discovered = discoverSessionsIn ? await discoverSessions(discoverSessionsIn) : [];
+			const next = /* @__PURE__ */ new Map();
+			const paths = /* @__PURE__ */ new Set();
+			for (const config of [...sessions, ...discovered]) {
+				const path = resolve(config.socketPath);
+				if (paths.has(path)) continue;
+				if (next.has(config.name)) throw new Error("Herdr session aliases collide");
+				next.set(config.name, {
+					...config,
+					socketPath: path
+				});
+				paths.add(path);
+			}
+			configs = next;
+			return [...next.keys()];
+		},
+		catch: (error) => error
+	});
+	const invoke = (session, method, params) => Effect.tryPromise({
+		try: async (signal) => {
+			const config = configs.get(session);
+			if (!config) throw new Error("Unknown Herdr session");
+			const socket = await lstat(config.socketPath);
+			if (!socket.isSocket() || (socket.mode & 63) !== 0 || socket.uid !== process.getuid?.()) throw new Error("Herdr socket must be private and owned by the current user");
+			return {
+				result: await requestHerdrSocket(config.socketPath, method, params, timeoutMs, signal),
+				generation: `${socket.dev}:${socket.ino}:${socket.birthtimeMs}`
+			};
+		},
+		catch: (error) => error
+	});
+	const listSession = (session) => invoke(session, "session.snapshot", {}).pipe(Effect.flatMap(({ result, generation }) => Effect.try(() => {
+		const snapshot = object(result.snapshot);
+		if (snapshot.protocol !== 20 && snapshot.protocol !== 22 || !Array.isArray(snapshot.panes) || !Array.isArray(snapshot.agents)) throw new Error("Herdr protocol 20 or 22 session snapshot required");
+		const agents = snapshot.agents.map(object);
+		const labels = (values, key) => new Map((Array.isArray(values) ? values : []).map((item) => {
+			const entry = object(item);
+			return [string(entry[key]), string(entry.label)];
+		}));
+		const workspaces = labels(snapshot.workspaces, "workspace_id");
+		const tabs = labels(snapshot.tabs, "tab_id");
+		return snapshot.panes.map((entry) => {
+			const value = object(entry);
+			const pane = string(value.pane_id);
+			const terminal = string(value.terminal_id);
+			const agent = agents.find((item) => item.pane_id === pane && item.terminal_id === terminal);
+			const kind = typeof value.agent === "string" && value.agent ? value.agent : "terminal";
+			const workspace = string(value.workspace_id);
+			const tab = string(value.tab_id);
+			const title = [
+				agent?.name,
+				value.label,
+				value.terminal_title_stripped,
+				value.title
+			].find((item) => typeof item === "string" && item.length > 0) ?? kind;
+			return {
+				session,
+				pane,
+				identity: createHash("sha256").update(JSON.stringify([
+					generation,
+					session,
+					pane,
+					terminal,
+					kind,
+					value.agent_session ?? null
+				])).digest("hex"),
+				kind: kind === "terminal" ? "terminal" : "agent",
+				name: `${pane} / ${workspaces.get(workspace) ?? workspace} / ${tabs.get(tab) ?? tab} / ${title}`,
+				workspace: workspaces.get(workspace) ?? workspace,
+				tab: tabs.get(tab) ?? tab,
+				title,
+				status: string(value.agent_status),
+				ready: kind !== "terminal" && agent !== void 0 && (agent.launch_pending === void 0 || agent.launch_pending === false)
+			};
+		});
+	})));
+	const resolve$1 = (agent) => refresh().pipe(Effect.flatMap(() => listSession(agent.session)), Effect.flatMap((agents) => {
+		const current = agents.find((item) => item.pane === agent.pane && item.identity === agent.identity);
+		return current ? Effect.succeed(current) : Effect.fail(new TerminalTargetChangedError());
+	}));
+	return {
+		list: () => refresh().pipe(Effect.flatMap((names) => Effect.all(names.map((name) => listSession(name).pipe(Effect.map((agents) => ({
+			agents,
+			unavailableSessions: []
+		})), Effect.catch(() => Effect.succeed({
+			agents: [],
+			unavailableSessions: [name]
+		})))), { concurrency: 4 })), Effect.map((results) => ({
+			agents: results.flatMap((result) => result.agents),
+			unavailableSessions: results.flatMap((result) => result.unavailableSessions)
+		}))),
+		inspect: resolve$1,
+		read: (agent, visible) => resolve$1(agent).pipe(Effect.flatMap(() => invoke(agent.session, "pane.read", {
+			pane_id: agent.pane,
+			source: visible ? "visible" : "recent_unwrapped",
+			format: "text",
+			lines: visible ? 80 : 120
+		})), Effect.flatMap(({ result }) => Effect.try(() => {
+			const read = object(result.read);
+			return {
+				text: string(read.text),
+				truncated: read.truncated === true
+			};
+		}))),
+		prompt: (agent, text) => resolve$1(agent).pipe(Effect.catch((error) => Effect.fail(error instanceof TerminalTargetChangedError ? error : new TerminalPromptPreflightError("目标暂不可用；未提交指令。可 /exit 后重新选择。"))), Effect.flatMap((current) => {
+			const verdict = evaluateTerminalWriteInput(current, true);
+			return verdict.allowed ? Effect.void : Effect.fail(new TerminalPromptPreflightError(`Input rejected: ${verdict.text}`));
+		}), Effect.flatMap(() => invoke(agent.session, "agent.prompt", {
+			target: agent.pane,
+			text
+		})), Effect.asVoid)
+	};
+}
+async function discoverSessions(root) {
+	const directory = await lstat(root);
+	if (!directory.isDirectory() || directory.uid !== process.getuid?.() || (directory.mode & 18) !== 0) throw new Error("Herdr discovery root must be an owned, non-writable directory");
+	const candidates = [{
+		name: "default",
+		socketPath: join(root, "herdr.sock")
+	}];
+	const named = join(root, "sessions");
+	const info = await lstat(named).catch((error) => {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	});
+	if (info) {
+		if (!info.isDirectory() || info.uid !== process.getuid?.() || (info.mode & 18) !== 0) throw new Error("Invalid Herdr sessions directory");
+		for (const entry of (await readdir(named, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) if (entry.isDirectory()) candidates.push({
+			name: entry.name,
+			socketPath: join(named, entry.name, "herdr.sock")
+		});
+	}
+	const found = [];
+	for (const candidate of candidates) if (await lstat(candidate.socketPath).catch((error) => {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	})) found.push(candidate);
+	return found;
+}
+//#endregion
+//#region src/adapters/outbound/persistence/terminal-session/terminal-agent-schema.ts
+/**
+* File schema for the Application `TerminalAgent` snapshot, shared by every
+* terminal-session store that persists an occupant identity (bindings, conversation
+* states) so validation cannot drift between stores.
+*/
+const terminalAgentSchema = Schema.Struct({
+	kind: Schema.Literals(["agent", "terminal"]),
+	session: Schema.String,
+	pane: Schema.String,
+	identity: Schema.String,
+	name: Schema.String,
+	workspace: Schema.optional(Schema.String),
+	tab: Schema.optional(Schema.String),
+	title: Schema.optional(Schema.String),
+	status: Schema.String,
+	ready: Schema.Boolean
+});
+//#endregion
+//#region src/adapters/outbound/persistence/terminal-session/terminal-bindings-store.ts
+const bindingSchema = Schema.Struct({
+	handle: Schema.String,
+	actorId: Schema.String,
+	chatId: Schema.String,
+	expires: Schema.optional(Schema.Number),
+	agent: terminalAgentSchema
+});
+const snapshotSchema = Schema.Struct({
+	version: Schema.Literal(1),
+	appId: Schema.String,
+	bindings: Schema.Array(bindingSchema)
+});
+async function openTerminalBindingsStore(directory, appId) {
+	const digest = createHash("sha256").update(appId).digest("hex");
+	const filePath = join(directory, `bindings-${digest}.json`);
+	const decode = (value) => {
+		const snapshot = Schema.decodeUnknownSync(snapshotSchema)(value);
+		if (snapshot.appId !== appId || snapshot.bindings.length > 1e3 || new Set(snapshot.bindings.map((binding) => binding.handle)).size !== snapshot.bindings.length || snapshot.bindings.some((binding) => !/^[a-f0-9]{12}$/.test(binding.handle) || binding.expires !== void 0 && !Number.isFinite(binding.expires))) throw new Error("Invalid terminal binding snapshot");
+		return snapshot.bindings;
+	};
+	let initial = [];
+	try {
+		const raw = await readFile(filePath, "utf8");
+		initial = decode(JSON.parse(raw));
+		await chmod(filePath, 384);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw new Error("Cannot restore terminal bindings", { cause: error });
+	}
+	return {
+		initial,
+		save: (bindings) => Effect.uninterruptible(Effect.tryPromise({
+			try: async () => {
+				const snapshot = {
+					version: 1,
+					appId,
+					bindings
+				};
+				const validated = decode(snapshot);
+				await writeAtomicTextFile(filePath, JSON.stringify({
+					...snapshot,
+					bindings: validated
+				}), {
+					mode: 384,
+					durable: true
+				});
+			},
+			catch: (error) => error
+		}))
+	};
+}
+//#endregion
+//#region src/adapters/outbound/persistence/terminal-session/terminal-message-claims.ts
+const isErrnoCode = Schema.Struct({ code: Schema.String });
+/**
+* Exclusive state-directory lifetime lock plus durable source-message and form
+* claims. The caller owns the lock for the store's lifetime: every terminal-session
+* or routing store in the same directory must be opened while this lock is held and
+* must never acquire its own duplicate. Normal stop joins all work before `close`
+* releases the lock; a crashed process leaves the lock on disk and recovery is
+* manual — never an automatic PID/age-based steal. An operator may remove the lock
+* only after the previous owner is verified stopped.
+*/
+function createDirectoryUnlessPresent(path) {
+	return mkdir(path, {
+		recursive: false,
+		mode: 448
+	}).then(() => void 0, (error) => {
+		if (!(Schema.is(isErrnoCode)(error) && error.code === "EEXIST")) throw error;
+	});
+}
+async function openTerminalMessageClaims(directory, appId) {
+	if (await lstat(join(directory, "..")).then(() => false, (error) => {
+		if (Schema.is(isErrnoCode)(error) && error.code === "ENOENT") return true;
+		throw error;
+	})) throw new Error(`State directory parent does not exist: provision the deployment directory before starting (${join(directory, "..")})`);
+	const parentInfo = await lstat(join(directory, ".."));
+	if (parentInfo.isSymbolicLink() || !parentInfo.isDirectory()) throw new Error("State directory parent is not a provisioned directory");
+	await createDirectoryUnlessPresent(directory);
+	const directoryInfo = await lstat(directory);
+	if (directoryInfo.isSymbolicLink() || !directoryInfo.isDirectory()) throw new Error("Claims state directory is not a regular directory");
+	if (directoryInfo.uid !== process.getuid?.() || (directoryInfo.mode & 63) !== 0) throw new Error("Unsafe claims state directory permissions or owner");
+	const parentHandle = await open(join(directory, ".."), "r");
+	try {
+		await parentHandle.sync();
+	} finally {
+		await parentHandle.close();
+	}
+	const lockPath = join(directory, "bridge.lock");
+	const lock = await open(lockPath, "wx", 384);
+	await lock.writeFile(JSON.stringify({
+		pid: process.pid,
+		appId
+	}));
+	const claims = join(directory, "claims");
+	try {
+		await createDirectoryUnlessPresent(claims);
+		const claimsInfo = await lstat(claims);
+		if (claimsInfo.isSymbolicLink() || !claimsInfo.isDirectory()) throw new Error("Claims directory is not a regular directory");
+		if (claimsInfo.uid !== process.getuid?.() || (claimsInfo.mode & 63) !== 0) throw new Error("Unsafe claims directory permissions or owner");
+		const folder = await open(directory, "r");
+		try {
+			await folder.sync();
+		} finally {
+			await folder.close();
+		}
+	} catch (error) {
+		await lock.close().catch(() => void 0);
+		await unlink(lockPath);
+		throw error;
+	}
+	const claimPath = (messageId) => {
+		const digest = createHash("sha256").update(JSON.stringify([appId, messageId])).digest("hex");
+		return join(claims, digest);
+	};
+	return {
+		claim: (message) => Effect.uninterruptible(Effect.tryPromise({
+			try: async () => {
+				let file;
+				try {
+					file = await open(claimPath(message.id), "wx", 384);
+				} catch (error) {
+					if (Schema.is(isErrnoCode)(error) && error.code === "EEXIST") return false;
+					throw error;
+				}
+				try {
+					await file.writeFile(JSON.stringify({
+						state: "claimed",
+						at: Date.now()
+					}));
+					await file.sync();
+					const folder = await open(claims, "r");
+					try {
+						await folder.sync();
+					} finally {
+						await folder.close();
+					}
+					await file.close();
+					return true;
+				} catch (error) {
+					await file.close().catch(() => void 0);
+					throw error;
+				}
+			},
+			catch: (error) => error
+		})),
+		/**
+		* Read-only legacy fence lookup with the exact claim digest. Existence is the
+		* fence: arbitrary or invalid file contents still count as claimed. `false` is
+		* only returned for a missing entry (ENOENT); every other I/O failure
+		* propagates. Never creates, mutates or deletes historic files.
+		*/
+		hasClaim: (messageId) => Effect.tryPromise({
+			try: async () => {
+				try {
+					await lstat(claimPath(messageId));
+					return true;
+				} catch (error) {
+					if (Schema.is(isErrnoCode)(error) && error.code === "ENOENT") return false;
+					throw error;
+				}
+			},
+			catch: (error) => error
+		}),
+		close: async () => {
+			await lock.close();
+			if (JSON.parse(await readFile(lockPath, "utf8")).pid === process.pid) await unlink(lockPath);
+		}
+	};
+}
+//#endregion
+//#region src/bootstrap/feishu/herdr-config.ts
+/** Shared Herdr field schemas for the standalone options and the embedded route config. */
+const herdrSessionSchema = Schema.Struct({
+	name: Schema.Trimmed.check(Schema.isNonEmpty()),
+	socketPath: Schema.String.check(Schema.makeFilter(isAbsolute))
+});
+const nonEmptyStringArray = Schema.NonEmptyArray(Schema.Trimmed.check(Schema.isNonEmpty()));
+const stringRecord = Schema.Record(Schema.String, Schema.Trimmed.check(Schema.isNonEmpty()));
+const absolutePath = Schema.String.check(Schema.makeFilter(isAbsolute));
+const optionalAbsolutePathArray = Schema.optional(Schema.Array(Schema.String.check(Schema.makeFilter(isAbsolute))));
+const sharedHerdrFields = {
+	appId: Schema.Trimmed.check(Schema.isNonEmpty()),
+	sessions: Schema.optional(Schema.Array(herdrSessionSchema)),
+	discoverSessionsIn: Schema.optional(Schema.String.check(Schema.makeFilter(isAbsolute))),
+	allowedActors: nonEmptyStringArray,
+	allowedChats: nonEmptyStringArray,
+	menuChats: Schema.optional(stringRecord),
+	stateDirectory: absolutePath,
+	writable: Schema.optional(Schema.Boolean),
+	fontFiles: optionalAbsolutePathArray
+};
+const standaloneHerdrOptionsSchema = Schema.Struct({
+	...sharedHerdrFields,
+	appSecret: Schema.Trimmed.check(Schema.isNonEmpty())
+});
+const embeddedHerdrRouteSchema = Schema.Struct({ ...sharedHerdrFields });
+//#endregion
+//#region src/adapters/herdr/rendering/terminal-text-image.ts
+const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+const emoji = /* @__PURE__ */ new RegExp("^\\p{RGI_Emoji}$", "v");
+const maxRows = 80;
+const maxColumns = 160;
+const maxGraphemes = 160;
+const maxLineCodeUnits = 1024;
+const maxUniqueGraphemes = 1024;
+const cellWidth = 10.8;
+const shapeWorkerUrl = new URL(`data:text/javascript,${encodeURIComponent(`
+import { parentPort, workerData } from "node:worker_threads";
+const { Resvg } = await import(workerData.resvgModuleUrl);
+parentPort.postMessage(new Resvg(workerData.svg, workerData.options).toString());
+parentPort.close();
+`)}`);
+async function renderTerminalTextImage(screen, fontFiles) {
+	const { renderAsync } = await import("@resvg/resvg-js");
+	const glyphs = /* @__PURE__ */ new Map();
+	const allLines = stripVTControlCharacters(screen.text).replace(/[^\P{Cc}\n\t]/gu, "").split("\n");
+	const title = renderLine(stripVTControlCharacters(screen.title).replace(/\p{Cc}/gu, ""), 30, glyphs);
+	const lines = allLines.slice(0, maxRows).map((line, index) => renderLine(line, 96 + index * 24, glyphs));
+	const clipped = screen.truncated || allLines.length > maxRows || title.clipped || lines.some((line) => line.clipped);
+	const width = 1800;
+	const height = 100 + Math.max(1, lines.length) * 24;
+	const label = `Terminal text rendering | ${new Date(screen.at).toISOString()}${clipped ? " | truncated" : ""}`;
+	const body = lines.map((line) => line.svg).join("");
+	return (await renderAsync(`<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}"><defs>${[1, 2].map((columns) => `<clipPath id="cell-${columns}"><rect width="${columns * cellWidth}" height="24"/></clipPath>`).join("")}<clipPath id="label"><rect width="1752" height="24"/></clipPath>${await shapeAtlas(`<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="24"><g fill="#e5e7eb" font-family="monospace" font-size="18" xml:space="preserve">${[...glyphs].map(([glyph, index]) => `<g id="terminal-glyph-${index}"><text x="0" y="20">${escapeXml(glyph)}</text></g>`).join("")}<g id="terminal-label" fill="#94a3b8"><text x="0" y="20">${escapeXml(label)}</text></g></g></svg>`, { font: {
+		loadSystemFonts: !fontFiles?.length,
+		...fontFiles ? { fontFiles: [...fontFiles] } : {},
+		defaultFontFamily: "monospace"
+	} })}</defs><rect width="100%" height="100%" fill="#101827"/>${title.svg}<g transform="translate(24 38)" clip-path="url(#label)"><use href="#terminal-label"/></g>${body}</svg>`, { font: { loadSystemFonts: false } })).asPng();
+}
+function shapeAtlas(svg, options) {
+	return new Promise((resolve, reject) => {
+		const worker = new Worker(shapeWorkerUrl, { workerData: {
+			svg,
+			options,
+			resvgModuleUrl: import.meta.resolve("@resvg/resvg-js")
+		} });
+		let settled = false;
+		const deadline = setTimeout(() => finish(/* @__PURE__ */ new Error("Terminal image shaping timed out.")), 3e4);
+		function finish(error, paths) {
+			if (settled) return;
+			settled = true;
+			clearTimeout(deadline);
+			worker.terminate().then(() => {
+				worker.removeAllListeners();
+				if (error) reject(error);
+				else resolve(paths);
+			}, (terminationError) => {
+				worker.removeAllListeners();
+				reject(error ?? terminationError);
+			});
+		}
+		worker.once("message", (paths) => {
+			if (typeof paths !== "string") finish(/* @__PURE__ */ new Error("Terminal image shaping returned invalid paths."));
+			else finish(void 0, paths);
+		});
+		worker.once("error", (error) => finish(error));
+		worker.once("exit", (code) => finish(/* @__PURE__ */ new Error(`Terminal image shaping exited before replying (${code}).`)));
+	});
+}
+function renderLine(line, y, glyphs) {
+	const nodes = [];
+	let column = 0;
+	let graphemes = 0;
+	let codeUnits = 0;
+	for (const { segment } of segmenter.segment(line)) {
+		const columns = segment === "	" ? 4 - column % 4 : graphemeColumns(segment);
+		if (column + columns > maxColumns || graphemes >= maxGraphemes || codeUnits + segment.length > maxLineCodeUnits) return {
+			svg: nodes.join(""),
+			clipped: true
+		};
+		if (segment !== "	" && segment !== " ") {
+			let index = glyphs.get(segment);
+			if (index === void 0) {
+				if (glyphs.size >= maxUniqueGraphemes) throw new Error("Terminal image exceeds its unique grapheme budget.");
+				index = glyphs.size;
+				glyphs.set(segment, index);
+			}
+			nodes.push(`<g transform="translate(${24 + column * cellWidth} ${y - 20})" clip-path="url(#cell-${Math.max(1, columns)})"><use href="#terminal-glyph-${index}"/></g>`);
+		}
+		column += columns;
+		graphemes += 1;
+		codeUnits += segment.length;
+	}
+	return {
+		svg: nodes.join(""),
+		clipped: false
+	};
+}
+function graphemeColumns(grapheme) {
+	if (emoji.test(grapheme)) return 2;
+	for (const codePoint of grapheme) if (!/[\p{Mark}\p{Format}]/u.test(codePoint)) return eastAsianWidth(codePoint.codePointAt(0));
+	return 0;
+}
+function escapeXml(text) {
+	return text.replace(/[&<>"']/g, (char) => ({
+		"&": "&amp;",
+		"<": "&lt;",
+		">": "&gt;",
+		"\"": "&quot;",
+		"'": "&apos;"
+	})[char]);
+}
+//#endregion
+//#region src/bootstrap/herdr-feishu-runtime.ts
+const QUEUE_LIMIT = 32;
+const WATCH_INTERVAL_MS = 5e3;
+const STOP_TIMEOUT_MS = 1e4;
+/**
+* Connection-less Herdr bridge core shared by the standalone entrypoint and the
+* embedded single-WebSocket route. Owns the bounded serial work queue, the
+* watch loop, every admitted network promise and the claims-store lifetime.
+*/
+function createHerdrFeishuBridgeRuntime(options) {
+	let stopped = false;
+	const bridge = createTerminalSessionBridge({
+		sessions: {
+			...options.sessions,
+			prompt: (agent, text) => stopped ? Effect.fail(/* @__PURE__ */ new Error("Herdr runtime is stopped; prompt refused")) : options.sessions.prompt(agent, text)
+		},
+		actors: options.actors,
+		chats: options.chats,
+		writable: options.writable,
+		now: options.now ?? Date.now,
+		newHandle: options.newHandle ?? (() => randomBytes(6).toString("hex")),
+		claim: options.claim,
+		...options.bindings === void 0 ? {} : { bindings: options.bindings },
+		...options.conversation === void 0 ? {} : { conversation: options.conversation }
+	});
+	let pending = 0;
+	let tail = Promise.resolve();
+	let watchTimer;
+	const activeFibers = /* @__PURE__ */ new Set();
+	const activeSends = /* @__PURE__ */ new Set();
+	const activeAdmissions = /* @__PURE__ */ new Set();
+	let scheduledAdmissions = 0;
+	const trackAdmission = (start) => {
+		const admission = Promise.resolve().then(start);
+		const tracked = admission.then(() => void 0, () => void 0);
+		activeAdmissions.add(tracked);
+		tracked.then(() => {
+			activeAdmissions.delete(tracked);
+		});
+		return admission;
+	};
+	const gatedSend = (send) => {
+		if (stopped) return Promise.reject(/* @__PURE__ */ new Error("Herdr runtime is stopped; delivery refused"));
+		const started = send();
+		const tracked = started.then(() => void 0, () => void 0);
+		activeSends.add(tracked);
+		tracked.finally(() => {
+			activeSends.delete(tracked);
+		});
+		return started;
+	};
+	const deliverEffect = (reply, messageId, isCurrent = () => true) => Effect.tryPromise({
+		try: async () => {
+			if (!isCurrent()) return false;
+			const delivery = {
+				sendText: (chatId, text) => isCurrent() ? gatedSend(() => options.delivery.sendText(chatId, text)) : Promise.resolve(),
+				sendImage: (chatId, image) => isCurrent() ? gatedSend(() => options.delivery.sendImage(chatId, image)) : Promise.resolve(),
+				...options.delivery.sendCard === void 0 ? {} : { sendCard: (chatId, card) => isCurrent() ? gatedSend(() => options.delivery.sendCard(chatId, card)) : Promise.resolve() }
+			};
+			try {
+				await deliverTerminalBridgeReply(reply, delivery, (screen) => renderTerminalTextImage(screen, options.fontFiles));
+			} catch (error) {
+				if (!isCurrent()) return false;
+				throw error;
+			}
+			if (!isCurrent()) return false;
+			options.onObservation?.({
+				messageId,
+				type: "replied"
+			});
+			return true;
+		},
+		catch: (error) => error
+	});
+	const enqueue = (work) => {
+		if (stopped || pending >= QUEUE_LIMIT) return false;
+		pending++;
+		tail = tail.then(async () => {
+			if (stopped) {
+				pending--;
+				return;
+			}
+			try {
+				await Effect.runPromise(Effect.gen(function* () {
+					const fiber = yield* Effect.forkDetach(work);
+					activeFibers.add(fiber);
+					try {
+						yield* Fiber.join(fiber);
+					} finally {
+						activeFibers.delete(fiber);
+					}
+				}));
+			} catch {
+				options.onObservation?.({ type: "operation_failed" });
+			} finally {
+				pending--;
+			}
+		});
+		return true;
+	};
+	const start = async () => {
+		if (stopped) throw new Error("Herdr runtime is stopped; construct a new runtime instead");
+		if (watchTimer !== void 0) return;
+		watchTimer = setInterval(() => {
+			if (pending) return;
+			enqueue(Effect.gen(function* () {
+				for (const notification of yield* bridge.tick()) yield* deliverEffect(notification.reply, "watch", notification.isCurrent).pipe(Effect.tap((delivered) => delivered ? Effect.sync(() => notification.acknowledge()) : Effect.void), Effect.catch(() => Effect.sync(() => {
+					options.onObservation?.({ type: "notification_failed" });
+				})));
+			}));
+		}, WATCH_INTERVAL_MS);
+	};
+	const stopIntake = () => {
+		stopped = true;
+		if (options.stopState !== void 0) options.stopState.stopped = true;
+		if (watchTimer !== void 0) {
+			clearInterval(watchTimer);
+			watchTimer = void 0;
+		}
+	};
+	const scheduleAdmission = async (start) => {
+		if (stopped) {
+			options.onObservation?.({ type: "admission_refused_stopped" });
+			return "stopped";
+		}
+		if (scheduledAdmissions >= QUEUE_LIMIT) {
+			options.onObservation?.({ type: "admission_refused_full" });
+			return "full";
+		}
+		scheduledAdmissions++;
+		trackAdmission(start).catch((error) => {
+			options.onObservation?.({ type: "admission_failed" });
+			console.error("Herdr background admission failed", error);
+		}).then(() => {
+			scheduledAdmissions--;
+		});
+		return "accepted";
+	};
+	const runAdmission = async (start) => {
+		if (stopped) {
+			options.onObservation?.({ type: "admission_refused_stopped" });
+			return { kind: "stopped" };
+		}
+		return {
+			kind: "accepted",
+			value: await trackAdmission(start)
+		};
+	};
+	let stopPromise;
+	const completeStop = async () => {
+		stopIntake();
+		if (stopPromise) return stopPromise;
+		stopPromise = (async () => {
+			let timeoutHandle;
+			try {
+				await Promise.race([Promise.all([
+					tail.catch(() => void 0),
+					...[...activeFibers].map((fiber) => Effect.runPromise(Fiber.interrupt(fiber)).catch(() => void 0)),
+					...activeAdmissions,
+					...activeSends
+				]), new Promise((_, reject) => {
+					timeoutHandle = setTimeout(() => reject(/* @__PURE__ */ new Error("Herdr runtime stop timed out; the state lock is retained")), options.stopTimeoutMs ?? STOP_TIMEOUT_MS);
+				})]);
+			} catch (error) {
+				if (timeoutHandle !== void 0) clearTimeout(timeoutHandle);
+				stopPromise = void 0;
+				throw error;
+			}
+			if (timeoutHandle !== void 0) clearTimeout(timeoutHandle);
+			await options.closeStores();
+		})();
+		return stopPromise;
+	};
+	return {
+		bridge,
+		submit: async (message) => enqueue(Effect.gen(function* () {
+			const response = yield* bridge.handle(message);
+			if (response !== null) yield* deliverEffect(response, message.id);
+		})),
+		execute: async (entry) => {
+			const outcome = entry.outcome;
+			if (outcome.kind === "done") return enqueue(outcome.result.kind === "reply" ? deliverEffect(outcome.result.reply, entry.message.id) : Effect.void);
+			return enqueue(Effect.gen(function* () {
+				const result = yield* bridge.runAdmitted(outcome.work);
+				if (result.kind === "reply") yield* deliverEffect(result.reply, entry.message.id);
+			}));
+		},
+		reply: async (chatId, text) => {
+			try {
+				await gatedSend(() => options.delivery.sendText(chatId, text));
+			} catch {}
+		},
+		runAdmission,
+		scheduleAdmission,
+		start,
+		stopIntake,
+		completeStop,
+		stop: () => completeStop()
+	};
+}
+//#endregion
+export { openTerminalBindingsStore as a, classifyFeishuCardOwnership as c, parseFeishuTerminalMessage as d, openTerminalMessageClaims as i, createFeishuTerminalDelivery as l, embeddedHerdrRouteSchema as n, terminalAgentSchema as o, standaloneHerdrOptionsSchema as r, createHerdrSocketClient as s, createHerdrFeishuBridgeRuntime as t, parseFeishuTerminalAction as u };
+