agentworkshop 0.7.41 → 0.7.46

package/.output/server/chunks/build/useWorkshopWs-B-Es2Xg3.mjs

@@ -0,0 +1,1782 @@
+import { e as useUserStore } from '../virtual/entry.mjs';
+import { n as narrowFetch } from './narrow-fetch-CcG-BPxc.mjs';
+import { a as apiErrorMessage } from './api-error-BwAQLw44.mjs';
+import { u as useTownBus } from './useTownBus-D9SoIsAN.mjs';
+import { ref, watch, reactive } from 'vue';
+import { defineStore } from 'pinia';
+
+//#region app/stores/workshop/notifications.ts
+/**
+* 用户级通知 store(v17 主计划 §6)。
+*
+* 事实源是服务端 `user_notifications` 表:`notification.created` 帧只负责"到达",
+* 游标补拉(REST / WS subNotifications)负责"补齐"。因此本 store 的关键不是推送本身,
+* 而是**幂等 + 断线可补**:
+*  - `eventId` 是唯一幂等键 —— 同一条通知既可能经频道流副本、也可能经用户定向帧到达,
+*    重复 eventId 一律丢弃(绝不产生第二行、也不弹第二次);
+*  - `notification.*` 帧的 `seq` 恒为 0 且 `channelId` 可能是空串,不能参与频道 seq 去重,
+*    幂等只能落在本 store 的 eventId 集合上;
+*  - 重连/刷新后按游标向**后**补拉,与直播帧按 id 合并,不丢不重。
+*/
+/** seenEventIds 上限(防长会话内存无限增长;淘汰最旧一半) */
+var SEEN_CAP = 2e3;
+var useNotificationsStore = defineStore("workshop.notifications", () => {
+	/** 新→旧 */
+	const items = ref([]);
+	const unreadCount = ref(0);
+	/** 最新一条的游标(断线补拉的起点) */
+	const cursor = ref(null);
+	/** 已消费的 eventId(幂等键;直播帧与补拉帧共用) */
+	const seenEventIds = ref(/* @__PURE__ */ new Set());
+	/** 快照是否已加载(重连时的路径选择:未加载 → 快照;已加载 → 游标补拉) */
+	const loaded = ref(false);
+	/** 最近一条**实时**通知(不含补拉/快照):NotificationCenter 据此弹窗,避免重连补发刷屏 */
+	const liveItem = ref(null);
+	const liveSeq = ref(0);
+	/**
+	* 补发窗口标志:服务端 subNotifications 会把游标之后的历史通知**以
+	* notification.created 帧逐条直发**(ws.ts 的补发循环),与直播帧形状完全一致。
+	* 若不区分,重连补发 200 条就会弹 200 个提示 —— 这里在发出订阅帧时开窗、
+	* 收到 notification.snapshot 收尾帧时关窗;窗口内照常入库,只是不弹窗。
+	*/
+	const replaying = ref(false);
+	let replayTimer = null;
+	function beginReplay(timeoutMs = 5e3) {
+		replaying.value = true;
+		if (replayTimer) clearTimeout(replayTimer);
+		replayTimer = setTimeout(() => {
+			replaying.value = false;
+			replayTimer = null;
+		}, timeoutMs);
+	}
+	function endReplay() {
+		replaying.value = false;
+		if (replayTimer) {
+			clearTimeout(replayTimer);
+			replayTimer = null;
+		}
+	}
+	function markSeen(eventId) {
+		if (!eventId) return;
+		const seen = seenEventIds.value;
+		if (!seen.has(eventId)) seen.add(eventId);
+		if (seen.size > SEEN_CAP) {
+			const keep = [...seen].slice(-Math.floor(SEEN_CAP / 2));
+			seenEventIds.value = new Set(keep);
+		}
+	}
+	/** 按 createdAt 降序插入(同毫秒保持先到先排 => 后到者更靠前) */
+	function insertDesc(n) {
+		const list = items.value;
+		let idx = 0;
+		while (idx < list.length && list[idx].createdAt >= n.createdAt) idx++;
+		list.splice(idx, 0, n);
+	}
+	/** 幂等入库;返回是否为**新增**(重复帧返回 false —— 不重复弹窗、不重复计数) */
+	function upsertNotification(n, opts = {}) {
+		if (!n?.id) return false;
+		const idx = items.value.findIndex((x) => x.id === n.id);
+		if (idx >= 0) {
+			items.value[idx] = {
+				...items.value[idx],
+				...n
+			};
+			return false;
+		}
+		if (n.eventId && seenEventIds.value.has(n.eventId)) return false;
+		markSeen(n.eventId);
+		insertDesc(n);
+		if (!n.readAt) unreadCount.value += 1;
+		advanceCursor(n);
+		if (opts.live) {
+			liveItem.value = n;
+			liveSeq.value += 1;
+		}
+		return true;
+	}
+	/** 游标只朝"更新"方向推进(补拉回来的旧行不倒退游标) */
+	function advanceCursor(n) {
+		const cur = cursor.value;
+		if (!cur || n.createdAt > cur.createdAt || n.createdAt === cur.createdAt && n.id > cur.id) cursor.value = {
+			createdAt: n.createdAt,
+			id: n.id
+		};
+	}
+	/** 帧消费(由 useWorkshopWs 在频道 seq 守卫之外调用:seq=0 / channelId 可能为空) */
+	function applyEnvelope(e) {
+		if (e.type === "notification.created") {
+			upsertNotification(e.payload, { live: !replaying.value });
+			return;
+		}
+		if (e.type === "notification.read") applyRead(e.payload);
+	}
+	/** 已读帧(多标签页同步):按单条 / 频道范围 / 全部收敛 */
+	function applyRead(p) {
+		const at = p.readAt || (/* @__PURE__ */ new Date()).toISOString();
+		for (const n of items.value) {
+			if (n.readAt) continue;
+			if (p.id && n.id !== p.id) continue;
+			if (!p.id && p.channelId && n.channelId !== p.channelId) continue;
+			n.readAt = at;
+		}
+		unreadCount.value = items.value.filter((n) => !n.readAt).length;
+	}
+	/** 首屏/刷新快照:替换式(以 DB 为准收敛 WS 期间的可能漂移) */
+	async function loadSnapshot() {}
+	/**
+	* 断线/重连补拉:以本端游标向**后**取,按 id/eventId 合并(幂等)。
+	* 未加载过快照时退化为 loadSnapshot()。
+	*
+	* **必须循环排空**:服务端单页上限 200,而本端每页只取 PAGE_LIMIT;
+	* 原实现只抓一页就返回 —— 断线期间积压超过一页时,游标只推进一页,
+	* 其余通知要等**下一次**重连才可能补上(计划 §11.11「重连后通知不丢」)。
+	* 这里按"返回满页即有更多"排空,并设页数上限兜底(防服务端 bug 导致死循环)。
+	*/
+	async function backfill() {
+		return 0;
+	}
+	/**
+	* WS 重连收尾帧(`notification.snapshot`)携带的服务端游标。
+	* 服务端按 200 条/页重放,超过一页时只靠帧是补不全的 —— 用它把游标推到
+	* 服务端最后重放的位置,再交给 `backfill()` 继续排空。
+	*/
+	function applyReplayCursor(next) {
+		if (!next) return;
+		if (!cursor.value || next.createdAt > cursor.value.createdAt || next.createdAt === cursor.value.createdAt && next.id > cursor.value.id) cursor.value = next;
+	}
+	/** 标记已读(REST 为准;先请求后本地收敛,失败抛出交给调用方提示) */
+	async function markRead(opts) {
+		const token = useUserStore().token;
+		const res = await narrowFetch("/api/workshop/notifications/read", {
+			method: "POST",
+			body: { ...opts },
+			headers: token ? { authorization: `Bearer ${token}` } : {}
+		});
+		if (res.code !== 0 || !res.data) throw new Error(res.message ?? "标记已读失败");
+		const at = (/* @__PURE__ */ new Date()).toISOString();
+		for (const n of items.value) {
+			if (n.readAt) continue;
+			if (opts.id && n.id !== opts.id) continue;
+			if (!opts.id && !opts.all && opts.channelId && n.channelId !== opts.channelId) continue;
+			n.readAt = at;
+		}
+		unreadCount.value = res.data.unreadCount ?? items.value.filter((n) => !n.readAt).length;
+		return res.data.count ?? 0;
+	}
+	/** 退出登录:清空本用户可见内容(防串号) */
+	function clear() {
+		items.value = [];
+		unreadCount.value = 0;
+		cursor.value = null;
+		seenEventIds.value = /* @__PURE__ */ new Set();
+		loaded.value = false;
+		liveItem.value = null;
+		endReplay();
+	}
+	return {
+		items,
+		unreadCount,
+		cursor,
+		seenEventIds,
+		loaded,
+		liveItem,
+		liveSeq,
+		replaying,
+		beginReplay,
+		endReplay,
+		applyEnvelope,
+		applyRead,
+		upsertNotification,
+		loadSnapshot,
+		backfill,
+		applyReplayCursor,
+		markRead,
+		clear
+	};
+});
+//#endregion
+//#region app/stores/workshop/connection.ts
+/**
+* WS 连接管理:单条 WebSocket 复用订阅多 channel(sub/unsub),
+* 指数退避重连 + lastSeq 断线续传;连接态/seq 供状态条渲染。
+*/
+/** 半死连接阈值:超过该时长无任何帧(pong/事件)→ 主动断开重连 */
+var STALE_MS = 45e3;
+/**
+* 数据级失联阈值:pong 仍应答但长期无数据帧(服务端 HMR 后 hub 失联等)→ 主动重连恢复订阅。
+* 需与心跳周期(30s)联动:检测延迟最坏为阈值 + 一个心跳周期。阈值须显著大于
+* 空闲 channel 的正常静默(无活动即无数据帧),避免健康空闲连接被反复重连。
+*/
+var DATA_STALE_MS = 9e4;
+var useWsConnectionStore = defineStore("workshop.connection", { state: () => ({
+	state: "closed",
+	/** 已订阅 channel → 最近 seq(断线续传游标) */
+	cursors: {},
+	/** 最近一次数据帧到达时间(ms;0 = 尚无数据)——状态条"最后已知更新"依据(open-tag 规范:断连时不假装在线) */
+	lastDataAt: 0,
+	/** 断线期间是否有已订阅 channel 游标待对齐(重连后收到首帧清零) */
+	pendingReplay: false,
+	lastError: "",
+	retryCount: 0
+}) });
+/** WS 会话对象(非 store:持原生 WebSocket,事件回调注入消费方) */
+var WorkshopWsSession = class {
+	onEvent;
+	onStateChange;
+	onPendingReplay;
+	onDataRecovered;
+	ws = null;
+	retry = 0;
+	closedByUser = false;
+	subscribed = /* @__PURE__ */ new Set();
+	/** 每 channel 订阅引用计数:多组件(总览页/控制台/抽屉)共享同一订阅,最后一个引用释放才真正退订 */
+	refCounts = /* @__PURE__ */ new Map();
+	/** 每 channel 最近 seq(重连续传游标;由事件回调 updateCursor 持续推进) */
+	lastSeqByChannel = /* @__PURE__ */ new Map();
+	/** 最近收帧时间(半死连接检测基准) */
+	lastFrameAt = 0;
+	/** 最近收数据帧时间(pong 除外;数据级失联检测基准) */
+	lastDataAt = 0;
+	/** 用户 token(用户级隔离:sub 帧鉴权;由消费方注入) */
+	userToken = "";
+	constructor(onEvent, onStateChange, onPendingReplay = () => {}, onDataRecovered = () => {}) {
+		this.onEvent = onEvent;
+		this.onStateChange = onStateChange;
+		this.onPendingReplay = onPendingReplay;
+		this.onDataRecovered = onDataRecovered;
+	}
+	/** 事件消费方推进游标(供重连 lastSeq 续传) */
+	updateCursor(channelId, seq) {
+		if (Number.isFinite(seq)) this.lastSeqByChannel.set(channelId, seq);
+	}
+	url() {
+		return "ws://localhost/api/workshop/ws";
+	}
+	connect() {}
+	/** 半死连接检测(心跳窗口):无任何帧超阈值 → 主动断开;pong-only 无数据帧超阈值(HMR 后 hub 失联)→ 主动断开重连恢复订阅 */
+	checkStale() {
+		const ws = this.ws;
+		if (!ws || ws.readyState !== WebSocket.OPEN) return;
+		if (Date.now() - this.lastFrameAt > STALE_MS) ws.close();
+		else if (Date.now() - this.lastDataAt > DATA_STALE_MS) ws.close();
+	}
+	sendSub(channelId, lastSeq) {
+		const frame = {
+			type: "sub",
+			channelId,
+			token: this.userToken
+		};
+		if (typeof lastSeq === "number") frame.lastSeq = lastSeq;
+		this.ws?.send(JSON.stringify(frame));
+	}
+	subscribe(channelId, lastSeq) {
+		const prev = this.refCounts.get(channelId) ?? 0;
+		this.refCounts.set(channelId, prev + 1);
+		if (prev > 0) return;
+		this.subscribed.add(channelId);
+		if (typeof lastSeq === "number") this.lastSeqByChannel.set(channelId, lastSeq);
+		if (this.ws?.readyState === WebSocket.OPEN) this.sendSub(channelId, this.lastSeqByChannel.get(channelId));
+		else if (!this.ws) this.connect();
+	}
+	/** 建连但不订阅任何 channel:纯场景事件消费方(daq 实时帧)用。
+	*  服务端在连接层注册 scene peer,连上即收 daq.reading 等无频道广播。 */
+	ensureConnected() {}
+	unsubscribe(channelId) {
+		const prev = this.refCounts.get(channelId) ?? 0;
+		if (prev <= 1) {
+			this.refCounts.delete(channelId);
+			this.subscribed.delete(channelId);
+			if (this.ws?.readyState === WebSocket.OPEN) this.ws?.send(JSON.stringify({
+				type: "unsub",
+				channelId
+			}));
+		} else this.refCounts.set(channelId, prev - 1);
+	}
+	/** 当前 channel 的订阅引用数(0 = 会话已不持有;消费方据此决定是否清本地缓冲) */
+	refCount(channelId) {
+		return this.refCounts.get(channelId) ?? 0;
+	}
+	ping() {
+		try {
+			this.ws?.send(JSON.stringify({ type: "ping" }));
+		} catch {
+			try {
+				this.ws?.close();
+			} catch {}
+		}
+	}
+	close() {
+		this.closedByUser = true;
+		this.ws?.close();
+	}
+};
+//#endregion
+//#region app/composables/workshop/event-blocks/classify.ts
+var TOOL_PREFIX = /^🔧\s*\S+/;
+/** 事件 → 聚合类别 */
+function classifyEvent(e) {
+	switch (e.type) {
+		case "agent.status.message": return TOOL_PREFIX.test(String(e.payload.text ?? "")) ? "tool" : "status";
+		case "agent.status": return "life";
+		case "a2a.message": return "route";
+		case "agent.delta":
+		case "agent.message": return "stream";
+		case "task.status":
+		case "task.progress": return "task";
+		case "a2a.artifact": return "artifact";
+		case "agent.member": return "member";
+		case "memory.saved": return "memory";
+		case "error": return "error";
+		default: return "other";
+	}
+}
+/** agent 稳定配色(id hash → hue;无 id 灰。饱和度/亮度压低:白字首字母可达 AA 对比;
+*  同一色相供头像/泳道头/提及悬停卡共用 —— 身份色全站同源,不另造配色) */
+function agentHueColor(agentId) {
+	if (!agentId) return "#6e6e77";
+	let h = 0;
+	for (const ch of agentId) h = (h * 31 + ch.charCodeAt(0)) % 360;
+	return `hsl(${h}, 42%, 34%)`;
+}
+//#endregion
+//#region app/composables/workshop/event-blocks/attention.ts
+var TIER_ORDER = {
+	silent: 0,
+	status: 1,
+	attention: 2,
+	terminal: 3
+};
+/** 事件 → 注意力档位 */
+function envelopeTier(e) {
+	switch (e.type) {
+		case "error": return "attention";
+		case "a2a.artifact":
+		case "agent.message": return "terminal";
+		case "task.status": {
+			const s = String(e.payload.state ?? "");
+			if (s === "COMPLETED" || s === "FAILED" || s === "CANCELED") return "terminal";
+			if (s === "WAITING") return "attention";
+			return "status";
+		}
+		case "a2a.message": return (e.payload.metadata ?? {})["x-aw-require-reply"] === "true" ? "attention" : "status";
+		case "agent.delta":
+		case "agent.status.message":
+		case "task.progress":
+		case "memory.saved": return "silent";
+		default: return "status";
+	}
+}
+/** 块 → 注意力档位(块内最高档;终局产出块不被同块 silent 帧拉低) */
+function blockTier(events) {
+	let best = "silent";
+	for (const e of events) {
+		const t = envelopeTier(e);
+		if (TIER_ORDER[t] > TIER_ORDER[best]) best = t;
+	}
+	return best;
+}
+//#endregion
+//#region app/composables/workshop/event-blocks/text-utils.ts
+/** 统一化空白比较 */
+function normText(s) {
+	return s.replace(/\s+/g, " ").trim();
+}
+/** 流块当前是否处于打字机状态(尾巴是 delta 且未落定) */
+function isStreaming(block) {
+	const ev = block.events[block.events.length - 1];
+	if (!ev) return false;
+	return ev.type === "agent.delta" && !block.settled;
+}
+/** 任务语义类的 taskId(信封 taskId 优先) */
+function taskIdOf(e) {
+	if (e.taskId) return e.taskId;
+	switch (e.type) {
+		case "task.status":
+		case "task.progress": return String(e.payload.taskId ?? "") || null;
+		case "a2a.artifact": return String(e.payload.taskId ?? "") || null;
+		default: return null;
+	}
+}
+/** 合并键内 taskId 兼容:单侧缺省视为无约束 */
+function taskCompatible(a, b) {
+	return a == null || b == null || a === b;
+}
+/** 落定文本与累计水路的关系 */
+function foldRelation(trail, short) {
+	const t = trail.trim();
+	const s = short.trim();
+	if (!t || !s) return "none";
+	if (t === s || normText(t) === normText(s)) return "dup";
+	if (s.startsWith(t)) return "extend";
+	return "none";
+}
+/** 事件正文(delta/status.text/message.parts/artifact.parts) */
+function textOf(e) {
+	switch (e.type) {
+		case "agent.delta": return String(e.payload.delta ?? "");
+		case "agent.status.message": return String(e.payload.text ?? "");
+		case "agent.message":
+		case "a2a.message": return (e.payload.parts ?? []).map((p) => p.text ?? "").join("\n");
+		case "a2a.artifact": return (e.payload.artifact?.parts ?? []).map((p) => p.text ?? "").join("\n");
+		default: return "";
+	}
+}
+/** 流块的最终可见文本(delta 累计;落定帧不重复该文) */
+function buildStreamText(block) {
+	if (block.overrideText) return block.overrideText;
+	let acc = "";
+	for (const e of block.events) {
+		if (e.type === "agent.delta") {
+			acc += textOf(e);
+			continue;
+		}
+		if (e.type === "agent.status.message") continue;
+		if (e.type === "agent.message") {
+			const t = textOf(e).trim();
+			if (t) acc = `${acc ? `${acc}\n` : ""}${t}`;
+			continue;
+		}
+	}
+	return acc;
+}
+/**
+* 打字光标可见性(空光标闪烁修复的权威语义):
+* 仅当"已有文本 &&(流式未落定 || 揭示未追平)"时显示;空文本块绝不显示光标。
+*/
+function streamCursorVisible(fullLen, visibleLen, streaming) {
+	return fullLen > 0 && (streaming || visibleLen < fullLen);
+}
+//#endregion
+//#region app/composables/workshop/event-blocks/clusterer.ts
+/**
+* 增量聚类器:块对象身份稳定,只处理新增帧。
+*
+* 与旧版差异:
+*  - 增量聚类:只处理新增帧,块对象身份稳定(Vue 按 key 复用组件,流式更新不整树重建)
+*  - 内容智能去重:落定全文(status.message/agent.message)与已累计 delta 相同或为前缀扩展时
+*    绝不重复渲染第二遍——修复"连续两次重复渲染"(omp 消息流 delta 与 message_end 全文重复)
+*  - 跨块落定折回:工具调用把流切段时,deltas 累计跨块跟踪,message_end 全文按内容比对折回
+*    最后一段流块;先前流片段标记 coveredBy 折叠为一行提示(OpenHands 风格)
+*/
+var BlockClusterer = class {
+	arr = [];
+	last = null;
+	tracks = /* @__PURE__ */ new Map();
+	trail = Object.create(null);
+	idSeq = 0;
+	processed = 0;
+	/** 上次同步时列表头部事件的 seq(头部变化 = 历史回填插入/ring 裁剪/过滤切换 → 必须全量重建,否则索引错位重复聚类) */
+	headSeq = void 0;
+	get blocks() {
+		return this.arr;
+	}
+	get processedCount() {
+		return this.processed;
+	}
+	reset() {
+		this.arr.length = 0;
+		this.last = null;
+		this.tracks.clear();
+		this.trail = Object.create(null);
+		this.processed = 0;
+		this.headSeq = void 0;
+	}
+	/**
+	* 序列同步:只处理新增帧。列表头部 seq 变化(loadHistory 头部插入历史帧并整体
+	* 排序 / ring 容量裁剪 / 过滤切换)时,已处理事件整体右移——按索引继续会把已
+	* 聚类事件重复成块,故检测到头部变化即全量重建(一次重建,确定性无重复)。
+	*/
+	sync(events) {
+		const head = events.length > 0 ? events[0]?.seq : void 0;
+		if (events.length < this.processed || head !== this.headSeq) this.reset();
+		for (let i = this.processed; i < events.length; i++) this.push(events[i]);
+		this.processed = events.length;
+		this.headSeq = events.length > 0 ? events[0]?.seq : void 0;
+	}
+	push(e) {
+		if (e.type === "channel.snapshot" || e.type === "pong") return this.last;
+		if (e.type === "agent.delta" && !textOf(e)) return this.last;
+		if ((e.type === "agent.status.message" || e.type === "agent.message") && !textOf(e).trim()) return this.last;
+		const agentId = e.agentId ?? null;
+		const taskId = taskIdOf(e);
+		const agentKey = agentId ?? "";
+		const trackKey = `${agentKey}\u0000${taskId ?? ""}`;
+		const baseKind = classifyEvent(e);
+		if (e.type === "agent.status.message" && baseKind === "status") {
+			const t = textOf(e).trim();
+			const track = this.tracks.get(trackKey);
+			if (t && track && track.text) {
+				const rel = foldRelation(track.text, t);
+				if (rel === "dup" || rel === "extend") return this.foldInto(track, e, t);
+			}
+		}
+		if (e.type === "agent.message") {
+			const t = textOf(e).trim();
+			const track = this.tracks.get(trackKey);
+			if (t && track && track.text) {
+				const rel = foldRelation(track.text, t);
+				if (rel === "dup" || rel === "extend") return this.foldInto(track, e, t);
+			}
+		}
+		let kind = baseKind;
+		if (e.type === "agent.delta") kind = "stream";
+		else if (e.type === "agent.message") kind = "stream";
+		else if (baseKind === "status") {
+			const lb = this.last;
+			if (lb !== null && lb.kind === "stream" && e.agentId === lb.agentId && taskCompatible(lb.taskId, taskId) && !lb.settled) kind = "stream";
+		}
+		if (this.last !== null && this.last.kind === kind && this.last.agentId === e.agentId && agentId !== null && taskCompatible(this.last.taskId, taskId) && !(kind === "stream" && this.last.settled) && !(kind === "task" && this.last.taskId && taskId && this.last.taskId !== taskId) && !(kind === "artifact" && this.last.taskId && taskId && this.last.taskId !== taskId) && this.last) {
+			const b = this.last;
+			b.events.push(e);
+			b.lastAt = e.at;
+			if (kind === "stream") {
+				if (e.type === "agent.delta") {
+					b.settled = false;
+					const t = this.tracks.get(trackKey);
+					if (t) {
+						t.text += textOf(e);
+						t.last = b;
+						this.setTrail(agentKey, taskId, t.text);
+					} else {
+						b.settled = false;
+						this.setTrail(agentKey, taskId, textOf(e));
+					}
+				} else {
+					b.settled = true;
+					this.setTrail(agentKey, taskId, `${textOf(e)}`);
+				}
+			}
+			return b;
+		}
+		const block = reactive({
+			id: `b${++this.idSeq}`,
+			kind,
+			agentId,
+			taskId,
+			events: [e],
+			firstAt: e.at,
+			lastAt: e.at,
+			settled: kind === "stream" ? e.type !== "agent.delta" : false,
+			folded: 0,
+			overrideText: null,
+			coveredBy: null,
+			dupStream: false
+		});
+		this.arr.push(block);
+		this.last = block;
+		if (kind === "stream") {
+			const tk = this.tracks.get(trackKey);
+			if (tk && tk.pieces.length > 0 && !tk.pieces.includes(block)) {
+				tk.pieces.push(block);
+				tk.last = block;
+			} else if (!tk) this.tracks.set(trackKey, {
+				text: "",
+				pieces: [block],
+				last: block
+			});
+			if (e.type === "agent.delta") {
+				const t = this.tracks.get(trackKey);
+				if (t) {
+					t.text += textOf(e);
+					this.setTrail(agentKey, taskId, t.text);
+				}
+			}
+		}
+		if (kind === "artifact") {
+			const t = textOf(e);
+			const prior = this.trail[trackKey] ?? this.trail[`${agentKey}\u0000`];
+			if (prior && t && normText(prior) === normText(t)) block.dupStream = true;
+		}
+		return block;
+	}
+	/** 内容重复折回:已累计流足够覆盖时不再成块;折回块重渲染一律以落定全文为准
+	*  (跨工具切段折回时,目标块只含尾部 delta,不覆盖全文则文本被截断) */
+	foldInto(track, e, text) {
+		const target = track.last;
+		target.events.push(e);
+		target.folded += 1;
+		target.lastAt = e.at;
+		target.settled = true;
+		target.overrideText = text;
+		for (const p of track.pieces) if (p !== target) p.coveredBy = target.id;
+		track.text = "";
+		track.pieces = [target];
+		track.last = target;
+		this.setTrail(target.agentId ?? "", target.taskId, text);
+		return target;
+	}
+	setTrail(agentKey, taskId, text) {
+		this.trail[`${agentKey}\u0000${taskId ?? ""}`] = text;
+	}
+};
+//#endregion
+//#region app/stores/workshop/events.ts
+/**
+* AEP 事件缓冲:per-channel 环形(ring 5000,与服务端 RING_CAP 同量级)+
+* lastSeq 游标 + 派生 selectors。全部渲染组件从本 store 派生,不直接持有事件。
+*/
+var RING_CAP = 5e3;
+/** 过滤器 → 允许的事件类型集合(key = 档位过滤:只看注意级+终局级,open-tag deliveryTier)。导出供回归测试复用。 */
+var FILTER_TYPES = {
+	all: null,
+	messages: [
+		"agent.message",
+		"agent.delta",
+		"agent.status.message",
+		"a2a.message"
+	],
+	tasks: [
+		"task.status",
+		"task.progress",
+		"a2a.artifact"
+	],
+	team: ["agent.member", "task.status"],
+	errors: ["error"],
+	key: null
+};
+/**
+* 单帧是否命中时间线过滤 —— **唯一事实源**。
+* 全量重算(computeTimeline)与增量追加(timeline getter)必须共用本函数,
+* 否则两条路径的语义会悄悄分叉(表现为"刷新后少了/多了几条")。
+*
+* 导出供回归测试使用:测试要验证的是「增量维护 ⊆ 与全量重算等价」,
+* 参照实现必须调用同一个谓词,否则测的是参照写得对不对,而不是实现是否等价。
+*
+* 注意 `filter === 'key'` 是**提前返回**:该档位只看注意级/终局级,
+* 刻意不受 focus 影响(聚焦是"看某人的流",key 是"只看需要我介入的",两者正交)。
+*/
+function matchesTimeline(e, filter, allow, focus) {
+	if (e.type === "channel.snapshot") return false;
+	if (filter === "key") {
+		const t = envelopeTier(e);
+		return t === "attention" || t === "terminal";
+	}
+	if (allow && !allow.includes(e.type)) return false;
+	if (focus && e.type !== "task.status" && e.type !== "task.progress") {
+		if (e.agentId === focus) return true;
+		if (e.type === "a2a.message") return e.payload.metadata?.["x-aw-target-agent"] === focus;
+		return false;
+	}
+	return true;
+}
+/** 时间线过滤纯函数(全量重算路径;增量路径见 matchesTimeline) */
+function computeTimeline(items, filter, allow, focus) {
+	return items.filter((e) => matchesTimeline(e, filter, allow, focus));
+}
+/** 稳定空数组:让"无数据"返回同一引用,避免下游 computed 每帧产出新数组触发重渲染 */
+var EMPTY_ITEMS = Object.freeze([]);
+var timelineCache = /* @__PURE__ */ new Map();
+/** 在按 seq 升序的数组里找第一个 seq > 目标值 的下标(二分,O(log n)) */
+function firstIndexAfterSeq(items, seq) {
+	let lo = 0;
+	let hi = items.length;
+	while (lo < hi) {
+		const mid = lo + hi >>> 1;
+		if ((items[mid]?.seq ?? 0) > seq) hi = mid;
+		else lo = mid + 1;
+	}
+	return lo;
+}
+var EMPTY_RING = () => ({
+	lastSeq: 0,
+	items: [],
+	consumed: /* @__PURE__ */ new Set(),
+	byAgent: /* @__PURE__ */ new Map()
+});
+/** 尾部追加建档(与 items.push 配对) */
+function indexAppend(ring, e) {
+	const key = e.agentId;
+	if (!key) return;
+	const bucket = ring.byAgent.get(key);
+	if (bucket) bucket.push(e);
+	else ring.byAgent.set(key, [e]);
+}
+/** 头部淘汰出档(与 items.splice(0, n) 配对);按引用查找,防同 seq 重放误删 */
+function indexEvict(ring, dropped) {
+	for (const e of dropped) {
+		const bucket = ring.byAgent.get(e.agentId ?? "");
+		if (!bucket) continue;
+		const idx = bucket.indexOf(e);
+		if (idx >= 0) bucket.splice(idx, 1);
+		if (bucket.length === 0) ring.byAgent.delete(e.agentId ?? "");
+	}
+}
+var useEventsStore = defineStore("workshop.events", {
+	state: () => ({
+		rings: {},
+		filters: {},
+		/** 时间线聚焦的 agent(只看该 agent 的流;null = 全部) */
+		focusAgents: {},
+		/** lane 历史已回填的 agent(channelId → agentId 集合;防视图切换重复拉取) */
+		laneLoaded: {}
+	}),
+	getters: {
+		ring(state) {
+			return (channelId) => state.rings[channelId] ?? EMPTY_RING();
+		},
+		/** 应用过滤 + agent 聚焦后的时间线(虚拟滚动/自动吸底消费;per-channel 增量缓存) */
+		timeline(state) {
+			return (channelId) => {
+				const ring = state.rings[channelId];
+				if (!ring) return EMPTY_ITEMS;
+				const filter = state.filters[channelId] ?? "all";
+				const focus = state.focusAgents[channelId] ?? null;
+				const items = ring.items;
+				const allow = FILTER_TYPES[filter];
+				const maxSeq = items.length > 0 ? items[items.length - 1]?.seq ?? 0 : -1;
+				const prev = timelineCache.get(channelId);
+				if (!prev || prev.filter !== filter || prev.focus !== focus || items.length === 0 && prev.result.length > 0 || prev.lastSeq > maxSeq) {
+					const result = computeTimeline(items, filter, allow, focus);
+					timelineCache.set(channelId, {
+						filter,
+						focus,
+						lastSeq: maxSeq,
+						result
+					});
+					return result;
+				}
+				const headSeq = items[0]?.seq ?? 0;
+				const res = prev.result;
+				if (res.length > 0 && (res[0]?.seq ?? 0) < headSeq) {
+					let drop = 0;
+					while (drop < res.length && (res[drop]?.seq ?? 0) < headSeq) drop++;
+					res.splice(0, drop);
+				}
+				if (maxSeq > prev.lastSeq) {
+					const from = firstIndexAfterSeq(items, prev.lastSeq);
+					for (let i = from; i < items.length; i++) {
+						const e = items[i];
+						if (matchesTimeline(e, filter, allow, focus)) res.push(e);
+					}
+					prev.lastSeq = maxSeq;
+				}
+				return res;
+			};
+		},
+		/**
+		* 某 agent 的事件子序列(增量索引,O(1) 取用)。
+		* lane 视图用它替代 `items.filter(e => e.agentId === id)` —— 后者每帧对每个成员
+		* 各扫一遍整条 ring(见 ChannelRing.byAgent 的说明)。
+		* 无数据时返回**同一个冻结空数组**,避免下游 computed 每帧产出新引用而触发重渲染。
+		*/
+		agentEvents(state) {
+			return (channelId, agentId) => {
+				if (!agentId) return EMPTY_ITEMS;
+				return state.rings[channelId]?.byAgent.get(agentId) ?? EMPTY_ITEMS;
+			};
+		},
+		lastSeq(state) {
+			return (channelId) => state.rings[channelId]?.lastSeq ?? 0;
+		}
+	},
+	actions: {
+		/** 消费一帧 AEP(连接回调入口):快照重建 ring,增量追加并推进游标 */
+		ingest(e) {
+			if (!e.channelId) return;
+			const ring = this.rings[e.channelId] ?? EMPTY_RING();
+			if (e.type === "channel.snapshot") {
+				this.rings[e.channelId] = {
+					lastSeq: e.seq,
+					items: [],
+					consumed: /* @__PURE__ */ new Set([e.seq]),
+					byAgent: /* @__PURE__ */ new Map()
+				};
+				return;
+			}
+			if (typeof e.seq === "number" && e.seq > ring.lastSeq) {
+				ring.consumed.add(e.seq);
+				if (e.type === "agent.delta") {
+					const last = ring.items[ring.items.length - 1];
+					if (last && last.type === "agent.delta" && last.agentId === e.agentId && (last.taskId ?? null) === (e.taskId ?? null) && last) {
+						const prev = last.payload.delta;
+						last.payload.delta = prev + e.payload.delta;
+						ring.lastSeq = e.seq;
+						this.rings[e.channelId] = ring;
+						return;
+					}
+				}
+				ring.items.push(e);
+				indexAppend(ring, e);
+				if (ring.items.length > RING_CAP) indexEvict(ring, ring.items.splice(0, ring.items.length - RING_CAP));
+				ring.lastSeq = e.seq;
+				if (ring.consumed.size > 2e4) ring.consumed = new Set(ring.items.map((i) => i.seq));
+				this.rings[e.channelId] = ring;
+			}
+		},
+		setFilter(channelId, filter) {
+			this.filters[channelId] = filter;
+		},
+		/**
+		* 持久化历史拉取(server 驱动):刷新后从 DB 拉最近事件并填充 ring。
+		* 与 WS 增量无缝衔接:仅接受 seq ≤ 当前游标的帧;已消费过的 seq
+		* (含被 delta 合并吃掉的中间 seq,经 consumed 集合识别)绝不重复插入。
+		* 剔除 agent.delta 过程帧:落定 agent.message 携带全文,历史窗口
+		* 不被单 agent 的打字机帧淹没(其他 agent 的消息才能进窗口)。
+		*/
+		async loadHistory(channelId, limit = 200) {},
+		/**
+		* 向上翻页加载更早历史(beforeSeq 游标;时间线"加载更早"按钮驱动)。
+		* 仅接受 seq < 当前 ring 最小 seq 的帧,插入头部;consumed 去重防御。
+		* 返回 false 表示已无更早历史(按钮隐藏)。
+		*/
+		async loadEarlier(channelId, limit = 200) {
+			return false;
+		},
+		/**
+		* lane 历史按需回填:按 agent 维度拉取该成员的全部事件(剔除 delta 过程帧),
+		* 合并进 channel ring —— lanes 谓词按 agentId 过滤,时间线同样受益。
+		* laneLoaded 守卫保证每订阅生命周期内每 agent 只回填一次(视图切换不重复拉取;
+		* clear 随 ring 一并重置);拉取失败移除守卫,下次挂载可重试。
+		* 快照竞态防御:ring 未建立(lastSeq=0,channel.snapshot 未到)时先有界等待 ——
+		* 过早合并会被快照全量重建整环覆盖,等价于白拉。
+		*/
+		async loadLaneHistory(channelId, agentId, limit = 200) {},
+		/**
+		* lane 向上翻页:该 agent 在 ring 内的最小 seq 为游标,拉更早一段。
+		* 返回 false 表示该 agent 已无更早历史(lane"加载更早"按钮隐藏)。
+		*/
+		async loadLaneEarlier(channelId, agentId, limit = 200) {
+			return false;
+		},
+		setFocusAgent(channelId, agentId) {
+			this.focusAgents[channelId] = agentId;
+		},
+		clear(channelId) {
+			Reflect.deleteProperty(this.rings, channelId);
+			Reflect.deleteProperty(this.laneLoaded, channelId);
+		}
+	}
+});
+//#endregion
+//#region app/stores/workshop/entities.ts
+/**
+* 实体归一化:channel/agent/task 快照 + AEP 增量 upsert(幂等)。
+* REST 命令后的状态以 WS 事件回流为准(REST 返回值不直接写状态,避免双源)。
+*/
+/** 终态判定(与后端 TERMINAL_TASK_STATES 同口径) */
+function isTerminalState(state) {
+	return state === "COMPLETED" || state === "FAILED" || state === "CANCELED";
+}
+/** 空根队列投影(未收到快照/队列帧时的安全缺省) */
+function emptyRootQueue() {
+	return {
+		activeRootId: null,
+		queuedRoots: [],
+		completedRoots: 0,
+		activeRootCount: 0,
+		queuedRootCount: 0
+	};
+}
+/**
+* 快照缺 rootQueue 字段时的兜底推导(旧服务端帧/测试)。
+* 排序口径与后端一致:rootQueueSeq ASC,再 created_at ASC。
+*/
+function deriveRootQueue(tasks) {
+	const roots = tasks.filter((t) => !t.parentId && t.rootQueueSeq != null).sort((a, b) => (a.rootQueueSeq ?? 0) - (b.rootQueueSeq ?? 0) || String(a.createdAt).localeCompare(String(b.createdAt)));
+	const open = roots.filter((t) => !isTerminalState(t.state));
+	return {
+		activeRootId: open[0]?.id ?? null,
+		queuedRoots: open.slice(1).map((t, i) => ({
+			taskId: t.id,
+			title: t.title,
+			position: i + 2,
+			state: t.state,
+			createdAt: t.createdAt
+		})),
+		completedRoots: roots.length - open.length,
+		activeRootCount: open.length > 0 ? 1 : 0,
+		queuedRootCount: Math.max(0, open.length - 1)
+	};
+}
+var useEntitiesStore = defineStore("workshop.entities", {
+	state: () => ({
+		channels: {},
+		agents: {},
+		tasks: {},
+		/**
+		* 根任务队列(§2.2/§8):**后端权威投影**,前端不再自行推导 active root。
+		* 来源 = channel.snapshot.rootQueue + `root.queue` 增量帧。
+		*/
+		rootQueues: {},
+		/** refreshTasks 进行中标志(节流) */
+		refreshing: {},
+		/** refreshAgents 进行中标志(节流) */
+		refreshingAgents: {}
+	}),
+	getters: {
+		agentById(state) {
+			return (channelId, agentId) => state.agents[channelId]?.find((a) => a.agentId === agentId);
+		},
+		/** agent 名字解析(事件渲染用):已知成员取名字,否则 id 前 8 位 */
+		agentName(state) {
+			return (channelId, agentId) => {
+				if (!agentId) return "system";
+				return (state.agents[channelId]?.find((x) => x.agentId === agentId))?.name ?? agentId.slice(0, 8);
+			};
+		},
+		/** 任务标题解析(事件渲染用):已知任务取标题,否则 id 前 8 位 */
+		taskTitle(state) {
+			return (channelId, taskId) => {
+				if (!taskId) return "";
+				return (state.tasks[channelId]?.find((x) => x.id === taskId))?.title ?? taskId.slice(0, 8);
+			};
+		},
+		rootTasks(state) {
+			return (channelId) => (state.tasks[channelId] ?? []).filter((t) => !t.parentId);
+		},
+		taskById(state) {
+			return (channelId, taskId) => state.tasks[channelId]?.find((t) => t.id === taskId);
+		},
+		busyCount(state) {
+			return (channelId) => (state.agents[channelId] ?? []).filter((a) => a.state === "busy").length;
+		},
+		/** 根任务队列(§2.2;后端权威投影 + 本地兜底推导) */
+		rootQueue(state) {
+			return (channelId) => state.rootQueues[channelId] ?? emptyRootQueue();
+		},
+		/** active root id(前端所有"当前根任务"判断的**唯一**来源) */
+		activeRootId(state) {
+			return (channelId) => state.rootQueues[channelId]?.activeRootId ?? (state.tasks[channelId] ?? []).filter((t) => !t.parentId && !isTerminalState(t.state))[0]?.id ?? null;
+		}
+	},
+	actions: {
+		applySnapshot(payload) {
+			const { channelId } = payload;
+			this.channels[channelId] = {
+				...payload.channel,
+				loadedAt: Date.now()
+			};
+			this.agents[channelId] = payload.agents.map((a) => ({
+				...a,
+				modelRef: a.config?.modelRef ?? a.modelRef ?? null
+			}));
+			this.tasks[channelId] = payload.tasks.map((t) => this.toTaskView(t));
+			this.rootQueues[channelId] = payload.rootQueue ?? deriveRootQueue(payload.tasks);
+		},
+		applyEvent(e) {
+			const cid = e.channelId;
+			switch (e.type) {
+				case "agent.status": {
+					const list = this.agents[cid] ?? [];
+					const raw = e.payload;
+					const p = {
+						agentId: raw.agentId,
+						state: raw.state,
+						currentTaskId: raw.currentTaskId ?? null,
+						currentTaskTitle: raw.currentTaskTitle ?? null,
+						currentTaskProgress: raw.currentTaskProgress ?? null,
+						queued: raw.queued ?? raw.queuedCount ?? 0,
+						completed: raw.completed ?? raw.completedCount ?? 0,
+						/** §8:监督 / 连续性帧必须落 store —— 旧实现丢弃 supervision,watchdog 只闪首帧 */
+						...raw.context !== void 0 ? { context: raw.context } : {},
+						...raw.supervision ? { supervision: raw.supervision } : {},
+						...raw.continuity ? { continuity: raw.continuity } : {}
+					};
+					const idx = list.findIndex((a) => a.agentId === p.agentId);
+					if (idx >= 0) list[idx] = {
+						...list[idx],
+						...p
+					};
+					else {
+						const fresh = {
+							agentId: p.agentId,
+							state: p.state,
+							currentTaskId: p.currentTaskId ?? null,
+							queued: p.queued,
+							completed: p.completed,
+							name: p.agentId.slice(0, 8),
+							role: "worker",
+							harness: "-",
+							...raw.supervision ? { supervision: raw.supervision } : {},
+							...raw.continuity ? { continuity: raw.continuity } : {}
+						};
+						list.push(fresh);
+						this.refreshAgents(cid);
+					}
+					this.agents[cid] = [...list];
+					break;
+				}
+				case "agent.member": {
+					const p = e.payload;
+					const list = this.agents[cid] ?? [];
+					const idx = list.findIndex((a) => a.agentId === p.agentId);
+					if (p.op === "added") {
+						if (idx < 0) list.push({
+							agentId: p.agentId,
+							name: p.name,
+							role: p.role,
+							harness: p.harness,
+							enabled: p.enabled,
+							config: p.config,
+							modelRef: p.config?.modelRef ?? null,
+							state: "idle",
+							currentTaskId: null,
+							queued: 0,
+							completed: 0
+						});
+					} else if (p.op === "updated") {
+						if (idx >= 0) {
+							const prev = list[idx];
+							const nextConfig = p.config ?? prev.config;
+							list[idx] = {
+								...prev,
+								name: p.name ?? prev.name,
+								role: p.role ?? prev.role,
+								harness: p.harness ?? prev.harness,
+								enabled: p.enabled ?? prev.enabled,
+								config: nextConfig,
+								modelRef: nextConfig?.modelRef ?? prev.modelRef ?? null
+							};
+						}
+					} else if (p.op === "removed") {
+						if (idx >= 0) list.splice(idx, 1);
+					}
+					this.agents[cid] = [...list];
+					break;
+				}
+				case "task.status": {
+					const p = e.payload;
+					const list = this.tasks[cid] ?? [];
+					const idx = list.findIndex((t) => t.id === p.taskId);
+					if (idx >= 0) {
+						const prev = list[idx];
+						list[idx] = {
+							...prev,
+							state: p.state,
+							assigneeId: p.assigneeId ?? prev.assigneeId,
+							title: p.title ?? prev.title,
+							parentId: p.parentId ?? prev.parentId,
+							rootQueueSeq: p.rootQueueSeq ?? prev.rootQueueSeq,
+							progress: Math.max(prev.progress, p.progress ?? 0),
+							routeReason: p.routeReason ?? prev.routeReason,
+							closeReason: p.closeReason ?? prev.closeReason,
+							deadlineAt: p.deadlineAt ?? prev.deadlineAt,
+							retryCount: p.retryCount ?? prev.retryCount,
+							createdAt: p.createdAt ?? prev.createdAt,
+							artifacts: Math.max(prev.artifacts, p.artifacts ?? 0)
+						};
+					} else {
+						const fresh = {
+							id: p.taskId,
+							title: p.title ?? p.taskId.slice(0, 8),
+							state: p.state,
+							progress: p.progress ?? 0,
+							assigneeId: p.assigneeId ?? "",
+							artifacts: p.artifacts ?? 0
+						};
+						if (p.parentId) fresh.parentId = p.parentId;
+						if (p.rootQueueSeq != null) fresh.rootQueueSeq = p.rootQueueSeq;
+						if (p.routeReason) fresh.routeReason = p.routeReason;
+						if (p.closeReason) fresh.closeReason = p.closeReason;
+						if (p.deadlineAt) fresh.deadlineAt = p.deadlineAt;
+						if (p.retryCount != null) fresh.retryCount = p.retryCount;
+						if (p.createdAt) fresh.createdAt = p.createdAt;
+						list.push(fresh);
+						if (p.title === void 0) this.refreshTasks(cid);
+					}
+					this.tasks[cid] = [...list];
+					break;
+				}
+				case "task.progress": {
+					const p = e.payload;
+					const list = this.tasks[cid] ?? [];
+					const idx = list.findIndex((t) => t.id === p.taskId);
+					const prev = idx >= 0 ? list[idx] : void 0;
+					if (prev) list[idx] = {
+						...prev,
+						progress: p.progress
+					};
+					this.tasks[cid] = [...list];
+					break;
+				}
+				case "root.queue":
+					this.rootQueues[cid] = e.payload;
+					break;
+				case "a2a.artifact": {
+					const p = e.payload;
+					if (!p.taskId) break;
+					const list = this.tasks[cid] ?? [];
+					const idx = list.findIndex((t) => t.id === p.taskId);
+					const prev = idx >= 0 ? list[idx] : void 0;
+					if (prev) list[idx] = {
+						...prev,
+						artifacts: prev.artifacts + 1
+					};
+					this.tasks[cid] = [...list];
+					break;
+				}
+			}
+		},
+		toTaskView(t) {
+			return {
+				id: t.id,
+				parentId: t.parentId,
+				rootQueueSeq: t.rootQueueSeq,
+				title: t.title,
+				state: t.state,
+				progress: t.progress,
+				assigneeId: t.assigneeId,
+				artifacts: t.artifacts.length,
+				routeReason: t.routeReason,
+				sourceChatMessageId: t.sourceChatMessageId,
+				sourceChatDeliveryId: t.sourceChatDeliveryId,
+				retryCount: t.retryCount,
+				closeReason: t.closeReason,
+				deadlineAt: t.deadlineAt,
+				createdAt: t.createdAt,
+				updatedAt: t.updatedAt
+			};
+		},
+		/** WS 断连后的 REST 兜底刷新(命令后立即对齐用) */
+		refreshChannel(channelId, snapshot) {
+			this.applySnapshot(snapshot);
+		},
+		/**
+		* 节流 REST 成员对齐:事件流里冒出的未知 agent 缺 name/role/harness 元信息,
+		* 拉一次成员列表 upsert(以 REST 为准;事件流继续增量更新 state)。
+		*/
+		refreshAgents(channelId) {
+			if (this.refreshingAgents[channelId]) return;
+			this.refreshingAgents[channelId] = true;
+			narrowFetch(`/api/workshop/channels/${channelId}/agents`, { headers: { authorization: `Bearer ${useUserStore().token}` } }).then((res) => {
+				const fresh = res.data ?? [];
+				const merged = [...this.agents[channelId] ?? []];
+				for (const m of fresh) {
+					const idx = merged.findIndex((a) => a.agentId === m.id);
+					if (idx >= 0) merged[idx] = {
+						...merged[idx],
+						name: m.name,
+						role: m.role,
+						harness: m.harness,
+						config: m.config
+					};
+					else merged.push({
+						agentId: m.id,
+						name: m.name,
+						role: m.role,
+						harness: m.harness,
+						config: m.config,
+						state: "idle",
+						currentTaskId: null,
+						queued: 0,
+						completed: 0
+					});
+				}
+				this.agents[channelId] = merged;
+			}).catch(() => {}).finally(() => {
+				this.refreshingAgents[channelId] = false;
+			});
+		},
+		/**
+		* 节流 REST 任务对齐:订阅后新建任务从事件构建时缺标题/父子关系,
+		* 拉一次任务列表 upsert(以 REST 为准;事件流继续增量更新)。
+		*/
+		refreshTasks(channelId) {
+			if (this.refreshing[channelId]) return;
+			this.refreshing[channelId] = true;
+			narrowFetch(`/api/workshop/channels/${channelId}/tasks`, { headers: { authorization: `Bearer ${useUserStore().token}` } }).then((res) => {
+				const fresh = res.data ?? [];
+				const current = this.tasks[channelId] ?? [];
+				const byId = new Map(current.map((t) => [t.id, t]));
+				const freshIds = new Set(fresh.map((t) => t.id));
+				const merged = fresh.map((t) => {
+					const prev = byId.get(t.id);
+					const next = this.toTaskView(t);
+					return prev && prev.progress > next.progress ? {
+						...next,
+						progress: prev.progress
+					} : next;
+				});
+				for (const t of current) if (!freshIds.has(t.id)) merged.push(t);
+				this.tasks[channelId] = merged;
+			}).catch(() => {}).finally(() => {
+				this.refreshing[channelId] = false;
+			});
+		}
+	}
+});
+//#endregion
+//#region app/stores/workshop/hitl.ts
+/**
+* HITL 全局待办 store:omp ask 对话框 + dcw 工具审批 + 各 harness 原生提问/审批的统一待答视图。
+*
+* 数据源:
+*  - AEP hitl.request/hitl.resolved 帧(v17 起服务端按用户定向推送;频道流 seq 帧与
+*    channelId='' 直推帧各到一次,upsert 按 kind+id 幂等去重;徽标不依赖 channel 订阅)
+*  - GET /api/workshop/hitl/pending 快照(页面挂载/重连后的基线对齐)—— **快照是权威**:
+*    替换式写入,WS 期间漂移的陈旧条目不会残留(例如他端已决策但本端漏帧)
+*
+* 应答统一走 `answer()`(REST /workshop/hitl/respond):
+*  - 409 ALREADY_RESOLVED(他端/引擎已处理)→ 重拉快照收敛,UI 提示"已被他人处理";
+*  - 403 APPROVAL_FORBIDDEN(审批策略 owner_only 或资格快照不收)→ 原样上抛策略文案。
+* 终端面板(omp)另有直连 WS 应答路径,与本 store 互不影响。
+*/
+var keyOf = (i) => `${i.kind}:${i.id}`;
+/** 从 FetchError/Error 中取业务码(信封 code 优先,其次 HTTP 状态映射) */
+function outcomeOf(err) {
+	const e = err ?? {};
+	const raw = e.data?.code ?? e.response?.data?.code;
+	const status = Number(e.statusCode ?? e.status ?? e.response?.status ?? 0);
+	return {
+		ok: false,
+		code: raw !== void 0 && raw !== null ? String(raw) : status === 409 ? "ALREADY_RESOLVED" : status === 403 ? "APPROVAL_FORBIDDEN" : status ? `HTTP_${status}` : "",
+		message: apiErrorMessage(err)
+	};
+}
+var useHitlStore = defineStore("workshop.hitl", {
+	state: () => ({
+		/** 当前待人工处理条目(kind+id 幂等;v17 可选字段 method/options/questions/policy 原样透传) */
+		items: [],
+		/** 快照已加载(防重复拉取;WS 掉线重连后由 invalidate 重置) */
+		snapshotLoaded: false,
+		/** 正在提交的条目 `${kind}:${id}`(按钮 loading / 防重复点击) */
+		answering: null
+	}),
+	getters: {
+		count: (state) => state.items.length,
+		/** 按 agent 分组(徽标下拉/跳转用) */
+		byAgent: (state) => {
+			const map = /* @__PURE__ */ new Map();
+			for (const i of state.items) {
+				const list = map.get(i.agentId) ?? [];
+				list.push(i);
+				map.set(i.agentId, list);
+			}
+			return map;
+		},
+		/** 单条查询(页头按 kind+id 定位当前条目状态) */
+		byKey: (state) => (kind, id) => state.items.find((i) => i.kind === kind && i.id === id)
+	},
+	actions: {
+		/** AEP 帧消费(hitl.request / hitl.resolved;幂等 upsert/remove) */
+		applyEnvelope(e) {
+			if (e.type === "hitl.request") {
+				const item = e.payload;
+				const key = keyOf(item);
+				const idx = this.items.findIndex((i) => keyOf(i) === key);
+				if (idx >= 0) this.items[idx] = item;
+				else this.items.push(item);
+			} else if (e.type === "hitl.resolved") {
+				const r = e.payload;
+				this.items = this.items.filter((i) => keyOf(i) !== keyOf(r));
+			}
+		},
+		/** 快照对齐(挂载/重连;替换式 —— 以 REST 为准收敛 WS 期间的可能漂移) */
+		async loadSnapshot() {},
+		/**
+		* 统一应答(REST;页头 ask/审批表单与任何非终端入口共用)。
+		* 409/403 不抛出:调用方按 code 渲染"已被他人处理 / 无审批权限"专用提示。
+		*/
+		async answer(item, payload) {
+			const key = keyOf(item);
+			if (this.answering) return {
+				ok: false,
+				code: "BUSY",
+				message: "已有应答提交中"
+			};
+			this.answering = key;
+			const token = useUserStore().token;
+			try {
+				const res = await narrowFetch("/api/workshop/hitl/respond", {
+					method: "POST",
+					body: {
+						kind: item.kind,
+						id: item.id,
+						...payload
+					},
+					headers: token ? { authorization: `Bearer ${token}` } : {}
+				});
+				if (res.code !== 0) {
+					await this.loadSnapshot();
+					return {
+						ok: false,
+						code: String(res.code ?? ""),
+						message: res.message ?? "应答失败"
+					};
+				}
+				this.items = this.items.filter((i) => keyOf(i) !== key);
+				await this.loadSnapshot();
+				return {
+					ok: true,
+					code: "",
+					message: res.message ?? "ok"
+				};
+			} catch (err) {
+				const out = outcomeOf(err);
+				if (out.code === "ALREADY_RESOLVED" || out.code === "APPROVAL_FORBIDDEN" || out.code === "NOT_RESPONDABLE") await this.loadSnapshot();
+				return out;
+			} finally {
+				this.answering = null;
+			}
+		},
+		/** WS 断线重连后重新对齐 */
+		invalidate() {
+			this.snapshotLoaded = false;
+		},
+		clear() {
+			this.items = [];
+			this.snapshotLoaded = false;
+			this.answering = null;
+		}
+	}
+});
+//#endregion
+//#region app/stores/workshop/chat.ts
+/**
+* 群聊 store(v17 主计划 §5-§7 的前端事实层)。
+*
+* 数据来源三路,共用同一份状态:
+*  ① 频道流 chat.* 帧(chat.message / chat.delivery.status / chat.member / chat.settings);
+*  ② channel.snapshot 的群聊侧基线(payload.chat:成员/最近消息/设置/能力);
+*  ③ REST 历史/名册/权限(断线后补齐 WS 窗口外的数据)。
+*
+* **幂等是硬约束**:同一条 chat.message 可能同时来自实时帧、快照重放与 REST 回填,
+* 三路一律按消息 `id` 去重(投递按 deliveryId、成员按 userId、通知按 eventId),
+* 重复帧绝不产生第二行 —— 否则刷新/重连后时间线会整体翻倍。
+*
+* 排序:createdAt 升序 + 插入序稳定(同毫秒消息保持先到先排)。
+*/
+/** 业务错误码(VERSION_CONFLICT / CHAT_DISABLED / ALREADY_RESOLVED …) */
+function chatErrorCode(err) {
+	const e = err ?? {};
+	const code = e.response?.data?.code ?? e.data?.code;
+	return code === void 0 || code === null ? "" : String(code);
+}
+/**
+* 统一错误文案:axios 把服务端信封放在 `response.data`,ofetch 放在 `data`,
+* 项目的 `apiErrorMessage` 只识别后者 —— 这里先补 axios 分支再回落到它。
+*/
+function chatErrorMessage(err) {
+	const e = err ?? {};
+	const msg = e.response?.data?.message ?? e.data?.message;
+	if (typeof msg === "string" && msg.trim()) return msg.trim();
+	return apiErrorMessage(err);
+}
+/** 同一 createdAt 时保持插入序:找到第一个「严格更晚」的下标插入 */
+function insertSorted(list, msg) {
+	let idx = list.length;
+	for (let i = list.length - 1; i >= 0; i--) {
+		if (list[i].createdAt <= msg.createdAt) {
+			idx = i + 1;
+			break;
+		}
+		idx = i;
+	}
+	list.splice(idx, 0, msg);
+}
+var useChatStore = defineStore("workshop.chat", () => {
+	const messages = ref({});
+	const members = ref({});
+	const settings = ref({});
+	const deliveries = ref({});
+	const permissions = ref({});
+	/**
+	* 已成功拉过历史的频道集合。
+	*
+	* 注意:「还能不能继续往前拉」由 `hasMoreHistory` 决定,本集合只表示"至少拉过一次"
+	* (用于跳过重复的首屏加载)。两者语义不同,不要互相替代。
+	*/
+	const loadedChannels = ref(/* @__PURE__ */ new Set());
+	/** 每频道「还有更早历史」标志(loadHistory/loadEarlier 判定为空后置 false) */
+	const hasMoreHistory = ref({});
+	const loadingHistory = ref({});
+	/** 回复目标(引用链;Composer 消费,发完即清) */
+	const replyTarget = ref(null);
+	function listOf(channelId) {
+		return messages.value[channelId] ??= [];
+	}
+	/** 幂等 upsert:同 id 只保留一行(实时帧 / 快照重放 / REST 回填三路共用) */
+	function upsertMessage(msg, channelId) {
+		const cid = channelId || msg.channelId;
+		if (!cid || !msg?.id) return false;
+		const list = listOf(cid);
+		const idx = list.findIndex((m) => m.id === msg.id);
+		if (idx >= 0) {
+			list[idx] = {
+				...list[idx],
+				...msg
+			};
+			return false;
+		}
+		insertSorted(list, msg);
+		return true;
+	}
+	function upsertDelivery(d) {
+		const cid = d.channelId;
+		if (!cid || !d.deliveryId) return;
+		const byChannel = deliveries.value[cid] ??= {};
+		byChannel[d.deliveryId] = {
+			...byChannel[d.deliveryId],
+			...d
+		};
+	}
+	/** 频道流 chat.* 帧消费(由 useWorkshopWs 在 seq 守卫之后调用,重复 seq 帧不会到这里) */
+	function applyEnvelope(e) {
+		switch (e.type) {
+			case "chat.message":
+				upsertMessage(e.payload, e.channelId || void 0);
+				break;
+			case "chat.delivery.status":
+				upsertDelivery(e.payload);
+				break;
+			case "chat.member": {
+				const m = e.payload;
+				const cid = e.channelId;
+				if (!cid || !m?.userId) break;
+				const list = members.value[cid] ??= [];
+				const idx = list.findIndex((x) => x.userId === m.userId);
+				const next = {
+					userId: m.userId,
+					displayName: m.displayName ?? null,
+					role: m.role,
+					status: m.status,
+					joinedAt: m.joinedAt,
+					leftAt: m.leftAt ?? null
+				};
+				if (idx >= 0) list[idx] = next;
+				else list.push(next);
+				break;
+			}
+			case "chat.settings": {
+				const s = e.payload;
+				const cid = s?.id || e.channelId;
+				if (cid) settings.value[cid] = s;
+				break;
+			}
+		}
+	}
+	/**
+	* channel.snapshot 的群聊侧基线(payload.chat / payload.permissions)。
+	* 消息走 upsert(不 replace):重连快照只含最近 50 条,替换会抹掉已翻页加载的更早历史。
+	*/
+	function applySnapshot(channelId, chat, perms) {
+		if (!channelId) return;
+		if (chat?.channel) settings.value[channelId] = chat.channel;
+		if (Array.isArray(chat?.members)) members.value[channelId] = chat.members.map((m) => ({ ...m }));
+		for (const msg of chat?.chatMessages ?? []) upsertMessage(msg, channelId);
+		if (chat?.permissions) permissions.value[channelId] = chat.permissions;
+		else if (perms !== void 0) permissions.value[channelId] = perms ?? null;
+		loadedChannels.value.add(channelId);
+	}
+	async function request(path, init = {}) {
+		const token = useUserStore().token;
+		const qs = init.query ? `?${Object.entries(init.query).filter(([, v]) => v !== void 0 && v !== "").map(([k, v]) => `${k}=${encodeURIComponent(String(v))}`).join("&")}` : "";
+		const res = await narrowFetch(`${path}${qs}`, {
+			method: init.method ?? "GET",
+			body: init.body,
+			headers: token ? { authorization: `Bearer ${token}` } : {}
+		});
+		if (res.code !== 0 || res.data == null) throw new Error(res.message ?? "群聊请求失败");
+		return res.data;
+	}
+	/**
+	* 拉取群聊历史(`before` = 上一页最旧消息 id;缺省拉最新一页)。
+	* 只 upsert 不替换 —— 与 WS 实时帧并存时不做"谁覆盖谁"的假设。
+	* @returns 是否可能还有更早历史
+	*/
+	async function loadHistory(channelId, opts = {}) {
+		return false;
+	}
+	/** 名册(成员可见;非成员会被 403 拒绝 → 保持空名册,不抛给 UI) */
+	async function loadMembers(channelId) {}
+	/** 能力视图(非成员也可调用;ChatMemberPanel/Composer 的按钮可用性据此渲染) */
+	async function loadPermissions(channelId) {
+		return null;
+	}
+	/** 群聊发言(唯一入站口;mentions 只是意图提示,服务端会重新解析文本) */
+	async function send(input) {
+		const data = await request(`/api/workshop/channels/${input.channelId}/chat/messages`, {
+			method: "POST",
+			body: {
+				text: input.text,
+				mentions: input.mentions ?? [],
+				replyToId: input.replyToId ?? null,
+				clientMessageId: input.clientMessageId
+			}
+		});
+		if (data.message) upsertMessage(data.message, input.channelId);
+		for (const d of data.deliveries ?? []) upsertDelivery({
+			deliveryId: d.deliveryId,
+			chatMessageId: data.message?.id ?? "",
+			channelId: input.channelId,
+			targetAgentId: d.agentId,
+			mailboxMessageId: null,
+			status: d.status,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		return data;
+	}
+	async function join(channelId) {
+		const data = await request(`/api/workshop/channels/${channelId}/members/join`, {
+			method: "POST",
+			body: {}
+		});
+		if (data.permissions) permissions.value[channelId] = data.permissions;
+		await Promise.all([loadMembers().catch(() => {}), loadHistory().catch(() => {})]);
+		return data.status;
+	}
+	async function leave(channelId) {
+		await request(`/api/workshop/channels/${channelId}/members/leave`, {
+			method: "POST",
+			body: {}
+		});
+		await loadPermissions();
+	}
+	/** owner 移除成员 / owner 批准待审成员 */
+	async function removeMember(channelId, userId) {
+		await request(`/api/workshop/channels/${channelId}/members/${encodeURIComponent(userId)}`, { method: "DELETE" });
+		await loadMembers();
+	}
+	async function approveMember(channelId, userId) {
+		await request(`/api/workshop/channels/${channelId}/members/${encodeURIComponent(userId)}/approve`, {
+			method: "POST",
+			body: {}
+		});
+		await loadMembers();
+	}
+	/** 群聊设置(owner-only;必须带 version 乐观锁 → 409 VERSION_CONFLICT) */
+	async function updateSettings(channelId, patch) {
+		const version = settings.value[channelId]?.version;
+		const data = await request(`/api/workshop/channels/${channelId}`, {
+			method: "PATCH",
+			body: {
+				...patch,
+				version
+			}
+		});
+		const prev = settings.value[channelId];
+		settings.value[channelId] = {
+			id: data.id ?? channelId,
+			name: data.name ?? prev?.name ?? "",
+			description: data.description ?? prev?.description ?? "",
+			visibility: data.visibility ?? prev?.visibility ?? "private",
+			joinPolicy: data.joinPolicy ?? prev?.joinPolicy ?? "owner_approve",
+			approvalPolicy: data.approvalPolicy ?? prev?.approvalPolicy ?? "owner_only",
+			chatEnabled: data.chatEnabled ?? prev?.chatEnabled ?? 0,
+			version: data.version ?? prev?.version ?? 0,
+			legacy: data.ownerUserId === void 0 ? prev?.legacy ?? false : data.ownerUserId === null
+		};
+		await loadPermissions();
+	}
+	function setReplyTarget(target) {
+		replyTarget.value = target;
+	}
+	function clearReplyTarget() {
+		replyTarget.value = null;
+	}
+	/**
+	* 某频道全部投递台账(扁平数组)。
+	*
+	* 渲染方需要"按消息分组",而按消息逐个 `deliveriesOf(channelId, messageId)` 会让
+	* 每条消息都全量扫一遍投递表(未虚拟滚动时是 O(消息数 × 投递数));
+	* 因此暴露这个"取一次、调用方自己建索引"的入口。
+	*/
+	function deliveriesOfChannel(channelId) {
+		const byChannel = deliveries.value[channelId];
+		if (!byChannel) return [];
+		return Object.values(byChannel);
+	}
+	/** 单条消息的投递台账(低频调用方用;高频渲染请用 deliveriesOfChannel 自建索引) */
+	function deliveriesOf(channelId, messageId) {
+		return deliveriesOfChannel(channelId).filter((d) => d.chatMessageId === messageId);
+	}
+	function clear(channelId) {
+		Reflect.deleteProperty(messages.value, channelId);
+		Reflect.deleteProperty(members.value, channelId);
+		Reflect.deleteProperty(deliveries.value, channelId);
+		loadedChannels.value.delete(channelId);
+	}
+	return {
+		messages,
+		members,
+		settings,
+		deliveries,
+		permissions,
+		loadedChannels,
+		hasMoreHistory,
+		loadingHistory,
+		replyTarget,
+		applyEnvelope,
+		applySnapshot,
+		loadHistory,
+		loadMembers,
+		loadPermissions,
+		send,
+		join,
+		leave,
+		removeMember,
+		approveMember,
+		updateSettings,
+		setReplyTarget,
+		clearReplyTarget,
+		deliveriesOf,
+		deliveriesOfChannel,
+		clear
+	};
+});
+//#endregion
+//#region app/composables/workshop/useWorkshopWs.ts
+var hookGlobal = globalThis;
+hookGlobal.__workshopWsHeartbeat ??= null;
+hookGlobal.__workshopWsHeartbeatUsers ??= 0;
+hookGlobal.__workshopWsNotifHosts ??= 0;
+hookGlobal.__workshopWsNotifSubscribed ??= false;
+/**
+* 频道流帧的单调 seq 守卫。
+* @returns true = 该帧应被**丢弃**(重复/倒退)
+*/
+function channelSeqGuard(e, appliedSeq) {
+	if (!e.channelId || typeof e.seq !== "number" || e.seq <= 0 || e.type === "channel.snapshot") return false;
+	const last = appliedSeq.get(e.channelId) ?? 0;
+	if (e.seq <= last) return true;
+	appliedSeq.set(e.channelId, e.seq);
+	return false;
+}
+function useWorkshopWs() {
+	const conn = useWsConnectionStore();
+	const userStore = useUserStore();
+	const townBus = useTownBus();
+	/** 模块级单例:多组件共享一条连接 */
+	let session = hookGlobal.__workshopWs ?? null;
+	const appliedSeq = /* @__PURE__ */ new Map();
+	if (!session) {
+		const s = new WorkshopWsSession((e) => {
+			const events = useEventsStore();
+			const entities = useEntitiesStore();
+			const chat = useChatStore();
+			const hitl = useHitlStore();
+			const notifications = useNotificationsStore();
+			if (channelSeqGuard(e, appliedSeq)) return;
+			if (e.channelId && typeof e.seq === "number" && e.seq > 0) {
+				if (conn.pendingReplay) conn.pendingReplay = false;
+			}
+			if (e.type === "channel.snapshot" && e.channelId) {
+				appliedSeq.set(e.channelId, typeof e.seq === "number" ? e.seq : 0);
+				conn.pendingReplay = false;
+				events.ingest(e);
+				entities.applyEvent(e);
+				entities.applySnapshot(e.payload);
+				const payload = e.payload;
+				chat.applySnapshot(e.channelId, payload.chat ?? null, payload.permissions);
+				events.loadHistory(e.channelId);
+			} else {
+				events.ingest(e);
+				entities.applyEvent(e);
+				if (typeof e.type === "string" && e.type.startsWith("chat.")) chat.applyEnvelope(e);
+			}
+			if (e.type === "hitl.request" || e.type === "hitl.resolved") hitl.applyEnvelope(e);
+			if (e.type === "notification.created" || e.type === "notification.read") notifications.applyEnvelope(e);
+			if (e.type === "notification.snapshot") {
+				notifications.applyReplayCursor(e.payload?.nextCursor ?? null);
+				notifications.endReplay();
+			}
+			if (typeof e.seq === "number" && e.seq > 0 && e.channelId) {
+				conn.cursors[e.channelId] = e.seq;
+				s.updateCursor(e.channelId, e.seq);
+			}
+			townBus.emit(e);
+		}, (state, retry) => {
+			conn.state = state;
+			conn.retryCount = retry;
+			if (state === "open") useNotificationsStore().backfill();
+		}, () => {
+			conn.pendingReplay = true;
+		}, () => {
+			conn.lastDataAt = Date.now();
+			const notifications = useNotificationsStore();
+			if (hookGlobal.__workshopWsNotifSubscribed) sendNotificationsSub();
+			notifications.backfill();
+		});
+		session = s;
+		hookGlobal.__workshopWs = session;
+	}
+	/**
+	* 发送一条上行帧。
+	*
+	* `WorkshopWsSession` 只暴露 sub/unsub/ping 三个语义方法(该类由连接层独占维护),
+	* 通知订阅帧没有对应方法 —— 这里以最小侵入方式取底层 socket 直发,
+	* 不改动连接层的实现与 seq/重连语义。若后续连接层开放通用 `send()`,
+	* 本函数应替换为对该方法的调用。
+	*/
+	const sendFrame = (frame) => {
+		const socket = session?.ws;
+		if (!socket || socket.readyState !== WebSocket.OPEN) return;
+		try {
+			socket.send(JSON.stringify(frame));
+		} catch {}
+	};
+	const sendNotificationsSub = () => {
+		const notifications = useNotificationsStore();
+		const cursor = notifications.cursor;
+		notifications.beginReplay();
+		sendFrame(cursor ? {
+			type: "subNotifications",
+			cursor
+		} : { type: "subNotifications" });
+	};
+	/**
+	* 宿主用户级通知订阅(引用计数;返回释放函数)。
+	* 未登录时不发送(服务端要求已认证 peer);登录后由 token watcher 补发。
+	*/
+	const hostNotifications = () => {
+		const notifications = useNotificationsStore();
+		hookGlobal.__workshopWsNotifHosts = (hookGlobal.__workshopWsNotifHosts ?? 0) + 1;
+		if (!hookGlobal.__workshopWsNotifSubscribed && userStore.token) {
+			hookGlobal.__workshopWsNotifSubscribed = true;
+			sendNotificationsSub();
+			notifications.loadSnapshot();
+		}
+		let done = false;
+		return () => {
+			if (done) return;
+			done = true;
+			const left = (hookGlobal.__workshopWsNotifHosts ?? 1) - 1;
+			hookGlobal.__workshopWsNotifHosts = left > 0 ? left : 0;
+			if (left <= 0) {
+				hookGlobal.__workshopWsNotifSubscribed = false;
+				if (userStore.token) sendFrame({ type: "unsubNotifications" });
+			}
+		};
+	};
+	watch(() => userStore.token, (t) => {
+		const notifications = useNotificationsStore();
+		if (session instanceof WorkshopWsSession) session.userToken = t;
+		if (t) {
+			if ((hookGlobal.__workshopWsNotifHosts ?? 0) > 0) {
+				hookGlobal.__workshopWsNotifSubscribed = true;
+				sendNotificationsSub();
+			}
+			notifications.loadSnapshot();
+		} else {
+			if (hookGlobal.__workshopWsNotifSubscribed) {
+				hookGlobal.__workshopWsNotifSubscribed = false;
+				sendFrame({ type: "unsubNotifications" });
+			}
+			notifications.clear();
+		}
+	}, { immediate: true });
+	const subscribe = (channelId) => {
+		const lastSeq = useEventsStore().lastSeq(channelId);
+		session?.subscribe(channelId, lastSeq > 0 ? lastSeq : void 0);
+	};
+	const unsubscribe = (channelId) => {
+		if (!session) return;
+		session.unsubscribe(channelId);
+		if (session.refCount(channelId) === 0) useEventsStore().clear(channelId);
+	};
+	/** 建连但不订阅 channel:纯场景事件消费方(daq 实时帧)用。
+	*  服务端在连接层注册 scene peer,连上即收 daq.reading 等无频道广播。 */
+	const ensureConnected = () => {
+		session?.ensureConnected();
+	};
+	return {
+		subscribe,
+		unsubscribe,
+		ensureConnected,
+		hostNotifications,
+		conn
+	};
+}
+
+export { BlockClusterer as B, useWorkshopWs as a, agentHueColor as b, useEventsStore as c, useChatStore as d, useNotificationsStore as e, chatErrorCode as f, chatErrorMessage as g, useWsConnectionStore as h, blockTier as i, buildStreamText as j, isStreaming as k, useHitlStore as l, streamCursorVisible as s, useEntitiesStore as u };
+//# sourceMappingURL=useWorkshopWs-B-Es2Xg3.mjs.map