pi-firecode 1.0.0 → 1.0.1

package/master/event-format.ts

@@ -1,83 +0,0 @@
-/**
- * Master 事件正文的唯一产文处：第一行是给人看的标题“<名字> <结果词>”（名字是第一个空格前的词），
- * 给模型的指令放在后续正文。分节标记独占一行“<标记>：”；失败只由“错误：”分节表示——
- * 红色、失败计数与活动列表失败组都从这一个事实来（失败、审查停止、审查未完成；被中断不是失败）。
- * 折叠界面（tools/machine.ts）按标题、“错误：”分节与“耗时：本次运行 …”行投影，改格式两侧都要同步。
- */
-import { formatDuration } from "../format.js";
-import type { ReviewOutcome } from "../review/outcome.js";
-
-export const MASTER_EVENT_TYPE = "firecode-master-event";
-
-const SECTIONS = {
-	reply: "回复：",
-	error: "错误：",
-	finalReply: "最终回复：",
-	advice: "顾问意见：",
-} as const;
-
-const OBLIGATION = "此票有审查义务，请显式 review。";
-
-/**
- * 产出的事件：正文与是否落定类。落定类（已返回、失败、被中断、审查通过/停止/未完成）才带“本次运行”耗时，
- * 界面据此触发到达高亮；其余事件（待续跑、已切换模型、补充说明未送达）只带当前任务耗时。
- */
-export interface MasterEvent {
-	body: string;
-	settled: boolean;
-}
-
-const lines = (...parts: (string | undefined)[]) => parts.filter((part) => part !== undefined).join("\n");
-const settled = (...parts: (string | undefined)[]): MasterEvent => ({ body: lines(...parts), settled: true });
-const notice = (...parts: (string | undefined)[]): MasterEvent => ({ body: lines(...parts), settled: false });
-
-/**
- * 一次运行里用户在子代理全过程视图直接说的话（按顺序）。有就在标题结果词后注明来源、正文先列原话：
- * 指挥官据此知道这次运行不是它派的，只记下不向用户复述；成败、发落、在飞数与普通 send 完全相同。
- */
-export type ViewPrompts = readonly string[];
-const VIEW_MARK = "（你在子代理视图里直接派的）";
-const runTitle = (name: string, word: string, view: ViewPrompts) => `${name} ${word}${view.length ? VIEW_MARK : ""}`;
-const youSaid = (view: ViewPrompts) => view.map((prompt) => `你说：${prompt}`);
-
-export const masterEvent = {
-	returned: (name: string, reply: string, obligation = false, view: ViewPrompts = []) =>
-		settled(runTitle(name, "已返回", view), ...youSaid(view), SECTIONS.reply, reply, obligation ? OBLIGATION : undefined),
-	failed: (name: string, error: string, obligation = false, view: ViewPrompts = []) =>
-		settled(runTitle(name, "失败", view), ...youSaid(view), SECTIONS.error, error, obligation ? OBLIGATION : undefined),
-	interrupted: (name: string, obligation: boolean, view: ViewPrompts = []) =>
-		settled(runTitle(name, "被中断", view), ...youSaid(view), obligation ? "会话与审查义务均已保留，可 send 续派" : "会话已保留，可 send 续派"),
-	reviewIncomplete: (name: string, reason: string, reply?: string) =>
-		settled(`${name} 审查未完成`, SECTIONS.error, reason, ...(reply === undefined ? [] : [SECTIONS.finalReply, reply || "（无回复）"])),
-	/** 审查终态；reply 是 Worker 最后一条回复。停止与未完成是失败：原因进“错误：”分节，顾问意见在其后。 */
-	review(name: string, outcome: ReviewOutcome, reply: string): MasterEvent {
-		const final = [SECTIONS.finalReply, reply || "（无回复）"];
-		if (outcome.status === "passed") return settled(`${name} 审查通过（${outcome.rounds} 轮）`, ...final);
-		if (outcome.status === "stopped")
-			return settled(
-				`${name} 审查停止（${outcome.rounds} 轮）`,
-				SECTIONS.error,
-				outcome.advisorAdvice ? `审查 ${outcome.rounds} 轮未通过，顾问叫停` : `审查 ${outcome.rounds} 轮用尽仍未通过`,
-				...(outcome.advisorAdvice ? [SECTIONS.advice, outcome.advisorAdvice] : []),
-				...final,
-			);
-		if (outcome.status === "failed") return masterEvent.reviewIncomplete(name, outcome.reason, reply);
-		if (outcome.status === "error") return masterEvent.reviewIncomplete(name, `审查读取失败：${outcome.message}`);
-		return masterEvent.reviewIncomplete(name, `审查结束时没有终态：${outcome.status}`);
-	},
-	/** 只给会话重载打断的回合：指挥官自己发起的 interrupt 它知道现场，不提醒。 */
-	resumeReminder: (name: string) => notice(`${name} 待续跑`, "上次回合被会话重载打断，恢复后一直没有续派；请 send 续派或 kill 收口"),
-	stranded: (name: string, texts: string[]) =>
-		notice(`${name} 补充说明未送达`, `回合结束时有 ${texts.length} 条补充说明未送达，请重发：`, texts.join("\n---\n")),
-	modelSwitched: (name: string, from: string, to: string, reason: string) =>
-		notice(`${name} 已切换模型`, `已切换 ${from}→${to}（${reason}），正在同一会话自动续跑`),
-};
-
-/** 落定类正文末尾追加 Worker 本次运行耗时（子代理会话写下的轮记录给出）；没有记录或非落定事件不追加，不用别处的计时冒充。 */
-export function withElapsed(event: MasterEvent, { run, task }: { run?: number; task?: number }): string {
-	const parts = [
-		...(run === undefined || !event.settled ? [] : [`本次运行 ${formatDuration(run)}`]),
-		...(task === undefined ? [] : [`当前任务 ${formatDuration(task)}`]),
-	];
-	return parts.length ? `${event.body}\n耗时：${parts.join(" · ")}` : event.body;
-}

package/master/guard.ts

@@ -1,46 +0,0 @@
-/**
- * Worker 会话里 Master 只注册这一件事：edit/write 只能落在当前 checkout 或系统临时目录内（按真实路径判断）。
- * 临时目录放行是因为调研报告、评测产物这类交付物本来就写在那里；拦掉只会逼 Worker 改用 bash 绕过守卫。
- */
-import { realpath } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
-import { isToolCallEventType, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
-
-export function registerWorkerGuard(pi: ExtensionAPI): void {
-	pi.on("tool_call", async (event, ctx) => {
-		if (!isToolCallEventType("edit", event) && !isToolCallEventType("write", event)) return;
-		const reason = await outsideCheckoutReason(event.input.path, ctx.cwd);
-		if (reason) return { block: true, reason };
-	});
-}
-
-/** os.tmpdir() 在 macOS 是每用户的 /var/folders/…，/tmp 是另一处，两处都是临时目录。 */
-const TEMP_ROOTS = [tmpdir(), "/tmp"];
-
-async function outsideCheckoutReason(path: string, cwd: string): Promise<string | undefined> {
-	const target = await canonicalWritePath(resolve(cwd, path));
-	const roots = await Promise.all([cwd, ...TEMP_ROOTS].map(canonicalWritePath));
-	return roots.some((root) => within(root, target)) ? undefined : `子代理只能修改当前 checkout 或系统临时目录：${path}`;
-}
-
-function within(root: string, target: string): boolean {
-	const local = relative(root, target);
-	return local !== ".." && !local.startsWith(`..${sep}`) && !isAbsolute(local);
-}
-
-/** 目标可能还不存在：沿祖先找到第一个真实存在的目录取真实路径，再拼回缺失的部分。 */
-async function canonicalWritePath(path: string): Promise<string> {
-	let ancestor = path;
-	const missing: string[] = [];
-	while (true) {
-		try {
-			return resolve(await realpath(ancestor), ...missing.reverse());
-		} catch {
-			const parent = dirname(ancestor);
-			if (parent === ancestor) return path;
-			missing.push(basename(ancestor));
-			ancestor = parent;
-		}
-	}
-}

package/master/index.ts

@@ -1,252 +0,0 @@
-/**
- * /fire-master 的注册入口：激活与停用、命令、两个工具与生命周期。
- * 运行时事实在 runtime.ts，回合编排在 run.ts，七个动作在 actions.ts，发件箱在 outbox.ts，工具行在 list-view.ts。
- */
-import { StringEnum, Type } from "@earendil-works/pi-ai";
-import { getAgentDir, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { HERDR_WORKING_CHANNEL, HERDR_WORKING_LABEL, WORKERS_CHANNEL, type HerdrWorkingPayload, type WorkersPayload, watchBusy } from "../busy.js";
-import { loadConfig, type MasterRole } from "../config.js";
-import { ToolLine } from "../tools/line.js";
-import { ACTION_HANDLERS, ACTIONS } from "./actions.js";
-import { registerMasterEventRenderer } from "./event-card.js";
-import { registerWorkerGuard } from "./guard.js";
-import {
-	compactWorker, currentWorkerAction, expandedWorkerList, listMeta, renderSubagentsResult, statusText, subagentsCallParts,
-} from "./list-view.js";
-import { assembleMasterPrompt, readMasterPrompt } from "./prompt.js";
-import { armInterruptReminder, modelAtomText } from "./run.js";
-import { MasterRuntime, type MasterSetup } from "./runtime.js";
-import { InProcessSessionPool } from "./spawn.js";
-import { loadMasterState, masterStatePath, recoverMasterState, THINKING_LEVELS, type MasterState } from "./state.js";
-
-const MASTER_TOOL = "subagents";
-const MASTER_LIST_TOOL = "subagents_list";
-const MASTER_TOOLS = [MASTER_TOOL, MASTER_LIST_TOOL];
-const INTERRUPT_RESUME_MS = 5 * 60_000;
-/**
- * 一批结果陆续返回时，最后一条后静默这么久才唤醒空闲的指挥官：合并唤醒，单条结果最多多等这一下。
- * 这是业务语义的等待：“这一批还会不会马上再来一条”没有事件能回答。同批结果相邻间隔约 2～3 秒，而唤醒回合本身要数秒，
- * 1.5 秒足以把紧挨着的并进一次唤醒，回合开跑后再到的走句缝。
- */
-const WAKE_QUIET_MS = 1_500;
-
-interface MasterDependencies {
-	pool?: InProcessSessionPool;
-	interruptResumeMs?: number;
-	wakeQuietMs?: number;
-}
-
-export function registerMaster(pi: ExtensionAPI, dependencies: MasterDependencies = {}, worker = false): void {
-	// Worker 会话里只注册 checkout 守卫，不注册命令、工具与生命周期。
-	if (worker) return registerWorkerGuard(pi);
-	const loaded = loadConfig().master;
-	const prompts = loadMasterPrompts();
-	const startupError = "error" in loaded ? loaded.error : "error" in prompts ? prompts.error : undefined;
-	const roster = "error" in loaded ? [] : loaded.config.roles;
-	const autoActivate = "error" in loaded ? false : loaded.config.autoActivate;
-	const requirePrompts = () => {
-		if ("error" in prompts) throw new Error(prompts.error);
-		return prompts;
-	};
-	// 在飞子代理数的唯一发布者；herdr:working 只在 0↔正数跃迁时发布，active 按计数配对。
-	let publishedInFlight = 0;
-	const publishInFlight = (count: number, teardown = false) => {
-		if (count === publishedInFlight) return;
-		const wasBusy = publishedInFlight > 0;
-		publishedInFlight = count;
-		pi.events.emit(WORKERS_CHANNEL, { inFlight: count, ...(teardown ? { teardown: true as const } : {}) } satisfies WorkersPayload);
-		if (wasBusy !== count > 0)
-			pi.events.emit(HERDR_WORKING_CHANNEL, { active: count > 0, label: HERDR_WORKING_LABEL } satisfies HerdrWorkingPayload);
-	};
-	// 事件末尾的“当前任务”耗时是给指挥官的时间信号（Opus 5.5 据已用时间安排并行）；起点只取 busy.ts。
-	let sessionSince: number | undefined;
-	watchBusy(pi, { onChange: (view) => { sessionSince = view.since; } });
-	const setup: MasterSetup = {
-		pi,
-		pool: dependencies.pool ?? new InProcessSessionPool(),
-		roster,
-		exclusions: "error" in loaded ? [] : loaded.config.workerExcludeExtensions,
-		workerPrompt: () => requirePrompts().worker,
-		reviewGate: reviewGateError(),
-		interruptResumeMs: dependencies.interruptResumeMs ?? INTERRUPT_RESUME_MS,
-		wakeQuietMs: dependencies.wakeQuietMs ?? WAKE_QUIET_MS,
-		publishInFlight,
-		sessionSince: () => sessionSince,
-	};
-	let runtime: MasterRuntime | undefined;
-	registerMasterEventRenderer(pi);
-
-	const setTools = (active: boolean) => {
-		const tools = pi.getActiveTools().filter((name) => !MASTER_TOOLS.includes(name));
-		pi.setActiveTools(active ? [...tools, ...MASTER_TOOLS] : tools);
-	};
-	const activate = (ctx: ExtensionContext, restored?: MasterState): MasterRuntime => {
-		if (startupError) throw new Error(startupError);
-		if (runtime) {
-			runtime.ctx = ctx;
-			return runtime;
-		}
-		const active = runtime = new MasterRuntime(setup, ctx, restored);
-		setTools(true);
-		if (active.store.discardedLegacyVersion !== undefined)
-			ctx.ui.notify(`旧版 v${active.store.discardedLegacyVersion} 子代理池已丢弃并从空池重建；旧运行时进程不会纳入新池，请手动清理`, "warning");
-		active.render();
-		return active;
-	};
-	/** 会话关闭先清空当前 runtime，再释放池、订阅与定时器：迟到任务不写状态、投递、UI 或持久化。 */
-	const deactivate = async () => {
-		const active = runtime;
-		runtime = undefined;
-		active?.close();
-		// 遗弃在飞子代理不是歇下：带 teardown 归零，busy.ts 只结束本段。
-		publishInFlight(0, true);
-		await setup.pool.disposeAll();
-		setTools(false);
-	};
-	/** reload 恢复：在飞状态收敛为 idle + interruptedAt，补挂续跑提醒，重投未确认事件。 */
-	const activateSession = (ctx: ExtensionContext): MasterRuntime => {
-		if (runtime) return activate(ctx);
-		let restored: MasterState | undefined;
-		try {
-			restored = loadMasterState(masterStatePath(getAgentDir(), ctx.sessionManager.getSessionId()));
-		} catch {
-			return activate(ctx);
-		}
-		const active = activate(ctx, restored);
-		if (restored) {
-			const recovered = recoverMasterState(restored);
-			for (const worker of recovered.workers) {
-				if (worker !== restored.workers.find((candidate) => candidate.name === worker.name))
-					active.store.dispatch({ type: "UPSERT_WORKER", worker });
-				if (worker.interruptedAt) armInterruptReminder(active, worker);
-			}
-		}
-		active.outbox.replayUnacked(ctx);
-		return active;
-	};
-
-	pi.registerCommand("fire-master", {
-		description: "翻转当前会话的指挥官模式；status 查看状态",
-		handler: async (args, ctx) => {
-			const input = args.trim();
-			if (input === "status") {
-				ctx.ui.notify(runtime ? statusText(runtime.store.state.workers) : "指挥官模式未启动", "info");
-				return;
-			}
-			if (input) {
-				ctx.ui.notify("/fire-master 只接受 status；裸命令翻转开关", "error");
-				return;
-			}
-			if (runtime) {
-				await deactivate();
-				ctx.ui.notify("指挥官模式已关闭", "info");
-				return;
-			}
-			try {
-				activateSession(ctx);
-				ctx.ui.notify("指挥官模式已启动", "info");
-			} catch (error) {
-				ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
-			}
-		},
-	});
-
-	pi.on("input", (event) => {
-		if (event.source !== "extension") runtime?.collapseList();
-	});
-
-	pi.on("before_agent_start", async (event) => {
-		if (!runtime || !pi.getActiveTools().includes(MASTER_TOOL)) return;
-		return {
-			systemPrompt: `${event.systemPrompt}\n\n${assembleMasterPrompt(requirePrompts().master, rosterText(roster))}`,
-		};
-	});
-
-	pi.registerTool({
-		name: MASTER_LIST_TOOL,
-		label: "子代理",
-		description: "查看子代理池快照",
-		renderShell: "self",
-		renderCall: (_args, theme, ctx) =>
-			new ToolLine({ label: "子代理", value: subagentsCallParts({ action: "list" }), clip: "end", theme, ctx }),
-		renderResult: (result, options, theme, context) => {
-			const details = result.details as { workers?: unknown } | undefined;
-			context.state.meta = !context.isError && Array.isArray(details?.workers) ? listMeta(details.workers) : undefined;
-			if (options.expanded && Array.isArray(details?.workers))
-				return expandedWorkerList(details.workers, theme, context);
-			return renderSubagentsResult(result, options, theme, context);
-		},
-		parameters: Type.Object({}),
-		async execute() {
-			const active = runtime;
-			if (!active) throw new Error("subagents_list 只在 Master 中可用");
-			const workers = active.store.state.workers.map(compactWorker);
-			return {
-				content: [{ type: "text" as const, text: JSON.stringify({ workers }) }],
-				details: {
-					workers: workers.map((worker) => ({ ...worker, currentAction: currentWorkerAction(worker, active.live.get(worker.name)) })),
-				},
-			};
-		},
-	});
-
-	pi.registerTool({
-		name: MASTER_TOOL,
-		label: "子代理",
-		description: "指挥官的七动作子代理接口：start 按角色新建，send 续派或切换角色，interrupt 中断，review 显式审查，tail 读轨迹，ack 确认落定，kill 收口移除；无 sleep/session。",
-		renderShell: "self",
-		renderCall: (args, theme, ctx) =>
-			new ToolLine({ label: "子代理", value: subagentsCallParts(args as Record<string, unknown>), clip: "end", theme, ctx }),
-		renderResult: renderSubagentsResult,
-		parameters: Type.Object({
-			action: StringEnum(ACTIONS, { description: "七动作之一；等待状态变化，不要用 sleep 轮询。" }),
-			worker: Type.String({ description: "start 起简短任务名；其余动作填目标 Worker。" }),
-			prompt: Type.Optional(Type.String({ description: "start/send 必填自包含任务说明，包括交付物、限制与验证要求。" })),
-			// 角色词只来自角色表，代码不持有固定词表；代价是角色名拼错无法在加载时报出。
-			role: Type.Optional(StringEnum(roster.map((entry) => entry.role), { description: "start 必填角色表中的角色；send 可选，传入时切换角色，省略则沿用。" })),
-			thinking: Type.Optional(StringEnum(THINKING_LEVELS, { description: "可选思考档覆盖；省略时使用角色原子档或当前档。" })),
-			cwd: Type.Optional(Type.String({ description: "Worker 工作目录的绝对路径；start 默认当前目录，send 给空闲 Worker 换检出时带上（同一会话重开）。" })),
-			review: Type.Optional(Type.Boolean({ description: "按审查纪律为 start/send 记录义务；true 不自动开审。" })),
-		}),
-		async execute(_id, params: Record<string, unknown>, _signal, _update, ctx) {
-			const active = runtime;
-			if (!active) throw new Error("subagents 只在 Master 中可用");
-			const handler = ACTION_HANDLERS[params.action as keyof typeof ACTION_HANDLERS];
-			if (!handler) throw new Error(`未知 subagents action：${String(params.action)}`);
-			return handler(active, params, ctx);
-		},
-	});
-
-	pi.on("session_start", async (_event, ctx) => {
-		await deactivate();
-		if (!autoActivate) return;
-		try {
-			activateSession(ctx);
-		} catch (error) {
-			ctx.ui.notify(`指挥官模式恢复失败：${error instanceof Error ? error.message : String(error)}`, "error");
-		}
-	});
-
-	pi.on("session_shutdown", () => deactivate());
-}
-
-function reviewGateError(): string | undefined {
-	const loaded = loadConfig();
-	if (loaded.config.features.review === false) return "fire-review 已关闭，不能挂审查义务或发起审查";
-	return "error" in loaded.review ? loaded.review.error : undefined;
-}
-
-function loadMasterPrompts() {
-	try {
-		return { master: readMasterPrompt("master"), worker: readMasterPrompt("worker") };
-	} catch (error) {
-		return { error: error instanceof Error ? error.message : String(error) };
-	}
-}
-
-function rosterText(models: MasterRole[]): string {
-	return models.map((entry) => {
-		const fallback = entry.fallback.length ? `，fallback ${entry.fallback.map(modelAtomText).join(" → ")}` : "";
-		return `${entry.role}：${modelAtomText(entry)}（${entry.use}${fallback}）`;
-	}).join("；");
-}

package/master/list-view.ts

@@ -1,129 +0,0 @@
-/** subagents / subagents_list 的工具行与 /fire-master status 文本：纯投影，不改状态。 */
-import { statSync } from "node:fs";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { formatDuration } from "../format.js";
-import { ToolLine, makeResultRenderer } from "../tools/line.js";
-import type { Part } from "../tools/parts.js";
-import type { WorkerLive } from "./runtime.js";
-import type { WorkerRef, WorkerStatus } from "./state.js";
-
-export const renderSubagentsResult = makeResultRenderer(false);
-const STATUS_WORD = { working: "工作", idle: "空闲", reviewing: "审查" } satisfies Record<WorkerStatus, string>;
-const ACTION_VERB: Record<string, string> = { start: "启动", list: "查看", kill: "移除", send: "发送", interrupt: "中断", review: "审查", tail: "近况", ack: "待命" };
-
-export function subagentsCallParts(args: Record<string, unknown>): Part[] {
-	const action = typeof args.action === "string" ? args.action : "?";
-	const parts: Part[] = [{ text: ACTION_VERB[action] ?? action, bold: true }];
-	const target = optionalText(args.worker);
-	if (target) parts.push({ text: ` ${target}`, color: "accent" });
-	const role = optionalText(args.role);
-	if ((action === "start" || action === "send") && role) parts.push({ text: ` · ${role}`, color: "muted" });
-	const prompt = optionalText(args.prompt)?.split("\n", 1)[0];
-	if (prompt && action === "start") parts.push({ text: ` — ${prompt}`, color: "muted" });
-	return parts;
-}
-
-export type CompactWorker = ReturnType<typeof compactWorker>;
-
-/** 给模型的池快照：只有档案事实。 */
-export function compactWorker(worker: WorkerRef) {
-	return {
-		name: worker.name,
-		role: worker.role,
-		status: worker.status,
-		model: worker.model,
-		thinking: worker.thinking,
-		session: worker.sessionPath,
-		...(worker.interruptedAt ? { interruptedAt: worker.interruptedAt } : {}),
-		...(worker.reviewNeeded ? { reviewNeeded: true } : {}),
-		...(worker.disposition ? { disposition: worker.disposition } : {}),
-	};
-}
-
-/** 展开行用的当前动作：审查进度、落定时刻（reload 后退到会话文件 mtime）或最近的工具。 */
-export function currentWorkerAction(worker: CompactWorker, live: WorkerLive | undefined) {
-	if (worker.status === "reviewing") return live?.reviewProgress && { kind: "review" as const, ...live.reviewProgress };
-	if (worker.status === "idle") {
-		let since = live?.idleAt;
-		try {
-			since ??= statSync(worker.session).mtimeMs;
-		} catch {
-			// 缺失档案仍可 list；真正恢复时由 send 明确报错。
-		}
-		return { kind: "idle" as const, ...(since ? { since } : {}) };
-	}
-	const current = [...(live?.currentTools.values() ?? [])].at(-1);
-	return current ? { kind: "tool" as const, ...current } : undefined;
-}
-
-export function expandedWorkerList(
-	workers: unknown[],
-	theme: ExtensionContext["ui"]["theme"],
-	context: Parameters<typeof renderSubagentsResult>[3],
-) {
-	return {
-		invalidate() {},
-		render(width: number): string[] {
-			return ["", ...workers.flatMap((value) => {
-				const worker = value as Record<string, unknown>;
-				const action = worker.currentAction as {
-					kind?: string;
-					tool?: string;
-					startedAt?: number;
-					since?: number;
-					round?: number;
-					settled?: number;
-					total?: number;
-				} | undefined;
-				const actionParts: Part[] = action?.kind === "tool" && action.tool && action.startedAt
-					? [{
-						text: ` · ${action.tool} · 已 ${formatDuration(Math.max(0, Date.now() - action.startedAt))}`,
-						color: "accent",
-					}]
-					: action?.kind === "idle"
-						? [{
-							text: action.since ? ` · 落定 ${formatDuration(Date.now() - action.since)}前` : " · 已落定",
-							color: "muted",
-						}]
-						: action?.kind === "review"
-							? [{ text: ` · 第 ${action.round} 轮 · 审查者 ${action.settled}/${action.total}`, color: "accent" }]
-							: [];
-				return new ToolLine({
-					label: String(worker.name),
-					value: [
-						{ text: roleStatusText(worker), color: "accent" },
-						...actionParts,
-						{ text: ` · ${String(worker.model).split("/").pop()}/${String(worker.thinking)}`, color: "muted" },
-					],
-					clip: "end",
-					theme,
-					ctx: { ...context, state: {}, expanded: false },
-				}).render(width);
-			})];
-		},
-	};
-}
-
-export function listMeta(workers: unknown[]): Part[] {
-	if (!workers.length) return [{ text: " — 池 0", color: "muted" }];
-	return [{ text: ` — 池 ${workers.length}：${workers.map((value) => {
-		const worker = value as Record<string, unknown>;
-		return `${String(worker.name)} ${roleStatusText(worker)}`;
-	}).join(" · ")}`, color: "muted" }];
-}
-
-export function statusText(workers: WorkerRef[]): string {
-	return workers.length
-		? workers.map((worker) => `${worker.name} ${roleStatusText(worker)} ${worker.model.split("/").pop()}`).join("\n")
-		: "没有子代理";
-}
-
-/** 角色为主的状态投影：「工程师·工作」；档案缺角色时退到纯状态词。 */
-function roleStatusText(worker: { role?: unknown; status?: unknown }): string {
-	const status = STATUS_WORD[worker.status as WorkerStatus] ?? String(worker.status);
-	return worker.role ? `${String(worker.role)}·${status}` : status;
-}
-
-function optionalText(value: unknown): string | undefined {
-	return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}