pi-firecode 1.0.0 → 1.0.2

package/master/actions.ts

@@ -1,293 +0,0 @@
-/** subagents 七个命令动作：每个动作一个处理函数，表驱动分发。 */
-import { existsSync } from "node:fs";
-import { readFile, realpath } from "node:fs/promises";
-import { isAbsolute } from "node:path";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { MasterRole } from "../config.js";
-import { textOf } from "../format.js";
-import { readReviewOutcome } from "../review/outcome.js";
-import { compactWorker } from "./list-view.js";
-import {
-	monitorAndSettleReview, observeWorker, openWorkerSession, resumeCheckPrompt, reviewRunId, runWorker, spawnWorker,
-} from "./run.js";
-import type { MasterRuntime } from "./runtime.js";
-import { preallocateWorkerSession } from "./spawn.js";
-import { requireWorker, THINKING_LEVELS, type WorkerRef } from "./state.js";
-
-export const ACTIONS = ["start", "send", "interrupt", "review", "tail", "ack", "kill"] as const;
-export type Action = (typeof ACTIONS)[number];
-type Params = Record<string, unknown>;
-type ToolResult = { content: { type: "text"; text: string }[]; details: unknown };
-type Handler = (active: MasterRuntime, params: Params, ctx: ExtensionContext) => Promise<ToolResult>;
-
-/** 同时 working/reviewing 的 Worker 上限；超出直接拒绝，不排队。 */
-const MAX_IN_FLIGHT = 15;
-
-export const ACTION_HANDLERS: Record<Action, Handler> = { start, send, interrupt, review, tail, ack, kill };
-
-async function kill(active: MasterRuntime, params: Params): Promise<ToolResult> {
-	const target = requireWorker(active.store.state, requiredString(params.worker, "worker"));
-	// 同步段内删档案与运行时事实，迟到的异步写回据此全部作废；随后等 session_shutdown 收口释放热会话。
-	active.remove(target.name);
-	await active.setup.pool.dispose(target.sessionPath);
-	return toolResult({ killed: true });
-}
-
-async function tail(active: MasterRuntime, params: Params): Promise<ToolResult> {
-	const target = requireWorker(active.store.state, requiredString(params.worker, "worker"));
-	return { content: [{ type: "text", text: await readWorkerTrace(target) }], details: undefined };
-}
-
-/** 动作名按模型先验取：曾叫 hold，被读成“暂停”而假成功。名字治误读，非 idle 报错治假成功。 */
-async function ack(active: MasterRuntime, params: Params): Promise<ToolResult> {
-	const target = requireWorker(active.store.state, requiredString(params.worker, "worker"));
-	if (target.reviewNeeded) throw new Error(`${target.name} 此票有审查义务，完成 review 后才能 ack`);
-	if (target.status !== "idle") throw new Error(`${target.name} 正在 ${target.status}，不能 ack`);
-	if (target.disposition) {
-		const { disposition: _disposition, ...rest } = target;
-		active.store.dispatch({ type: "UPSERT_WORKER", worker: rest });
-	}
-	// ack 发落失败与被中断的行；完成的留在“✓ N 个已完成”里直到 kill。
-	const live = active.live.get(target.name);
-	if (live?.outcome && live.outcome.kind !== "done") live.outcome = undefined;
-	active.render();
-	return toolResult({ acked: true });
-}
-
-async function review(active: MasterRuntime, params: Params): Promise<ToolResult> {
-	if (active.setup.reviewGate) throw new Error(active.setup.reviewGate);
-	const target = requireWorker(active.store.state, requiredString(params.worker, "worker"));
-	const live = active.liveOf(target.name);
-	if (target.status !== "idle" || live.transitioning) throw new Error(`${target.name} 正在处理其他动作，不能 review`);
-	live.transitioning = true;
-	try {
-		const session = await openWorkerSession(active, target);
-		await session.waitForIdle();
-		active.assertOpen();
-		observeWorker(active, target, session);
-		const previousRunId = reviewRunId(readReviewOutcome(target.sessionPath));
-		active.commit(target, ({ disposition: _disposition, interruptedAt: _interruptedAt, ...rest }) => ({ ...rest, status: "reviewing" }));
-		active.beginRun(target.name);
-		monitorAndSettleReview(active, target, session, previousRunId);
-		return toolResult({ reviewing: true });
-	} finally {
-		live.transitioning = undefined;
-	}
-}
-
-async function interrupt(active: MasterRuntime, params: Params): Promise<ToolResult> {
-	const target = requireWorker(active.store.state, requiredString(params.worker, "worker"));
-	if (target.status !== "working") throw new Error(`${target.name} 当前是 ${target.status}，不能 interrupt`);
-	const session = active.setup.pool.getSession(target.sessionPath);
-	if (!session) throw new Error(`${target.name} 的进程内会话已释放，无法 interrupt`);
-	const live = active.liveOf(target.name);
-	const run = live.run;
-	if (!run) throw new Error(`${target.name} 当前没有可中断的回合`);
-	live.interruptedRun = run;
-	try {
-		await session.abort();
-		active.assertOpen();
-		return toolResult({ interrupted: true });
-	} catch (error) {
-		if (live.interruptedRun === run) live.interruptedRun = undefined;
-		throw error;
-	}
-}
-
-async function send(active: MasterRuntime, params: Params): Promise<ToolResult> {
-	const { reviewGate, pool, roster } = active.setup;
-	if (params.review === true && reviewGate) throw new Error(reviewGate);
-	const target = requireWorker(active.store.state, requiredString(params.worker, "worker"));
-	const live = active.liveOf(target.name);
-	if (live.transitioning) throw new Error(`${target.name} 正在切换，稍后再 send`);
-	const requestedRole = optionalString(params.role);
-	const requestedThinking = optionalString(params.thinking);
-	const requestedCwd = optionalString(params.cwd);
-	const prompt = requiredString(params.prompt, "prompt");
-	validateDelegationText(prompt);
-	// 子代理全过程视图的补话走同一入口，只多一个来源标记：视图起的运行指挥官不在等（见 RunOrigin），
-	// 落定事件注明是用户在视图里直接派的；视图补进别人起的运行只记原话，不改来源。
-	const fromView = params.origin === "view";
-	if (target.status === "working" && !requestedRole && !requestedThinking && !requestedCwd) {
-		const result = await steer(active, target, prompt, params.review === true);
-		if (fromView) live.viewPrompts.push(prompt);
-		else if (live.origin !== "master") {
-			live.origin = "master";
-			active.render();
-		}
-		return result;
-	}
-	if (target.status === "working") throw new Error(`${target.name} 正在工作；切换 role/thinking/cwd 需先 interrupt`);
-	if (target.status !== "idle") throw new Error(`${target.name} 正在审查，等落定再 send`);
-	const selection = requestedRole ? resolveRole(roster, requestedRole) : undefined;
-	const thinkingOverride = validThinking(requestedThinking);
-	live.transitioning = true;
-	try {
-		const cwd = await resolveSendCwd(target, requestedCwd);
-		if (cwd !== target.cwd) await pool.dispose(target.sessionPath);
-		const nextModel = selection ? await pool.resolveModel(selection.model) : undefined;
-		active.assertOpen();
-		const session = await openWorkerSession(active, { ...target, cwd });
-		await session.waitForIdle();
-		active.assertOpen();
-		let { role, model, thinking } = target;
-		if (selection && nextModel) {
-			await session.setModel(nextModel);
-			active.assertOpen();
-			({ role, model, thinking } = selection);
-		}
-		if (selection || thinkingOverride) {
-			thinking = thinkingOverride ?? thinking;
-			session.setThinkingLevel(thinking);
-		}
-		const interruptedAt = active.current(target).interruptedAt;
-		const working = active.commit(target, ({ disposition: _disposition, interruptedAt: _interrupted, ...rest }) => ({
-			...rest,
-			role,
-			model,
-			thinking,
-			cwd,
-			status: "working",
-			...(params.review === true || rest.reviewNeeded ? { reviewNeeded: true } : {}),
-		}));
-		active.beginRun(target.name, fromView ? "view" : "master");
-		if (fromView) live.viewPrompts.push(prompt);
-		await runWorker(active, working, session, interruptedAt ? `${resumeCheckPrompt()}\n\n${prompt}` : prompt);
-		return toolResult({ sent: true });
-	} finally {
-		live.transitioning = undefined;
-	}
-}
-
-/**
- * working Worker 的普通 send 经宿主 steer 在句缝送达，不打断。steer 会 await 子会话的 input 处理器：
- * 期间可能落定或被 kill，写回只认重读后的档案；回合已结束时清掉滞留队列并报未送达。
- */
-async function steer(active: MasterRuntime, target: WorkerRef, prompt: string, review: boolean): Promise<ToolResult> {
-	const session = active.setup.pool.getSession(target.sessionPath);
-	if (!session?.isStreaming) throw new Error(`${target.name} 回合正在收尾，稍后再 send`);
-	await session.steer(prompt);
-	if (active.current(target).status !== "working") {
-		session.clearQueue();
-		throw new Error(`${target.name} 的回合已结束，补充说明未送达，请重新 send`);
-	}
-	if (review) active.commit(target, (latest) => ({ ...latest, reviewNeeded: true }));
-	return toolResult({ steered: true });
-}
-
-async function start(active: MasterRuntime, params: Params, ctx: ExtensionContext): Promise<ToolResult> {
-	const { reviewGate, roster } = active.setup;
-	if (params.review === true && reviewGate) throw new Error(reviewGate);
-	if (typeof params.worker !== "string" || !params.worker.trim())
-		throw new Error("start 需要 worker：给子代理起个简短任务名（如 fix-auth、repo-scan）");
-	const name = params.worker.trim();
-	validateWorkerName(name);
-	const starting = [...active.live].flatMap(([candidate, live]) => (live.starting ? [candidate] : []));
-	if (active.store.state.workers.some((worker) => worker.name === name) || starting.includes(name))
-		throw new Error(`子代理已存在：${name}`);
-	const inFlight = active.store.state.workers.filter((worker) => worker.status === "working" || worker.status === "reviewing");
-	if (inFlight.length + starting.length >= MAX_IN_FLIGHT)
-		throw new Error(`Worker 并发上限 ${MAX_IN_FLIGHT}，当前在飞：${[...inFlight.map((worker) => worker.name), ...starting].join("、")}`);
-	const prompt = requiredString(params.prompt, "prompt");
-	validateDelegationText(prompt);
-	const selectedRole = resolveRole(roster, requiredString(params.role, "start 必须指定 role"));
-	const thinking = validThinking(optionalString(params.thinking)) ?? selectedRole.thinking;
-	const { live, launch } = active.reserve(name);
-	try {
-		const cwd = await resolveWorkerCwd(optionalString(params.cwd) ?? ctx.cwd);
-		active.assertOpen();
-		const mainSessionPath = ctx.sessionManager.getSessionFile();
-		if (!mainSessionPath) throw new Error("主会话尚未落盘，无法创建子代理会话目录");
-		const worker: WorkerRef = {
-			name,
-			role: selectedRole.role,
-			model: selectedRole.model,
-			thinking,
-			status: "working",
-			sessionPath: preallocateWorkerSession(mainSessionPath, cwd),
-			cwd,
-			launch,
-			...(params.review === true ? { reviewNeeded: true } : {}),
-		};
-		active.store.dispatch({ type: "UPSERT_WORKER", worker });
-		live.starting = undefined;
-		active.beginRun(name);
-		const session = await spawnWorker(active, worker, false);
-		await runWorker(active, worker, session, prompt);
-		return toolResult({ started: true, worker: compactWorker(worker) });
-	} catch (error) {
-		// 只撤自己这一票：kill 后同名重开的新票不受影响。
-		if (!active.closed && active.live.get(name) === live) active.remove(name, live);
-		throw error;
-	}
-}
-
-async function readWorkerTrace(worker: WorkerRef): Promise<string> {
-	let raw: string;
-	try {
-		raw = await readFile(worker.sessionPath, "utf8");
-	} catch (error) {
-		throw new Error(`无法读取子代理 ${worker.name} 会话：${error instanceof Error ? error.message : String(error)}`);
-	}
-	const lines: string[] = [];
-	for (const line of raw.split(/\r?\n/u)) {
-		if (!line) continue;
-		try {
-			const entry = JSON.parse(line) as { type?: string; message?: { role?: string; content?: unknown } };
-			if (entry.type !== "message" || !entry.message?.role) continue;
-			const text = textOf(entry.message.content);
-			if (text) lines.push(`${entry.message.role}: ${text}`);
-		} catch {
-			// 正在追加的尾行可暂时不完整；近况保留此前完整记录。
-		}
-	}
-	return `子代理 ${worker.name} 近况（${worker.status}）\n${lines.join("\n").slice(-4_000)}`;
-}
-
-function toolResult(value: unknown): ToolResult {
-	return { content: [{ type: "text", text: JSON.stringify(value) }], details: value };
-}
-
-function requiredString(value: unknown, field: string): string {
-	if (typeof value !== "string" || !value.trim()) throw new Error(`${field} 不能为空`);
-	return value.trim();
-}
-
-function optionalString(value: unknown): string | undefined {
-	return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-
-function validThinking(value: string | undefined): WorkerRef["thinking"] | undefined {
-	if (value && !THINKING_LEVELS.includes(value as WorkerRef["thinking"])) throw new Error(`thinking 值无效：${value}`);
-	return value as WorkerRef["thinking"] | undefined;
-}
-
-/** 宿主已按 schema 枚举校验过 role，这里只查表。 */
-function resolveRole(roles: MasterRole[], role: string): MasterRole {
-	return roles.find((candidate) => candidate.role === role)!;
-}
-
-function validateWorkerName(name: string): void {
-	if (!/^[a-z][a-z0-9_-]{0,31}$/u.test(name)) throw new Error("Worker name 必须匹配 [a-z][a-z0-9_-]{0,31}");
-}
-
-function validateDelegationText(prompt: string): void {
-	const text = prompt.trimStart();
-	if (/^\/skills?:/u.test(text) && !text.startsWith("/skill:tdd ")) throw new Error("委派文本只允许 /skill:tdd 技能前缀");
-}
-
-async function resolveWorkerCwd(path: string): Promise<string> {
-	if (!isAbsolute(path)) throw new Error("cwd 必须是已存在的绝对目录");
-	try {
-		return await realpath(path);
-	} catch {
-		throw new Error(`cwd 不存在：${path}`);
-	}
-}
-
-async function resolveSendCwd(worker: WorkerRef, requested: string | undefined): Promise<string | undefined> {
-	if (requested) return resolveWorkerCwd(requested);
-	if (worker.cwd && !existsSync(worker.cwd))
-		throw new Error(`${worker.name} 的 cwd 已不存在：${worker.cwd}；send 请带 cwd 指向新检出`);
-	return worker.cwd;
-}

package/master/activity-list.ts

@@ -1,281 +0,0 @@
-/**
- * 输入框上方的子代理活动列表：需要处理的（失败、被中断、卡住）置顶，然后在跑与审查，再合计已完成与空闲。
- * 行布局在 activity.ts；这里只决定谁上榜、怎么排、哪些折叠、整表是否留角色，以及何时需要动画时钟；落定事实只在运行时，reload 后不展示历史。
- */
-import type { Theme } from "@earendil-works/pi-coding-agent";
-import { visibleWidth, type TuiMouseEvent } from "@earendil-works/pi-tui";
-import { type ActivityRow as Row, nameWidthFor, renderActivityRow, roleFits } from "../activity.js";
-import { flame, HEAT_COLORS, onFrame, paint, phaseOf, reviewMark } from "../flame.js";
-import { clip, formatDuration } from "../format.js";
-import { toolActionText } from "../tools/actions.js";
-import type { ReviewProgress } from "../review/outcome.js";
-import type { WorkerRef } from "./state.js";
-
-/** 本次运行的落定事实：落定时刻、结局与行上的说明。失败与被中断留到 ack 或 kill，完成留到 kill。 */
-export interface SettledFact {
-	at: number;
-	/** 被中断不是失败：会话与义务都在，等指挥官续派或收口。 */
-	kind: "done" | "failed" | "interrupted";
-	note?: string;
-}
-
-export interface ActivityFacts {
-	workers: readonly Pick<WorkerRef, "name" | "role" | "status" | "sessionPath" | "cwd" | "launch">[];
-	currentTools: ReadonlyMap<string, ReadonlyMap<string, { tool: string; args: unknown }>>;
-	reviewProgress: ReadonlyMap<string, ReviewProgress>;
-	runStartedAt: ReadonlyMap<string, number>;
-	/** 最近一次输出（工具事件或模型 token）的时刻；卡住按它与本次运行起点中较晚者计算。 */
-	lastOutputAt: ReadonlyMap<string, number>;
-	settled: ReadonlyMap<string, SettledFact>;
-}
-
-type Toggle = "running" | "done" | "idle";
-/** 一行输出：子代理行，或可点击的折叠行。 */
-/** 折叠行：计数（可点）与收起时被折叠的名字。 */
-type Line = { row: Row } | { label: string; mark: string; toggle: Toggle; names: readonly string[] };
-/** 点击命中：折叠行翻转展开，子代理行打开它的全过程视图。 */
-type Target = { toggle: Toggle } | { open: string };
-
-/** working 子代理这么久没有任何输出（模型 token 或工具事件）就追加“N 分钟无输出”。 */
-const STUCK_MS = 5 * 60_000;
-const MINUTE_MS = 60_000;
-const STUCK_GLYPH = "◌";
-const INTERRUPTED_GLYPH = "‖";
-/** 可见行数下限；终端每 6 行再容纳一条在跑的行。 */
-const MIN_ROWS = 4;
-const ROWS_PER_ACTIVITY = 6;
-
-const duration = (ms: number) => formatDuration(Math.max(0, ms));
-const DONE_MARK = paint(HEAT_COLORS.green, "✓");
-const IDLE_GLYPH = "·";
-
-/** 卡住提醒的全写法与窄屏短写法。 */
-function silentNote(minutes: number): { full: string; short: string } {
-	return { full: `${minutes} 分钟无输出`, short: `${minutes}m 无输出` };
-}
-const FAILED_MARK = paint(HEAT_COLORS.fail, "✗");
-
-/**
- * 可见的在跑行数：随终端高度放宽；宿主拿不到高度时用下限。ctrl+o 是聊天区的全局展开，不展开活动列表——
- * 它常驻在输入框上方，再展开只会挤掉正文视口；要看全部点折叠行。
- */
-export function visibleRows(terminalRows: number | undefined): number {
-	return Math.max(MIN_ROWS, Math.floor((terminalRows ?? 0) / ROWS_PER_ACTIVITY));
-}
-
-interface Groups {
-	failed: Row[];
-	interrupted: Row[];
-	stuck: Row[];
-	running: Row[];
-	done: Row[];
-	/** 空闲且本进程内没有落定结局的（resume 恢复的、ack 过的）。 */
-	idle: Row[];
-	/** 有行在动：在跑、审查、卡住（耗时仍在走），需要动画时钟；落定行静止。 */
-	animating: boolean;
-}
-
-/** 按档案里的启动序。 */
-function launchSorted(facts: ActivityFacts): number[] {
-	return facts.workers.map((_, index) => index).sort((a, b) => facts.workers[a].launch - facts.workers[b].launch);
-}
-
-/** 子代理按启动序的名字：全过程视图按它换子代理，位置不随状态分组跳动。 */
-export function launchOrder(facts: ActivityFacts): string[] {
-	return launchSorted(facts).map((index) => facts.workers[index].name);
-}
-
-/** 一个子代理在活动列表里的分组（审查与在跑同组展示）；全过程视图顶行读同一份。 */
-export type RowKind = "failed" | "interrupted" | "stuck" | "running" | "review" | "done" | "idle";
-
-/** 有行在动（耗时仍在走）的分组：需要动画时钟。 */
-export const ANIMATING_KINDS: ReadonlySet<RowKind> = new Set(["stuck", "running", "review"]);
-
-/** 一个子代理的行状态：所在分组与这一行（标记、动作、耗时）。index 是它在 facts.workers 里的位置（决定火苗相位）。 */
-export function rowState(facts: ActivityFacts, index: number, now: number, theme: Theme): { kind: RowKind; row: Row } {
-	const worker = facts.workers[index];
-	const path = worker.sessionPath;
-	const phase = phaseOf(index);
-	const start = facts.runStartedAt.get(path);
-	const base = { name: worker.name, role: worker.role, elapsed: start === undefined ? "" : duration(now - start) };
-	if (worker.status === "working") {
-		const silent = now - Math.max(start ?? now, facts.lastOutputAt.get(path) ?? 0);
-		const tool = [...(facts.currentTools.get(path)?.values() ?? [])].at(-1);
-		const action = tool ? toolActionText(tool.tool, tool.args, worker.cwd ?? "") : "思考中";
-		// 卡住时动作照常显示（用户要知道卡在哪条命令上），只追加提醒；前台长命令同样按无输出计时。
-		if (silent >= STUCK_MS)
-			// 右侧不放总耗时：要看的是“多久没输出”，两个时长并排（“5m 无输出 5m13s”）只会看混。
-			return { kind: "stuck", row: { ...base, elapsed: "", mark: theme.fg("warning", STUCK_GLYPH), action, note: silentNote(Math.floor(silent / MINUTE_MS)) } };
-		return { kind: "running", row: { ...base, mark: flame(1, phase), action } };
-	}
-	if (worker.status === "reviewing") {
-		const progress = facts.reviewProgress.get(path);
-		const action = progress ? `审查第 ${progress.round} 轮 · ${progress.settled}/${progress.total} 通过` : "审查中";
-		return { kind: "review", row: { ...base, mark: reviewMark(phase), action, tone: "review" } };
-	}
-	const fact = facts.settled.get(path);
-	// 组名已经说了“空闲”，展开行只列谁。
-	if (!fact) return { kind: "idle", row: { ...base, elapsed: "", mark: theme.fg("dim", IDLE_GLYPH), action: "", settled: true } };
-	const settledRow = { ...base, elapsed: start === undefined ? "" : duration(fact.at - start), settled: true };
-	if (fact.kind === "done") return { kind: "done", row: { ...settledRow, mark: DONE_MARK, action: fact.note ?? "已返回" } };
-	if (fact.kind === "interrupted")
-		return { kind: "interrupted", row: { ...settledRow, mark: theme.fg("warning", INTERRUPTED_GLYPH), action: "被中断", tone: "warning" } };
-	return { kind: "failed", row: { ...settledRow, mark: FAILED_MARK, action: fact.note ?? "失败", tone: "failed" } };
-}
-
-function group(facts: ActivityFacts, now: number, theme: Theme): Groups {
-	const groups: Groups = { failed: [], interrupted: [], stuck: [], running: [], done: [], idle: [], animating: false };
-	for (const index of launchSorted(facts)) {
-		const { kind, row } = rowState(facts, index, now, theme);
-		groups.animating ||= ANIMATING_KINDS.has(kind);
-		groups[kind === "review" ? "running" : kind].push(row);
-	}
-	return groups;
-}
-
-interface Folding {
-	limit: number;
-	showAllRunning: boolean;
-	showDone: boolean;
-	showIdle: boolean;
-}
-
-/** 需要处理的永远可见、不计入上限；上限只约束在跑的行，超出折成可点击的“+N 个在跑”。 */
-function layout({ failed, interrupted, stuck, running, done, idle }: Groups, folding: Folding, theme: Theme): Line[] {
-	const lines: Line[] = [...failed, ...interrupted, ...stuck].map((row) => ({ row }));
-	const idleMark = theme.fg("dim", IDLE_GLYPH);
-	const names = (rows: readonly Row[], open: boolean) => (open ? [] : rows.map((row) => row.name));
-	const overflow = running.length > folding.limit;
-	if (!overflow || folding.showAllRunning) {
-		lines.push(...running.map((row) => ({ row })));
-		if (overflow) lines.push({ label: "收起", mark: idleMark, toggle: "running", names: [] });
-	} else {
-		const shown = running.slice(0, folding.limit - 1);
-		const hidden = running.slice(shown.length);
-		lines.push(...shown.map((row) => ({ row })), { label: `+${hidden.length} 个在跑`, mark: idleMark, toggle: "running", names: names(hidden, false) });
-	}
-	if (done.length) {
-		lines.push({ label: `${done.length} 个已完成`, mark: DONE_MARK, toggle: "done", names: names(done, folding.showDone) });
-		if (folding.showDone) lines.push(...done.map((row) => ({ row })));
-	}
-	if (idle.length) {
-		lines.push({ label: `${idle.length} 个空闲`, mark: idleMark, toggle: "idle", names: names(idle, folding.showIdle) });
-		if (folding.showIdle) lines.push(...idle.map((row) => ({ row })));
-	}
-	return lines;
-}
-
-function renderLines(lines: Line[], width: number, theme: Theme): string[] {
-	const rows = lines.flatMap((line) => ("row" in line ? [line.row] : []));
-	const nameWidth = nameWidthFor(rows, width);
-	// 退让整表一致：任何一行放不下“角色 · 动作”就全表丢角色，列才对得齐。
-	const showRole = rows.every((row) => roleFits(row, width, nameWidth));
-	// 折叠行的名字预览列对齐：按最宽的计数补齐。
-	const labelWidth = Math.max(0, ...lines.map((line) => ("label" in line ? visibleWidth(line.label) : 0)));
-	return lines.map((line) => {
-		if ("row" in line) return renderActivityRow(line.row, width, nameWidth, theme, showRole);
-		const head = `  ${line.mark} ${chip(line.label, theme)}`;
-		const pad = labelWidth - visibleWidth(line.label) + 1;
-		const preview = fitNames(line.names, width - visibleWidth(head) - pad);
-		const text = preview ? `${head}${" ".repeat(pad)}${theme.fg("dim", preview)}` : head;
-		return clip(text, width, "end", "");
-	});
-}
-
-/**
- * 折叠行计数的可点提示：两侧各一格空白、铺工具行同族的中性暗底。theme.bg 以背景关闭（49）收尾、不带全量重置，
- * clip 在胶囊中间截断也保留这个关闭序列，底色不会被掐断或漏到后面。不用下划线：终端按字形画，数字粗、中文细。
- */
-const chip = (label: string, theme: Theme) => theme.bg("toolPendingBg", theme.fg("muted", ` ${label} `));
-
-/** 能放下几个名字列几个，只列整名，不在名字中间截断。 */
-function fitNames(names: readonly string[], room: number): string {
-	let text = "";
-	for (const name of names) {
-		const next = text ? `${text} · ${name}` : name;
-		if (visibleWidth(next) > room) break;
-		text = next;
-	}
-	return text;
-}
-
-/** widget 组件：动画时钟只在有行在动时订阅，静止即取消；折叠行可点击展开/收起。 */
-export class ActivityList {
-	private unsubscribe: (() => void) | undefined;
-	private showAllRunning = false;
-	private showDone = false;
-	private showIdle = false;
-	private moving = true;
-	/** 上一次渲染每行对应的点击目标。 */
-	private targets: (Target | undefined)[] = [];
-
-	constructor(
-		private readonly tui: { requestRender(): void },
-		private readonly theme: Theme,
-		private readonly facts: () => ActivityFacts,
-		private readonly limit: () => number,
-		private readonly open: (name: string) => void = () => {},
-	) {}
-
-	/** 事实变化后调用：对齐时钟订阅并重绘一次。 */
-	sync(): void {
-		const animating = group(this.facts(), Date.now(), this.theme).animating;
-		if (animating && !this.unsubscribe) this.unsubscribe = onFrame(() => this.onFrame());
-		if (!animating) this.release();
-		this.tui.requestRender();
-	}
-
-	/** 每帧只重绘；是否还在动由上一次 render 的分组顺带给出，不再单独分组一遍。 */
-	private onFrame(): void {
-		if (!this.moving) this.release();
-		this.tui.requestRender();
-	}
-
-	private release(): void {
-		this.unsubscribe?.();
-		this.unsubscribe = undefined;
-	}
-
-	invalidate(): void {}
-
-	render(width: number): string[] {
-		const limit = this.limit();
-		const groups = group(this.facts(), Date.now(), this.theme);
-		this.moving = groups.animating;
-		const lines = layout(groups, {
-			limit,
-			showAllRunning: this.showAllRunning,
-			showDone: this.showDone,
-			showIdle: this.showIdle,
-		}, this.theme);
-		this.targets = lines.map((line) => ("toggle" in line ? { toggle: line.toggle } : { open: line.row.name }));
-		return renderLines(lines, width, this.theme);
-	}
-
-	handleMouse(event: TuiMouseEvent) {
-		if (event.type !== "click" || event.button !== "left") return undefined;
-		const target = this.targets[event.y];
-		if (!target) return undefined;
-		if ("open" in target) {
-			this.open(target.open);
-			return { handled: true };
-		}
-		const { toggle } = target;
-		if (toggle === "running") this.showAllRunning = !this.showAllRunning;
-		else if (toggle === "done") this.showDone = !this.showDone;
-		else this.showIdle = !this.showIdle;
-		this.tui.requestRender();
-		return { handled: true };
-	}
-
-	/** 展开不常驻：下一轮人类输入时收起，免得一直占着输入框上方。 */
-	collapse(): void {
-		if (!this.showAllRunning && !this.showDone && !this.showIdle) return;
-		this.showAllRunning = this.showDone = this.showIdle = false;
-		this.tui.requestRender();
-	}
-
-	dispose(): void {
-		this.release();
-	}
-}

package/master/event-card.ts

@@ -1,87 +0,0 @@
-/**
- * Master 事件卡：默认紧凑（每事件一行标题行），ctrl+o 展开完整内容。
- * 数据只来自消息正文里的信封（deliver.ts 是格式的唯一事实源）；渲染器永不抛异常。
- */
-import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
-import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
-import { Box, type Component, Markdown, Text } from "@earendil-works/pi-tui";
-import { clip, firstSentence, oneLine, textOf } from "../format.js";
-import { parseEnvelopes } from "../deliver.js";
-import { machineEntries } from "../tools/machine.js";
-import { MASTER_EVENT_TYPE } from "./event-format.js";
-
-export function registerMasterEventRenderer(pi: ExtensionAPI): void {
-	pi.registerMessageRenderer(
-		MASTER_EVENT_TYPE,
-		(message, options, theme) => new MasterEventCard(message.content, options.expanded, theme),
-	);
-}
-
-class MasterEventCard implements Component {
-	private readonly card: Component;
-	private readonly fallback: Component;
-
-	constructor(content: string | (string | unknown)[], expanded: boolean, theme: Theme) {
-		const text = textOf(content);
-		this.fallback = new Text(text, 0, 0);
-		let card: Component | undefined;
-		try {
-			card = !expanded ? compactCard(text, theme) : fullCard(text, theme);
-		} catch {
-			card = undefined;
-		}
-		this.card = card ?? this.fallback;
-	}
-
-	render(width: number): string[] {
-		try {
-			return this.card.render(Math.max(1, width));
-		} catch {
-			try {
-				return this.fallback.render(Math.max(1, width));
-			} catch {
-				return [];
-			}
-		}
-	}
-
-	invalidate(): void {
-		this.card.invalidate?.();
-		this.fallback.invalidate?.();
-	}
-}
-
-/** 每个事件一行：标题 + 正文首句；不是信封的旧消息退化为完整内容。 */
-function compactCard(text: string, theme: Theme): Component {
-	const entries = machineEntries(text);
-	if (!entries) return fullCard(text, theme);
-	return card(theme, entries.map((entry) =>
-		new CompactTitle(`◆ ${entry.title}${entry.preview ? ` — ${firstSentence(entry.preview)}` : ""}`)));
-}
-
-/**
- * 单行截断：不用 pi-tui 的 TruncatedText——它的省略号带 `\x1b[0m` 全量重置，
- * 会在截断点把外层 Box 的背景色掠断（行尾露底色、右缘参差）；
- * clip 是纯文本截断，Box 补位后背景整行连续。
- */
-class CompactTitle implements Component {
-	constructor(private readonly text: string) {}
-
-	invalidate(): void {}
-
-	render(width: number): string[] {
-		return [clip(oneLine(this.text), Math.max(1, width))];
-	}
-}
-
-function fullCard(text: string, theme: Theme): Component {
-	const bodies = parseEnvelopes(text)?.map((envelope) => envelope.body).join("\n\n") ?? text;
-	return card(theme, [new Markdown(bodies, 0, 0, getMarkdownTheme())]);
-}
-
-function card(theme: Theme, children: Component[]): Component {
-	// 宿主 CustomMessageComponent 已自带一行消息间距，这里不再叠加；垂直内边距也为 0。
-	const box = new Box(1, 0, (text) => theme.bg("customMessageBg", text));
-	for (const child of children) box.addChild(child);
-	return box;
-}