pi-firecode 0.8.1 → 1.0.0

package/review/occupancy.ts

@@ -0,0 +1,25 @@
+/**
+ * 审查占用频道：review 是唯一发布者，herdr 集成、输入框外壳与观察员订阅；频道名与 payload 只在这里定义。
+ * 消费者按 active 的 true/false 做计数配对，所以进度变化不能靠重发 true：持有时带活的 progress 访问器，
+ * 外壳每次绘制调用它。progress 是进程内求值函数，频道不可序列化转发。
+ */
+export const OCCUPANCY_CHANNEL = "herdr:blocked";
+/** 持有时的展示标签：herdr 侧边栏与 Master 的 state_labels 判定都读它。 */
+export const OCCUPANCY_LABEL = "对抗审查进行中";
+
+/** 审查此刻在哪一步：排队等回合结束、审查者在审、顾问介入、执行模型修复、总结回合。 */
+export type ReviewStage = "queued" | "reviewing" | "advisor" | "fixing" | "summarizing";
+
+export interface ReviewProgress {
+	stage: ReviewStage;
+	/** 当前轮次；排队时为 0。 */
+	round: number;
+	/** 本轮通过 / 阻断 / 审查者总数；只有 reviewing 有意义。 */
+	passed: number;
+	blocked: number;
+	total: number;
+}
+
+export type OccupancyPayload =
+	| { active: true; label: string; progress: () => ReviewProgress | undefined }
+	| { active: false };

package/review/outcome.ts

@@ -2,9 +2,6 @@ import { readFileSync } from "node:fs";
 import { CHECKPOINT_TYPE, isValidCheckpoint } from "./checkpoint.js";
 import type { ReviewState } from "./state.js";
 
-/** 审查活跃期在 herdr:blocked 频道发布的展示标签。 */
-export const REVIEW_OCCUPANCY_LABEL = "对抗审查进行中";
-
 export type ReviewOutcome =
 	| { status: "passed"; runId: string; rounds: number }
 	| { status: "stopped"; runId: string; rounds: number; advisorAdvice?: string }
@@ -13,7 +10,7 @@ export type ReviewOutcome =
 	| { status: "none"; runId?: string }
 	| { status: "error"; message: string };
 
-/** 只读 Worker session，解析最近一条 fire-review checkpoint 的判定。 */
+/** 只读 Worker session，解析最近一条 fire-review checkpoint 的判定；会话结束时的一次性兜底读取用它。 */
 export function readReviewOutcome(sessionPath: string): ReviewOutcome {
 	let content: string;
 	try {
@@ -41,20 +38,47 @@ export function readReviewOutcome(sessionPath: string): ReviewOutcome {
 		else damage ??= "fire-review checkpoint 格式无效";
 	}
 	if (!latest) return damage ? { status: "error", message: damage } : { status: "none" };
+	return outcomeOf(latest);
+}
+
+/** 会话事件里刚追加的一条记录若是有效 checkpoint，给出它的判定；订阅方据此增量跟进，不重读整份 JSONL。 */
+export function outcomeOfEntry(entry: unknown): ReviewOutcome | undefined {
+	const state = checkpointOf(entry);
+	return state && outcomeOf(state);
+}
+
+/** 审查进行中的轮次与审查者进度；不是审查相的 checkpoint 或不是 checkpoint 都给 undefined。 */
+export interface ReviewProgress {
+	round: number;
+	settled: number;
+	total: number;
+}
+
+export function reviewProgressOf(entry: unknown): ReviewProgress | undefined {
+	const active = checkpointOf(entry)?.active;
+	return active ? { round: active.round, settled: active.settledCount, total: active.reviewers.length } : undefined;
+}
+
+function checkpointOf(entry: unknown): ReviewState | undefined {
+	return isCheckpointEntry(entry) && isValidCheckpoint(entry.data) ? entry.data as ReviewState : undefined;
+}
 
+function outcomeOf(latest: ReviewState): ReviewOutcome {
 	if (latest.phase === "idle") return { status: "none", runId: latest.runId };
 	if (latest.phase !== "settled") return { status: "in_progress", runId: latest.runId };
 	const rounds = latest.history.length;
-	const result = latest.history.at(-1)?.result;
+	const last = latest.history.at(-1);
+	const result = last?.result;
 	if (result === "passed") return { status: "passed", runId: latest.runId, rounds };
 	// stopped（顾问叫停）与 failed（maxRounds 用尽）都是质量裁决终止；
 	// error / cancelled / timed_out 是基础设施故障或人为中断，不弱化成“停止”。
 	if (result === "stopped" || result === "failed") {
 		// 顾问叫停时把裁决带给读取方：Master 拿到停止原因才能调整方向。
-		const advice = latest.history.at(-1)?.advisor?.advice;
+		const advice = last?.advisor?.advice;
 		return { status: "stopped", runId: latest.runId, rounds, ...(advice ? { advisorAdvice: advice } : {}) };
 	}
-	return { status: "failed", runId: latest.runId, rounds, reason: result ?? "unknown" };
+	// 轮记录的 details 已写明故障形态（超时/供应商报错）；枚举名只是它缺失时的兜底。
+	return { status: "failed", runId: latest.runId, rounds, reason: last?.details?.trim() || result || "unknown" };
 }
 
 function isCheckpointEntry(value: unknown): value is { data: unknown } {

package/review/prompt.ts

@@ -6,6 +6,7 @@ import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { Language } from "../config.js";
+import { wrapEnvelope } from "../deliver.js";
 import type { AdvisorResult, ReviewState, SummaryKind } from "./state.js";
 
 const PROMPTS_DIR = join(dirname(fileURLToPath(import.meta.url)), "prompts");
@@ -67,7 +68,7 @@ function reviewReminder(language: Language) {
 }
 
 /** 往轮 FAIL 发现清单（两相收敛的闭环输入）：第 2 轮起注入。 */
-export function priorRoundsSection(
+function priorRoundsSection(
 	history: ReviewState["history"],
 	round: number,
 	language: Language,
@@ -141,12 +142,9 @@ export function buildFixFeedback(input: FixFeedbackInput): string {
 					: "顾问建议";
 		parts.push("", `${label}${input.language === "en" ? ":" : "："}`, input.advisor.advice);
 	}
-	return reviewEnvelope(parts.join("\n"));
+	return wrapEnvelope("firecode_review", parts.join("\n"));
 }
 
-export function reviewEnvelope(content: string): string {
-	return `<firecode_review>\n${content}\n</firecode_review>`;
-}
 
 function narrowInstruction(language: Language, narrowed: boolean) {
 	if (!narrowed) return language === "en" ? FIX_INSTRUCTION_EN : FIX_INSTRUCTION_ZH;
@@ -175,14 +173,15 @@ export interface SummaryPromptInput {
 
 /** 质量裁决终态后投给执行模型的总结回合提示：人话收尾，带反循环禁令。 */
 export function buildSummaryPrompt(input: SummaryPromptInput): string {
-	const material = input.material.length > SUMMARY_MATERIAL_LIMIT
-		? `${input.material.slice(0, SUMMARY_MATERIAL_LIMIT)}\n…`
+	const omitted = input.material.length - SUMMARY_MATERIAL_LIMIT;
+	const material = omitted > 0
+		? `${input.material.slice(0, SUMMARY_MATERIAL_LIMIT)}\n${input.language === "en" ? `[material truncated: ${omitted} characters omitted]` : `[材料截断：省略 ${omitted} 字]`}`
 		: input.material;
 	const body = summaryInstruction(input.language, input.kind, input.rounds);
 	const content = material.trim()
 		? `${body}\n\n${summaryMaterialLabel(input.language, input.kind)}\n${material}`
 		: body;
-	return reviewEnvelope(content);
+	return wrapEnvelope("firecode_review", content);
 }
 
 function summaryMaterialLabel(language: Language, kind: SummaryKind): string {

package/review/prompts/review.en.md

@@ -22,6 +22,8 @@ Requirement anchor: the first user message is the original request; later user m
 Blocking candidates (High/Medium):
 - Logic defects: wrong assumptions, missed edge cases, missing error handling, races
 - Fake or insufficient tests: new logic uncovered, weak assertions, hardcoded bypass of real logic
+- Acceptance-test integrity: the implementation commit modified acceptance tests (assertions, cases, special-cased inputs); acceptance tests are implementation-coupled or tautological and verify the implementation rather than the requirement; the red run did not fail for "not yet implemented"
+- Engineering principles (Medium): a second source for the same fact, rule, or config; fallbacks, dead code, or stale notes kept for old paths; patching the symptom while the root cause stands; a new layer or abstraction that does not absorb existing duplication; new or touched tests that fail the better-test value gate
 - Key delivery claims you verified to be false
 - Regression risk: changes break existing behavior
 - The original or corrected current scope is unmet
@@ -31,12 +33,11 @@ Non-blocking (always to suggestions, never FAIL): unrelated changes mixed into d
 
 ## Evidence
 
-- Only two kinds of facts count: project files you actually read, and output of safe verification commands you actually ran. Session evidence is a lead, never a substitute.
-- Second-hand claims are not evidence: "done / changed / tests pass" claims are not review evidence; verify independently.
-- The working tree may contain parallel work or pre-existing uncommitted changes: scope-violation or unrelated-change findings must be grounded in edits this session actually performed per the session evidence; diff changes that cannot be attributed to this session must not be filed as findings — at most note them in the suggestions section.
-- First-hand code and logic verification is the strongest evidence. Test or command failures may come from parallel edits on a shared checkout: when a failure involves areas this session never touched, first verify whether parallel changes caused it; failures that cannot be attributed to this session must not be filed — at most note them in the suggestions section with a rerun hint.
-- Running tests alone is not enough for PASS: actually read the source files relevant to this change and check the implementation logic; a passing test is not proof of correctness.
-- If you use bash, only run safe verification; never modify files, install dependencies, delete files, or run git reset/clean/checkout/commit/rebase.
+- Only two kinds of facts count: project files you actually read, and output of verification commands you actually ran. Session evidence is a lead; key judgments return to these two.
+- "evidence truncated" / "truncated, N chars" markers in the session record are omissions made when assembling evidence, not messages that were left unfinished; before judging a deliverable incomplete, read the original from the session file the marker points to.
+- Attribution: the checkout may carry parallel work or pre-existing uncommitted changes; attribute by the tool trail in the session record (the paths this session actually edited). File scope-violation, unrelated-change, and command-failure findings only against changes attributable to this session; anything else goes to suggestions at most, failures with a rerun hint.
+- PASS rests on reading the source relevant to this change and checking its logic; run verification through the project's existing entry points at the narrowest scope covering the change, widening only when the affected scope cannot be judged.
+- bash is for verification only; never modify files, install dependencies, delete files, or run git reset/clean/checkout/commit/rebase.
 
 ## Two-phase convergence (no lowering the bar)
 

package/review/prompts/review.zh.md

@@ -22,6 +22,8 @@
 阻塞项（高/中候选）：
 - 逻辑缺陷：错误假设、边界条件遗漏、错误处理缺失、竞态
 - 虚假或不充分的测试：未覆盖新逻辑、断言过弱、硬编码绕过真实逻辑
+- 验收测试失信：实现提交改动了验收测试（断言、用例、特判输入）；验收测试与实现耦合或同义反复，验的不是需求；红的原因不是"尚未实现"
+- 工程原则（中）：同一事实、规则或配置出现第二个来源；为兼容旧路径保留的回退、死代码或过时说明；在症状处打补丁而根因未动；新增中间层或抽象却没有收口既有重复；新增或触及的测试不过 better-test 的价值门
 - 关键交付声明经你核实不成立
 - 回归风险：变更破坏既有行为
 - 原始需求或修正后的当前范围未被满足
@@ -31,12 +33,11 @@
 
 ## 证据规则
 
-- 事实证据只有两类：你实际读取的当前项目文件、你实际运行的安全验证命令输出。会话证据是线索，可作指引，但关键判断必须回到这两类证据。
-- 二手声明不是证据：assistant 自称"已完成 / 已修改 / 测试通过"都不是审查证据；必须独立核实。
-- 工作树可能包含并行工作或既有未提交改动：范围越界、混入无关变更类判定必须以会话证据中本会话实际执行的编辑为准；无法归因到本会话的 diff 变更不得立案为发现，至多写入建议区。
-- 代码与逻辑的一手核对是最硬的证据。测试或命令失败可能来自共享 checkout 上并行修改的干扰：失败涉及本会话未触碰的区域时，先核实是否并行改动所致；无法归因到本会话的失败不得立案，至多写入建议区并提示复跑。
-- 只运行测试或检查命令不足以支撑 PASS：必须实际读取与本次变更相关的源码文件，核对实现逻辑；测试通过不等于逻辑正确。
-- 若使用 bash，只做安全验证；不得修改文件、安装依赖、删除文件，或执行 git reset/clean/checkout/commit/rebase。
+- 事实证据只有两类：你实际读取的当前项目文件、你实际运行的验证命令输出。会话证据是线索，关键判断回到这两类证据。
+- 会话记录里的「证据截断」「截断，原文 N 字」标记是证据组装为控制篇幅做的省略，不是消息本身没写完；判断交付是否完整前，按标记给出的会话文件路径用 read 核对原文。
+- 归因：checkout 可能含并行工作或既有未提交改动，以会话记录中的工具轨迹（本会话实际编辑的路径）归因。范围越界、混入无关变更与命令失败只对归因到本会话的改动立案；归因不到的至多写入建议区，失败附复跑提示。
+- PASS 建立在实读与本次变更相关的源码并核对逻辑之上；验证命令走项目现有入口，跑覆盖变更的最窄范围，影响范围无法判断时再扩大。
+- bash 只做验证；不得修改文件、安装依赖、删除文件，或执行 git reset/clean/checkout/commit/rebase。
 
 ## 两相收敛（不降低质量标准）
 

package/review/reviewer.ts

@@ -19,8 +19,6 @@ export interface RunReviewerOptions {
 	language: Language;
 	signal?: AbortSignal;
 	runSession: ReviewSessionRunner;
-	/** 结构化会话事件：驱动活动条的实时进度。 */
-	onEvent?: (event: Record<string, unknown>) => void;
 }
 
 export type ParseOutcome = {
@@ -40,7 +38,6 @@ export async function runReviewer(options: RunReviewerOptions): Promise<Reviewer
 		cwd: options.cwd,
 		timeoutMs: options.config.timeoutMs,
 		signal: options.signal,
-		onEvent: options.onEvent,
 	});
 	const parsed =
 		result.kind === "output"
@@ -193,7 +190,7 @@ const FINDING_FIELDS = [
 const SUGGESTIONS_HEADING = /^##\s+(?:建议（非阻塞）|Suggestions \(non-blocking\))\s*$/iu;
 
 /** PASS 证据锚点闸门：摘要行在前，首个证据行必须同时含文件段（带扩展名）与命令段。 */
-export function passIssue(body: string): string | undefined {
+function passIssue(body: string): string | undefined {
 	const lines = body
 		.split(/\r?\n/)
 		.map((line) => line.trim())
@@ -211,7 +208,7 @@ export function passIssue(body: string): string | undefined {
  * FAIL 发现闸门：至少一条带「问题」的发现，且不能全落在「建议（非阻塞）」区。
  * 空 FAIL 或一段散文都不能驱动执行模型改代码——格式非法的票一律作废为基础设施错误。
  */
-export function failIssue(body: string, language: Language): string | undefined {
+function failIssue(body: string, language: Language): string | undefined {
 	const noFinding =
 		language === "en"
 			? "FAIL has no blocking finding: a `## Finding` section is required"

package/review/session.ts

@@ -1,8 +1,8 @@
-import type { Model } from "@earendil-works/pi-ai";
 import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
 import type { ThinkingLevelValue } from "../config.js";
 import type { InProcessSessionPool } from "../master/spawn.js";
 import type { PromptLayers } from "./prompt.js";
+import { textOf } from "../format.js";
 
 export type ReviewSessionResult =
 	| { kind: "output"; text: string }
@@ -13,7 +13,6 @@ export type ReviewSessionResult =
 
 export interface ReviewSessionOptions {
 	pool: InProcessSessionPool;
-	resolveModel(id: string): Promise<Model<any>>;
 	role: "reviewer" | "advisor";
 	model: string;
 	thinking: ThinkingLevelValue;
@@ -22,28 +21,24 @@ export interface ReviewSessionOptions {
 	cwd: string;
 	timeoutMs: number;
 	signal?: AbortSignal;
-	onEvent?: (event: AgentSessionEvent) => void;
 }
 
 export type ReviewSessionRunner = (
-	options: Omit<ReviewSessionOptions, "pool" | "resolveModel">,
+	options: Omit<ReviewSessionOptions, "pool">,
 ) => Promise<ReviewSessionResult>;
 
-export function createReviewSessionRunner(
-	pool: InProcessSessionPool,
-	resolveModel: ReviewSessionOptions["resolveModel"],
-): ReviewSessionRunner {
-	return (options) => runReviewSession({ ...options, pool, resolveModel });
+export function createReviewSessionRunner(pool: InProcessSessionPool): ReviewSessionRunner {
+	return (options) => runReviewSession({ ...options, pool });
 }
 
-export async function runReviewSession(options: ReviewSessionOptions): Promise<ReviewSessionResult> {
+async function runReviewSession(options: ReviewSessionOptions): Promise<ReviewSessionResult> {
 	if (options.signal?.aborted) return { kind: "aborted" };
 	let spawned: Awaited<ReturnType<InProcessSessionPool["spawn"]>>;
 	try {
 		spawned = await options.pool.spawn({
 			cwd: options.cwd,
 			role: options.role,
-			model: await options.resolveModel(options.model),
+			model: await options.pool.resolveModel(options.model),
 			thinking: options.thinking,
 			tools: [...new Set(options.tools)].filter((tool) => tool !== "write" && tool !== "edit"),
 			systemPrompt: { mode: "replace", text: clean(options.prompt.system) },
@@ -57,7 +52,7 @@ export async function runReviewSession(options: ReviewSessionOptions): Promise<R
 			: { kind: "error", message: errorText(error) };
 	}
 	if (options.signal?.aborted) {
-		spawned.dispose();
+		await spawned.dispose();
 		return { kind: "aborted" };
 	}
 
@@ -66,12 +61,11 @@ export async function runReviewSession(options: ReviewSessionOptions): Promise<R
 	const unsubscribe = spawned.session.subscribe((event) => {
 		const assistant = assistantMessage(event);
 		if (assistant) {
-			finalText = messageText(assistant.content);
+			finalText = textOf(assistant.content);
 			finalError = assistant.stopReason === "error"
 				? assistant.errorMessage || "model error"
 				: undefined;
 		}
-		options.onEvent?.(event);
 	});
 	let interrupted: "aborted" | "timeout" | undefined;
 	let wake!: () => void;
@@ -84,17 +78,15 @@ export async function runReviewSession(options: ReviewSessionOptions): Promise<R
 			finalError = errorText(error);
 		});
 		await Promise.race([run, interruption]);
-		if (interrupted) {
-			await spawned.session.abort();
-			return { kind: interrupted };
-		}
+		// 中断只靠 finally 的 dispose 收尾：pi 的 abort 在模型流卡死时永不返回，等它会拖住整个关闭链。
+		if (interrupted) return { kind: interrupted };
 		if (finalError) return { kind: "error", message: finalError };
 		return finalText?.trim() ? { kind: "output", text: finalText } : { kind: "empty" };
 	} finally {
 		clearTimeout(timeout);
 		options.signal?.removeEventListener("abort", onAbort);
 		unsubscribe();
-		spawned.dispose();
+		await spawned.dispose();
 	}
 }
 
@@ -109,17 +101,6 @@ function assistantMessage(event: AgentSessionEvent): {
 	return [...event.messages].reverse().find((message) => message.role === "assistant");
 }
 
-function messageText(content: unknown): string {
-	if (typeof content === "string") return content;
-	if (!Array.isArray(content)) return "";
-	return content
-		.filter((part): part is { type: "text"; text: string } =>
-			typeof part === "object" && part !== null && (part as { type?: unknown }).type === "text"
-			&& typeof (part as { text?: unknown }).text === "string")
-		.map((part) => part.text)
-		.join("\n");
-}
-
 function clean(text: string): string {
 	return text.replaceAll("\0", "");
 }

package/review/state.ts

@@ -10,6 +10,8 @@
  * 事故终态（取消 / 超时 / 基础设施错误）直接 settled，不烧总结回合。
  * 不变量：同一时刻至多一个活动轮；round 单调递增；history 只追加不改写。
  */
+import type { ModelAtom } from "../config.js";
+
 export type Phase =
 	| "idle"
 	| "queued"
@@ -25,10 +27,8 @@ export type AdvisorVerdict = "continue" | "stop" | "narrow";
 export type StopReason = "advisor" | "max_rounds" | "user" | "shutdown" | "timeout";
 
 /** 单个审查者的输出（output 契约解析结果，纯数据）。 */
-export interface ReviewerResult {
+export interface ReviewerResult extends ModelAtom {
 	index: number;
-	model: string;
-	thinking: string;
 	status: Exclude<ReviewerStatus, "running">;
 	/** 短摘要：PASS 一行收敛摘要 / FAIL 发现一句话。 */
 	summary: string;
@@ -37,10 +37,8 @@ export interface ReviewerResult {
 }
 
 /** 审查中某个审查者的进行状态；settled 后携带完整结果。 */
-export interface ActiveReviewer {
+export interface ActiveReviewer extends ModelAtom {
 	index: number;
-	model: string;
-	thinking: string;
 	status: ReviewerStatus;
 	result: ReviewerResult | null;
 }
@@ -125,7 +123,7 @@ export interface ReviewLimits {
 	advisorAfterFailures: number;
 	advisorModel: string;
 	/** 本轮审查者（model/thinking），beginRound 时填入 active。 */
-	reviewers: { model: string; thinking: string }[];
+	reviewers: ModelAtom[];
 	language?: "zh" | "en";
 }
 
@@ -242,7 +240,7 @@ function onStart(
 	if (state.phase === "reviewing" || state.phase === "needs_fix" || state.phase === "awaiting_fix")
 		return { state, effects: [] };
 	const focus = event.focus.trim();
-	// 排队相不发卡：状态栏与活动条已各有一份排队提示，记录里只留开始/结果卡。
+	// 排队相不发卡：输入框边框与审查活动行已各有一份排队提示，记录里只留开始/结果卡。
 	if (event.busy)
 		return {
 			state: {
@@ -490,7 +488,7 @@ function settleRound(
 		return {
 			state: { ...base, phase: "needs_fix", pending, consecutiveFailures },
 			// 顾问可能裁定 stop，反馈永远不会投递：此时不能提前宣布「已交回修复」；
-			// 卡里也不写「顾问介入中」——持久记录会过时，实况由活动条与状态栏承担。
+			// 卡里也不写「顾问介入中」——持久记录会过时，实况由审查活动行与输入框边框承担。
 			effects: [failCard, { kind: "advance" }],
 		};
 	return {
@@ -518,7 +516,6 @@ function onAdvisorSettled(
 	if (state.phase !== "needs_fix" || !state.pending) return { state, effects: [] };
 	const pending = state.pending;
 	const advisor = event.result;
-	const displayDetails = aggregateDetails(pending.reviewers, limits.language ?? "zh");
 	if (advisor.verdict === "stop") {
 		const round = roundRecord(pending.round, "stopped", advisor.advice, pending.reviewers, advisor, state.roundStartedAt, now);
 		return {
@@ -718,20 +715,14 @@ function aggregate(
 	archiveDetails: string;
 	summary: string;
 } {
-	const failed = reviewers.filter((item) => item.status === "failed");
-	const errors = reviewers.filter((item) => item.status === "error");
+	const verdicts = reviewers.filter((item) => item.status === "passed" || item.status === "failed");
+	const absent = reviewers.filter((item) => item.status === "error");
 	const archiveDetails = aggregateDetails(reviewers, language);
-	const fatalErrors = errors.filter((item) => !isFormatError(item.details));
-	// 只忽略明确的格式错误票；任何真实基础设施错误都阻止形成质量结论，
-	// 即使同轮已有 FAIL，也不能把未完整形成的审查误报为 Review Failed。
-	if (fatalErrors.length > 0)
-		return {
-			result: "error",
-			displayDetails: aggregateDetails(fatalErrors, language),
-			feedbackDetails: "",
-			archiveDetails,
-			summary: "",
-		};
+	// 有裁决就成轮：缺席者（会话故障或输出契约违例）只在结论里点名，不阻止形成质量结论；
+	// 全员缺席才是基础设施不可用。否则一个供应商额度耗尽就会让整条审查通道停摆。
+	if (verdicts.length === 0)
+		return { result: "error", displayDetails: archiveDetails, feedbackDetails: "", archiveDetails, summary: "" };
+	const failed = verdicts.filter((item) => item.status === "failed");
 	if (failed.length > 0)
 		return {
 			result: "failed",
@@ -740,65 +731,46 @@ function aggregate(
 			archiveDetails,
 			summary: "",
 		};
-	const passed = reviewers.filter((item) => item.status === "passed");
-	if (passed.length === 0)
-		return {
-			result: "error",
-			displayDetails: aggregateDetails(errors, language),
-			feedbackDetails: "",
-			archiveDetails,
-			summary: "",
-		};
 	return {
 		result: "passed",
 		displayDetails: archiveDetails,
 		feedbackDetails: "",
 		archiveDetails,
-		summary: aggregatePassSummary(passed, language),
+		summary: aggregatePassSummary(verdicts, absent, language),
 	};
 }
 
-function isFormatError(details: string) {
-	return details.startsWith("审查输出格式无效") || details.startsWith("review output format invalid");
-}
-
 function aggregateDetails(reviewers: ReviewerResult[], language: "zh" | "en"): string {
 	return reviewers
 		.map((item) => `${modelLabel(item, language)}\n${item.details.trim()}`)
 		.join("\n\n");
 }
 
-function aggregatePassSummary(reviewers: ReviewerResult[], language: "zh" | "en") {
-	const fallback = language === "en" ? "Review passed." : "审查通过。";
-	if (reviewers.length === 1) {
-		const reviewer = reviewers[0];
-		const body = passBody(reviewer?.summary ?? "") || fallback;
-		const suggestions = splitSuggestions(reviewer?.details ?? "").suggestions;
-		if (suggestions.length === 0) return body;
-		return [
-			body,
-			"",
-			language === "en" ? "## Suggestions (non-blocking)" : "## 建议（非阻塞）",
-			...suggestions.map((item) => `- ${item}`),
-		].join("\n");
-	}
-	const parts = reviewers.map((item) => ({
-		body: item.summary,
-		suggestions: splitSuggestions(item.details).suggestions,
-	}));
-	const lines = parts.map((part, index) =>
-		`• ${shortModel(reviewers[index]?.model ?? "")}${language === "en" ? ": " : "："}${passBody(part.body) || fallback}`,
-	);
-	const suggestions = [...new Set(parts.flatMap((part) => part.suggestions))];
+function aggregatePassSummary(passed: ReviewerResult[], absent: ReviewerResult[], language: "zh" | "en") {
+	const en = language === "en";
+	const fallback = en ? "Review passed." : "审查通过。";
+	const lines = passed.length === 1
+		? [passBody(passed[0]?.summary ?? "") || fallback]
+		: passed.map((item) => `• ${shortModel(item.model)}${en ? ": " : "："}${passBody(item.summary) || fallback}`);
+	if (absent.length > 0)
+		lines.push(
+			(en ? "No verdict from " : "未形成裁决：")
+				+ absent.map((item) => `${shortModel(item.model)}${en ? ` (${firstLine(item.details)})` : `（${firstLine(item.details)}）`}`).join(en ? ", " : "、"),
+		);
+	const suggestions = [...new Set(passed.flatMap((item) => splitSuggestions(item.details).suggestions))];
 	if (suggestions.length === 0) return lines.join("\n");
 	return [
 		...lines,
 		"",
-		language === "en" ? "## Suggestions (non-blocking)" : "## 建议（非阻塞）",
+		en ? "## Suggestions (non-blocking)" : "## 建议（非阻塞）",
 		...suggestions.map((item) => `- ${item}`),
 	].join("\n");
 }
 
+function firstLine(text: string) {
+	return text.trim().split(/\r?\n/u, 1)[0]?.split(/[：:]/u, 1)[0]?.trim() ?? "";
+}
+
 function splitSuggestions(summary: string) {
 	const lines = summary.split(/\r?\n/u);
 	const index = lines.findIndex((line) => /^##\s*(?:建议（非阻塞）|Suggestions \(non-blocking\))/iu.test(line.trim()));