finch-session-board 0.0.0-stage → 0.1.2

package/dist/index.js

@@ -0,0 +1,1134 @@
+import { appendFileSync, mkdirSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// finchapp/shared/utils/env.js
+/** 开发档为 "yes"（build.js --dev 与 dev.js 注入），正式档为 "no"；字符串而非布尔，注入缺失时能一眼看出没钉上。 */
+function isDev() {
+	return false;
+}
+/** 包名，取 package.json 的 name；打包遗漏时退回一个固定值，日志照常能落盘。 */
+function appId() {
+	return "finch-session-board";
+}
+// finchapp/shared/utils/error.js
+/**
+* @param {unknown} error 任意抛出物
+* @returns {string} 可读的一行错误信息
+*/
+function reasonOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+// finchapp/shared/backend/log.js
+/** 开发日志目录名：与 desktop、vscode、web 共用同一个仓库级约定。 */
+const DEV_DIR = ".yicodeLogsDev";
+/** 敏感字段名，命中的值不进日志。 */
+const SECRET_PATTERN = /password|passwd|token|secret|cookie|authorization|api[-_]?key|credential/i;
+/** 脱敏递归的最大深度，防止深对象和循环引用把日志写炸。 */
+const SANITIZE_DEPTH = 4;
+/** 开发日志的完整路径。 */
+function devLogPath() {
+	return join(homedir(), DEV_DIR, `${appId()}.dev.log.jsonl`);
+}
+/** 递归抹掉敏感字段的值；非对象原样返回。 */
+function sanitize(value, depth = 0) {
+	if (depth > SANITIZE_DEPTH || value === null || typeof value !== "object") return value;
+	if (Array.isArray(value)) return value.map((item) => sanitize(item, depth + 1));
+	const result = {};
+	for (const [key, item] of Object.entries(value)) result[key] = SECRET_PATTERN.test(key) ? "[redacted]" : sanitize(item, depth + 1);
+	return result;
+}
+/** Error 要手动展开：JSON.stringify 会把它序列化成空对象。 */
+function describe(value) {
+	if (value instanceof Error) return {
+		name: value.name,
+		message: value.message,
+		stack: value.stack
+	};
+	return value;
+}
+/** 补零到指定宽度，默认两位；毫秒要三位。 */
+const pad = (value, size = 2) => String(value).padStart(size, "0");
+/**
+* 本地时间带时区偏移，形如 2026-11-04T20:37:12.345+08:00。
+* 不用 toISOString 的 UTC：翻日志时还要心算 +8，也没法一眼看出是哪一刻。
+* 仍然是标准 ISO 8601，new Date() 与字符串排序都照常。
+*/
+function stampOf(date) {
+	const offset = -date.getTimezoneOffset();
+	const zone = `${offset >= 0 ? "+" : "-"}${pad(Math.floor(Math.abs(offset) / 60))}:${pad(Math.abs(offset) % 60)}`;
+	return `${`${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`}T${`${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}.${pad(date.getMilliseconds(), 3)}`}${zone}`;
+}
+/**
+* 建一个带作用域前缀的日志器。
+* @param {object} ctx 小程序上下文，只用 logger
+* @param {string} scope 模块名，例如 window / canvas / events
+* @returns {{ debug: Function, info: Function, warn: Function, error: Function, file: string }}
+*/
+function createLog(ctx, scope) {
+	const dev = isDev();
+	const file = dev ? devLogPath() : "";
+	if (dev) try {
+		mkdirSync(join(homedir(), DEV_DIR), { recursive: true });
+		rmSync(file, { force: true });
+	} catch (error) {
+		ctx.logger.warn(`${scope} 开发日志目录不可用`, reasonOf(error));
+	}
+	/** 开发档落盘一份，两种形态都转发给 Finch 插件日志；两件事互不依赖。 */
+	const write = (level, message, detail) => {
+		if (!dev && level === "debug") return;
+		if (file) {
+			const row = {
+				ts: stampOf(/* @__PURE__ */ new Date()),
+				level,
+				scope,
+				msg: message
+			};
+			if (detail !== void 0) row.data = sanitize(detail);
+			try {
+				appendFileSync(file, `${JSON.stringify(row)}\n`, "utf8");
+			} catch (error) {
+				ctx.logger.warn(`${scope} 日志落盘失败`, reasonOf(error));
+			}
+		}
+		ctx.logger[level](`[${scope}] ${message}`, ...detail === void 0 ? [] : [detail]);
+	};
+	return {
+		file,
+		debug: (message, detail) => write("debug", message, detail),
+		info: (message, detail) => write("info", message, detail),
+		warn: (message, detail) => write("warn", message, detail),
+		error: (message, error, detail) => write("error", message, {
+			...detail,
+			...error ? { error: describe(error) } : {}
+		})
+	};
+}
+/**
+* 由记录数算出窗口尺寸。
+* 高度跟着条数走：一条都没有时只剩一条标题带，不留空行。
+* 全篇只有 PAD 一个间隙值——标题带上下各一份、行间一份、列表底部一份，四处看起来才一样齐。
+* @param {number} count 记录条数
+* @returns {{ count: number, rows: number, rowH: number, width: number, height: number, overflow: number }}
+*/
+function layoutOf(count = 0) {
+	const total = Math.max(0, Math.floor(count) || 0);
+	const rows = Math.min(total, 8);
+	return {
+		count: total,
+		rows,
+		rowH: 22,
+		width: 240,
+		height: rows === 0 ? 32 : 42 + rows * 22,
+		overflow: total - rows
+	};
+}
+/**
+* 图标预览模式的窗口尺寸。
+* 高度由图标墙加色卡推出，和真实列表一样只有 PAD 一个间隙值。
+* @returns {{ width: number, height: number }}
+*/
+function previewOf() {
+	return {
+		width: 240,
+		height: 266
+	};
+}
+// finchapp/sessionBoard/src/sessions.js
+/** 记录阶段。idle 只出现在会话刚出现、还没跑出第一条实质事件的时候。 */
+const PHASE = {
+	idle: "idle",
+	thinking: "thinking",
+	answering: "answering",
+	tool: "tool",
+	waiting: "waiting",
+	retry: "retry",
+	interrupting: "interrupting",
+	interrupted: "interrupted",
+	compacting: "compacting",
+	done: "done",
+	error: "error"
+};
+/**
+* 阶段 → 色调。颜色只回答"要不要紧"，具体在做什么交给图标。
+* 蓝：一切只读工作；紫：会改文件；玫红：会动系统；橙：等你动手；黄绿：系统在自己处理；绿红：两种收场。
+*/
+const PHASE_TONE = {
+	idle: "gray",
+	thinking: "blue",
+	answering: "blue",
+	tool: "blue",
+	waiting: "orange",
+	retry: "lime",
+	interrupting: "lime",
+	interrupted: "lime",
+	compacting: "blue",
+	done: "green",
+	error: "red"
+};
+/**
+* 工具色调覆盖：同样在 tool 阶段，写文件和跑命令比读取要紧，单独给色。
+* 没列到的动作一律沿用阶段色（蓝）。
+*/
+const ACTION_TONE = {
+	write: "purple",
+	shell: "rose"
+};
+/** 推进时钟的间隔。只用来淘汰长时间没动静的会话，完成的记录不在这里清。 */
+const SWEEP_MS = 5e3;
+/** 活跃会话多久没有任何事件就当作结束；等待中和已完成的会话不适用这条。 */
+const IDLE_EVICT_MS = 6e4;
+/** 看板最多记住多少会话，防止长跑之后 Map 无限涨。 */
+const MAX_CELLS = 40;
+/**
+* 工具名归类：一个工具名同时给出图标和动作说法。
+* 顺序即优先级——"websearch" 含 web 也含 search，先命中联网，才不会掉进查找。
+* 查找单列一类：grep/glob 这类只翻不改的活，和读文件的图标要分开看。
+*/
+const TOOL_RULES = [
+	{
+		key: "net",
+		icon: "globe",
+		action: "联网查询",
+		words: [
+			"web",
+			"http",
+			"browser",
+			"fetch",
+			"mcp",
+			"url"
+		]
+	},
+	{
+		key: "shell",
+		icon: "terminal",
+		action: "执行命令",
+		words: [
+			"bash",
+			"shell",
+			"exec",
+			"kill",
+			"command"
+		]
+	},
+	{
+		key: "write",
+		icon: "pencil",
+		action: "改写文件",
+		words: [
+			"write",
+			"edit",
+			"notebook",
+			"patch",
+			"apply"
+		]
+	},
+	{
+		key: "search",
+		icon: "magnifier",
+		action: "查找",
+		words: [
+			"grep",
+			"glob",
+			"find",
+			"search",
+			"list"
+		]
+	},
+	{
+		key: "read",
+		icon: "file",
+		action: "读取文件",
+		words: [
+			"read",
+			"cat",
+			"open",
+			"file"
+		]
+	},
+	{
+		key: "task",
+		icon: "branch",
+		action: "调度子任务",
+		words: [
+			"task",
+			"agent",
+			"spawn"
+		]
+	}
+];
+/** 没有匹配到任何规则时用空心圆，代表"在想"而不是"在做某种具体动作"。 */
+const DEFAULT_ICON = "dot";
+/** 按工具名找规则；找不到返回 null。 */
+function ruleOf(toolName) {
+	if (!toolName) return null;
+	const name = String(toolName).toLowerCase();
+	return TOOL_RULES.find((rule) => rule.words.some((word) => name.includes(word))) ?? null;
+}
+/**
+* 由工具名推出图标名。
+* @param {string | undefined} toolName 事件里的工具名
+* @returns {string} globe | terminal | pencil | magnifier | file | checklist | dot
+*/
+function iconOf(toolName) {
+	return ruleOf(toolName)?.icon ?? DEFAULT_ICON;
+}
+/**
+* 由工具名推出动作的中文说法。认不出来的工具直接显示原名，不硬猜。
+* @param {string | undefined} toolName 事件里的工具名
+* @returns {string} 中文动作，或工具原名
+*/
+function actionOf(toolName) {
+	if (!toolName) return "";
+	return ruleOf(toolName)?.action ?? String(toolName);
+}
+/** 阶段的中文状态词。 */
+const PHASE_TEXT = {
+	idle: "空闲",
+	thinking: "思考中",
+	answering: "回答中",
+	tool: "执行中",
+	waiting: "等待确认",
+	retry: "重试中",
+	interrupting: "正在打断",
+	interrupted: "已打断",
+	compacting: "压缩上下文",
+	done: "已完成",
+	error: "出错"
+};
+/**
+* 阶段自带的图标。工具阶段走 iconOf(工具名)，其余阶段各有一个固定图标。
+* 图标回答"在做什么/到哪一步"，和颜色（要不要紧）是两套信号。
+*/
+const PHASE_ICON = {
+	idle: "dot",
+	thinking: "hourglass",
+	answering: "bubble",
+	tool: DEFAULT_ICON,
+	waiting: "bang",
+	retry: "loop",
+	interrupting: "stop",
+	interrupted: "slashbox",
+	compacting: "collapse",
+	done: "check",
+	error: "cross"
+};
+/**
+* 取一条记录该用哪个图标。
+* 工具阶段看工具名，其余阶段看阶段本身。
+* @param {{ phase: string, toolName?: string }} cell 记录
+* @returns {string} 图标名
+*/
+function iconFor(cell) {
+	if (cell.phase === PHASE.tool) return iconOf(cell.toolName);
+	return PHASE_ICON[cell.phase] ?? DEFAULT_ICON;
+}
+/**
+* 取一条记录该用哪个色调。
+* 先看工具类别（写文件和跑命令要比只读更醒目），再退回阶段色。
+* @param {{ phase: string, toolName?: string }} cell 记录
+* @returns {string} gray | blue | purple | rose | orange | lime | green | red
+*/
+function toneFor(cell) {
+	if (cell.phase === PHASE.tool) {
+		const tone = ACTION_TONE[ruleOf(cell.toolName)?.key];
+		if (tone) return tone;
+	}
+	return PHASE_TONE[cell.phase] ?? "gray";
+}
+/**
+* 动作文案：只有在动作比阶段名多说了点东西时才给。
+* 思考、回答这类"正在做什么"和阶段名同义，一律留空，交给阶段名去念。
+*/
+function hintOf(cell) {
+	switch (cell.phase) {
+		case PHASE.waiting: return "等你确认";
+		case PHASE.retry: return "失败，正在重试";
+		case PHASE.tool: return actionOf(cell.toolName);
+		default: return "";
+	}
+}
+/** 终态集合：这些阶段算收场了，等用户点掉。被打断也算一种收场。 */
+const TERMINAL = /* @__PURE__ */ new Set([
+	PHASE.done,
+	PHASE.error,
+	PHASE.interrupted
+]);
+/**
+* Finch 的执行阶段 → 我们的阶段。
+* kind 只说明"来了哪条消息"，executionPhase 才说明"这一轮整体到哪一步了"，
+* 尤其是 interrupting 在 kind 里根本没有对应类型，只能从这里认。
+*/
+const PHASE_OF_EXECUTION = {
+	starting: PHASE.thinking,
+	requesting: PHASE.thinking,
+	streaming: PHASE.answering,
+	tool_running: PHASE.tool,
+	waiting_user: PHASE.waiting,
+	retry_wait: PHASE.retry,
+	interrupting: PHASE.interrupting,
+	completed: PHASE.done,
+	interrupted: PHASE.interrupted,
+	failed: PHASE.error
+};
+/** 排序权重：等确认的永远排最前，用户最需要先看到它。 */
+const waitingFirst = (cell) => cell.phase === PHASE.waiting ? 0 : 1;
+/**
+* 建一个看板归并器。
+* @param {{ getTitle?: (sessionId: string) => string | undefined }} options getTitle 只对当前会话有值
+*/
+function createBoard(options = {}) {
+	/** sessionId → 格子 */
+	const cells = /* @__PURE__ */ new Map();
+	/**
+	* 取格子的标题。
+	* Finch 只对自家会话开放标题，用户会话多半拿不到；拿不到就返回空串，
+	* 让渲染层留白——退到会话短码只会让人误以为那是标题。
+	*/
+	const labelOf = (cell) => options.getTitle?.(cell.sessionId)?.trim() || "";
+	/** 按需创建格子；超过上限时淘汰最久没动静的那个。 */
+	const ensure = (sessionId, now) => {
+		const existing = cells.get(sessionId);
+		if (existing) return existing;
+		const cell = {
+			sessionId,
+			phase: PHASE.idle,
+			toolName: void 0,
+			startedAt: now,
+			updatedAt: now,
+			terminalAt: 0
+		};
+		cells.set(sessionId, cell);
+		if (cells.size > MAX_CELLS) {
+			let oldestId;
+			let oldestAt = Infinity;
+			for (const [id, item] of cells) if (item.updatedAt < oldestAt) {
+				oldestAt = item.updatedAt;
+				oldestId = id;
+			}
+			if (oldestId) cells.delete(oldestId);
+		}
+		return cell;
+	};
+	/**
+	* 写入一个阶段。
+	* @param {string} sessionId 会话 id
+	* @param {string} phase 目标阶段
+	* @param {number} now 当前时间
+	* @param {{ toolName?: string, startedAt?: number, terminal?: boolean }} [patch] 附带字段
+	* @returns {boolean} 是否产生了变化
+	*/
+	const set = (sessionId, phase, now, patch = {}) => {
+		const cell = ensure(sessionId, now);
+		const changed = cell.phase !== phase || cell.toolName !== patch.toolName;
+		cell.phase = phase;
+		cell.updatedAt = now;
+		cell.terminalAt = patch.terminal ? now : 0;
+		if (patch.toolName !== void 0) cell.toolName = patch.toolName;
+		if (patch.startedAt !== void 0) cell.startedAt = patch.startedAt;
+		if (patch.toolName === void 0 && phase !== PHASE.tool) cell.toolName = void 0;
+		return changed;
+	};
+	/** 只更新心跳，不动阶段。未知事件用它兜底。 */
+	const touch = (sessionId, now) => {
+		const cell = cells.get(sessionId);
+		if (!cell) return false;
+		cell.updatedAt = now;
+		return false;
+	};
+	/**
+	* 用 delta 事件推断阶段：只在格子还没有明确阶段时生效。
+	* 冷启动时已经在跑的会话没有历史，靠持续冒出来的 delta 把它们认回来。
+	*/
+	const infer = (sessionId, phase, now) => {
+		const cell = cells.get(sessionId);
+		if (!cell) return set(sessionId, phase, now);
+		cell.updatedAt = now;
+		if (cell.phase !== PHASE.idle) return false;
+		cell.phase = phase;
+		return true;
+	};
+	/**
+	* 吃一个 AgentEvent。
+	* @param {object} event Finch 的 AgentEvent
+	* @param {number} [now] 注入时间便于测试
+	* @returns {boolean} 看板是否需要重画
+	*/
+	const apply = (event, now = Date.now()) => {
+		const sessionId = event?.sessionId;
+		if (!sessionId) return false;
+		if (event.retryState) return set(sessionId, PHASE.retry, now);
+		switch (event.kind) {
+			case "user": return set(sessionId, PHASE.thinking, now, {
+				startedAt: now,
+				toolName: void 0
+			});
+			case "thinking": return set(sessionId, PHASE.thinking, now, { toolName: void 0 });
+			case "assistant_text": return set(sessionId, PHASE.answering, now, { toolName: void 0 });
+			case "tool_use": return set(sessionId, PHASE.tool, now, { toolName: event.toolName });
+			case "tool_progress":
+			case "tool_input_delta": return set(sessionId, PHASE.tool, now);
+			case "tool_result": return set(sessionId, PHASE.thinking, now, { toolName: void 0 });
+			case "permission_request": return set(sessionId, PHASE.waiting, now);
+			case "result": return set(sessionId, PHASE.done, now, {
+				terminal: true,
+				toolName: void 0
+			});
+			case "error": return set(sessionId, PHASE.error, now, { terminal: true });
+			case "interrupted": return set(sessionId, PHASE.interrupted, now, {
+				terminal: true,
+				toolName: void 0
+			});
+			case "compact_boundary": return set(sessionId, PHASE.compacting, now);
+			case "session_status": return event.runStatus === "waiting" ? set(sessionId, PHASE.waiting, now) : touch(sessionId, now);
+			case "thinking_delta": return infer(sessionId, PHASE.thinking, now);
+			case "assistant_text_delta": return infer(sessionId, PHASE.answering, now);
+			default: {
+				const phase = PHASE_OF_EXECUTION[event.executionPhase];
+				if (phase === PHASE.interrupting) return set(sessionId, PHASE.interrupting, now);
+				return phase ? infer(sessionId, phase, now) : touch(sessionId, now);
+			}
+		}
+	};
+	/**
+	* 吃一条等待卡（来自 listWaits 或 onInteractionWait 的 pending）。
+	* 等待卡是唯一能认回"已经卡在等确认、但长时间没事件"的会话的来源。
+	*/
+	const applyWait = (wait, now = Date.now()) => {
+		if (!wait?.sessionId) return false;
+		return set(wait.sessionId, PHASE.waiting, now);
+	};
+	/** 等待卡结算：会话回到思考，事件流随后会给出真实阶段。 */
+	const resolveWait = (sessionId, now = Date.now()) => {
+		if (!sessionId) return false;
+		const cell = cells.get(sessionId);
+		if (!cell || cell.phase !== PHASE.waiting) return false;
+		return set(sessionId, PHASE.thinking, now);
+	};
+	/**
+	* 推进时钟：淘汰长时间无事件的活跃会话。
+	* 已完成的记录不在这里清——它们要一直留着，直到用户自己点掉。
+	* @returns {boolean} 是否有记录被移除
+	*/
+	const tick = (now = Date.now()) => {
+		let removed = false;
+		for (const [sessionId, cell] of cells) {
+			if (TERMINAL.has(cell.phase)) continue;
+			if (cell.phase === PHASE.waiting) continue;
+			if (now - cell.updatedAt >= IDLE_EVICT_MS) {
+				cells.delete(sessionId);
+				removed = true;
+			}
+		}
+		return removed;
+	};
+	/**
+	* 用户点掉一条记录：跑完的才算看完并移除，还在跑的只是跳过去，记录留着。
+	* @param {string} sessionId 会话 id
+	* @returns {boolean} 是否真的移除了一条
+	*/
+	const dismiss = (sessionId) => {
+		const cell = cells.get(sessionId);
+		if (!cell || !TERMINAL.has(cell.phase)) return false;
+		return cells.delete(sessionId);
+	};
+	/**
+	* 一次清掉所有跑完的记录，进行中的不动——用户想清的是看完的结果，不是正在跑的任务。
+	* @returns {number} 被清掉的条数
+	*/
+	const clearFinished = () => {
+		let removed = 0;
+		for (const [sessionId, cell] of cells) {
+			if (!TERMINAL.has(cell.phase)) continue;
+			cells.delete(sessionId);
+			removed += 1;
+		}
+		return removed;
+	};
+	/** 排序后的记录：等确认的永远在最前，其余按最近活动倒序，位置不会因为新旧任务穿插而乱跳。 */
+	const list = () => [...cells.values()].toSorted((a, b) => waitingFirst(a) - waitingFirst(b) || b.updatedAt - a.updatedAt);
+	/**
+	* 给渲染层的纯数据快照。
+	* 传绝对时间戳而不是时长：画布自己有帧循环，让它按当前时间算，时长弧才会走。
+	*/
+	const snapshot = () => ({
+		total: cells.size,
+		waiting: [...cells.values()].filter((cell) => cell.phase === PHASE.waiting).length,
+		cells: list().map((cell) => {
+			const status = PHASE_TEXT[cell.phase] ?? cell.phase;
+			const hint = hintOf(cell);
+			return {
+				id: cell.sessionId,
+				label: labelOf(cell),
+				phase: cell.phase,
+				icon: iconFor(cell),
+				tone: toneFor(cell),
+				status,
+				hint,
+				text: hint || status,
+				startedAt: cell.startedAt,
+				endedAt: cell.terminalAt,
+				updatedAt: cell.updatedAt
+			};
+		})
+	});
+	return {
+		apply,
+		applyWait,
+		resolveWait,
+		tick,
+		dismiss,
+		clearFinished,
+		list,
+		snapshot,
+		labelOf
+	};
+}
+// finchapp/sessionBoard/src/index.js
+/** 事件密集时的合并推送间隔：多个 delta 同时到，只画最后一种状态。 */
+const PUSH_GAP_MS = 120;
+/** 自带图标：内置图标库里没有"列表看板"，注册一套最小的，避免图标退化成文字。 */
+const ICONS = {
+	board: "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.8\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M9 6h12\"/><path d=\"M9 12h12\"/><path d=\"M9 18h12\"/><circle cx=\"4.5\" cy=\"6\" r=\"1.5\" fill=\"currentColor\" stroke=\"none\"/><circle cx=\"4.5\" cy=\"12\" r=\"1.5\" fill=\"currentColor\" stroke=\"none\"/><circle cx=\"4.5\" cy=\"18\" r=\"1.5\" fill=\"currentColor\" stroke=\"none\"/></svg>",
+	show: "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.8\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M2.06 12.35a1 1 0 0 1 0-.7 10.75 10.75 0 0 1 19.88 0 1 1 0 0 1 0 .7 10.75 10.75 0 0 1-19.88 0\"/><circle cx=\"12\" cy=\"12\" r=\"3\"/></svg>",
+	hide: "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.8\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M10.73 5.08a10.74 10.74 0 0 1 11.2 6.57 1 1 0 0 1 0 .7 10.75 10.75 0 0 1-1.44 2.49\"/><path d=\"M14.08 14.16a3 3 0 1 1-4.24-4.24\"/><path d=\"M17.48 17.5a10.75 10.75 0 0 1-15.42-5.15 1 1 0 0 1 0-.7 10.75 10.75 0 0 1 4.45-5.14\"/><path d=\"m2 2 20 20\"/></svg>",
+	clear: "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.8\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M4 7h16\"/><path d=\"M10 11v6\"/><path d=\"M14 11v6\"/><path d=\"M6 7l1 13h10l1-13\"/><path d=\"M9 7V4h6v3\"/></svg>"
+};
+function activate(ctx) {
+	/** 诊断日志：开发档一次运行一份，正式档按天分片。 */
+	const log = createLog(ctx, "board");
+	ctx.subscriptions.push(ctx.icons.register("session-board", {
+		board: { svg: ICONS.board },
+		show: { svg: ICONS.show },
+		hide: { svg: ICONS.hide },
+		clear: { svg: ICONS.clear }
+	}));
+	/** 会话 id → 标题。ctx.session.title 只有当前会话、且常是空的，标题得从会话列表里取。 */
+	const titles = /* @__PURE__ */ new Map();
+	/**
+	* 会话 id → 右侧标签。
+	* 优先真标题；拿不到就退回 id 前八位——实测 sessions.list() 连小程序自建的会话也返回空 title，
+	* 七行全空看不出谁是谁，短码至少能区分。Space 名不兜底：七行都写同一个名字，等于没写。
+	*/
+	const board = createBoard({ getTitle: (sessionId) => titles.get(sessionId) || String(sessionId).slice(0, 8) });
+	/** 当前窗口句柄，没打开时为 undefined。 */
+	let win;
+	/** 合并推送的定时器。 */
+	let pushTimer;
+	/** 推进时钟的定时器：只负责淘汰长时间没动静的会话。 */
+	let sweepTimer;
+	/** 用户的显示意图：关了窗口就别被下一次启动重新打开。 */
+	let visible = true;
+	/** 图标预览：整窗铺一张图标墙，用来确认 14px 下的实际观感。 */
+	let preview = false;
+	/** 窗口该多大：预览模式看固定尺寸，否则跟条数走。 */
+	const boardSize = () => preview ? previewOf() : layoutOf(board.snapshot().cells.length);
+	/** 窗口位置，拖动后持久化。 */
+	let position;
+	/** 窗口自身的事件释放器，关窗时统一收尾。 */
+	let windowSubscriptions = [];
+	/** 下发给画布的文案。 */
+	const strings = () => ({
+		total: ctx.i18n.t("board.total"),
+		waiting: ctx.i18n.t("board.waiting"),
+		preview: ctx.i18n.t("preview.title")
+	});
+	/**
+	* 刷新 id → 标题。
+	* Finch 只对"本小程序创建的会话"开放描述，用户自己的会话查不到标题；
+	* 能拿到的两处是当前会话快照和用户可见通知，这里先把这两处收进来。
+	*/
+	const syncTitles = async () => {
+		const current = ctx.session?.title;
+		if (ctx.session?.id && current) titles.set(ctx.session.id, current);
+		try {
+			const list = await ctx.sessions.list();
+			if (!Array.isArray(list)) return;
+			let named = 0;
+			for (const item of list) if (item?.id && item.title) {
+				titles.set(item.id, item.title);
+				named += 1;
+			}
+			log.debug("刷新会话标题", {
+				total: list.length,
+				named,
+				cached: titles.size
+			});
+		} catch (error) {
+			log.info("读不到会话列表，标题退回短码", { reason: reasonOf(error) });
+		}
+	};
+	/**
+	* 把当前快照推给画布。
+	* 条数变化时先同步窗口高度——没有记录就只剩标题带，不留空窗。
+	* 判断依据是系统回来的实际 bounds，不是内存里记的目标高度：
+	* 一次 update 被系统吞掉后，缓存的"已经对了"会让窗口永远停在旧尺寸上。
+	*/
+	const push = () => {
+		if (!win) return;
+		const snapshot = board.snapshot();
+		const layout = boardSize();
+		const target = `${layout.width}x${layout.height}`;
+		if (lastBounds !== target) {
+			log.debug("窗口高度跟随条数调整", {
+				count: snapshot.cells.length,
+				rows: layout.rows,
+				target,
+				actual: lastBounds || "未读取"
+			});
+			win.postMessage({
+				type: "size",
+				count: snapshot.cells.length
+			}).catch((error) => {
+				log.warn("看板尺寸消息失败", { reason: reasonOf(error) });
+			});
+			win.update({ bounds: {
+				width: layout.width,
+				height: layout.height
+			} }).then(() => verifyBounds("跟随条数")).catch((error) => {
+				log.warn("看板窗口重设尺寸失败", { reason: reasonOf(error) });
+			});
+		}
+		win.postMessage({
+			type: "board",
+			board: snapshot
+		}).catch((error) => {
+			log.warn("看板推送失败", { reason: reasonOf(error) });
+		});
+	};
+	/**
+	* 回读真实 bounds，把 update 到底有没有生效记下来。
+	* 窗口尺寸对不上画面时，这条日志能直接指出是没设下去，还是设了又被系统改回。
+	* @param {string} where 触发这次校验的动作
+	*/
+	const verifyBounds = async (where) => {
+		if (!win) return;
+		try {
+			const bounds = await win.getBounds();
+			if (!bounds) return;
+			lastBounds = `${bounds.width}x${bounds.height}`;
+			const layout = boardSize();
+			log.debug("尺寸回读", {
+				where,
+				size: lastBounds,
+				expect: `${layout.width}x${layout.height}`,
+				ok: Math.abs(bounds.width - layout.width) <= 6 && Math.abs(bounds.height - layout.height) <= 6
+			});
+		} catch (error) {
+			log.warn("回读窗口尺寸失败", {
+				where,
+				reason: reasonOf(error)
+			});
+		}
+	};
+	/** 合并短时间内的多次变化，避免一次工具调用刷出几十帧。 */
+	const schedulePush = () => {
+		if (!win || pushTimer) return;
+		pushTimer = setTimeout(() => {
+			pushTimer = void 0;
+			push();
+		}, PUSH_GAP_MS);
+	};
+	/** 隔一段时间推进一次时钟：淘汰长时间没动静的会话，顺便刷新标题。 */
+	const scheduleSweep = () => {
+		clearTimeout(sweepTimer);
+		sweepTimer = setTimeout(() => {
+			sweepTimer = void 0;
+			board.tick();
+			syncTitles().then(() => schedulePush());
+		}, SWEEP_MS);
+	};
+	/** 保存窗口位置，节流到 50ms，拖动时不会每秒写几十次存储。 */
+	let positionTimer;
+	/** 上一次记录尺寸异常的时间，用来把拖动中的连续触发压成每秒一条。 */
+	let sizeWarnAt = 0;
+	/** 上一次记 bounds 明细时的尺寸，只在尺寸变化或位置大幅跳动时记一条。 */
+	let lastBounds = "";
+	/** 拖动中是否有一次 update 还在路上，用来防止 Promise 排队。 */
+	let movingFrame = false;
+	/**
+	* 记录窗口尺寸被系统改动。
+	* 这个回调在拖动时每帧都来，只比对不修正：正常情况一条日志都不会产生，
+	* 一旦出现就说明窗口尺寸确实被外部改过，是排查"越拖越大"的直接证据。
+	*/
+	const watchSize = (bounds) => {
+		const layout = boardSize();
+		const size = `${bounds.width}x${bounds.height}`;
+		if (size !== lastBounds) {
+			lastBounds = size;
+			log.debug("窗口 bounds 尺寸变化", {
+				size,
+				pos: `${bounds.x},${bounds.y}`,
+				expect: `${layout.width}x${layout.height}`,
+				dw: bounds.width - layout.width,
+				dh: bounds.height - layout.height
+			});
+		}
+		if (Math.abs(bounds.width - layout.width) <= 6 && Math.abs(bounds.height - layout.height) <= 6) return;
+		if (Date.now() - sizeWarnAt < 1e3) return;
+		sizeWarnAt = Date.now();
+		log.warn("窗口尺寸被改动", {
+			width: bounds.width,
+			height: bounds.height,
+			expect: `${layout.width}x${layout.height}`
+		});
+	};
+	const savePosition = (bounds) => {
+		position = {
+			x: bounds.x,
+			y: bounds.y
+		};
+		watchSize(bounds);
+		clearTimeout(positionTimer);
+		positionTimer = setTimeout(() => {
+			positionTimer = void 0;
+			ctx.storage.set("window.position", position).catch((error) => {
+				log.warn("窗口位置保存失败", { reason: reasonOf(error) });
+			});
+		}, 50);
+	};
+	/** 打开看板窗口。已经开着就直接返回；失败时把原因弹出来，不留在控制台里。 */
+	const open = async () => {
+		if (win) return;
+		if (!ctx.api.supports("ui.createCanvasWindow")) {
+			log.warn("当前 Finch 不支持浮动窗口，看板无法打开");
+			await ctx.ui.showToast({
+				title: ctx.i18n.t("toast.unsupported"),
+				variant: "error",
+				position: "TC"
+			});
+			return;
+		}
+		const snapshot = board.snapshot();
+		const layout = boardSize();
+		log.info("创建看板窗口", {
+			count: snapshot.cells.length,
+			width: layout.width,
+			height: layout.height,
+			x: position?.x,
+			y: position?.y
+		});
+		try {
+			win = ctx.ui.createCanvasWindow({
+				entry: "dist/canvas.js",
+				width: layout.width,
+				height: layout.height,
+				x: position?.x,
+				y: position?.y,
+				alwaysOnTop: true,
+				transparent: true,
+				clickThrough: false,
+				resizable: false,
+				frameRate: 30,
+				maxDevicePixelRatio: 2,
+				initialData: {
+					count: snapshot.cells.length,
+					preview,
+					strings: strings(),
+					board: snapshot
+				}
+			});
+			const TIMEOUT = "timeout";
+			if (await Promise.race([win.ready.then(() => "ready"), new Promise((resolve) => {
+				setTimeout(() => resolve(TIMEOUT), 12e3);
+			})]) === TIMEOUT) {
+				log.warn("canvas 脚本 12 秒内没有就绪", {
+					state: win.state,
+					visible: win.visible
+				});
+				await ctx.ui.showToast({
+					title: ctx.i18n.t("toast.notReady"),
+					description: `state=${win.state} · visible=${win.visible}`,
+					variant: "error",
+					position: "TC"
+				});
+			} else log.debug("canvas 脚本已就绪");
+		} catch (error) {
+			log.error("看板窗口创建失败", error, { count: snapshot.cells.length });
+			win = void 0;
+			await ctx.ui.showToast({
+				title: ctx.i18n.t("toast.failed"),
+				description: reasonOf(error),
+				variant: "error",
+				position: "TC"
+			});
+			return;
+		}
+		windowSubscriptions = [
+			win.onDidChangeBounds(savePosition),
+			win.onDidReceiveMessage(handleCanvasMessage),
+			win.onDidChangeFocus((focused) => {
+				log.debug("窗口焦点变化", { focused });
+			}),
+			win.onDidDispose(() => {
+				log.info("看板窗口已销毁");
+				win = void 0;
+				action.notifyUpdate();
+			})
+		];
+		lastBounds = "";
+		await syncWaits();
+		push();
+	};
+	/** 关掉窗口；释放器逐个兜住异常，窗口已经没了也不该把停用流程搞崩。 */
+	const close = () => {
+		if (!win) return;
+		clearTimeout(pushTimer);
+		pushTimer = void 0;
+		clearTimeout(sweepTimer);
+		sweepTimer = void 0;
+		win.dispose();
+		win = void 0;
+		for (const subscription of windowSubscriptions) try {
+			subscription.dispose();
+		} catch {}
+		windowSubscriptions = [];
+	};
+	/** 用户层面的开关。 */
+	const setVisible = async (next) => {
+		visible = next;
+		await ctx.storage.set("visible", next);
+		if (next) await open();
+		else close();
+		action.notifyUpdate();
+	};
+	/** 拉一次全量等待卡，补齐冷启动时看不到的 waiting 会话。没有权限时静默跳过。 */
+	const syncWaits = async () => {
+		try {
+			const waits = await ctx.sessions.listWaits();
+			for (const wait of waits) board.applyWait(wait);
+		} catch (error) {
+			log.info("读不到全局等待列表，等待状态只能靠事件流", { reason: reasonOf(error) });
+		}
+	};
+	/** 画布发来的消息：点击格子跳会话、拖动中移动、拖动结束校正、脚本内部错误回传。 */
+	const handleCanvasMessage = (message) => {
+		if (message?.type === "move") {
+			if (movingFrame) return;
+			movingFrame = true;
+			const layout = boardSize();
+			win?.update({ bounds: {
+				x: message.x,
+				y: message.y,
+				width: layout.width,
+				height: layout.height
+			} }).catch((error) => {
+				log.warn("拖动更新失败", { reason: reasonOf(error) });
+			}).finally(() => {
+				movingFrame = false;
+			});
+			return;
+		}
+		if (message?.type === "dragEnd") {
+			const layout = boardSize();
+			win?.update({ bounds: {
+				x: message.x ?? position?.x,
+				y: message.y ?? position?.y,
+				width: layout.width,
+				height: layout.height
+			} }).catch((error) => {
+				log.warn("拖动结束校正失败", { reason: reasonOf(error) });
+			});
+			log.info("拖动结束，已校正窗口", {
+				x: message.x,
+				y: message.y,
+				width: layout.width,
+				height: layout.height
+			});
+			lastBounds = "";
+			win?.getBounds().then((bounds) => {
+				log.debug("校正后 bounds", {
+					size: `${bounds.width}x${bounds.height}`,
+					pos: `${bounds.x},${bounds.y}`,
+					expect: `${layout.width}x${layout.height}`
+				});
+			}).catch((error) => {
+				log.warn("回读 bounds 失败", { reason: reasonOf(error) });
+			});
+			return;
+		}
+		if (message?.type === "log") {
+			const text = `[canvas] ${message.message ?? ""}`;
+			const detail = message.data === void 0 ? void 0 : { data: message.data };
+			if (message.level === "error") log.error(text, void 0, detail);
+			else if (message.level === "warn") log.warn(text, detail);
+			else log.debug(text, detail);
+			return;
+		}
+		if (message?.type === "hide") {
+			setVisible(false);
+			return;
+		}
+		if (message?.type === "clear-finished") {
+			const removed = board.clearFinished();
+			log.info("清空已完成", {
+				removed,
+				from: "titlebar"
+			});
+			push();
+			scheduleSweep();
+			action.notifyUpdate();
+			return;
+		}
+		if (message?.type !== "focus" || typeof message.sessionId !== "string") return;
+		if (board.dismiss(message.sessionId)) {
+			push();
+			scheduleSweep();
+			action.notifyUpdate();
+		}
+		ctx.navigation.openSession(message.sessionId).catch((error) => {
+			log.warn("跳转会话失败", {
+				sessionId: message.sessionId,
+				reason: reasonOf(error)
+			});
+		});
+	};
+	ctx.subscriptions.push(ctx.events.onAgentEvent((event) => {
+		if (board.apply(event)) schedulePush();
+		if (event.kind === "result" || event.kind === "error" || event.kind === "interrupted") scheduleSweep();
+	}));
+	ctx.subscriptions.push(ctx.notifications.onDidPost((event) => {
+		log.debug("收到用户通知", {
+			kind: event?.kind,
+			sessionId: event?.sessionId,
+			title: event?.title
+		});
+		if (!event?.sessionId || !event.title) return;
+		titles.set(event.sessionId, event.title);
+		schedulePush();
+	}));
+	try {
+		ctx.subscriptions.push(ctx.events.onInteractionWait((event) => {
+			if (event.phase === "waiting") {
+				if (event.sessionTitle) titles.set(event.sessionId, event.sessionTitle);
+				board.applyWait(event.wait);
+			} else board.resolveWait(event.sessionId);
+			schedulePush();
+		}));
+	} catch (error) {
+		log.info("没有全局等待权限，等待状态改用事件流推断", { reason: reasonOf(error) });
+	}
+	ctx.subscriptions.push(ctx.status.onDidChange(() => {
+		if (board.tick()) schedulePush();
+	}));
+	log.info("事件订阅完成");
+	const action = ctx.composerActions.register("session-board", {
+		async getBadge() {
+			return {
+				text: ctx.i18n.t("name"),
+				active: visible
+			};
+		},
+		async getMenu() {
+			const snapshot = board.snapshot();
+			return [
+				{
+					id: "__summary__",
+					label: ctx.i18n.t("menu.summary", { count: snapshot.total }),
+					iconName: "ext:board",
+					disabled: true
+				},
+				{
+					id: "__sep__",
+					label: "",
+					separator: true
+				},
+				{
+					id: "toggle-visible",
+					label: visible ? ctx.i18n.t("menu.hide") : ctx.i18n.t("menu.show"),
+					iconName: visible ? "ext:hide" : "ext:show",
+					checked: visible
+				},
+				{
+					id: "toggle-preview",
+					label: ctx.i18n.t("menu.preview"),
+					iconName: "ext:board",
+					checked: preview
+				},
+				{
+					id: "clear-finished",
+					label: ctx.i18n.t("menu.clearFinished"),
+					iconName: "ext:clear",
+					disabled: !snapshot.cells.some((cell) => cell.endedAt)
+				}
+			];
+		},
+		async execute(context, itemId) {
+			if (itemId === "toggle-visible") {
+				await setVisible(!visible);
+				return;
+			}
+			if (itemId === "toggle-preview") {
+				preview = !preview;
+				await ctx.storage.set("preview", preview);
+				await win?.postMessage({
+					type: "config",
+					preview,
+					strings: strings()
+				});
+				lastBounds = "";
+				push();
+				log.info("切换图标预览", { preview });
+				action.notifyUpdate();
+				return;
+			}
+			if (itemId === "clear-finished") {
+				const removed = board.clearFinished();
+				log.info("清空已完成", {
+					removed,
+					from: "composer"
+				});
+				push();
+				scheduleSweep();
+				action.notifyUpdate();
+			}
+		}
+	});
+	ctx.subscriptions.push(action);
+	ctx.subscriptions.push(ctx.i18n.onDidChangeLocale(() => {
+		if (win) win.postMessage({
+			type: "config",
+			preview,
+			strings: strings()
+		}).catch(() => {});
+		action.notifyUpdate();
+	}));
+	/** 停用时关窗口，别把孤儿窗口留在桌面上。 */
+	const shutdown = () => {
+		log.info("看板已停用");
+		close();
+		clearTimeout(positionTimer);
+	};
+	ctx.subscriptions.push({ dispose: shutdown });
+	/** 恢复持久化状态，然后按上次的意图决定是否打开。 */
+	(async () => {
+		try {
+			const [savedVisible, savedPreview, savedPosition] = await Promise.all([
+				ctx.storage.get("visible"),
+				ctx.storage.get("preview"),
+				ctx.storage.get("window.position")
+			]);
+			visible = savedVisible !== false;
+			preview = savedPreview === true;
+			position = savedPosition ?? void 0;
+			log.info("看板已激活", {
+				dev: isDev(),
+				visible,
+				preview,
+				logFile: log.file
+			});
+			await syncTitles();
+			if (visible) await open();
+			action.notifyUpdate();
+		} catch (error) {
+			log.error("看板初始化失败", error);
+			await ctx.ui.showToast({
+				title: ctx.i18n.t("toast.initFailed"),
+				description: reasonOf(error),
+				variant: "error",
+				position: "TC"
+			});
+		}
+	})();
+}
+function deactivate() {}
+export { activate, deactivate };