dsh-plugin-om 0.0.26 → 0.0.28

package/dist/index.mjs

@@ -39,30 +39,87 @@ function isPluginOwnedSource(source) {
 	return source.plugin === "dsh-plugin-om" || source.plugin === "compact";
 }
 //#endregion
+//#region src/om-event.ts
+/** om 信封 text 前缀：标识该 feedback/record 记录由本插件写入。 */
+const OM_EVENT_PREFIX = "om:1:";
+/** 校验载荷字段与类别匹配（运行时守卫，保证返回类型的诚实性）。 */
+function isValidPayload(kind, data) {
+	switch (kind) {
+		case "om/warning": return typeof data.problem === "string" && typeof data.message === "string";
+		case "om/observe-pending": return typeof data.triggerMessageIndex === "number" && Number.isSafeInteger(data.triggerMessageIndex);
+		case "om/observe-invalidate": return typeof data.pendingSeq === "number" && Number.isSafeInteger(data.pendingSeq);
+	}
+}
+/**
+* 解码一条会话事件为 om 私有事件：仅识别 feedback/record 中带 om 信封前缀的
+* text；前缀缺失、JSON 非法、kind 未知或载荷字段缺失时返回 undefined。
+*/
+function readOmEvent(event) {
+	if (event === void 0 || event === null || event.type !== "feedback/record") return void 0;
+	const text = event.data?.text;
+	if (typeof text !== "string" || !text.startsWith("om:1:")) return void 0;
+	let envelope;
+	try {
+		envelope = JSON.parse(text.slice(5));
+	} catch {
+		return;
+	}
+	if (envelope === null || typeof envelope !== "object" || Array.isArray(envelope)) return void 0;
+	const { kind, ...rest } = envelope;
+	if (typeof kind !== "string") return void 0;
+	if (![
+		"om/warning",
+		"om/observe-pending",
+		"om/observe-invalidate"
+	].includes(kind)) return void 0;
+	const omKind = kind;
+	if (!isValidPayload(omKind, rest)) return void 0;
+	return {
+		kind: omKind,
+		data: rest,
+		seq: event.seq
+	};
+}
+/** 编码一条 om 私有事件为 feedback/record 的 text 信封。 */
+function encodeOmEvent(kind, data) {
+	return `${OM_EVENT_PREFIX}${JSON.stringify({
+		kind,
+		...data
+	})}`;
+}
+/** 追加一条 om 私有事件（借用 feedback/record，log-only，不进 surface），返回事件 seq。 */
+function appendOmEvent(session, kind, data) {
+	return session.append("feedback/record", { text: encodeOmEvent(kind, data) }).seq;
+}
+function findOmEvents(session, kind) {
+	const result = [];
+	for (const event of session.events) {
+		const om = readOmEvent(event);
+		if (om !== void 0 && (kind === void 0 || om.kind === kind)) result.push(om);
+	}
+	return result;
+}
+//#endregion
 //#region src/degrade.ts
 /**
 * 降级报告：压缩流程中的挂载失败统一出口。
 * 导出 reportDegrade / DEGRADE_PROBLEMS / DegradedProblem。
 *
 * - 挂载失败类问题（服务缺失、服务调用异常）始终 console.warn 到宿主进程外部输出，
-*   并向会话日志追加 log-only 的 `om/warning` 事件（客户端渲染为「功能降级」警告行）；
+*   并向会话日志追加 log-only 的 om 警告事件（借用 feedback/record 的 om 信封，
+*   见 om-event.ts；客户端渲染为「功能降级」警告行）；
 *   同一会话同一问题只报告一次（按日志扫描去重，重启不重复）
 * - 报告动作自身绝不抛错：追加失败只记日志，不阻塞压缩
 * - 辅助函数的普通运行时报错（组装失败、请求头读取失败）不走本模块，仅记日志
 */
-/** 各降级问题面向用户的简短说明（om/warning 载荷 message；客户端警告行直接展示）。 */
+/** 各降级问题面向用户的简短说明（om/warning 信封载荷 message；客户端警告行直接展示）。 */
 const DEGRADE_PROBLEMS = {
 	"systemPrompt-missing": "系统提示词服务未挂载，上下文压力估算不扣除系统提示词 tokens（压缩触发会偏早）",
 	"tokenMeter-unavailable": "token 计量服务异常，上下文压力估算降级（可能跳过压缩或按 0 计）"
 };
-/** 判定事件是否为指定 problem 的已有 om/warning 记录（会话内去重依据）。 */
-function isWarningFor(event, problem) {
-	if (event.type !== "om/warning") return false;
-	return event.data?.problem === problem;
-}
 /**
 * 报告一次挂载失败类降级：console.warn 始终输出到宿主进程外部；同会话同问题首次
-* 出现时，向会话日志追加 log-only `om/warning` 事件（客户端渲染警告行，每会话最多
+* 出现时，向会话日志追加 log-only om 警告事件（客户端渲染警告行，每会话最多
 * 一次）并输出 logger.warn（避免每个 pre-step 重复刷日志）。
 * 日志扫描/事件追加失败只记日志，绝不抛错、不阻塞压缩。
 */
@@ -70,19 +127,19 @@ function reportDegrade(session, logger, problem) {
 	const message = DEGRADE_PROBLEMS[problem];
 	let first = true;
 	try {
-		first = !session.events.some((event) => isWarningFor(event, problem));
+		first = !findOmEvents(session, "om/warning").some((om) => om.data.problem === problem);
 	} catch {}
 	if (!first) return;
 	console.warn(`${PLUGIN_LABEL}: ${message}`);
 	logger.warn(message);
 	try {
-		session.append("om/warning", {
+		appendOmEvent(session, "om/warning", {
 			problem,
 			message
 		});
 	} catch (error) {
 		const text = error instanceof Error ? error.message : String(error);
-		logger.warn(`om/warning 事件追加失败: ${text}`);
+		logger.warn(`om 警告事件追加失败: ${text}`);
 	}
 }
 //#endregion
@@ -7482,9 +7539,9 @@ function phaseLabel(phase) {
 	if (phase === "reflect") return "反思";
 	return "压缩";
 }
-/** 诊断子会话 label：含压缩阶段与尝试次数。 */
-function compactionLogLabel(phase, attemptCount) {
-	return `OM 压缩失败日志（${phaseLabel(phase)} · ${attemptCount} 次尝试）`;
+/** 诊断子会话 label：含压缩阶段与尝试序号。 */
+function compactionLogLabel(phase, attemptNo) {
+	return `OM 压缩日志（${phaseLabel(phase)} · 第 ${attemptNo} 次尝试）`;
 }
 /** 追加一次尝试的「提示词 → 原始输出」消息组（surfaceOp append；id 为品牌类型，session.append 运行时校验）。 */
 function appendAttemptMessages(child, attempt, step, target) {
@@ -7521,14 +7578,13 @@ function appendAttemptMessages(child, attempt, step, target) {
 	}, { surfaceOp: "append" });
 }
 /**
-* 把一次最终失败的摘要 run 落盘为诊断子会话：ctx.sessions.create 创建子会话
-* （header origin 'subagent'、parentSession 指向主会话、delegationDepth = 父 + 1、
-* cwd 继承主会话），追加 one-shot descriptor（provider om-compaction-log，label 含
-* 压缩阶段与尝试次数），逐尝试原样追加「提示词 + 原始输出」消息组，flush 持久化
-* 检查点，返回子会话 id。落盘自身绝不抛错：任何失败仅 logger.warn 并返回
-* undefined（不影响压缩失败流程）。
+* 把一次摘要尝试落盘为诊断子会话：ctx.sessions.create 创建子会话（header origin
+* 'subagent'、parentSession 指向主会话、delegationDepth = 父 + 1、cwd 继承主会话），
+* 追加 one-shot descriptor（provider om-compaction-log，label 含压缩阶段与尝试序号），
+* 原样追加「提示词 + 原始输出」消息组，flush 持久化检查点，返回子会话 id。落盘自身
+* 绝不抛错：任何失败仅 logger.warn 并返回 undefined（不影响压缩流程）。
 */
-async function recordCompactionFailure(ctx, parentSession, options) {
+async function recordCompactionAttempt(ctx, parentSession, options) {
 	const logger = makeLogger(ctx, options.debug);
 	try {
 		const header = parentSession.header;
@@ -7542,23 +7598,19 @@ async function recordCompactionFailure(ctx, parentSession, options) {
 			version: SUBAGENT_DESCRIPTOR_VERSION,
 			mode: "one-shot",
 			provider: COMPACTION_LOG_PROVIDER,
-			label: compactionLogLabel(options.phase, options.attempts.length)
+			label: compactionLogLabel(options.phase, options.attemptNo)
 		});
-		for (let i = 0; i < options.attempts.length; i += 1) {
-			const attempt = options.attempts[i];
-			if (attempt === void 0) continue;
-			appendAttemptMessages(child, attempt, i + 1, options.target);
-		}
+		appendAttemptMessages(child, options.attempt, 1, options.target);
 		try {
 			await ctx.sessions.flush(child);
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
-			logger.warn(`压缩失败诊断子会话 flush 失败（子会话 ${child.id} 已创建）: ${message}`);
+			logger.warn(`压缩日志子会话 flush 失败（子会话 ${child.id} 已创建）: ${message}`);
 		}
 		return child.id;
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
-		logger.warn(`压缩失败诊断子会话落盘失败: ${message}`);
+		logger.warn(`压缩日志子会话落盘失败（第 ${options.attemptNo} 次尝试）: ${message}`);
 		return;
 	}
 }
@@ -7621,8 +7673,10 @@ async function gateRateLimit(waitMs, signal) {
 /**
 * 共享压缩提示词（观察/反思同一套）：定义 history 块（模型消息 + index 的表达形式）、
 * 完整消息定义、压缩要求、输出格式与数据源说明。
+* skipReasoning=true（默认，与 compressSkipReasoning 默认一致）时压缩输入不含
+* <reasoning> 参考条目，提示词相应省略 <reasoning> 的说明两行。
 */
-function buildHistoryPrompt() {
+function buildHistoryPrompt(skipReasoning = true) {
 	return [
 		"压缩 <history> 消息记录。你应当输出**单个**合法的 <history> 块。",
 		"",
@@ -7630,17 +7684,18 @@ function buildHistoryPrompt() {
 		"- <history> 是历史消息的记录块。",
 		"- <user_message index=\"N\">：用户消息条目。",
 		"- <sys type=\"(kind)\" index=\"N\">：系统消息条目。",
-		"- <reasoning>：模型的思考过程，仅作压缩参考，产物中不要出现。",
+		...skipReasoning ? [] : ["- <reasoning>：模型的思考过程，仅作压缩参考，产物中不要出现。"],
 		"- <assistant index=\"N\">：单条完整消息（模型输出文本，或 toolcall 及其 result）。",
 		"- <assistant start=\"A\" end=\"B\">：多条连续完整消息聚合的模块（A/B 为模块首尾完整消息的 index）。",
 		"",
 		"【压缩要求】",
 		"- <user_message> <sys> 条目从输入中逐条保留，不做任何处理。",
-		"- <reasoning> 只作参考，输出产物中不包含 <reasoning> 块。",
-		"- 将具有关联性的 <assistant> 消息按内在逻辑连贯性划分为连续模块，聚合为 <assistant start=\"\" end=\"\"> 块：块内描述模块的目的、行为与结果；涉及的具体文件保留在模块内容中，多个前缀相同的路径合并简写。",
-		"- 单条重要的完整消息以 <assistant index=\"\"> 单独呈现，内容不受限制。",
+		...skipReasoning ? [] : ["- <reasoning> 只作参考，输出产物中不包含 <reasoning> 块。"],
+		"- 将具有关联性的 <assistant> 消息按内在逻辑连贯性划分为连续模块，聚合为 <assistant start=\"\" end=\"\"> 块",
+		"- 单条重要的完整消息以 <assistant index=\"\"> 单独呈现",
+		"- 压缩后的 <assistant> 块内，应当描述**行为逻辑**，强调关键的**结论、产出和任务**；涉及到的具体文件保留完整路径",
 		"- 加载的 skill 属于**关键信息**：应当产出独立块且不过多省略。",
-		"- 条目按 index 顺序覆盖本次压缩的全部完整消息：index/start/end 必须连续（区间内 index 连续、相邻条目相接），不跳号、不重叠、不遗漏。",
+		"- 压缩后的消息，区间边界与输入的消息必须完全相同，内部 index/start/end 必须连续，相邻区间的左右界必须相邻，",
 		"",
 		"【摘要粒度】",
 		"- 越往后越细：靠近末尾（最近）的完整消息保留更多细节（关键文件、改动与结论），开头（较早）的完整消息可适当从简。",
@@ -7697,14 +7752,15 @@ function renderUserEntry(doc, session, cm) {
 }
 /**
 * 渲染完整消息记录（观察输入）：输出一个合法的 <history> 块——
-* user → <user_message>（文本原样、图片注释）、sys → <sys> 空块、assistant 的
-* reasoning → <reasoning>（参考条目）、assistant/toolcall → <assistant>（原样文本）。
+* user → <user_message>（文本原样、图片注释）、sys → <sys> 空块、
+* assistant/toolcall → <assistant>（原样文本）；skipReasoning=false 时另把
+* assistant 的 reasoning → <reasoning>（参考条目）。
 * 文本经 XML 序列化自动转义；仅渲染 seqs 全部落在给定集合内的完整消息。
 */
-function renderMessages(session, seqs) {
+function renderMessages(session, seqs, skipReasoning = true) {
 	const shadowed = new Set(seqs);
 	const reasoningBySeq = /* @__PURE__ */ new Map();
-	for (const seq of seqs) {
+	if (!skipReasoning) for (const seq of seqs) {
 		const event = session.events[seq];
 		if (event?.type !== "assistant/message") continue;
 		const message = event.data.message;
@@ -7733,7 +7789,7 @@ function renderMessages(session, seqs) {
 		} else {
 			const callSeq = cm.seqs[0];
 			const reasonings = callSeq === void 0 ? void 0 : reasoningBySeq.get(callSeq);
-			if (callSeq !== void 0 && reasonings !== void 0 && !emittedReasoning.has(callSeq)) {
+			if (!skipReasoning && callSeq !== void 0 && reasonings !== void 0 && !emittedReasoning.has(callSeq)) {
 				emittedReasoning.add(callSeq);
 				for (const text of reasonings) {
 					const re = doc.createElement("reasoning");
@@ -7815,6 +7871,14 @@ function buildSummaryOptions(session, instruction, contextText, maxTokens, targe
 }
 /** 产出日志后插入首个 <history> 后的格式说明（XML 注释，完整消息定义 + 条目标签语义）。 */
 const HISTORY_FORMAT_NOTE = `<!-- 完整消息：${COMPLETE_MESSAGE_DEFINITION} <TAG index="N">表示单条完整消息，<TAG start="A" end="B"> 表示连续模块，start/end 是首尾完整消息的 index；<sys type="KIND" index="N"> 表示被压缩的系统消息，块中为空 -->`;
+/**
+* 剥离 <history> 块内文块首的格式说明注释（HISTORY_FORMAT_NOTE 整体精确匹配，仅块首
+* 一处）；正文条目内出现的同名注释串不动。非块首或不匹配时原样返回。
+*/
+function stripLeadingFormatNote(inner) {
+	if (!inner.startsWith(HISTORY_FORMAT_NOTE)) return inner;
+	return inner.slice(HISTORY_FORMAT_NOTE.length).replace(/^\s+/, "");
+}
 /** 读取元素整数属性（非负整数；缺失 / 非数字返回 undefined）。 */
 function intAttr(el, name) {
 	const raw = el.getAttribute(name);
@@ -7886,7 +7950,7 @@ function parseHistoryBlock(xml) {
 	};
 }
 /**
-* 解析文本中全部 <history> 块内的条目（反思输入为多个块拼接：逐块解析提取）。
+* 解析文本中全部 <history> 块内的条目（逐块解析提取，兼容多块拼接文本）。
 * 非法块跳过；仅提取不校验顺序（连续性由 historyContinuity 校验）。
 */
 function parseHistoryEntries(text) {
@@ -8031,95 +8095,109 @@ function extractSummaryDetailed(raw, expected) {
 }
 /**
 * 直连 LLM 执行一次摘要（观察或反思），返回文本与可选 token usage。
-* 失败（抛异常 / 空输出 / 非 stop 结束 / 校验不通过）均记录日志并重试，每次尝试的
-* 结果或报错始终写入日志（成功 info / 失败 warn，不受 debug 影响）；全部尝试耗尽
-* 返回失败结果（携带最后一次尝试的实际报错/具体问题）。最终失败（耗尽或 signal
-* 中止）时把每次尝试的完整提示词与模型原始输出原样落盘为诊断子会话（phase 标注
-* 观察或反思），诊断子会话 id 随失败结果返回。signal 中止（含限流等待被中止）
-* 立即放弃并标记 aborted。每次请求发出前先过全局限流等待门。
+* 每次实际发出的 LLM 调用（无论成功、校验不通过、非 stop 结束还是异常）完成后，
+* 立即把该次尝试的完整提示词与模型原始输出原样落盘为诊断子会话（phase 标注观察
+* 或反思），子会话 id 写入该次尝试的主会话日志；请求发出前被中止的尝试（无实际
+* 调用）不落盘。失败（抛异常 / 空输出 / 非 stop 结束 / 校验不通过）记录日志并重试；
+* 全部尝试耗尽返回失败结果（携带最后一次尝试的实际报错/具体问题与其诊断子会话 id）。
+* signal 中止（含限流等待被中止）立即放弃并标记 aborted。每次请求发出前先过全局
+* 限流等待门。
 */
 async function runSummarySubagent(ctx, agent, instruction, contextText, maxTokens, target, debug, signal, options) {
 	const session = agent.session;
 	const logger = makeLogger(ctx, debug);
 	const maxAttempts = options?.maxAttempts ?? 11;
 	let lastFailure = {};
-	/** 逐尝试的完整记录（提示词 + 原始输出原样收集，仅最终失败时落盘）。 */
-	const attempts = [];
-	/** 最终失败的统一出口：落盘诊断子会话并携带其 id 返回。 */
-	const finishFailure = async (error, aborted) => {
-		const diagnosticSessionId = await recordCompactionFailure(ctx, session, {
-			phase: options?.phase,
-			target,
-			attempts,
-			debug
-		});
-		return {
-			ok: false,
-			error,
-			aborted,
-			...diagnosticSessionId === void 0 ? {} : { diagnosticSessionId }
-		};
-	};
 	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
 		if (signal?.aborted) {
 			logger.warn(`摘要调用中止（第 ${attempt}/${maxAttempts} 次尝试前 signal 已中止），放弃本次压缩`);
-			return await finishFailure(COMPACTION_ABORTED_ERROR, true);
+			return {
+				ok: false,
+				error: COMPACTION_ABORTED_ERROR,
+				aborted: true,
+				...lastFailure.diagnosticSessionId === void 0 ? {} : { diagnosticSessionId: lastFailure.diagnosticSessionId }
+			};
 		}
 		const rateLimitWaitMs = options?.rateLimitWaitMs ?? 6e4;
 		if (!await gateRateLimit(rateLimitWaitMs, signal)) {
 			logger.warn(`摘要调用中止（第 ${attempt}/${maxAttempts} 次尝试前限流等待被 signal 中止），放弃本次压缩`);
-			return await finishFailure(COMPACTION_ABORTED_ERROR, true);
+			return {
+				ok: false,
+				error: COMPACTION_ABORTED_ERROR,
+				aborted: true,
+				...lastFailure.diagnosticSessionId === void 0 ? {} : { diagnosticSessionId: lastFailure.diagnosticSessionId }
+			};
 		}
 		logger.step(`摘要调用开始（第 ${attempt}/${maxAttempts} 次，provider ${target.provider}，model ${target.model}，maxTokens ${maxTokens === void 0 ? "未设置" : String(maxTokens)}）`);
 		const prompt = `${instruction}\n\n${contextText ?? ""}`;
 		const collector = new StreamCollector();
 		let streamCompleted = false;
+		/** 本次尝试的诊断子会话 id（调用完成后立即落盘；落盘失败时缺失）。 */
+		const logAttempt = async () => recordCompactionAttempt(ctx, session, {
+			phase: options?.phase,
+			target,
+			attempt: {
+				prompt,
+				rawOutput: collector.text
+			},
+			attemptNo: attempt,
+			debug
+		});
 		try {
 			const requestOptions = buildSummaryOptions(session, instruction, contextText, maxTokens, target, signal);
 			for await (const chunk of ctx.llm.stream(requestOptions)) collector.push(chunk);
 			streamCompleted = true;
-			attempts.push({
-				prompt,
-				rawOutput: collector.text
-			});
+			const diagnosticSessionId = await logAttempt();
 			const extracted = extractSummaryDetailed(collector.text, options?.expected);
 			const finish = collector.finish;
 			if (finish.kind !== "stop") {
-				lastFailure = { reason: `摘要流以 ${String(finish.kind)} 结束（非正常完成）` };
-				logger.warn(`摘要未完成（第 ${attempt}/${maxAttempts} 次，${lastFailure.reason}）` + (attempt < maxAttempts ? "，将重试" : "，重试耗尽，放弃本次压缩"));
+				lastFailure = {
+					reason: `摘要流以 ${String(finish.kind)} 结束（非正常完成）`,
+					...diagnosticSessionId === void 0 ? {} : { diagnosticSessionId }
+				};
+				logger.warn(`摘要未完成（第 ${attempt}/${maxAttempts} 次，${lastFailure.reason}，子会话 ${diagnosticSessionId ?? "未落盘"}）` + (attempt < maxAttempts ? "，将重试" : "，重试耗尽，放弃本次压缩"));
 				continue;
 			}
 			if ("error" in extracted) {
-				lastFailure = { reason: extracted.error };
-				logger.warn(`摘要输出未通过校验（第 ${attempt}/${maxAttempts} 次，${extracted.error}）` + (attempt < maxAttempts ? "，将重试" : "，重试耗尽，放弃本次压缩"));
+				lastFailure = {
+					reason: extracted.error,
+					...diagnosticSessionId === void 0 ? {} : { diagnosticSessionId }
+				};
+				logger.warn(`摘要输出未通过校验（第 ${attempt}/${maxAttempts} 次，${extracted.error}，子会话 ${diagnosticSessionId ?? "未落盘"}）` + (attempt < maxAttempts ? "，将重试" : "，重试耗尽，放弃本次压缩"));
 				continue;
 			}
 			const text = extracted.log;
 			const usage = collector.usage;
-			logger.info(`摘要调用成功（第 ${attempt}/${maxAttempts} 次，输出 ${text.length} 字符` + (usage === void 0 ? "" : `，input ${String(usage.inputTokens ?? "?")} / output ${String(usage.outputTokens ?? "?")} tokens`) + "）");
+			logger.info(`摘要调用成功（第 ${attempt}/${maxAttempts} 次，输出 ${text.length} 字符` + (usage === void 0 ? "" : `，input ${String(usage.inputTokens ?? "?")} / output ${String(usage.outputTokens ?? "?")} tokens`) + `，子会话 ${diagnosticSessionId ?? "未落盘"}）`);
 			return {
 				ok: true,
 				text,
 				attemptCount: attempt,
-				...usage === void 0 ? {} : { usage }
+				...usage === void 0 ? {} : { usage },
+				...diagnosticSessionId === void 0 ? {} : { diagnosticSessionId }
 			};
 		} catch (error) {
-			if (!streamCompleted) attempts.push({
-				prompt,
-				rawOutput: collector.text
-			});
+			const diagnosticSessionId = streamCompleted ? void 0 : await logAttempt();
 			const message = error instanceof Error ? error.message : String(error);
 			if (isRateLimitError(message)) {
 				noteRateLimit();
 				logger.warn(`摘要调用触发限流（429，第 ${attempt}/${maxAttempts} 次），下一次请求前至少等待 ${rateLimitWaitMs}ms`);
 			}
-			lastFailure = { error: message };
-			logger.warn(`摘要调用失败（第 ${attempt}/${maxAttempts} 次，${message}）` + (attempt < maxAttempts ? "，将重试" : "，重试耗尽，放弃本次压缩"));
+			lastFailure = {
+				error: message,
+				...diagnosticSessionId === void 0 ? {} : { diagnosticSessionId }
+			};
+			logger.warn(`摘要调用失败（第 ${attempt}/${maxAttempts} 次，${message}，子会话 ${diagnosticSessionId ?? "未落盘"}）` + (attempt < maxAttempts ? "，将重试" : "，重试耗尽，放弃本次压缩"));
 		}
 	}
 	const lastError = lastFailure.error ?? lastFailure.reason ?? "未知原因";
 	logger.warn(`摘要调用最终失败（已尝试 ${maxAttempts} 次，最后错误：${lastError}），拒绝放行本轮 step`);
-	return await finishFailure(lastError, false);
+	return {
+		ok: false,
+		error: lastError,
+		aborted: false,
+		...lastFailure.diagnosticSessionId === void 0 ? {} : { diagnosticSessionId: lastFailure.diagnosticSessionId }
+	};
 }
 //#endregion
 //#region src/compress.ts
@@ -8128,15 +8206,17 @@ async function runSummarySubagent(ctx, agent, instruction, contextText, maxToken
 * 导出 estimateTextTokens / isPairBalancedAfter / computeCompressRange / historySection /
 * findObservePending / reflectPass / observePass / maybeCompress。
 *
-* - 反思：全部 <history> 块 token 合计 ≥ reflectThresholdTokens 时，摘要合并为一条
+* - 反思：全部 <history> 块 token 合计 ≥ reflectThresholdTokens 时，块内文拼合为单个
+*   <history> 块输入摘要，合并为一条
 * - 观察（触发 → 待定 → 延迟执行）：净压力（上下文压力 − 已压缩块 token 合计 − 系统提示词
 *   token 估算 − 工具定义 token 估算）首次 ≥ observeThresholdTokens 时记录待定标记
 *   （触发点 = 当时的最后一条完整消息 index），本次不压缩；待定后新增完整消息数 ≥
 *   tailMessageCount 时，把压缩边界至触发点的全部消息摘要为新 <history> 块并精确替换
 *   被压缩区间（旧块保留），等待期间的新消息成为下一轮未压缩尾部（延迟窗口内压力允许
 *   短暂超阈值）；tailMessageCount=0 时触发当轮直接执行（不落待定标记）
-* - 待定标记以 log-only om/observe-pending / om/observe-invalidate 事件持久化在会话
-*   日志中（重启后从日志恢复）；摘要失败保留待定，下个 pre-step 直接重试执行
+* - 待定标记以 log-only om 信封事件（借用 feedback/record，kind 为 om/observe-pending /
+*   om/observe-invalidate，见 om-event.ts）持久化在会话日志中（重启后从日志恢复）；
+*   摘要失败保留待定，下个 pre-step 直接重试执行
 * - 两级在 pre-step 阻塞串行执行（先反思后观察）；仅主会话生效；omEnabled=false 关闭
 * - 压缩边界：最后一个合法 <history> 块之后的消息视为未压缩，其前不重复压缩
 * - 摘要尝试全部耗尽时 pass 返回失败结果（携带最后一次尝试的实际报错），压缩流程
@@ -8144,7 +8224,8 @@ async function runSummarySubagent(ctx, agent, instruction, contextText, maxToken
 * - 提交走宿主 compaction/* 生命周期事件（start 带 phase → summary → 替换消息 → end），
 *   失败补 end(error，实际报错 + 诊断子会话 sessionId)；替换消息 source 标记插件标识供 UI 认领
 * - 挂载失败类问题（systemPrompt/tokenMeter 服务异常）始终 console 到外部进程，并追加
-*   log-only om/warning 事件（客户端渲染功能降级警告行，每会话同一问题至多一次）；
+*   log-only om 警告事件（借用 feedback/record，客户端渲染功能降级警告行，每会话同一
+*   问题至多一次）；
 *   辅助估算的普通运行时报错仅记日志。降级与报错都不阻塞压缩（tokenMeter 压力数据
 *   缺失时本轮跳过观察）
 */
@@ -8192,6 +8273,14 @@ function historyInnerText(text) {
 	return text.slice(gt + 1, close).trim();
 }
 /**
+* 反思输入拼合：全部块内文（historyInnerText 去掉开标签属性，块首格式说明注释剥离）
+* 按序合并进单个 <history> 块。正文条目内出现的属性/注释同名串原样保留。
+*/
+function mergeHistoryBlocks(blocks) {
+	const inner = blocks.map((block) => stripLeadingFormatNote(historyInnerText(block.text))).join("\n");
+	return `<${HISTORY_TAG}>\n${inner}\n</${HISTORY_TAG}>`;
+}
+/**
 * 判定表层节点 seq 之后的切点是否 tool-call/result 配对平衡：按表层顺序折叠未闭合的
 * 工具调用数，处理到 seq 后计数为 0 即平衡（防止把 tool-call 与其结果切到两侧）。
 */
@@ -8266,40 +8355,35 @@ function historySection(session) {
 	};
 }
 /**
-* 查找当前活跃的观察压缩待定标记：按日志顺序取最后一条 om/observe-pending，其后须无
-* 引用它的 om/observe-invalidate（已失效），且其后的压缩边界 seq 不大于标记 seq（边界
-* 后移说明标记期间已发生过压缩，标记过期——兜底「执行成功但失效标记未写出」的崩溃
-* 窗口）。无活跃标记返回 undefined。
+* 查找当前活跃的观察压缩待定标记：按日志顺序取最后一条 om/observe-pending 信封事件，
+* 其后须无引用它的 om/observe-invalidate（已失效），且其后的压缩边界 seq 不大于标记
+* seq（边界后移说明标记期间已发生过压缩，标记过期——兜底「执行成功但失效标记未写出」
+* 的崩溃窗口）。无活跃标记返回 undefined。
 */
 function findObservePending(session) {
 	let pending;
 	for (let seq = 0; seq < session.events.length; seq += 1) {
 		const event = session.events[seq];
 		if (!event) continue;
-		if (event.type === "om/observe-pending") pending = {
+		const om = readOmEvent(event);
+		if (om?.kind === "om/observe-pending") pending = {
 			seq,
-			triggerMessageIndex: event.data.triggerMessageIndex
+			triggerMessageIndex: om.data.triggerMessageIndex
 		};
-		else if (event.type === "om/observe-invalidate" && pending !== void 0 && event.data.pendingSeq === pending.seq) pending = void 0;
+		else if (om?.kind === "om/observe-invalidate" && pending !== void 0 && om.data.pendingSeq === pending.seq) pending = void 0;
 	}
 	if (pending === void 0) return void 0;
 	const { boundarySeq } = historySection(session);
 	if (boundarySeq !== void 0 && boundarySeq > pending.seq) return void 0;
 	return pending;
 }
-/** 追加观察压缩待定标记（log-only）：记录触发点完整消息 index，返回事件 seq。 */
+/** 追加观察压缩待定标记（log-only om 信封事件）：记录触发点完整消息 index，返回事件 seq。 */
 function appendObservePending(session, triggerMessageIndex) {
-	return session.append("om/observe-pending", {
-		key: "observe",
-		triggerMessageIndex
-	}).seq;
+	return appendOmEvent(session, "om/observe-pending", { triggerMessageIndex });
 }
-/** 追加观察压缩待定失效标记（log-only）：声明指定 pending 已失效，返回事件 seq。 */
+/** 追加观察压缩待定失效标记（log-only om 信封事件）：声明指定 pending 已失效，返回事件 seq。 */
 function appendObserveInvalidate(session, pendingSeq) {
-	return session.append("om/observe-invalidate", {
-		key: "observe",
-		pendingSeq
-	}).seq;
+	return appendOmEvent(session, "om/observe-invalidate", { pendingSeq });
 }
 /** 当前打开中的 turn 号（最近 turn/start 且未被 turn/end 关闭）；无则 null。 */
 function openTurnOf(session) {
@@ -8346,7 +8430,7 @@ function appendCompactionSummary(session, data) {
 }
 /**
 * 追加 compaction/end（log-only，结束生命周期；error 记录失败原因，
-* diagnosticSessionId 记录最终失败时的诊断子会话 id）。
+* diagnosticSessionId 记录最后一次摘要尝试（无论成功或失败）的诊断子会话 id）。
 */
 function appendCompactionEnd(session, lifecycle, error, diagnosticSessionId) {
 	const payload = {
@@ -8378,9 +8462,9 @@ function appendHistoryMessage(session, content, sourceEventSeqs, surfaceOp, comp
 	});
 }
 /**
-* 反思：全部 <history> 块 token 合计 ≥ reflectThresholdTokens 时，摘要调用把整个块
-* 区段合并替换为一条更紧凑的摘要。失败不产生部分替换；摘要尝试全部耗尽返回
-* 失败结果（error = 最后一次尝试的实际报错/具体问题）。
+* 反思：全部 <history> 块 token 合计 ≥ reflectThresholdTokens 时，全部块内文拼合为
+* 单个 <history> 块送入摘要调用，整个块区段合并替换为一条更紧凑的摘要。失败不产生
+* 部分替换；摘要尝试全部耗尽返回失败结果（error = 最后一次尝试的实际报错/具体问题）。
 */
 async function reflectPass(ctx, agent, config, target, signal) {
 	const session = agent.session;
@@ -8406,8 +8490,8 @@ async function reflectPass(ctx, agent, config, target, signal) {
 		return { failed: false };
 	}
 	const blockSeqs = blocks.map((block) => block.seq);
-	const instruction = buildHistoryPrompt();
-	const contextText = blocks.map((block) => block.text).join("\n");
+	const instruction = buildHistoryPrompt(config.compressSkipReasoning);
+	const contextText = mergeHistoryBlocks(blocks);
 	const expectedEnd = reflectExpectedEnd(contextText);
 	const lifecycle = {
 		compactionId: newCompactionId(),
@@ -8468,7 +8552,7 @@ async function reflectPass(ctx, agent, config, target, signal) {
 			end: last.seq
 		}, lifecycle.compactionId);
 		logger.step("反思提交：追加 compaction/end");
-		appendCompactionEnd(session, lifecycle);
+		appendCompactionEnd(session, lifecycle, void 0, summaryResult.diagnosticSessionId);
 		logger.info(`反思完成（摘要 ${tokens} tokens ≥ 阈值 ${threshold}，合并 ${blocks.length} 个块为一条）`);
 		return { failed: false };
 	} catch (error) {
@@ -8484,7 +8568,7 @@ async function reflectPass(ctx, agent, config, target, signal) {
 * 估算系统提示词 tokens：按 agent 作用域组装并渲染系统提示词，按长度/4 启发式计。
 * systemPrompt 服务经 ctx.get 容错读取（ctx 属性访问在服务未挂载时抛错）；服务缺失
 * 或组装/渲染失败时按 0 计——只影响观察触发时机（偏早触发），不阻塞压缩。
-* 服务缺失属挂载失败：console 外部 + om/warning 事件每会话报告一次；组装失败仅记日志。
+* 服务缺失属挂载失败：console 外部 + om 警告事件每会话报告一次；组装失败仅记日志。
 */
 async function estimateSystemPromptTokens(ctx, agent, logger, signal) {
 	const systemPrompt = ctx.get("systemPrompt");
@@ -8524,7 +8608,7 @@ function estimateToolsTokens(session, logger) {
 }
 /**
 * 读取上下文压力 tokens（tokenMeter.measure 的 totalTokens）。tokenMeter 调用异常时
-* 记日志并报告降级（console 外部 + om/warning 每会话一次），返回 undefined——本轮
+* 记日志并报告降级（console 外部 + om 警告事件每会话一次），返回 undefined——本轮
 * 跳过观察压缩（无压力数据不触发），不阻塞 turn。
 */
 function measurePressureTokens(ctx, session, logger) {
@@ -8631,8 +8715,8 @@ async function observePass(ctx, agent, config, waitCount, target, signal) {
 	const startIndex = inRangeCms[0]?.index ?? 0;
 	const endIndex = inRangeCms[inRangeCms.length - 1]?.index ?? startIndex;
 	logger.step(`观察：保留旧块 ${blocks.length} 条，替换 [${replaceStart}..${range.end}]（${replaceSeqs.length} 个表层节点，压缩至${triggerNote}），新消息 index ${startIndex}..${endIndex}`);
-	const instruction = buildHistoryPrompt();
-	const contextText = renderMessages(session, replaceSeqs);
+	const instruction = buildHistoryPrompt(config.compressSkipReasoning);
+	const contextText = renderMessages(session, replaceSeqs, config.compressSkipReasoning);
 	const lifecycle = {
 		compactionId: newCompactionId(),
 		turn: openTurnOf(session)
@@ -8710,7 +8794,7 @@ async function observePass(ctx, agent, config, waitCount, target, signal) {
 			end: range.end
 		}, lifecycle.compactionId);
 		logger.step("观察提交：追加 compaction/end");
-		appendCompactionEnd(session, lifecycle);
+		appendCompactionEnd(session, lifecycle, void 0, summaryResult.diagnosticSessionId);
 		clearPending();
 		logger.info(`观察压缩完成（替换 ${replaceSeqs.length} 个表层节点，约 ${shadowedTokenCount} tokens，压缩至${triggerNote}）`);
 		return { failed: false };
@@ -8968,6 +9052,7 @@ const DEFAULT_CONFIG = Object.freeze({
 	rateLimitWaitMs: 6e4,
 	tailMessageCount: 5,
 	compressRetryCount: 5,
+	compressSkipReasoning: true,
 	omEnabled: true,
 	debug: false,
 	recallEnabled: true,
@@ -9009,6 +9094,7 @@ function resolveConfig(raw) {
 		if (integer && !Number.isInteger(value)) continue;
 		config[key] = value;
 	}
+	config.compressSkipReasoning = resolveBoolean(input.compressSkipReasoning, true);
 	config.omEnabled = resolveBoolean(input.omEnabled, true);
 	config.debug = resolveBoolean(input.debug, process.env.NODE_ENV !== "production");
 	config.recallEnabled = resolveBoolean(input.recallEnabled, true);