agentworkshop 0.7.44 → 0.7.46

package/.output/server/chunks/build/useWorkshopWs-C_I7q9As.mjs

@@ -1,1319 +0,0 @@
-import { b as useUserStore, ar as $fetch$2 } from '../virtual/entry.mjs';
-import { u as useTownBus } from './useTownBus-D9SoIsAN.mjs';
-import { watch, reactive } from 'vue';
-import { defineStore } from 'pinia';
-
-//#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/stores/workshop/hitl.ts
-/**
-* HITL 全局待办 store:omp ask 对话框 + dcw 工具审批的统一待答视图。
-*
-* 数据源:
-*  - AEP hitl.request/hitl.resolved 帧(频道流 seq 帧与 channelId='' 全员直推
-*    会各到一次,upsert 按 kind+id 幂等去重;徽标不依赖 channel 订阅)
-*  - GET /api/workshop/hitl/pending 快照(页面挂载/重连后的基线对齐)
-*/
-var keyOf = (i) => `${i.kind}:${i.id}`;
-var useHitlStore = defineStore("workshop.hitl", {
-	state: () => ({
-		/** 当前待人工处理条目(kind+id 幂等) */
-		items: [],
-		/** 快照已加载(防重复拉取;WS 掉线重连后由 ensureBaseline 重置) */
-		snapshotLoaded: false
-	}),
-	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;
-		}
-	},
-	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() {},
-		/** WS 断线重连后重新对齐 */
-		invalidate() {
-			this.snapshotLoaded = false;
-		},
-		clear() {
-			this.items = [];
-			this.snapshotLoaded = false;
-		}
-	}
-});
-//#endregion
-//#region app/composables/workshop/useEventBlocks.ts
-/**
-* 事件聚类引擎 — Codex/OpenHands 风格 turn block 增量版。
-*
-* 与旧版差异:
-*  - 增量聚类:只处理新增帧,块对象身份稳定(Vue 按 key 复用组件,流式更新不整树重建)
-*  - 内容智能去重:落定全文(status.message/agent.message)与已累计 delta 相同或为前缀扩展时
-*    绝不重复渲染第二遍——修复"连续两次重复渲染"(omp 消息流 delta 与 message_end 全文重复)
-*  - 跨块落定折回:工具调用把流切段时,deltas 累计跨块跟踪,message_end 全文按内容比对折回
-*    最后一段流块;先前流片段标记 coveredBy 折叠为一行提示(OpenHands 风格)
-*  - 纯函数供密集行视图复用:classifyEvent / foldStreamDuplicates / buildStreamText
-*/
-var TOOL_PREFIX = /^🔧\s*\S+/;
-/** 工具元数据:native = omp 原生作业工具;host = harness 协作工具(任务/通信/记忆/团队) */
-var TOOL_META = {
-	read: {
-		icon: "i-tabler-file-search",
-		kind: "native"
-	},
-	write: {
-		icon: "i-tabler-pencil",
-		kind: "native"
-	},
-	edit: {
-		icon: "i-tabler-edit",
-		kind: "native"
-	},
-	bash: {
-		icon: "i-tabler-terminal-2",
-		kind: "native"
-	},
-	grep: {
-		icon: "i-tabler-search",
-		kind: "native"
-	},
-	glob: {
-		icon: "i-tabler-folders",
-		kind: "native"
-	},
-	dispatch_task: {
-		icon: "i-tabler-send",
-		kind: "host"
-	},
-	reassign_task: {
-		icon: "i-tabler-arrows-exchange",
-		kind: "host"
-	},
-	update_task: {
-		icon: "i-tabler-pencil-code",
-		kind: "host"
-	},
-	cancel_task: {
-		icon: "i-tabler-circle-x",
-		kind: "host"
-	},
-	complete_task: {
-		icon: "i-tabler-circle-check",
-		kind: "host"
-	},
-	report_progress: {
-		icon: "i-tabler-progress-check",
-		kind: "host"
-	},
-	send_message_to_agent: {
-		icon: "i-tabler-message",
-		kind: "host"
-	},
-	poll_messages: {
-		icon: "i-tabler-inbox",
-		kind: "host"
-	},
-	broadcast_message: {
-		icon: "i-tabler-rss",
-		kind: "host"
-	},
-	list_team_agents: {
-		icon: "i-tabler-users",
-		kind: "host"
-	},
-	list_channel_tasks: {
-		icon: "i-tabler-list",
-		kind: "host"
-	},
-	get_task_details: {
-		icon: "i-tabler-eye",
-		kind: "host"
-	},
-	get_my_task_queue: {
-		icon: "i-tabler-stack-2",
-		kind: "host"
-	},
-	get_queue_overview: {
-		icon: "i-tabler-chart-bar",
-		kind: "host"
-	},
-	search_memory: {
-		icon: "i-tabler-brain",
-		kind: "host"
-	},
-	save_memory: {
-		icon: "i-tabler-bookmark",
-		kind: "host"
-	},
-	create_team_agent: {
-		icon: "i-tabler-user-plus",
-		kind: "host"
-	},
-	update_team_agent: {
-		icon: "i-tabler-user-cog",
-		kind: "host"
-	},
-	remove_team_agent: {
-		icon: "i-tabler-user-minus",
-		kind: "host"
-	}
-};
-/** 类别展示元数据(壳层统一渲染头部) */
-var KIND_META = {
-	tool: {
-		label: "tool",
-		icon: "i-tabler-tool"
-	},
-	status: {
-		label: "status",
-		icon: "i-tabler-dots"
-	},
-	life: {
-		label: "state",
-		icon: "i-tabler-activity"
-	},
-	route: {
-		label: "message",
-		icon: "i-tabler-route"
-	},
-	stream: {
-		label: "llm",
-		icon: "i-tabler-message-dots"
-	},
-	task: {
-		label: "task",
-		icon: "i-tabler-checklist"
-	},
-	artifact: {
-		label: "artifact",
-		icon: "i-tabler-package"
-	},
-	member: {
-		label: "team",
-		icon: "i-tabler-users"
-	},
-	memory: {
-		label: "memory",
-		icon: "i-tabler-bookmark"
-	},
-	error: {
-		label: "error",
-		icon: "i-tabler-alert-triangle"
-	},
-	other: {
-		label: "event",
-		icon: "i-tabler-dots"
-	}
-};
-/** 事件 → 聚合类别 */
-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%)`;
-}
-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;
-}
-/** 统一化空白比较 */
-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";
-}
-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;
-	}
-};
-/** 事件正文(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);
-}
-function escapeHtml(s) {
-	return s.replace(/[&<>"']/g, (c) => ({
-		"&": "&amp;",
-		"<": "&lt;",
-		">": "&gt;",
-		"\"": "&quot;",
-		"'": "&#39;"
-	})[c] ?? c);
-}
-function inlineMd(s) {
-	return s.replace(/`([^`\n]+)`/g, "<code>$1</code>").replace(/\*\*([^*\n]+)\*\*/g, "<b>$1</b>").replace(/(^|\s)\*([^*\n]+)\*(?=\s|$)/g, "$1<i>$2</i>");
-}
-/** GitHub 风格提示框元数据(open-tag github-alert 移植;`> [!NOTE]` 等) */
-var GH_ALERTS = {
-	note: {
-		label: "说明",
-		icon: "i-tabler-info-circle"
-	},
-	tip: {
-		label: "提示",
-		icon: "i-tabler-bulb"
-	},
-	important: {
-		label: "重要",
-		icon: "i-tabler-flag"
-	},
-	warning: {
-		label: "警告",
-		icon: "i-tabler-alert-triangle"
-	},
-	caution: {
-		label: "注意",
-		icon: "i-tabler-shield-half"
-	}
-};
-/** 散文渲染:围栏代码块 / 段落 / # 标题 / - 列表 / > 引用 / GitHub 提示框 /
-*  任务列表勾选 / 行内代码与加粗(对部分流式文本安全) */
-function mdLite(src) {
-	const codeBlocks = [];
-	return escapeHtml(src).replace(/```([\w+-]*)\n?([\s\S]*?)(?:```|$)/g, (_m, lang, body) => {
-		const idx = codeBlocks.length;
-		codeBlocks.push(`<div class="code-block" data-lang="${lang || "text"}"><div class="code-head"><span class="code-lang">${lang || "text"}</span><button type="button" class="code-copy">复制</button></div><pre><code>${body.replace(/\n$/, "")}</code></pre></div>`);
-		return `@@AWCODE${idx}@@`;
-	}).split(/\n{2,}/).map((para) => {
-		const lines = para.split("\n");
-		if (/^### /.test(para)) return `<h5>${inlineMd(para.slice(4))}</h5>`;
-		if (/^## /.test(para)) return `<h4>${inlineMd(para.slice(3))}</h4>`;
-		if (/^# /.test(para)) return `<h4>${inlineMd(para.slice(2))}</h4>`;
-		if (lines.every((l) => /^\s*[-*] /.test(l))) {
-			if (lines.some((l) => /^\s*[-*] \[[ xX]\] /.test(l))) return `<ul class="task-list">${lines.map((l) => {
-				const m = /^\s*[-*] \[([ xX])\] (.*)$/.exec(l);
-				const done = (m[1] ?? " ").toLowerCase() === "x";
-				return `<li class="task-item${done ? " done" : ""}"><span class="task-check${done ? " on" : ""}">${done ? "✓" : ""}</span><span class="task-text">${inlineMd(m[2] ?? "")}</span></li>`;
-			}).join("")}</ul>`;
-			return `<ul>${lines.map((l) => `<li>${inlineMd(l.replace(/^\s*[-*] /, ""))}</li>`).join("")}</ul>`;
-		}
-		if (lines.every((l) => /^&gt;\s?/.test(l))) {
-			const am = /^&gt;\s*\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\]\s*(.*)$/.exec(lines[0] ?? "");
-			if (am) {
-				const meta = GH_ALERTS[am[1].toLowerCase()];
-				const firstRest = am[2] ?? "";
-				const bodyLines = [...firstRest ? [firstRest] : [], ...lines.slice(1).map((l) => l.replace(/^&gt;\s?/, ""))];
-				return `<div class="gh-alert gh-${am[1].toLowerCase()}"><div class="gh-title"><span class="${meta.icon}"></span>${meta.label}</div><p>${bodyLines.map((l) => inlineMd(l)).join("<br>")}</p></div>`;
-			}
-			return `<blockquote>${lines.map((l) => inlineMd(l.replace(/^&gt;\s?/, ""))).join("<br>")}</blockquote>`;
-		}
-		if (lines.length === 1 && /^@@AWCODE\d+@@$/.test(para)) return para;
-		return `<p>${lines.map((l) => inlineMd(l)).join("<br>")}</p>`;
-	}).join("").replace(/@@AWCODE(\d+)@@/g, (_m, i) => codeBlocks[Number(i)] ?? "");
-}
-/** @Name 形态的提及词边界(前面是行首/空白/括号,避免匹配邮箱与代码) */
-function mentionRegex(name) {
-	const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-	return new RegExp(`(^|(?<![\\w@]))@(${escaped})(?=$|[\\s,.;:!?、,。;:!?…)\\]】」』])`, "gu");
-}
-/**
-* 源文本提及占位:@Name → \uE000M{idx}\uE000(私用区码点,正文流不可能出现;
-* 先于 mdLite 转义执行,占位符不受转义/标记影响;名字按长度降序避免前缀遮蔽)。
-*/
-function maskMentions(src, members) {
-	const hits = [];
-	if (members.length === 0) return {
-		text: src,
-		hits
-	};
-	const sorted = [...members].sort((a, b) => b.name.length - a.name.length);
-	let text = src;
-	for (const m of sorted) {
-		if (!m.name) continue;
-		text = text.replace(mentionRegex(m.name), (_m, _pre, _name) => {
-			hits.push(m);
-			return `\uE000M${hits.length - 1}\uE000`;
-		});
-	}
-	return {
-		text,
-		hits
-	};
-}
-/** 还原占位为提及 pill HTML(mdLite 输出后执行;pill 点击由容器事件委托处理) */
-function restoreMentions(html, hits) {
-	return html.replace(/\uE000M(\d+)\uE000/g, (_m, i) => {
-		const m = hits[Number(i)];
-		if (!m) return "";
-		return `<span class="md-mention" data-agent-id="${escapeHtml(m.agentId)}">@${escapeHtml(m.name)}</span>`;
-	});
-}
-/** mdLite + @提及高亮一体化(聊天正文渲染入口) */
-function mdLiteMentions(src, members) {
-	const { text, hits } = maskMentions(src, members);
-	return restoreMentions(mdLite(text), hits);
-}
-//#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 返回值不直接写状态,避免双源)。
-*/
-var useEntitiesStore = defineStore("workshop.entities", {
-	state: () => ({
-		channels: {},
-		agents: {},
-		tasks: {},
-		/** 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;
-		}
-	},
-	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));
-		},
-		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
-					};
-					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: "-"
-						};
-						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,
-							progress: Math.max(prev.progress, p.progress ?? 0),
-							routeReason: p.routeReason ?? prev.routeReason,
-							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.routeReason) fresh.routeReason = p.routeReason;
-						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 "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,
-				title: t.title,
-				state: t.state,
-				progress: t.progress,
-				assigneeId: t.assigneeId,
-				artifacts: t.artifacts.length,
-				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;
-			$fetch$2(`/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;
-			$fetch$2(`/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/composables/workshop/useWorkshopWs.ts
-function useWorkshopWs() {
-	const conn = useWsConnectionStore();
-	const userStore = useUserStore();
-	const events = useEventsStore();
-	const entities = useEntitiesStore();
-	const hitl = useHitlStore();
-	const townBus = useTownBus();
-	let session = globalThis.__workshopWs ?? null;
-	const appliedSeq = /* @__PURE__ */ new Map();
-	if (!session) {
-		const s = new WorkshopWsSession((e) => {
-			if (e.channelId && typeof e.seq === "number" && e.seq > 0 && e.type !== "channel.snapshot") {
-				const last = appliedSeq.get(e.channelId) ?? 0;
-				if (e.seq <= last) return;
-				appliedSeq.set(e.channelId, e.seq);
-				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);
-				events.loadHistory(e.channelId);
-			} else {
-				events.ingest(e);
-				entities.applyEvent(e);
-			}
-			if (e.type === "hitl.request" || e.type === "hitl.resolved") hitl.applyEnvelope(e);
-			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;
-		}, () => {
-			conn.pendingReplay = true;
-		}, () => {
-			conn.lastDataAt = Date.now();
-		});
-		session = s;
-		globalThis.__workshopWs = session;
-	}
-	watch(() => userStore.token, (t) => {
-		if (session instanceof WorkshopWsSession) session.userToken = t;
-	}, { immediate: true });
-	const subscribe = (channelId) => {
-		const lastSeq = events.lastSeq(channelId);
-		session?.subscribe(channelId, lastSeq > 0 ? lastSeq : void 0);
-	};
-	const unsubscribe = (channelId) => {
-		if (!session) return;
-		session.unsubscribe(channelId);
-		if (session.refCount(channelId) === 0) events.clear(channelId);
-	};
-	/** 建连但不订阅 channel:纯场景事件消费方(daq 实时帧)用。
-	*  服务端在连接层注册 scene peer,连上即收 daq.reading 等无频道广播。 */
-	const ensureConnected = () => {
-		session?.ensureConnected();
-	};
-	return {
-		subscribe,
-		unsubscribe,
-		ensureConnected,
-		conn
-	};
-}
-
-export { BlockClusterer as B, KIND_META as K, TOOL_META as T, useWorkshopWs as a, agentHueColor as b, useEventsStore as c, blockTier as d, buildStreamText as e, useWsConnectionStore as f, useHitlStore as g, isStreaming as i, mdLiteMentions as m, streamCursorVisible as s, useEntitiesStore as u };
-//# sourceMappingURL=useWorkshopWs-C_I7q9As.mjs.map