pi-firecode 1.0.0 → 1.0.1

package/master/outbox.ts

@@ -1,188 +0,0 @@
-/**
- * 事件发件箱：落定事件先以 pending entry 写进主会话，再经 deliver.ts 投递，成功后写 ack；reload 重投差集。
- * 同一节拍内的落定合并成一条消息。在飞子代理数也在这里算：指挥官在等的 working/reviewing 加上它们的事件还在队列
- * 或投递中的子代理，所以归零只发生在事件交给指挥官之后。视图起的运行（见 RunOrigin）不算在飞，它的事件只告知不唤醒。
- */
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { deliver, inform, wrapEnvelope } from "../deliver.js";
-import { roundFromEntry } from "../tools/round.js";
-import { MASTER_EVENT_TYPE, withElapsed, type MasterEvent } from "./event-format.js";
-import type { MasterRuntime } from "./runtime.js";
-
-const PENDING_EVENT_TYPE = "firecode-master-pending-event";
-const EVENT_ACK_TYPE = "firecode-master-event-ack";
-const EVENT_RETRY_MS = 5_000;
-/** 指挥官空闲时，从第一条结果入队起最多等这么久就唤醒，即使结果还在陆续到达。 */
-const WAKE_MAX_MS = 6_000;
-
-export interface PendingMasterEvent {
-	id: string;
-	content: string;
-	worker?: string;
-	/** 指挥官没在等这个结果（视图起的运行）：只告知不唤醒，也不计入在飞。 */
-	inform?: true;
-}
-
-export class Outbox {
-	private readonly queued: PendingMasterEvent[] = [];
-	/** 已交给 deliver、尚未确认送达的事件：投递完成前对应子代理仍算在飞。 */
-	private readonly delivering = new Set<PendingMasterEvent>();
-	private flushTimer?: NodeJS.Timeout;
-	private retrying = false;
-	/** 空闲合并窗口里第一条事件入队的时刻。 */
-	private firstQueuedAt?: number;
-	private inFlightScheduled = false;
-
-	constructor(private readonly active: MasterRuntime) {}
-
-	/** 新产出的事件：追加耗时、持久化为 pending、排队投递。 */
-	enqueue(produced: MasterEvent, worker?: string): void {
-		if (this.active.closed) return;
-		const informOnly = worker !== undefined && this.active.live.get(worker)?.origin === "view";
-		const event: PendingMasterEvent = {
-			id: crypto.randomUUID(),
-			content: this.withElapsed(produced, worker),
-			...(worker ? { worker } : {}),
-			...(informOnly ? { inform: true as const } : {}),
-		};
-		try {
-			this.active.setup.pi.appendEntry(PENDING_EVENT_TYPE, event);
-		} catch (error) {
-			this.active.ctx.ui.notify(`子代理结果持久化失败，crash 时可能丢失：${String(error)}`, "warning");
-		}
-		this.push(event);
-	}
-
-	/** reload 重投 pending 与 ack 的差集：正文已带落定当时的耗时，原样再投。 */
-	replayUnacked(ctx: ExtensionContext): void {
-		for (const event of unackedEvents(ctx)) this.push(event);
-	}
-
-	/**
-	 * 在飞 = working/reviewing + 已落定但结果事件还在队列或投递中（投递失败重试期间也算）。
-	 * 落定先改 store、随后才入队事件：同一同步段内合并成一次计算，避免中间闪出一次归零。
-	 */
-	scheduleInFlight(): void {
-		if (this.inFlightScheduled) return;
-		this.inFlightScheduled = true;
-		queueMicrotask(() => {
-			this.inFlightScheduled = false;
-			if (this.active.closed) return;
-			const names = new Set<string>();
-			for (const worker of this.active.store.state.workers)
-				if ((worker.status === "working" || worker.status === "reviewing") && this.active.live.get(worker.name)?.origin !== "view")
-					names.add(worker.name);
-			for (const event of [...this.queued, ...this.delivering]) if (event.worker && !event.inform) names.add(event.worker);
-			this.active.setup.publishInFlight(names.size);
-		});
-	}
-
-	close(): void {
-		clearTimeout(this.flushTimer);
-	}
-
-	/**
-	 * 指挥官在跑：立即投（句缝送达，不打断）。指挥官空闲：每次唤醒都是一个完整回合，陆续到达的一批结果
-	 * 等一个安静窗口合并成一次唤醒——最后一条入队后 wakeQuietMs 内没有新结果才唤醒，从第一条起最多等 WAKE_MAX_MS。
-	 * 只告知的事件不开窗口、立即追加；窗口已开就随那一批唤醒送达。
-	 */
-	private push(event: PendingMasterEvent): void {
-		this.queued.push(event);
-		this.scheduleInFlight();
-		if (this.retrying) return;
-		const quiet = this.active.setup.wakeQuietMs;
-		if (!this.active.ctx.isIdle() || quiet <= 0) {
-			if (!this.flushTimer || this.firstQueuedAt !== undefined) this.schedule(0);
-			return;
-		}
-		if (event.inform) {
-			if (this.firstQueuedAt === undefined) this.schedule(0);
-			return;
-		}
-		this.firstQueuedAt ??= Date.now();
-		this.schedule(Math.min(quiet, Math.max(0, this.firstQueuedAt + WAKE_MAX_MS - Date.now())));
-	}
-
-	private schedule(delay: number): void {
-		clearTimeout(this.flushTimer);
-		this.flushTimer = setTimeout(() => this.flush(), delay);
-		this.flushTimer.unref?.();
-	}
-
-	private flush(): void {
-		const { active } = this;
-		if (active.closed) return;
-		this.flushTimer = undefined;
-		this.retrying = false;
-		this.firstQueuedAt = undefined;
-		if (!this.queued.length) return;
-		const batch = this.queued.splice(0);
-		for (const event of batch) this.delivering.add(event);
-		const send = batch.every((event) => event.inform) ? inform : deliver;
-		send(active.setup.pi, active.ctx, {
-			customType: MASTER_EVENT_TYPE,
-			content: batch.map((event) => wrapEnvelope("firecode_master_event", event.content)).join("\n\n"),
-		}).then(() => {
-			if (active.closed) return;
-			for (const event of batch) this.delivering.delete(event);
-			try {
-				active.setup.pi.appendEntry(EVENT_ACK_TYPE, { ids: batch.map((event) => event.id) });
-			} catch (error) {
-				active.ctx.ui.notify(`子代理结果确认写入失败，reload 后可能重复投递：${String(error)}`, "warning");
-			}
-			for (const event of batch) {
-				if (!event.worker) continue;
-				const worker = active.store.state.workers.find((candidate) => candidate.name === event.worker);
-				if (worker?.status === "idle" && worker.disposition !== "reminded")
-					active.store.dispatch({ type: "UPSERT_WORKER", worker: { ...worker, disposition: "pending" } });
-			}
-			this.scheduleInFlight();
-		}, (error) => {
-			if (active.closed) return;
-			for (const event of batch) this.delivering.delete(event);
-			this.queued.unshift(...batch);
-			active.ctx.ui.notify(`子代理结果投递失败，将自动重试：${String(error)}`, "warning");
-			this.retrying = true;
-			this.schedule(EVENT_RETRY_MS);
-		});
-	}
-
-	/**
-	 * 本次运行耗时 = 这次运行（start/send/review 起点之后）在子代理会话里写下的轮记录之和：fallback 续跑或审查里的
-	 * 修复回合各自成段，合起来才是这次运行。子代理排除了 FireCode（没有轮记录器）或 reload 后起点丢失时省略。
-	 * 读得到：宿主在 prompt 结束前发 agent_settled，审查则先写终态 checkpoint 再释放占用，记录都早于这里的读取。
-	 */
-	private withElapsed(produced: MasterEvent, worker?: string): string {
-		const live = worker === undefined ? undefined : this.active.live.get(worker);
-		const since = live?.runStartedAt;
-		const branch = live?.observed?.session.sessionManager.getBranch() ?? [];
-		const rounds = since === undefined ? [] : branch.flatMap((entry) => {
-			const round = roundFromEntry(entry);
-			return round && round.at >= since ? [round] : [];
-		});
-		const sessionSince = this.active.setup.sessionSince();
-		return withElapsed(produced, {
-			...(rounds.length ? { run: rounds.reduce((total, round) => total + round.elapsed, 0) } : {}),
-			...(sessionSince === undefined ? {} : { task: Date.now() - sessionSince }),
-		});
-	}
-}
-
-function unackedEvents(ctx: ExtensionContext): PendingMasterEvent[] {
-	const pending = new Map<string, PendingMasterEvent>();
-	const acked = new Set<string>();
-	for (const entry of ctx.sessionManager.getEntries()) {
-		if (entry.type !== "custom" || !entry.data || typeof entry.data !== "object") continue;
-		const data = entry.data as Record<string, unknown>;
-		if (entry.customType === PENDING_EVENT_TYPE && typeof data.id === "string" && typeof data.content === "string")
-			pending.set(data.id, {
-				id: data.id,
-				content: data.content,
-				...(typeof data.worker === "string" ? { worker: data.worker } : {}),
-				...(data.inform === true ? { inform: true as const } : {}),
-			});
-		if (entry.customType === EVENT_ACK_TYPE && Array.isArray(data.ids))
-			for (const id of data.ids) if (typeof id === "string") acked.add(id);
-	}
-	return [...pending.values()].filter((event) => !acked.has(event.id));
-}

package/master/prompt.ts

@@ -1,26 +0,0 @@
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const PROMPTS_DIR = join(dirname(fileURLToPath(import.meta.url)), "prompts");
-
-export type MasterPromptKind = "master" | "worker";
-
-export function readMasterPrompt(kind: MasterPromptKind): string {
-	let prompt: string;
-	try {
-		prompt = readFileSync(join(PROMPTS_DIR, `${kind}.zh.md`), "utf8");
-	} catch (error) {
-		throw new Error(`Master ${kind} prompt 读取失败：${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (!prompt.trim()) throw new Error(`Master ${kind} prompt 为空`);
-	return prompt.trim();
-}
-
-export function assembleMasterPrompt(prompt: string, roster: string): string {
-	return `${prompt}\n\n角色表：${roster}。`;
-}
-
-export function assembleWorkerPrompt(prompt: string, name: string): string {
-	return `<firecode_worker name="${name}">\n${prompt}\n</firecode_worker>`;
-}

package/master/role.ts

@@ -1,18 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-
-export type SubsessionRole = "worker" | "observer" | "reviewer" | "advisor";
-
-// pi 的扩展加载器（jiti，moduleCache: false）在子会话 cwd 变化或宿主 reload 后会重新
-// 求值整个模块图：模块级变量在两份拷贝间互不相通，角色标记必须挂在进程唯一的 globalThis
-// 上，否则新拷贝读不到 spawn 侧设置的角色，watcher/master 会级联注册进子会话。
-const ROLE_KEY = Symbol.for("firecode.subsession-role");
-const shared = globalThis as Record<symbol, AsyncLocalStorage<SubsessionRole> | undefined>;
-const ROLE = (shared[ROLE_KEY] ??= new AsyncLocalStorage<SubsessionRole>());
-
-export function currentSubsessionRole(): SubsessionRole | undefined {
-	return ROLE.getStore();
-}
-
-export function withSubsessionRole<T>(role: SubsessionRole, run: () => Promise<T>): Promise<T> {
-	return ROLE.run(role, run);
-}

package/master/run.ts

@@ -1,315 +0,0 @@
-/**
- * 回合编排：打开 Worker 会话、跑一个回合、按终态落定（成功/失败/中断/fallback 续跑）、审查监视与中断续跑提醒。
- * 所有 await 之后的写回经 runtime.current/commit 重读档案：kill 赢过迟到的异步写回。
- */
-import type { AgentSession } from "@earendil-works/pi-coding-agent";
-import type { MasterRole, ModelAtom } from "../config.js";
-import { wrapEnvelope } from "../deliver.js";
-import { clip, firstSentence, textOf } from "../format.js";
-import { outcomeOfEntry, readReviewOutcome, reviewProgressOf, type ReviewOutcome } from "../review/outcome.js";
-import { masterEvent, type MasterEvent } from "./event-format.js";
-import { assembleWorkerPrompt } from "./prompt.js";
-import type { MasterRuntime, WorkerLive } from "./runtime.js";
-import type { WorkerRef } from "./state.js";
-
-export const WORKER_TOOLS = ["read", "bash", "edit", "write"];
-/** Worker 跟随指挥官是否启用 codemode；on/only 由 Worker 会话读到的同一份 settings 决定，不另传。 */
-const CODEMODE_TOOL = "codemode";
-const FAULT_SUMMARY_WIDTH = 80;
-/** 算作“有输出”的子会话事件：模型 token 流与工具执行；活动列表据此判卡住。 */
-const OUTPUT_EVENTS = new Set(["message_update", "tool_execution_start", "tool_execution_update", "tool_execution_end"]);
-
-interface WorkerTerminal {
-	text: string;
-	stopReason?: string;
-	errorMessage?: string;
-}
-
-/** 新建（start）或恢复（send/review 冷启动）Worker 会话；会话路径是档案身份的唯一事实源。 */
-export async function spawnWorker(active: MasterRuntime, worker: WorkerRef, resume: boolean): Promise<AgentSession> {
-	const { pool, exclusions } = active.setup;
-	const model = await pool.resolveModel(worker.model);
-	active.assertOpen();
-	const spawned = await pool.spawn({
-		cwd: worker.cwd ?? process.cwd(),
-		role: "worker",
-		model,
-		thinking: worker.thinking,
-		tools: active.setup.pi.getActiveTools().includes(CODEMODE_TOOL) ? [...WORKER_TOOLS, CODEMODE_TOOL] : WORKER_TOOLS,
-		excludeExtensions: exclusions,
-		systemPrompt: { mode: "append", text: assembleWorkerPrompt(active.setup.workerPrompt(), worker.name) },
-		contextFiles: true,
-		persistence: { type: "file", sessionPath: worker.sessionPath, ...(resume ? { resume: true } : {}) },
-	});
-	if (active.closed) {
-		await spawned.dispose();
-		active.assertOpen();
-	}
-	return spawned.session;
-}
-
-export async function openWorkerSession(active: MasterRuntime, worker: WorkerRef): Promise<AgentSession> {
-	active.assertOpen();
-	return active.setup.pool.getSession(worker.sessionPath) ?? spawnWorker(active, worker, true);
-}
-
-/** 投影当前动作、卡住判定与审查进度的唯一订阅。 */
-export function observeWorker(active: MasterRuntime, worker: WorkerRef, session: AgentSession): void {
-	active.observe(worker, session, (live, event) => {
-		if (OUTPUT_EVENTS.has(event.type)) live.lastOutputAt = Date.now();
-		if (event.type === "tool_execution_start")
-			live.currentTools.set(event.toolCallId, { tool: event.toolName, args: event.args, startedAt: Date.now() });
-		if (event.type === "tool_execution_end") live.currentTools.delete(event.toolCallId);
-		if (event.type === "entry_appended") live.reviewProgress = reviewProgressOf(event.entry) ?? live.reviewProgress;
-	});
-}
-
-/** resolve 即回合已在飞：宿主 prompt 的前置阶段仍报空闲，期间 abort 会被丢弃，interrupt 必须晚于 preflight。 */
-export async function runWorker(active: MasterRuntime, worker: WorkerRef, session: AgentSession, prompt: string): Promise<void> {
-	// 启动回合的路径都经这里：准备期间被 kill 的不调模型、不留热会话。
-	active.current(worker);
-	observeWorker(active, worker, session);
-	const live = active.liveOf(worker.name);
-	const run = Symbol(worker.name);
-	live.run = run;
-	const mine = () => !active.closed && active.live.get(worker.name) === live && live.run === run;
-	let terminal: WorkerTerminal | undefined;
-	const unsubscribeTerminal = session.subscribe((event) => {
-		if (mine() && event.type === "agent_end") terminal = captureWorkerTerminal(event.messages);
-	});
-	const settled = async (error?: unknown) => {
-		unsubscribeTerminal();
-		if (!mine()) return;
-		const stranded = session.clearQueue().steering;
-		if (stranded.length) active.outbox.enqueue(masterEvent.stranded(worker.name, stranded), worker.name);
-		live.run = undefined;
-		if (live.interruptedRun === run) {
-			live.interruptedRun = undefined;
-			settleInterrupted(active, worker);
-			return;
-		}
-		if (terminal?.stopReason === "error" && error === undefined) {
-			await resumeWithFallback(active, worker, session, terminal, faultSummary(terminal));
-			return;
-		}
-		settleWorker(active, worker, terminal, error);
-	};
-	const inflight = Promise.withResolvers<void>();
-	void session.prompt(prompt, { preflightResult: () => inflight.resolve() })
-		.then(() => settled(), settled)
-		.finally(() => inflight.resolve());
-	await inflight.promise;
-}
-
-function settleInterrupted(active: MasterRuntime, identity: WorkerRef): void {
-	const current = active.find(identity);
-	if (!current) return;
-	const interrupted: WorkerRef = { ...current, status: "idle", interruptedAt: Date.now() };
-	active.store.dispatch({ type: "UPSERT_WORKER", worker: interrupted });
-	active.markIdle(interrupted, { kind: "interrupted" }, interrupted.interruptedAt);
-	active.outbox.enqueue(masterEvent.interrupted(identity.name, current.reviewNeeded === true, takeViewPrompts(active, identity)), identity.name);
-}
-
-/**
- * 会话重载打断的回合：恢复后满时限仍未续派就提醒指挥官；按档案里的中断时刻补算剩余时间。指挥官自己 interrupt 的不提醒。
- * 只提醒、不代发“继续”：工作说明归指挥官，插件盲续会复活它已作废的任务。
- */
-export function armInterruptReminder(active: MasterRuntime, worker: WorkerRef): void {
-	if (active.closed) return;
-	const live = active.liveOf(worker.name);
-	clearTimeout(live.interruptTimer);
-	const delay = Math.max(0, (worker.interruptedAt ?? Date.now()) + active.setup.interruptResumeMs - Date.now());
-	live.interruptTimer = setTimeout(() => {
-		if (active.closed || active.live.get(worker.name) !== live) return;
-		live.interruptTimer = undefined;
-		const current = active.find(worker);
-		if (!current?.interruptedAt || current.interruptedAt !== worker.interruptedAt) return;
-		active.store.dispatch({ type: "UPSERT_WORKER", worker: { ...current, disposition: "reminded" } });
-		active.outbox.enqueue(masterEvent.resumeReminder(worker.name), worker.name);
-	}, delay);
-	live.interruptTimer.unref?.();
-}
-
-/**
- * 任何 error 终态都沿角色链切换，不按关键词分类故障：供应商措辞多变，关键词白名单实测一次未命中，分类也不改变决策。
- * 瞬时限流与 Claude 令牌换发在 error 之前已由宿主重试和 claude-sub 自愈处理。由插件而非宿主做：宿主不知道角色与档案。
- */
-async function resumeWithFallback(
-	active: MasterRuntime,
-	identity: WorkerRef,
-	session: AgentSession,
-	terminal: WorkerTerminal,
-	reason: string,
-): Promise<void> {
-	const current = active.current(identity);
-	const configuredRole = active.setup.roster.find((entry) => entry.role === current.role);
-	if (!configuredRole)
-		return settleWorker(active, current, terminal, new Error(`${terminalFailure(terminal)}\n角色 ${current.role} 已不在角色表，无法 fallback`));
-	const fallback = nextFallback(configuredRole, current);
-	if (!fallback)
-		return settleWorker(active, current, terminal, new Error(`${terminalFailure(terminal)}\n角色 ${current.role} 的 fallback 链已用尽`));
-	try {
-		const model = await active.setup.pool.resolveModel(fallback.model);
-		active.assertOpen();
-		await session.setModel(model);
-		active.assertOpen();
-		session.setThinkingLevel(fallback.thinking);
-		const switched = active.commit(current, (latest) => ({ ...latest, ...fallback, status: "working" }));
-		const from = modelAtomText(current);
-		const to = modelAtomText(fallback);
-		active.outbox.enqueue(masterEvent.modelSwitched(current.name, from, to, reason), current.name);
-		await runWorker(active, switched, session, fallbackResumePrompt(from, to, reason));
-	} catch (error) {
-		const failure = `${terminalFailure(terminal)}\nfallback 切换失败：${error instanceof Error ? error.message : String(error)}`;
-		settleWorker(active, current, terminal, new Error(failure));
-	}
-}
-
-function settleWorker(active: MasterRuntime, identity: WorkerRef, terminal: WorkerTerminal | undefined, error?: unknown): void {
-	const current = active.find(identity);
-	if (!current) return;
-	const failure = error instanceof Error ? error.message : error === undefined ? terminalFailure(terminal) : String(error);
-	const idle: WorkerRef = { ...current, status: "idle" };
-	active.store.dispatch({ type: "UPSERT_WORKER", worker: idle });
-	// 活动列表展开行显示结果首句（失败是错误首句），不是千篇一律的“已返回”。
-	active.markIdle(idle, failure ? { kind: "failed", note: firstSentence(failure) } : { kind: "done", note: firstSentence(terminal!.text) });
-	const obligation = current.reviewNeeded === true;
-	const event: MasterEvent = failure
-		? masterEvent.failed(identity.name, failure, obligation, takeViewPrompts(active, identity))
-		: masterEvent.returned(identity.name, terminal!.text, obligation, takeViewPrompts(active, identity));
-	active.outbox.enqueue(event, identity.name);
-}
-
-/** 起审：在原 Worker 会话里跑 /fire-review，终态经 review/outcome.ts 读取后落定并投递。 */
-export function monitorAndSettleReview(active: MasterRuntime, target: WorkerRef, session: AgentSession, previousRunId: string | undefined): void {
-	const live = active.liveOf(target.name);
-	const reviewing = () => {
-		const current = active.closed || active.live.get(target.name) !== live ? undefined : active.find(target);
-		return current?.status === "reviewing" ? current : undefined;
-	};
-	void monitorReview(session, target.sessionPath, previousRunId).then(
-		(outcome) => {
-			const current = reviewing();
-			if (!current) return;
-			const { reviewNeeded: _needed, ...fulfilled } = current;
-			const idle: WorkerRef = { ...(outcome.status === "passed" || outcome.status === "stopped" ? fulfilled : current), status: "idle" };
-			active.store.dispatch({ type: "UPSERT_WORKER", worker: idle });
-			active.markIdle(idle, reviewOutcomeRow(outcome));
-			active.outbox.enqueue(masterEvent.review(target.name, outcome, latestAssistantText(session.messages)), target.name);
-		},
-		(error) => {
-			const current = reviewing();
-			if (!current) return;
-			const idle: WorkerRef = { ...current, status: "idle" };
-			active.store.dispatch({ type: "UPSERT_WORKER", worker: idle });
-			active.markIdle(idle, { kind: "failed", note: "审查未完成" });
-			active.outbox.enqueue(masterEvent.reviewIncomplete(target.name, String(error)), target.name);
-		},
-	);
-}
-
-/** 这次运行里视图说过的话交给落定事件后清空：下一次运行另算。 */
-function takeViewPrompts(active: MasterRuntime, worker: WorkerRef): string[] {
-	const live = active.liveOf(worker.name);
-	const prompts = live.viewPrompts;
-	live.viewPrompts = [];
-	return prompts;
-}
-
-export function reviewRunId(outcome: ReviewOutcome): string | undefined {
-	return "runId" in outcome ? outcome.runId : undefined;
-}
-
-function monitorReview(session: AgentSession, sessionPath: string, previousRunId: string | undefined): Promise<ReviewOutcome> {
-	return new Promise((resolve, reject) => {
-		let done = false;
-		let unsubscribe = () => {};
-		const fail = (error: unknown) => {
-			if (done) return;
-			done = true;
-			unsubscribe();
-			reject(error);
-		};
-		const finish = (outcome: ReviewOutcome) => {
-			if (done) return;
-			const runId = reviewRunId(outcome);
-			if (outcome.status !== "error"
-				&& (!runId || runId === previousRunId || outcome.status === "in_progress" || outcome.status === "none")) return;
-			done = true;
-			unsubscribe();
-			resolve(outcome);
-		};
-		// 只看刚追加的那条记录，不每条都重读整份 JSONL；回合结束时再读一次文件兜底。
-		unsubscribe = session.subscribe((event) => {
-			const outcome = event.type === "entry_appended" ? outcomeOfEntry(event.entry) : undefined;
-			if (outcome) finish(outcome);
-		});
-		void session.prompt("/fire-review").then(
-			() => {
-				const outcome = readReviewOutcome(sessionPath);
-				const runId = reviewRunId(outcome);
-				if (outcome.status === "error") return finish(outcome);
-				if (!runId || runId === previousRunId) return fail(new Error("fire-review 审查未启动"));
-				finish(outcome);
-			},
-			fail,
-		);
-	});
-}
-
-/** 审查落定在活动列表上的结局：只有通过算完成，停止与未完成都是要指挥官看的失败行。 */
-function reviewOutcomeRow(outcome: ReviewOutcome): WorkerLive["outcome"] {
-	if (outcome.status === "passed") return { kind: "done", note: "审查通过" };
-	return { kind: "failed", note: outcome.status === "stopped" ? "审查停止" : "审查未完成" };
-}
-
-function captureWorkerTerminal(
-	messages: Array<{ role: string; content?: unknown; stopReason?: string; errorMessage?: string }>,
-): WorkerTerminal | undefined {
-	const message = messages.findLast((candidate) => candidate.role === "assistant");
-	if (!message) return undefined;
-	return {
-		text: textOf(message.content),
-		...(message.stopReason ? { stopReason: message.stopReason } : {}),
-		...(message.errorMessage ? { errorMessage: message.errorMessage } : {}),
-	};
-}
-
-function terminalFailure(terminal: WorkerTerminal | undefined): string | undefined {
-	if (!terminal) return "回合结束但未产生 assistant 终态";
-	if (terminal.stopReason === "error") return terminal.errorMessage || "供应商返回未知错误";
-	if (terminal.stopReason === "aborted") return `回合意外中止：${terminal.errorMessage || "供应商未提供原因"}`;
-	if (!terminal.text) return "回合结束但未产生回复";
-	return undefined;
-}
-
-function faultSummary(terminal: WorkerTerminal): string {
-	const message = terminal.errorMessage?.trim();
-	if (!message) return "供应商返回未知错误";
-	const [first = message] = message.split(/(?<=[.。!！?？])\s|\n/u);
-	return clip(first.trim(), FAULT_SUMMARY_WIDTH);
-}
-
-function latestAssistantText(messages: Array<{ role: string; content?: unknown }>): string {
-	return textOf(messages.findLast((candidate) => candidate.role === "assistant")?.content);
-}
-
-function nextFallback(role: MasterRole, worker: WorkerRef): ModelAtom | undefined {
-	const chain: ModelAtom[] = [role, ...role.fallback];
-	let index = chain.findIndex((atom) => atom.model === worker.model && atom.thinking === worker.thinking);
-	if (index < 0) index = chain.findIndex((atom) => atom.model === worker.model);
-	return chain[index + 1];
-}
-
-export function modelAtomText(atom: Pick<ModelAtom, "model" | "thinking">): string {
-	return `${atom.model}/${atom.thinking}`;
-}
-
-/** 首次续派前置的现场核对提示。 */
-export function resumeCheckPrompt(): string {
-	return wrapEnvelope("firecode_master_event", "上次被外部中断，先核对 git status 与现场再继续，避免重复执行已经发生的副作用。");
-}
-
-function fallbackResumePrompt(from: string, to: string, reason: string): string {
-	return wrapEnvelope("firecode_master_event", `供应商故障，已切换 ${from}→${to}（${reason}）。沿用当前会话与原工作说明，从中断处继续，不要重复已经完成的副作用。`);
-}