@y9931666/dsh-plugin-crossfire 0.1.0 → 0.1.1

package/lib/index.js

@@ -1,4 +1,4 @@
-import { a as newReviewId, c as reviewDirOf, d as withCrossfireLock, f as writeJsonAtomic, i as listReviewIds, l as reviewLockKey, n as appendJsonLine, o as readJsonFile, p as writeTextAtomic, s as readJsonLines, u as stateRootOf } from "./state-DzrgVdrB.js";
+import { a as newReviewId, c as reviewDirOf, d as withCrossfireLock, f as writeJsonAtomic, i as listReviewIds, l as reviewLockKey, m as writeTextAtomicWithBom, n as appendJsonLine, o as readJsonFile, p as writeTextAtomic, s as readJsonLines, u as stateRootOf } from "./state-DvF_Jqcg.js";
 import z from "@deepseek-ai/schemastery";
 import { createHash, randomUUID } from "node:crypto";
 import { dirname, join } from "node:path";
@@ -157,6 +157,16 @@ function transcriptFile(stateRoot, reviewId) {
 function exportFile(stateRoot, reviewId) {
 	return join(reviewDirOf(stateRoot, reviewId), "export.md");
 }
+/**
+* `<reviewDir>/export.txt` —— 同一份内容的**人读副本**（UTF-8 带 BOM）。
+*
+* 为什么导出两份：`.md` 交给 Markdown 渲染器，但 Windows 上双击 `.md` 常被别的程序
+* 抢走，加上无 BOM 的 UTF-8 会被记事本误判成 ANSI —— 于是"导出物打不开"。`.txt` 带
+* BOM 后双击直接进记事本，中文也不乱码（用户反馈的正是这一点）。
+*/
+function exportTextFile(stateRoot, reviewId) {
+	return join(reviewDirOf(stateRoot, reviewId), "export.txt");
+}
 /** 通用：取一个非空字符串，否则返回 undefined。 */
 function asText(value, max = 4096) {
 	if (typeof value !== "string") return void 0;
@@ -250,6 +260,8 @@ function sanitizeExpert(value) {
 	if (model !== void 0) expert.model = model;
 	const role = asText(raw.role, 2e3);
 	if (role !== void 0) expert.role = role;
+	const persona = asText(raw.persona, 32e3);
+	if (persona !== void 0) expert.persona = persona;
 	const note = asText(raw.note, 500);
 	if (note !== void 0) expert.note = note;
 	return expert;
@@ -1478,6 +1490,29 @@ const TAIL_SECTION = /\[(?:核心产出|下一步建议)[^\]]*\]/;
 /** 括号里可能出现的维度引导词，去掉它们才剩下维度名。 */
 const DIMENSION_LABEL_WORD = /^(维度|方面|角度|类别|类型)/;
 /**
+* 专家报告里的「针对立场」标记（`redteam.ts` 的 `reportEnvelopeSpec` 规定每条缺陷里
+* 恰好有一行）。`未` 只允许出现在 `打穿` 之前 —— 见 {@link stanceMarkerStrikes}。
+*/
+const STANCE_MARKER = /针对\s*立场[^\n]{0,20}?[:：]\s*(未\s*)?打穿/;
+/**
+* 判定这段文字里专家自己写的「针对立场」结论是不是**打穿**。
+*
+* ## 为什么不能只写 `includes('打穿')`（这是真实存在的坑）
+*
+* `未打穿` 的后两个字就是 `打穿`，纯子串匹配会把"没打穿"读成"打穿了"，方向整个反过来。
+* 所以这里匹配有界的标记（`针对立场…：打穿|未打穿`）并**显式取反**：只有 `未` 缺席时
+* 才算打穿；标记压根不存在（含 `undefined`）也一律算没打穿。
+*
+* 之所以要有这个本地判定：专家的信封格式是**固定**的，报告正文里本来就写着结论。
+* 模型拆分失败退到本地启发式（{@link splitByMarkers}）时不该把这个信号丢掉 ——
+* 那正是"打穿立场"标签永远显示不出来的原因之一。
+*/
+function stanceMarkerStrikes(text$1) {
+	if (text$1 === void 0) return false;
+	const found = STANCE_MARKER.exec(text$1);
+	return found !== null && found[1] === void 0;
+}
+/**
 * 从段首括号的文字里提取维度，并交给 `resolveDimension` 归一化。
 *
 * 上一版的兜底把括号里的圆圈数字（①）直接当成了维度名，产出 `维度②`
@@ -1527,10 +1562,12 @@ function splitByMarkers(content, allowed) {
 		const text$1 = raw.replace(/^[\s*:：]+/, "").replace(/\s+/g, " ").trim();
 		if (text$1 === "") continue;
 		const { dimension, fallback } = dimensionOfSegmentHead(mark.head, allowed);
+		const strikes = stanceMarkerStrikes(mark.head) || stanceMarkerStrikes(text$1.slice(0, 160));
 		lines.push({
 			content: `观点 ${mark.label}（${mark.head}）：${text$1}`,
 			dimension,
 			...fallback ? { dimensionFallback: true } : {},
+			...strikes ? { strikesStance: true } : {},
 			quote: void 0
 		});
 	}
@@ -1541,10 +1578,10 @@ function splitByMarkers(content, allowed) {
 * quote 与发言原文做规范化子串校验（防线③），不匹配即丢弃。
 * dimension 一律过 `resolveDimension`（落库值必须 ∈ allowed）。
 */
-async function splitUtterance(llm, config, expertKey, content, allowed) {
+async function splitUtterance(llm, config, expertKey, content, allowed, stance) {
 	const trimmed = content.replace(/\s+/g, " ").trim();
 	if (trimmed === "") return null;
-	const raw = await callSplitLlm(llm, config, "你是 Crossfire「针锋」评审的缺陷拆分器。把下面一条红队专家发言拆成 1~3 条独立缺陷，每条缺陷只包含一个问题，不得发明原文没有的内容。dimension 必须**逐字取自给定清单 allowed 中的一项**，不得自创标签、不得输出编号；若该缺陷用「立场」中的某条理由打穿了用户的说法，把 strikes_stance 设为 true。对每条缺陷给出证据分级（C1）：代码/bug 类缺陷的 evidence.kind=repro 并写可复现步骤（1. 2. 3.）；设计类缺陷的 evidence.kind=argument 并写论证链——禁止为设计类缺陷编造\"运行某命令即可复现\"这类伪复现步骤。无法从原文提取证据时省略 evidence 字段。必须调用 split_crossfire_defect 工具返回结构化结果。", `本次评审采用的维度清单 allowed（dimension 只能取其中之一）：${allowed.length > 0 ? allowed.join(" / ") : "（未限定，按通用维度判断）"}\n\n专家 ${expertKey} 的发言：\n${trimmed}`);
+	const raw = await callSplitLlm(llm, config, "你是 Crossfire「针锋」评审的缺陷拆分器。把下面一条红队专家发言拆成 1~3 条独立缺陷，每条缺陷只包含一个问题，不得发明原文没有的内容。dimension 必须**逐字取自给定清单 allowed 中的一项**，不得自创标签、不得输出编号；若该缺陷用「立场」中的某条理由打穿了用户的说法，把 strikes_stance 设为 true；**用户没有写立场时（下文明确标注「未填写立场」）一律不得把任何一条标成打穿**。对每条缺陷给出证据分级（C1）：代码/bug 类缺陷的 evidence.kind=repro 并写可复现步骤（1. 2. 3.）；设计类缺陷的 evidence.kind=argument 并写论证链——禁止为设计类缺陷编造\"运行某命令即可复现\"这类伪复现步骤。无法从原文提取证据时省略 evidence 字段。必须调用 split_crossfire_defect 工具返回结构化结果。", `本次评审采用的维度清单 allowed（dimension 只能取其中之一）：${allowed.length > 0 ? allowed.join(" / ") : "（未限定，按通用维度判断）"}\n\n用户在本次评审里写下的「立场与理由」：\n${stance.trim() === "" ? "（未填写立场）用户这次**没有**写下立场与理由。因此不得把任何一条缺陷标成 strikes_stance=true（没有靶子就没有打穿）。" : stance.trim()}\n\n专家 ${expertKey} 的发言：\n${trimmed}`);
 	if (raw !== null) {
 		let parsed;
 		try {
@@ -1564,6 +1601,7 @@ async function splitUtterance(llm, config, expertKey, content, allowed) {
 					const candidate = obj.quote.replace(/\s+/g, " ").trim();
 					if (candidate !== "" && candidate.length <= 120 && trimmed.includes(candidate)) quote$1 = candidate;
 				}
+				const strikes = obj?.strikes_stance === true || stanceMarkerStrikes(line) || stanceMarkerStrikes(quote$1);
 				const resolved = resolveDimension(obj?.dimension, allowed);
 				let evidence;
 				const ev = obj?.evidence;
@@ -1578,7 +1616,7 @@ async function splitUtterance(llm, config, expertKey, content, allowed) {
 					content: line,
 					quote: quote$1,
 					dimension: resolved.dimension,
-					...obj?.strikes_stance === true ? { strikesStance: true } : {},
+					...strikes ? { strikesStance: true } : {},
 					...resolved.fallback ? { dimensionFallback: true } : {},
 					evidence
 				});
@@ -1624,10 +1662,8 @@ function planExperts(record, maxExperts, roster = []) {
 			};
 			if (matched !== void 0) {
 				if (matched.role !== void 0 && matched.role.trim() !== "") expert.role = matched.role.trim();
-				if (matched.provider !== void 0 && matched.model !== void 0) {
-					expert.provider = matched.provider;
-					expert.model = matched.model;
-				}
+				if (matched.provider !== void 0 && matched.provider.trim() !== "") expert.provider = matched.provider.trim();
+				if (matched.model !== void 0 && matched.model.trim() !== "") expert.model = matched.model.trim();
 			}
 			experts.push(expert);
 		}
@@ -1713,7 +1749,7 @@ async function collectDefects(input) {
 		};
 		try {
 			return {
-				lines: await splitUtterance(activeLlm, input.splitConfig, item.utterance.expertKey, item.content, allowed),
+				lines: await splitUtterance(activeLlm, input.splitConfig, item.utterance.expertKey, item.content, allowed, record.stance.text),
 				usedLlm: true
 			};
 		} catch {
@@ -1785,10 +1821,37 @@ function rosterFrom(input) {
 }
 /**
 * 把收集结果并入记录（原地修改；调用方负责落盘）。
+*
+* ## 幂等（A2）
+*
+* 此前是纯拼接（`[...record.defects, ...added]`），于是**同一条发言被收集两次**
+* 就在裁决面上出现两条一模一样的缺陷：重试、双击、两个并发请求都能触发它。
+* 用户面对的是一个"必须点两次驳回、理由还得写两遍"的列表。
+*
+* 现在按 `defect.id` 去重（`id` 由 `collectDefects` 从 `utteranceId` + 序号生成，
+* 因此同一批输入两次得到同一批 id）：**保留先到的那一条**，后来的同 id 项直接丢弃。
+* 保留先到的而不是新的，是因为"用户已经开始表态"的那一条不能被后来的副本顶掉
+* （缺陷的三态与驳回理由挂在 id 上，换掉实例等于丢掉已做出的判断）。
+*
+* `collectDefects` 里的 `utteranceId` 幂等键是第一道闸，这里的是第二道：前者防的是
+* "转录又被读了一遍"，后者防的是"合并写回被施加了同一批结果" —— 两道都需要，
+* 因为并发请求可以在第一道闸之后、第二道闸之前交错。
+*
+* @returns **实际追加的条数**（被去重丢弃的不算）。调用方必须如实上报这个数字，
+*          而不是 `added.length` —— 那会把"请求成功了但什么都没新增"报成
+*          "新增了 N 条"，用户看到条数却对不上列表。
 */
 function applyCollected(record, added) {
-	record.defects = [...record.defects, ...added];
+	const known = new Set(record.defects.map((defect) => defect.id));
+	const fresh = [];
+	for (const defect of added) {
+		if (known.has(defect.id)) continue;
+		known.add(defect.id);
+		fresh.push(defect);
+	}
+	record.defects = [...record.defects, ...fresh];
 	for (const expert of record.experts) expert.defectCount = record.defects.filter((defect) => defect.expertKey === expert.key).length;
+	return fresh.length;
 }
 
 //#endregion
@@ -2042,6 +2105,64 @@ function expertWelcome(input) {
 //#region src/members.ts
 /** 专家子代理的 label 前缀（持久化为该子会话的创建标签，便于在宿主侧辨认）。 */
 const EXPERT_LABEL_PREFIX = "crossfire-expert:";
+/** 取一个"真的写了东西"的字符串；空串与纯空白一律视为**缺席**。 */
+function nonEmpty(value) {
+	if (value === void 0) return void 0;
+	const trimmed = value.trim();
+	return trimmed === "" ? void 0 : trimmed;
+}
+/**
+* 把"专家显式指定的路由"与"宿主默认路由"收敛成一份确定的路由决定（A5 + B3）。
+*
+* ## 一条铁律
+*
+* **写回记录的值 = 真正下发的值。** 记录与下发必须由**同一次决定**产生，否则界面
+* 会显示一条并非事实的路由（红队抓出的原缺陷：只填了 provider 的成员，记录里却被
+* 写成 `defaultProvider` + `defaultModel` —— 界面说跑 A，实际跑 B）。
+*
+* ## 四种组合的行为（全都是确定的，没有"看情况"）
+*
+* | 专家显式指定 | agentOptions（下发） | 写回记录 |
+* |---|---|---|
+* | provider + model | `{provider, model}` | provider、model |
+* | 只有 provider | `{provider}` | provider（**不补 model**） |
+* | 只有 model | `{defaultProvider?, model}` | provider（补上的那个）、model |
+* | 都没有（继承） | `{}`（不干预） | defaultProvider、defaultModel |
+*
+* 逐条理由：
+* - **只有 provider 时刻意不补 model**：`provider` 自己会选它的默认模型，我们没有
+*   任何依据知道那会是哪一个；拿 `config.defaultModel` 去顶替就是编造（那正是原
+*   缺陷的写法）。记录的 `model` 缺席是诚实的"不知道"。
+* - **只有 model 时补 `defaultProvider`**：一个不给 provider 的 model id 在多数路由上
+*   无法解析，而"只写 model、不写 provider"在用户眼里就是"用默认 provider 跑这个
+*   模型"。补上的值同时写回记录 —— 于是界面显示的正是真正下发的。
+* - **都没有时 agentOptions 为空**：这一种情形下我们**不替宿主做决定**，真正的继承
+*   必须保持是继承。记录里那份 `defaultProvider`/`defaultModel` 是配置里声明的
+*   "继承主持人时**实际生效**的模型路由"（见 index.ts / ToolsConfig 的同一段注释），
+*   写它只为把"继承"画成真实品牌块（否则头像永远是中性灰 `?`，那是用户报过的缺陷）。
+*   这是**唯一**一处记录值不等于 agentOptions 的字段 —— 而它们仍然同源：记录里出现的
+*   每一个字段，要么是我们显式下发的，要么是宿主默认路由本身。
+* - **取不到生效值的字段一律不写**（保持"缺失 = 继承"的诚实语义），也不写空串。
+*
+* 纯函数：没有 I/O、没有时间、不改入参，所以四种组合都能被单测直接钉住
+* （见 `test/members.test.mjs`）。
+*/
+function resolveExpertRoute(expert, config) {
+	const explicitProvider = nonEmpty(expert.provider);
+	const explicitModel = nonEmpty(expert.model);
+	const fallbackProvider = nonEmpty(config.defaultProvider);
+	const fallbackModel = nonEmpty(config.defaultModel);
+	const agentOptions = {};
+	if (explicitProvider !== void 0) agentOptions.provider = explicitProvider;
+	else if (explicitModel !== void 0 && fallbackProvider !== void 0) agentOptions.provider = fallbackProvider;
+	if (explicitModel !== void 0) agentOptions.model = explicitModel;
+	const route = { agentOptions };
+	if (agentOptions.provider !== void 0) route.provider = agentOptions.provider;
+	else if (explicitProvider === void 0 && explicitModel === void 0 && fallbackProvider !== void 0) route.provider = fallbackProvider;
+	if (agentOptions.model !== void 0) route.model = agentOptions.model;
+	else if (explicitProvider === void 0 && explicitModel === void 0 && fallbackModel !== void 0) route.model = fallbackModel;
+	return route;
+}
 /**
 * 拉起一位红队专家，返回它的子会话 id。
 *
@@ -2064,12 +2185,14 @@ async function spawnExpert(ctx, config, record, expert, parent, signal, limits =
 		maxOpinions: limits.maxOpinions ?? 0,
 		...expert.role === void 0 ? {} : { role: expert.role }
 	};
-	const agentOptions = {};
-	if (expert.provider !== void 0 && expert.model !== void 0) {
-		agentOptions.provider = expert.provider;
-		agentOptions.model = expert.model;
-	}
+	const route = resolveExpertRoute(expert, config);
+	const agentOptions = { ...route.agentOptions };
 	if (limits.maxTokens !== void 0 && limits.maxTokens > 0) agentOptions.maxTokens = limits.maxTokens;
+	if (route.provider === void 0) delete expert.provider;
+	else expert.provider = route.provider;
+	if (route.model === void 0) delete expert.model;
+	else expert.model = route.model;
+	const persona = expertPersona(input);
 	const started = await ctx.subagents.startContinuable({
 		provider: config.provider,
 		label: `${EXPERT_LABEL_PREFIX}${record.reviewId}:${expert.key}`,
@@ -2079,13 +2202,14 @@ async function spawnExpert(ctx, config, record, expert, parent, signal, limits =
 				text: expertWelcome(input)
 			}],
 			parent,
-			persona: expertPersona(input),
+			persona,
 			toolFilter: expertToolRestriction(),
 			...Object.keys(agentOptions).length > 0 ? { agentOptions } : {},
 			...config.maxDepth === void 0 ? {} : { maxDepth: config.maxDepth }
 		},
 		signal
 	});
+	expert.persona = persona;
 	return String(started.childId);
 }
 
@@ -2102,7 +2226,7 @@ async function spawnExpert(ctx, config, record, expert, parent, signal, limits =
 * @module dsh-plugin-crossfire/version
 */
 /** 当前插件版本（必须与 package.json 的 version 逐字一致）。 */
-const PLUGIN_VERSION = "0.1.0";
+const PLUGIN_VERSION = "0.1.1";
 /** 导出物头部使用的插件标识行。 */
 const PLUGIN_ID = `@y9931666/dsh-plugin-crossfire v${PLUGIN_VERSION}`;
 /** DeepSeek Harness 版本区间（导出头部展示用）。
@@ -2594,6 +2718,35 @@ function registerRpc(ctx, runtime) {
 						status
 					});
 				}
+				case "crossfire/expert.prompt": {
+					const expertKey = typeof body.expertKey === "string" ? body.expertKey : "";
+					if (expertKey === "") return fail("payload must be { reviewId, expertKey }");
+					const located = await load(reviewId, session, preferredRoot);
+					const expert = located.record.experts.find((item) => item.key === expertKey);
+					if (expert === void 0) return fail(`no expert "${expertKey}" in this review`);
+					if (expert.persona !== void 0 && expert.persona !== "") return ok({
+						expertKey,
+						dimension: expert.dimension,
+						persona: expert.persona,
+						rebuilt: false
+					});
+					const persona = expertPersona({
+						reviewId: located.record.reviewId,
+						dimension: expert.dimension,
+						title: located.record.subject.title,
+						subject: located.record.subject.content,
+						stance: located.record.stance.text,
+						dimensions: located.record.dimensions,
+						maxOpinions: runtime.tools.getDefaults().expertMaxOpinions,
+						...expert.role === void 0 ? {} : { role: expert.role }
+					});
+					return ok({
+						expertKey,
+						dimension: expert.dimension,
+						persona,
+						rebuilt: true
+					});
+				}
 				case "crossfire/expert.setRole": {
 					const expertKey = typeof body.expertKey === "string" ? body.expertKey : "";
 					if (expertKey === "") return fail("payload must be { reviewId, expertKey, role }");
@@ -2654,8 +2807,16 @@ function registerRpc(ctx, runtime) {
 					const markdown = renderReviewMarkdown(located.record, countDefects(located.record));
 					const path = exportFile(located.stateRoot, reviewId);
 					await writeTextAtomic(path, markdown);
+					let textPath;
+					try {
+						textPath = exportTextFile(located.stateRoot, reviewId);
+						await writeTextAtomicWithBom(textPath, markdown);
+					} catch {
+						textPath = "";
+					}
 					return ok({
 						path,
+						textPath,
 						bytes: Buffer.byteLength(markdown, "utf8"),
 						markdown
 					});
@@ -2685,13 +2846,14 @@ async function advance(ctx, runtime, located, step, body, session) {
 	const reviewId = located.record.reviewId;
 	const defaults = runtime.tools.getDefaults();
 	if (step === "attack") {
-		if (await readRecord(stateRoot, reviewId) === void 0) return fail(`no review "${reviewId}"`);
 		const agent = agentOfSession(ctx, session);
 		if (agent === void 0) return fail("the session that owns this review is not live right now, so Crossfire cannot send in the red team from the card — ask in the conversation instead (crossfire_attack)", "session-offline");
-		const planned = await withCrossfireLock(reviewLockKey(stateRoot, reviewId), async () => {
+		return await withCrossfireLock(reviewLockKey(stateRoot, reviewId), async () => {
 			const current = await readRecord(stateRoot, reviewId);
-			if (current === void 0) throw new Error(`no review "${reviewId}"`);
-			if (current.status !== "draft" && current.status !== "attacking") throw new Error(`review "${reviewId}" is "${current.status}" — cannot send in the red team now (call crossfire_recheck to open a new pass on a settled review)`);
+			if (current === void 0) return fail(`no review "${reviewId}"`);
+			if (current.status !== "draft" && current.status !== "attacking") return fail(`review "${reviewId}" is "${current.status}" — cannot send in the red team now (call crossfire_recheck to open a new pass on a settled review)`);
+			const running = current.experts.filter((expert) => expert.status === "running");
+			if (running.length > 0) return fail(`experts are already running for this review (${running.map((expert) => expert.key).join(", ")}) — wait for them to report, or collect what they have already submitted`);
 			const prefs = runtime.prefs.get();
 			const roster = rosterFrom({
 				squads: prefs.squads.map((squad) => ({
@@ -2715,99 +2877,101 @@ async function advance(ctx, runtime, located, step, body, session) {
 			current.experts = experts;
 			current.status = "attacking";
 			await writeRecord(stateRoot, current);
-			return {
-				record: current,
-				experts
-			};
-		});
-		const failures = [];
-		for (const expert of planned.experts) {
-			const controller = new AbortController();
-			try {
-				const childId = await spawnExpert(ctx, {
-					provider: runtime.tools.memberProvider,
-					...runtime.tools.memberMaxDepth === void 0 ? {} : { maxDepth: runtime.tools.memberMaxDepth }
-				}, planned.record, expert, agent, controller.signal, {
-					maxTokens: defaults.expertMaxTokens,
-					maxOpinions: defaults.expertMaxOpinions
-				});
-				expert.childId = childId;
-				expert.status = "running";
-				registerExpertChild(childId, {
-					stateRoot,
-					reviewId
-				});
-			} catch (error) {
-				expert.status = "failed";
-				expert.note = error instanceof Error ? error.message : String(error);
-				failures.push(`${expert.key}: ${expert.note}`);
+			const failures = [];
+			for (const expert of experts) {
+				const controller = new AbortController();
+				try {
+					const childId = await spawnExpert(ctx, {
+						provider: runtime.tools.memberProvider,
+						...runtime.tools.memberMaxDepth === void 0 ? {} : { maxDepth: runtime.tools.memberMaxDepth },
+						...runtime.tools.defaultProvider === void 0 ? {} : { defaultProvider: runtime.tools.defaultProvider },
+						...runtime.tools.defaultModel === void 0 ? {} : { defaultModel: runtime.tools.defaultModel }
+					}, current, expert, agent, controller.signal, {
+						maxTokens: defaults.expertMaxTokens,
+						maxOpinions: defaults.expertMaxOpinions
+					});
+					expert.childId = childId;
+					expert.status = "running";
+					registerExpertChild(childId, {
+						stateRoot,
+						reviewId
+					});
+				} catch (error) {
+					expert.status = "failed";
+					expert.note = error instanceof Error ? error.message : String(error);
+					failures.push(`${expert.key}: ${expert.note}`);
+				}
 			}
-		}
-		await mutateRecord(stateRoot, reviewId, (current) => {
-			current.experts = planned.experts;
-		});
-		return ok({
-			spawned: planned.experts.filter((expert) => expert.status === "running").length,
-			failed: failures.length,
-			failures
+			current.experts = experts;
+			await writeRecord(stateRoot, current);
+			return ok({
+				spawned: experts.filter((expert) => expert.status === "running").length,
+				failed: failures.length,
+				failures
+			});
 		});
 	}
 	if (step === "collect") {
-		const record$1 = await readRecord(stateRoot, reviewId);
-		if (record$1 === void 0) return fail(`no review "${reviewId}"`);
-		if (record$1.status !== "attacking" && record$1.status !== "judging") return fail(`review "${reviewId}" is "${record$1.status}" — cannot collect now`);
-		const transcript = await readTranscriptReport(stateRoot, reviewId);
 		const llm = ctx.get("llm");
-		const outcome = await collectDefects({
-			record: record$1,
-			transcript: transcript.items,
-			malformed: transcript.malformed,
-			llm,
-			splitConfig: runtime.tools.reviewSplit
-		});
-		await mutateRecord(stateRoot, reviewId, (current) => {
-			applyCollected(current, outcome.added);
+		return await withCrossfireLock(reviewLockKey(stateRoot, reviewId), async () => {
+			const current = await readRecord(stateRoot, reviewId);
+			if (current === void 0) return fail(`no review "${reviewId}"`);
+			if (current.status !== "attacking" && current.status !== "judging") return fail(`review "${reviewId}" is "${current.status}" — cannot collect now`);
+			const transcript = await readTranscriptReport(stateRoot, reviewId);
+			const outcome = await collectDefects({
+				record: current,
+				transcript: transcript.items,
+				malformed: transcript.malformed,
+				llm,
+				splitConfig: runtime.tools.reviewSplit
+			});
+			const appended = applyCollected(current, outcome.added);
 			current.status = "judging";
-		});
-		return ok({
-			collected: outcome.added.length,
-			droppedDuplicates: outcome.droppedDuplicates,
-			skippedNoise: outcome.skippedNoise,
-			splitAttempts: outcome.splitAttempts,
-			recheckRound: record$1.reviewPass > 1 && record$1.history.length > 0
+			await writeRecord(stateRoot, current);
+			return ok({
+				collected: appended,
+				droppedDuplicates: outcome.droppedDuplicates,
+				skippedNoise: outcome.skippedNoise,
+				splitAttempts: outcome.splitAttempts,
+				recheckRound: current.reviewPass > 1 && current.history.length > 0
+			});
 		});
 	}
 	if (step === "finish") {
 		const summary = typeof body.summary === "string" ? body.summary.trim() : "";
-		const record$1 = await readRecord(stateRoot, reviewId);
-		if (record$1 === void 0) return fail(`no review "${reviewId}"`);
-		if (record$1.status !== "judging" && record$1.status !== "attacking" && record$1.status !== "settled") return fail(`review "${reviewId}" is "${record$1.status}" — cannot settle now`);
-		return ok({
-			settled: true,
-			counts: await mutateRecord(stateRoot, reviewId, (current) => {
-				current.history = [...current.history, {
-					pass: current.reviewPass,
-					subject: current.subject.content,
-					stanceText: current.stance.text,
-					dimensions: [...current.dimensions],
-					intensity: current.intensity,
-					defects: current.defects.map((defect) => ({ ...defect })),
-					finishedAt: Date.now(),
-					...summary === "" ? {} : { revisedSummary: summary }
-				}];
-				current.status = "settled";
-				current.settledAt = Date.now();
-				return countDefects(current);
-			}) ?? countDefects(record$1)
+		return await withCrossfireLock(reviewLockKey(stateRoot, reviewId), async () => {
+			const current = await readRecord(stateRoot, reviewId);
+			if (current === void 0) return fail(`no review "${reviewId}"`);
+			if (current.status !== "judging" && current.status !== "attacking" && current.status !== "settled") return fail(`review "${reviewId}" is "${current.status}" — cannot settle now`);
+			const snapshot = {
+				pass: current.reviewPass,
+				subject: current.subject.content,
+				stanceText: current.stance.text,
+				dimensions: [...current.dimensions],
+				intensity: current.intensity,
+				defects: current.defects.map((defect) => ({ ...defect })),
+				finishedAt: Date.now(),
+				...summary === "" ? {} : { revisedSummary: summary }
+			};
+			const existing = current.history.findIndex((item) => item.pass === current.reviewPass);
+			if (existing >= 0) current.history[existing] = snapshot;
+			else current.history = [...current.history, snapshot];
+			current.status = "settled";
+			current.settledAt = Date.now();
+			await writeRecord(stateRoot, current);
+			return ok({
+				settled: true,
+				counts: countDefects(current)
+			});
 		});
 	}
-	const record = await readRecord(stateRoot, reviewId);
-	if (record === void 0) return fail(`no review "${reviewId}"`);
-	if (record.status !== "settled") return fail(`review "${reviewId}" is "${record.status}" — only a settled review can be re-checked`);
 	const approved = body.approved === true;
-	const nextPass = record.reviewPass + 1;
-	if (nextPass > record.maxReviewPass && !approved) return fail(`re-review cap reached (pass ${nextPass} > max ${record.maxReviewPass}) — the user must approve continuing`, "cap-reached");
-	const result = await mutateRecord(stateRoot, reviewId, (current) => {
+	return await withCrossfireLock(reviewLockKey(stateRoot, reviewId), async () => {
+		const current = await readRecord(stateRoot, reviewId);
+		if (current === void 0) return fail(`no review "${reviewId}"`);
+		if (current.status !== "settled") return fail(`review "${reviewId}" is "${current.status}" — only a settled review can be re-checked`);
+		const nextPass = current.reviewPass + 1;
+		if (nextPass > current.maxReviewPass && !approved) return fail(`re-review cap reached (pass ${nextPass} > max ${current.maxReviewPass}) — the user must approve continuing`, "cap-reached");
 		const items = buildRecheckItems(current);
 		current.reviewPass = beginPass(current);
 		if (approved) current.maxReviewPass = Math.max(current.maxReviewPass, current.reviewPass);
@@ -2815,14 +2979,11 @@ async function advance(ctx, runtime, located, step, body, session) {
 		current.experts = [];
 		current.status = "attacking";
 		current.settledAt = void 0;
-		return {
-			pass: current.reviewPass,
-			items: items.length
-		};
-	});
-	return ok({
-		reviewPass: result?.pass ?? nextPass,
-		recheckItems: result?.items ?? 0
+		await writeRecord(stateRoot, current);
+		return ok({
+			reviewPass: current.reviewPass,
+			recheckItems: items.length
+		});
 	});
 }
 /**
@@ -2918,7 +3079,9 @@ function cloneDefect(defect) {
 function registerCrossfireTools(ctx, config) {
 	const memberConfig = {
 		provider: config.memberProvider,
-		...config.memberMaxDepth === void 0 ? {} : { maxDepth: config.memberMaxDepth }
+		...config.memberMaxDepth === void 0 ? {} : { maxDepth: config.memberMaxDepth },
+		...config.defaultProvider === void 0 ? {} : { defaultProvider: config.defaultProvider },
+		...config.defaultModel === void 0 ? {} : { defaultModel: config.defaultModel }
 	};
 	ctx.tools.register(defineTool({
 		name: "crossfire_open",
@@ -3097,6 +3260,8 @@ function registerCrossfireTools(ctx, config) {
 				requireOwner(record, caller.id);
 				assertBudget(record);
 				requireStatus(record, ["draft", "attacking"]);
+				const running = record.experts.filter((expert) => expert.status === "running");
+				if (running.length > 0) throw new Error(`experts are already running for review "${reviewId}" (${running.map((expert) => expert.key).join(", ")}) — wait for them to report, or collect what they have already submitted`);
 				const spec = INTENSITY_SPECS[record.intensity];
 				const experts = [];
 				for (const dimension of record.dimensions) {
@@ -3113,40 +3278,40 @@ function registerCrossfireTools(ctx, config) {
 				record.experts = trimmed;
 				record.status = "attacking";
 				await writeRecord(stateRoot, record);
+				const failures = [];
+				for (const expert of trimmed) {
+					const controller = new AbortController();
+					try {
+						const childId = await spawnExpert(ctx, memberConfig, record, expert, caller, controller.signal, {
+							maxTokens: defaults.expertMaxTokens,
+							maxOpinions: defaults.expertMaxOpinions
+						});
+						expert.childId = childId;
+						expert.status = "running";
+						registerExpertChild(childId, {
+							stateRoot,
+							reviewId
+						});
+					} catch (error) {
+						expert.status = "failed";
+						expert.note = error instanceof Error ? error.message : String(error);
+						failures.push(`${expert.key}: ${expert.note}`);
+					}
+				}
+				record.experts = trimmed;
+				await writeRecord(stateRoot, record);
 				return {
 					record,
-					experts: trimmed
+					experts: trimmed,
+					failures
 				};
 			});
-			const failures = [];
-			for (const expert of planned.experts) {
-				const controller = new AbortController();
-				try {
-					const childId = await spawnExpert(ctx, memberConfig, planned.record, expert, caller, controller.signal, {
-						maxTokens: defaults.expertMaxTokens,
-						maxOpinions: defaults.expertMaxOpinions
-					});
-					expert.childId = childId;
-					expert.status = "running";
-					registerExpertChild(childId, {
-						stateRoot,
-						reviewId
-					});
-				} catch (error) {
-					expert.status = "failed";
-					expert.note = error instanceof Error ? error.message : String(error);
-					failures.push(`${expert.key}: ${expert.note}`);
-				}
-			}
-			await mutateRecord(stateRoot, reviewId, (record) => {
-				record.experts = planned.experts;
-			});
 			return {
 				spawned: planned.experts.filter((expert) => expert.status === "running").length,
-				failed: failures.length,
+				failed: planned.failures.length,
 				dimensions: planned.record.dimensions,
 				review_pass: planned.record.reviewPass,
-				failures
+				failures: planned.failures
 			};
 		}
 	}));
@@ -3207,36 +3372,33 @@ function registerCrossfireTools(ctx, config) {
 			const stateRoot = stateRootOf(workspaceOf(caller), config.stateDir);
 			const reviewId = text(args.review_id);
 			if (reviewId === "") throw new Error("review_id must not be empty");
-			const record = await requireRecord(stateRoot, reviewId);
-			requireOwner(record, caller.id);
-			requireStatus(record, ["attacking", "judging"]);
-			const transcript = await readTranscriptReport(stateRoot, reviewId);
-			const llm = ctx.get("llm");
-			const outcome = await collectDefects({
-				record,
-				transcript: transcript.items,
-				malformed: transcript.malformed,
-				llm,
-				splitConfig: config.reviewSplit
-			});
-			const result = await mutateRecord(stateRoot, reviewId, (current) => {
-				applyCollected(current, outcome.added);
-				current.status = "judging";
+			return await withCrossfireLock(reviewLockKey(stateRoot, reviewId), async () => {
+				const record = await requireRecord(stateRoot, reviewId);
+				requireOwner(record, caller.id);
+				requireStatus(record, ["attacking", "judging"]);
+				const transcript = await readTranscriptReport(stateRoot, reviewId);
+				const llm = ctx.get("llm");
+				const outcome = await collectDefects({
+					record,
+					transcript: transcript.items,
+					malformed: transcript.malformed,
+					llm,
+					splitConfig: config.reviewSplit
+				});
+				const appended = applyCollected(record, outcome.added);
+				record.status = "judging";
+				await writeRecord(stateRoot, record);
 				return {
-					total: current.defects.length,
-					status: current.status
+					collected: appended,
+					dropped_duplicates: outcome.droppedDuplicates,
+					skipped_noise: outcome.skippedNoise,
+					split_attempts: outcome.splitAttempts,
+					malformed_lines: outcome.malformedLines,
+					total_defects: record.defects.length,
+					status: record.status,
+					recheck_round: record.reviewPass > 1 && record.history.length > 0
 				};
 			});
-			return {
-				collected: outcome.added.length,
-				dropped_duplicates: outcome.droppedDuplicates,
-				skipped_noise: outcome.skippedNoise,
-				split_attempts: outcome.splitAttempts,
-				malformed_lines: outcome.malformedLines,
-				total_defects: result?.total ?? record.defects.length,
-				status: result?.status ?? "judging",
-				recheck_round: record.reviewPass > 1 && record.history.length > 0
-			};
 		}
 	}));
 	ctx.tools.register(defineTool({
@@ -3458,10 +3620,16 @@ function registerCrossfireTools(ctx, config) {
 			assertBudget(record, { allowMuted: true });
 			const markdown = renderReviewMarkdown(record, countDefects(record));
 			const path = exportFile(stateRoot, reviewId);
-			const { writeTextAtomic: writeTextAtomic$1 } = await import("./state-CXNvzj_T.js");
+			const { writeTextAtomic: writeTextAtomic$1, writeTextAtomicWithBom: writeTextAtomicWithBom$1 } = await import("./state-B2anbn4l.js");
 			await writeTextAtomic$1(path, markdown);
+			let textPath = "";
+			try {
+				textPath = exportTextFile(stateRoot, reviewId);
+				await writeTextAtomicWithBom$1(textPath, markdown);
+			} catch {}
 			return {
 				path,
+				textPath,
 				bytes: Buffer.byteLength(markdown, "utf8"),
 				markdown
 			};
@@ -3724,6 +3892,8 @@ const Config = z.object({
 		"deep"
 	]).default("standard"),
 	memberMaxDepth: z.natural().default(1),
+	defaultProvider: z.string().default("deepseek-official"),
+	defaultModel: z.string().default("deepseek-flash"),
 	promptSectionOrder: z.natural().default(117)
 });
 function apply(ctx, config) {
@@ -3732,7 +3902,9 @@ function apply(ctx, config) {
 		memberProvider: config.memberProvider ?? "spawn",
 		maxExperts: config.maxExperts ?? 7,
 		defaultIntensity: config.defaultIntensity ?? "standard",
-		memberMaxDepth: config.memberMaxDepth ?? 1
+		memberMaxDepth: config.memberMaxDepth ?? 1,
+		defaultProvider: config.defaultProvider ?? "deepseek-official",
+		defaultModel: config.defaultModel ?? "deepseek-flash"
 	};
 	ctx.systemPrompt.section({
 		name: "crossfire:usage",
@@ -3752,6 +3924,8 @@ function apply(ctx, config) {
 			stateDir: resolved.stateDir,
 			memberProvider: resolved.memberProvider,
 			maxExperts: resolved.maxExperts,
+			defaultProvider: resolved.defaultProvider,
+			defaultModel: resolved.defaultModel,
 			...resolved.memberMaxDepth === void 0 ? {} : { memberMaxDepth: resolved.memberMaxDepth },
 			reviewSplit: {
 				provider: "deepseek-official",