dsh-plugin-om 0.0.25 → 0.0.27

package/dist/index.mjs

@@ -1,5 +1,7 @@
 import { scopeOf } from "@deepseek-ai/dsh-scope";
 import { renderPrompt } from "@deepseek-ai/dsh-system-prompt";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { SUBAGENT_DESCRIPTOR_VERSION } from "@deepseek-ai/dsh-subagent";
 import { copyFileSync, existsSync, mkdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
@@ -155,6 +157,11 @@ function routedTarget(session) {
 * assistant（模型输出文本）、toolcall（单个工具调用及其结果，result 按 callId 匹配并入）。
 * index 从 0 起、按日志顺序递增、只追加不重排（压缩后旧摘要条目引用的 index 仍然有效）。
 */
+/** 查找 seq 在表层节点序列中的下标（不在则返回 -1）。 */
+function surfaceIndexOf(nodes, seq) {
+	for (let i = 0; i < nodes.length; i += 1) if (nodes[i] === seq) return i;
+	return -1;
+}
 /**
 * 完整消息索引：按日志顺序把消息事件折叠为完整消息序列（四类，见文件头）。
 * 工具调用结果按 source.callId 匹配其 tool-call 并入该条；未匹配的 result 独立成条（防御）。
@@ -7427,7 +7434,7 @@ var require_dom_parser = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.onWarningStopParsing = onWarningStopParsing;
 }));
 //#endregion
-//#region src/rate-limit.ts
+//#region src/compaction-log.ts
 var import_lib = (/* @__PURE__ */ __commonJSMin(((exports) => {
 	var conventions = require_conventions();
 	exports.assign = conventions.assign;
@@ -7467,6 +7474,91 @@ var import_lib = (/* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.onErrorStopParsing = domParser.onErrorStopParsing;
 	exports.onWarningStopParsing = domParser.onWarningStopParsing;
 })))();
+/** 诊断子会话的 descriptor provider（宿主子代理列表识别用）。 */
+const COMPACTION_LOG_PROVIDER = "om-compaction-log";
+/** 压缩 pass 的中文标签（诊断子会话 label 用；未知阶段回落「压缩」）。 */
+function phaseLabel(phase) {
+	if (phase === "observe") return "观察";
+	if (phase === "reflect") return "反思";
+	return "压缩";
+}
+/** 诊断子会话 label：含压缩阶段与尝试序号。 */
+function compactionLogLabel(phase, attemptNo) {
+	return `OM 压缩日志（${phaseLabel(phase)} · 第 ${attemptNo} 次尝试）`;
+}
+/** 追加一次尝试的「提示词 → 原始输出」消息组（surfaceOp append；id 为品牌类型，session.append 运行时校验）。 */
+function appendAttemptMessages(child, attempt, step, target) {
+	const userMessage = {
+		id: uuid(),
+		role: "user",
+		content: [{
+			type: "text",
+			text: attempt.prompt
+		}],
+		source: {
+			kind: "plugin",
+			plugin: PLUGIN_LABEL
+		}
+	};
+	child.append("user/message", userMessage, { surfaceOp: "append" });
+	const assistantMessage = {
+		id: uuid(),
+		role: "assistant",
+		content: [{
+			type: "text",
+			text: attempt.rawOutput
+		}],
+		source: {
+			kind: "model",
+			provider: target.provider,
+			model: target.model
+		}
+	};
+	child.append("assistant/message", {
+		turn: 0,
+		step,
+		message: assistantMessage
+	}, { surfaceOp: "append" });
+}
+/**
+* 把一次摘要尝试落盘为诊断子会话：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 recordCompactionAttempt(ctx, parentSession, options) {
+	const logger = makeLogger(ctx, options.debug);
+	try {
+		const header = parentSession.header;
+		const child = ctx.sessions.create(SessionId(`om-compaction-log-${uuid()}`), { meta: {
+			...header.cwd === void 0 ? {} : { cwd: header.cwd },
+			parentSession: parentSession.id,
+			origin: "subagent",
+			delegationDepth: (header.delegationDepth ?? 0) + 1
+		} });
+		child.append("subagent/descriptor", {
+			version: SUBAGENT_DESCRIPTOR_VERSION,
+			mode: "one-shot",
+			provider: COMPACTION_LOG_PROVIDER,
+			label: compactionLogLabel(options.phase, options.attemptNo)
+		});
+		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}`);
+		}
+		return child.id;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		logger.warn(`压缩日志子会话落盘失败（第 ${options.attemptNo} 次尝试）: ${message}`);
+		return;
+	}
+}
+//#endregion
+//#region src/rate-limit.ts
 /**
 * 全局限流门（插件进程级共享状态）：任一摘要请求遇 429 后进入冷却期，
 * 此后所有摘要请求发出前先等待到「最近一次 429 + rateLimitWaitMs」之后。
@@ -7524,8 +7616,10 @@ async function gateRateLimit(waitMs, signal) {
 /**
 * 共享压缩提示词（观察/反思同一套）：定义 history 块（模型消息 + index 的表达形式）、
 * 完整消息定义、压缩要求、输出格式与数据源说明。
+* skipReasoning=true（默认，与 compressSkipReasoning 默认一致）时压缩输入不含
+* <reasoning> 参考条目，提示词相应省略 <reasoning> 的说明两行。
 */
-function buildHistoryPrompt() {
+function buildHistoryPrompt(skipReasoning = true) {
 	return [
 		"压缩 <history> 消息记录。你应当输出**单个**合法的 <history> 块。",
 		"",
@@ -7533,17 +7627,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=\"\"> 单独呈现，内容不受限制。",
-		"- 加载的 skill 属于关键信息：应当产出独立块且不过多省略。",
-		"- 条目按 index 顺序覆盖本次压缩的全部完整消息：index/start/end 必须连续（区间内 index 连续、相邻条目相接），不跳号、不重叠、不遗漏。",
+		...skipReasoning ? [] : ["- <reasoning> 只作参考，输出产物中不包含 <reasoning> 块。"],
+		"- 将具有关联性的 <assistant> 消息按内在逻辑连贯性划分为连续模块，聚合为 <assistant start=\"\" end=\"\"> 块",
+		"- 单条重要的完整消息以 <assistant index=\"\"> 单独呈现",
+		"- 压缩后的 <assistant> 块内，应当描述**行为逻辑**，强调关键的**结论、产出和任务**；涉及到的具体文件保留完整路径",
+		"- 加载的 skill 属于**关键信息**：应当产出独立块且不过多省略。",
+		"- 压缩后的消息，区间边界与输入的消息必须完全相同，内部 index/start/end 必须连续，相邻区间的左右界必须相邻，",
 		"",
 		"【摘要粒度】",
 		"- 越往后越细：靠近末尾（最近）的完整消息保留更多细节（关键文件、改动与结论），开头（较早）的完整消息可适当从简。",
@@ -7600,14 +7695,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;
@@ -7636,7 +7732,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");
@@ -7718,6 +7814,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);
@@ -7789,7 +7893,7 @@ function parseHistoryBlock(xml) {
 	};
 }
 /**
-* 解析文本中全部 <history> 块内的条目（反思输入为多个块拼接：逐块解析提取）。
+* 解析文本中全部 <history> 块内的条目（逐块解析提取，兼容多块拼接文本）。
 * 非法块跳过；仅提取不校验顺序（连续性由 historyContinuity 校验）。
 */
 function parseHistoryEntries(text) {
@@ -7934,9 +8038,11 @@ function extractSummaryDetailed(raw, expected) {
 }
 /**
 * 直连 LLM 执行一次摘要（观察或反思），返回文本与可选 token usage。
-* 失败（抛异常 / 空输出 / 非 stop 结束 / 校验不通过）均记录日志并重试，每次尝试的
-* 结果或报错始终写入日志（成功 info / 失败 warn，不受 debug 影响）；全部尝试耗尽
-* 返回失败结果（携带最后一次尝试的实际报错/具体问题，不产生任何日志变更）。
+* 每次实际发出的 LLM 调用（无论成功、校验不通过、非 stop 结束还是异常）完成后，
+* 立即把该次尝试的完整提示词与模型原始输出原样落盘为诊断子会话（phase 标注观察
+* 或反思），子会话 id 写入该次尝试的主会话日志；请求发出前被中止的尝试（无实际
+* 调用）不落盘。失败（抛异常 / 空输出 / 非 stop 结束 / 校验不通过）记录日志并重试；
+* 全部尝试耗尽返回失败结果（携带最后一次尝试的实际报错/具体问题与其诊断子会话 id）。
 * signal 中止（含限流等待被中止）立即放弃并标记 aborted。每次请求发出前先过全局
 * 限流等待门。
 */
@@ -7951,7 +8057,8 @@ async function runSummarySubagent(ctx, agent, instruction, contextText, maxToken
 			return {
 				ok: false,
 				error: COMPACTION_ABORTED_ERROR,
-				aborted: true
+				aborted: true,
+				...lastFailure.diagnosticSessionId === void 0 ? {} : { diagnosticSessionId: lastFailure.diagnosticSessionId }
 			};
 		}
 		const rateLimitWaitMs = options?.rateLimitWaitMs ?? 6e4;
@@ -7960,43 +8067,70 @@ async function runSummarySubagent(ctx, agent, instruction, contextText, maxToken
 			return {
 				ok: false,
 				error: COMPACTION_ABORTED_ERROR,
-				aborted: true
+				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);
-			const collector = new StreamCollector();
 			for await (const chunk of ctx.llm.stream(requestOptions)) collector.push(chunk);
+			streamCompleted = true;
+			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) {
+			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 ?? "未知原因";
@@ -8004,7 +8138,8 @@ async function runSummarySubagent(ctx, agent, instruction, contextText, maxToken
 	return {
 		ok: false,
 		error: lastError,
-		aborted: false
+		aborted: false,
+		...lastFailure.diagnosticSessionId === void 0 ? {} : { diagnosticSessionId: lastFailure.diagnosticSessionId }
 	};
 }
 //#endregion
@@ -8012,18 +8147,24 @@ async function runSummarySubagent(ctx, agent, instruction, contextText, maxToken
 /**
 * 两级自动压缩（观察/反思）与 compaction 生命周期提交。
 * 导出 estimateTextTokens / isPairBalancedAfter / computeCompressRange / historySection /
-* reflectPass / observePass / maybeCompress。
+* findObservePending / reflectPass / observePass / maybeCompress。
 *
-* - 反思：全部 <history> 块 token 合计 ≥ reflectThresholdTokens 时，摘要合并为一条
-* - 观察：净压力（上下文压力 − 已压缩块 token 合计 − 系统提示词 token 估算 − 工具定义
-*   token 估算）≥ observeThresholdTokens 时，
-*   摘要未压缩消息为新 <history> 块并精确替换被压缩区间（旧块保留）
+* - 反思：全部 <history> 块 token 合计 ≥ reflectThresholdTokens 时，块内文拼合为单个
+*   <history> 块输入摘要，合并为一条
+* - 观察（触发 → 待定 → 延迟执行）：净压力（上下文压力 − 已压缩块 token 合计 − 系统提示词
+*   token 估算 − 工具定义 token 估算）首次 ≥ observeThresholdTokens 时记录待定标记
+*   （触发点 = 当时的最后一条完整消息 index），本次不压缩；待定后新增完整消息数 ≥
+*   tailMessageCount 时，把压缩边界至触发点的全部消息摘要为新 <history> 块并精确替换
+*   被压缩区间（旧块保留），等待期间的新消息成为下一轮未压缩尾部（延迟窗口内压力允许
+*   短暂超阈值）；tailMessageCount=0 时触发当轮直接执行（不落待定标记）
+* - 待定标记以 log-only om/observe-pending / om/observe-invalidate 事件持久化在会话
+*   日志中（重启后从日志恢复）；摘要失败保留待定，下个 pre-step 直接重试执行
 * - 两级在 pre-step 阻塞串行执行（先反思后观察）；仅主会话生效；omEnabled=false 关闭
 * - 压缩边界：最后一个合法 <history> 块之后的消息视为未压缩，其前不重复压缩
 * - 摘要尝试全部耗尽时 pass 返回失败结果（携带最后一次尝试的实际报错），压缩流程
 *   向上传播，pre-step 据此拒绝本 step 中断当前 turn；signal 中止标记 aborted（不中断）
 * - 提交走宿主 compaction/* 生命周期事件（start 带 phase → summary → 替换消息 → end），
-*   失败补 end(error，实际报错)；替换消息 source 标记插件标识供 UI 认领
+*   失败补 end(error，实际报错 + 诊断子会话 sessionId)；替换消息 source 标记插件标识供 UI 认领
 * - 挂载失败类问题（systemPrompt/tokenMeter 服务异常）始终 console 到外部进程，并追加
 *   log-only om/warning 事件（客户端渲染功能降级警告行，每会话同一问题至多一次）；
 *   辅助估算的普通运行时报错仅记日志。降级与报错都不阻塞压缩（tokenMeter 压力数据
@@ -8073,6 +8214,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 与其结果切到两侧）。
 */
@@ -8087,17 +8236,26 @@ function isPairBalancedAfter(session, seq) {
 	return false;
 }
 /**
-* 观察压缩区间：压缩边界后的首个表层节点 → 表层长度-1-tailCount（尾部保留 tailCount
-* 条不压缩）；区间终点回退到 tool-call/result 配对平衡点（不切段）。无可行区间返回
-* undefined。返回区间起止表层 seq 与被遮蔽 seq 列表。
+* 观察压缩区间：压缩边界后的首个表层节点 → 触发点完整消息（endMessageIndex）对应的
+* 表层终点（取该完整消息最后一个事件 seq 在表层中的位置）；区间终点回退到
+* tool-call/result 配对平衡点（不切段）。触发点完整消息不存在或其事件已不在表层
+* （被后续压缩遮蔽）时返回 undefined。返回区间起止表层 seq 与被遮蔽 seq 列表。
 */
-function computeCompressRange(session, tailCount) {
+function computeCompressRange(session, endMessageIndex) {
 	const surface = [...session.surface.nodes];
 	if (surface.length === 0) return void 0;
 	const { boundarySeq } = historySection(session);
 	const startIdx = boundarySeq === void 0 ? 0 : surface.indexOf(boundarySeq) + 1;
 	if (startIdx >= surface.length) return void 0;
-	let endIdx = surface.length - 1 - tailCount;
+	const target = indexCompleteMessages(session).find((cm) => cm.index === endMessageIndex);
+	if (target === void 0) return void 0;
+	let endIdx = -1;
+	for (let i = target.seqs.length - 1; i >= 0; i -= 1) {
+		const seq = target.seqs[i];
+		if (seq === void 0) continue;
+		endIdx = surfaceIndexOf(surface, seq);
+		if (endIdx !== -1) break;
+	}
 	if (endIdx < startIdx) return void 0;
 	while (endIdx >= startIdx) {
 		const node = surface[endIdx];
@@ -8137,6 +8295,42 @@ function historySection(session) {
 		boundarySeq
 	};
 }
+/**
+* 查找当前活跃的观察压缩待定标记：按日志顺序取最后一条 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 = {
+			seq,
+			triggerMessageIndex: event.data.triggerMessageIndex
+		};
+		else if (event.type === "om/observe-invalidate" && pending !== void 0 && event.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。 */
+function appendObservePending(session, triggerMessageIndex) {
+	return session.append("om/observe-pending", {
+		key: "observe",
+		triggerMessageIndex
+	}).seq;
+}
+/** 追加观察压缩待定失效标记（log-only）：声明指定 pending 已失效，返回事件 seq。 */
+function appendObserveInvalidate(session, pendingSeq) {
+	return session.append("om/observe-invalidate", {
+		key: "observe",
+		pendingSeq
+	}).seq;
+}
 /** 当前打开中的 turn 号（最近 turn/start 且未被 turn/end 关闭）；无则 null。 */
 function openTurnOf(session) {
 	let turn = null;
@@ -8180,13 +8374,18 @@ function appendCompactionSummary(session, data) {
 	};
 	return session.append("compaction/summary", payload).seq;
 }
-/** 追加 compaction/end（log-only，结束生命周期；error 记录失败原因）。 */
-function appendCompactionEnd(session, lifecycle, error) {
-	return session.append("compaction/end", {
+/**
+* 追加 compaction/end（log-only，结束生命周期；error 记录失败原因，
+* diagnosticSessionId 记录最后一次摘要尝试（无论成功或失败）的诊断子会话 id）。
+*/
+function appendCompactionEnd(session, lifecycle, error, diagnosticSessionId) {
+	const payload = {
 		compactionId: lifecycle.compactionId,
 		turn: lifecycle.turn,
-		...error === void 0 ? {} : { error }
-	}).seq;
+		...error === void 0 ? {} : { error },
+		...diagnosticSessionId === void 0 ? {} : { diagnosticSessionId }
+	};
+	return session.append("compaction/end", payload).seq;
 }
 /** 追加 <history> 压缩日志消息（surfaceOp 替换遮蔽区间，source 标记插件自产 + compactionId）。 */
 function appendHistoryMessage(session, content, sourceEventSeqs, surfaceOp, compactionId) {
@@ -8209,9 +8408,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;
@@ -8237,8 +8436,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(),
@@ -8258,17 +8457,19 @@ async function reflectPass(ctx, agent, config, target, signal) {
 			start: 0,
 			end: expectedEnd
 		},
-		rateLimitWaitMs: config.rateLimitWaitMs
+		rateLimitWaitMs: config.rateLimitWaitMs,
+		phase: "reflect"
 	});
 	if (!summaryResult.ok) {
-		logger.warn(`反思：摘要调用失败（${summaryResult.error}），追加 compaction/end(error)`);
+		logger.warn(`反思：摘要调用失败（${summaryResult.error}），诊断子会话 ${summaryResult.diagnosticSessionId ?? "未落盘"}，追加 compaction/end(error)`);
 		try {
-			appendCompactionEnd(session, lifecycle, summaryResult.error);
+			appendCompactionEnd(session, lifecycle, summaryResult.error, summaryResult.diagnosticSessionId);
 		} catch {}
 		return {
 			failed: true,
 			error: summaryResult.error,
-			aborted: summaryResult.aborted
+			aborted: summaryResult.aborted,
+			...summaryResult.diagnosticSessionId === void 0 ? {} : { diagnosticSessionId: summaryResult.diagnosticSessionId }
 		};
 	}
 	const report = summaryResult.text;
@@ -8297,7 +8498,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) {
@@ -8367,51 +8568,101 @@ function measurePressureTokens(ctx, session, logger) {
 	}
 }
 /**
-* 观察：净压力 tokens（上下文压力 − 已压缩 <history> 块 token 合计 − 系统提示词
-* token 估算 − 工具定义 token 估算）≥ observeThresholdTokens 时，摘要调用把未压缩
-* 消息压缩为观察日志，追加到旧摘要并替换被压缩消息区间。失败不产生部分替换；
-* 摘要尝试全部耗尽返回失败结果（error = 最后一次尝试的实际报错/具体问题）。
+* 观察（触发 → 待定 → 延迟执行）：无活跃待定标记时测净压力 tokens（上下文压力 − 已压缩
+* <history> 块 token 合计 − 系统提示词 token 估算 − 工具定义 token 估算），首次 ≥
+* observeThresholdTokens 时记录待定标记（触发点 = 当时的最后一条完整消息 index），本次
+* 不压缩（tailMessageCount=0 当轮直接执行，不落待定标记）；已有待定标记时按新增完整
+* 消息数 ≥ tailMessageCount 决定执行，压缩区间截至触发点（新增消息成为新未压缩尾部，
+* 延迟窗口内压力允许短暂超阈值）。执行成功（或无可行区间）后写待定失效标记；摘要
+* 失败保留待定，下个 pre-step 直接重试执行。摘要尝试全部耗尽返回失败结果
+* （error = 最后一次尝试的实际报错/具体问题）。
 */
-async function observePass(ctx, agent, config, tailCount, target, signal) {
+async function observePass(ctx, agent, config, waitCount, target, signal) {
 	const session = agent.session;
 	const logger = makeLogger(ctx, config.debug);
-	logger.step(`观察检查（观察阈值 ${config.observeThresholdTokens} tokens，尾部保留 ${tailCount} 条）`);
-	const threshold = config.observeThresholdTokens;
-	const pressureTokens = measurePressureTokens(ctx, session, logger);
-	if (pressureTokens === void 0) return { failed: false };
+	logger.step(`观察检查（观察阈值 ${config.observeThresholdTokens} tokens，延迟等待 ${waitCount} 条完整消息）`);
 	const { blocks } = historySection(session);
-	const historyTokens = blocks.reduce((total, block) => total + estimateTextTokens(block.text), 0);
-	const systemTokens = await estimateSystemPromptTokens(ctx, agent, logger, signal);
-	const toolsTokens = estimateToolsTokens(session, logger);
-	const netTokens = pressureTokens - historyTokens - systemTokens - toolsTokens;
-	if (netTokens < threshold) {
-		logger.step(`观察：净压力 ${netTokens} tokens（上下文压力 ${pressureTokens} − 已压缩块 ${historyTokens} − 系统提示词 ${systemTokens} − 工具定义 ${toolsTokens}）< 阈值 ${threshold}，跳过`);
-		return { failed: false };
+	const pending = findObservePending(session);
+	let triggerMessageIndex;
+	let pendingSeq;
+	let triggerNote;
+	if (pending === void 0) {
+		const threshold = config.observeThresholdTokens;
+		const pressureTokens = measurePressureTokens(ctx, session, logger);
+		if (pressureTokens === void 0) return { failed: false };
+		const historyTokens = blocks.reduce((total, block) => total + estimateTextTokens(block.text), 0);
+		const systemTokens = await estimateSystemPromptTokens(ctx, agent, logger, signal);
+		const toolsTokens = estimateToolsTokens(session, logger);
+		const netTokens = pressureTokens - historyTokens - systemTokens - toolsTokens;
+		if (netTokens < threshold) {
+			logger.step(`观察：净压力 ${netTokens} tokens（上下文压力 ${pressureTokens} − 已压缩块 ${historyTokens} − 系统提示词 ${systemTokens} − 工具定义 ${toolsTokens}）< 阈值 ${threshold}，跳过`);
+			return { failed: false };
+		}
+		logger.step(`观察：净压力 ${netTokens} tokens（上下文压力 ${pressureTokens} − 已压缩块 ${historyTokens} − 系统提示词 ${systemTokens} − 工具定义 ${toolsTokens}）≥ 阈值 ${threshold}，触发压缩`);
+		const lastMessageIndex = indexCompleteMessages(session).length - 1;
+		if (lastMessageIndex < 0) {
+			logger.step("观察：会话尚无完整消息，跳过");
+			return { failed: false };
+		}
+		triggerMessageIndex = lastMessageIndex;
+		if (waitCount > 0) {
+			try {
+				pendingSeq = appendObservePending(session, triggerMessageIndex);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				logger.warn(`观察：待定标记追加失败，本轮跳过（下轮重新评估）: ${message}`);
+				return { failed: false };
+			}
+			logger.step(`观察：记录待定标记（触发点完整消息 index ${triggerMessageIndex}），等待 ${waitCount} 条新完整消息后压缩`);
+			return { failed: false };
+		}
+		triggerNote = `触发点完整消息 index ${triggerMessageIndex}`;
+	} else {
+		const arrived = indexCompleteMessages(session).length - 1 - pending.triggerMessageIndex;
+		if (arrived < waitCount) {
+			logger.step(`观察：待定标记等待中（触发点完整消息 index ${pending.triggerMessageIndex}，新增 ${arrived}/${waitCount} 条），跳过`);
+			return { failed: false };
+		}
+		logger.step(`观察：待定标记延迟到期（触发点完整消息 index ${pending.triggerMessageIndex}，新增 ${arrived} ≥ ${waitCount} 条），执行压缩`);
+		triggerMessageIndex = pending.triggerMessageIndex;
+		pendingSeq = pending.seq;
+		triggerNote = `待定标记触发点完整消息 index ${pending.triggerMessageIndex}`;
 	}
-	logger.step(`观察：净压力 ${netTokens} tokens（上下文压力 ${pressureTokens} − 已压缩块 ${historyTokens} − 系统提示词 ${systemTokens} − 工具定义 ${toolsTokens}）≥ 阈值 ${threshold}，触发压缩`);
-	const range = computeCompressRange(session, tailCount);
+	const clearPending = () => {
+		if (pendingSeq === void 0) return;
+		try {
+			appendObserveInvalidate(session, pendingSeq);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			logger.warn(`观察：待定失效标记追加失败: ${message}`);
+		}
+	};
+	const range = computeCompressRange(session, triggerMessageIndex);
 	if (!range) {
-		logger.step("观察：无可行压缩区间（边界后消息过短或配对无法平衡），跳过");
+		logger.step("观察：无可行压缩区间（边界后无消息、触发点已被压缩或配对无法平衡），清除待定标记视为完成");
+		clearPending();
 		return { failed: false };
 	}
 	logger.step(`观察：压缩区间 [${range.start}..${range.end}]，遮蔽 ${range.shadowedSeqs.length} 个表层节点`);
 	const replaceSeqs = range.shadowedSeqs;
 	const replaceStart = replaceSeqs[0];
 	if (replaceStart === void 0) {
-		logger.step("观察：区间内无新消息（全部为压缩日志块），跳过");
+		logger.step("观察：区间内无新消息（全部为压缩日志块），清除待定标记视为完成");
+		clearPending();
 		return { failed: false };
 	}
 	const shadowedSet = new Set(replaceSeqs);
 	const inRangeCms = indexCompleteMessages(session).filter((cm) => cm.seqs.every((seq) => shadowedSet.has(seq)));
 	if (inRangeCms.length === 0) {
-		logger.step("观察：区间内无完整消息，跳过");
+		logger.step("观察：区间内无完整消息，清除待定标记视为完成");
+		clearPending();
 		return { failed: false };
 	}
 	const startIndex = inRangeCms[0]?.index ?? 0;
 	const endIndex = inRangeCms[inRangeCms.length - 1]?.index ?? startIndex;
-	logger.step(`观察：保留旧块 ${blocks.length} 条，替换新消息 [${replaceSeqs[0]}..${range.end}]（${replaceSeqs.length} 条），尾部保留 ${tailCount} 条（不压缩、不进日志），新消息 index ${startIndex}..${endIndex}`);
-	const instruction = buildHistoryPrompt();
-	const contextText = renderMessages(session, replaceSeqs);
+	logger.step(`观察：保留旧块 ${blocks.length} 条，替换 [${replaceStart}..${range.end}]（${replaceSeqs.length} 个表层节点，压缩至${triggerNote}），新消息 index ${startIndex}..${endIndex}`);
+	const instruction = buildHistoryPrompt(config.compressSkipReasoning);
+	const contextText = renderMessages(session, replaceSeqs, config.compressSkipReasoning);
 	const lifecycle = {
 		compactionId: newCompactionId(),
 		turn: openTurnOf(session)
@@ -8430,17 +8681,19 @@ async function observePass(ctx, agent, config, tailCount, target, signal) {
 			start: startIndex,
 			end: endIndex
 		},
-		rateLimitWaitMs: config.rateLimitWaitMs
+		rateLimitWaitMs: config.rateLimitWaitMs,
+		phase: "observe"
 	});
 	if (!summaryResult.ok) {
-		logger.warn(`观察：摘要调用失败（${summaryResult.error}），追加 compaction/end(error)`);
+		logger.warn(`观察：摘要调用失败（${summaryResult.error}），诊断子会话 ${summaryResult.diagnosticSessionId ?? "未落盘"}，追加 compaction/end(error)`);
 		try {
-			appendCompactionEnd(session, lifecycle, summaryResult.error);
+			appendCompactionEnd(session, lifecycle, summaryResult.error, summaryResult.diagnosticSessionId);
 		} catch {}
 		return {
 			failed: true,
 			error: summaryResult.error,
-			aborted: summaryResult.aborted
+			aborted: summaryResult.aborted,
+			...summaryResult.diagnosticSessionId === void 0 ? {} : { diagnosticSessionId: summaryResult.diagnosticSessionId }
 		};
 	}
 	const report = summaryResult.text;
@@ -8487,8 +8740,9 @@ async function observePass(ctx, agent, config, tailCount, target, signal) {
 			end: range.end
 		}, lifecycle.compactionId);
 		logger.step("观察提交：追加 compaction/end");
-		appendCompactionEnd(session, lifecycle);
-		logger.info(`观察压缩完成（净压力 ${netTokens} tokens（上下文压力 ${pressureTokens} − 已压缩块 ${historyTokens}）≥ 阈值 ${threshold}，替换 ${replaceSeqs.length} 个表层节点，约 ${shadowedTokenCount} tokens）`);
+		appendCompactionEnd(session, lifecycle, void 0, summaryResult.diagnosticSessionId);
+		clearPending();
+		logger.info(`观察压缩完成（替换 ${replaceSeqs.length} 个表层节点，约 ${shadowedTokenCount} tokens，压缩至${triggerNote}）`);
 		return { failed: false };
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
@@ -8517,7 +8771,7 @@ async function maybeCompress(ctx, agent, config, signal) {
 		return { failed: false };
 	}
 	logger.step(`会话路由：provider ${target.provider}，model ${target.model}`);
-	const tailCount = config.tailMessageCount;
+	const waitCount = config.tailMessageCount;
 	logger.step("反思 pass 开始");
 	const reflect = await reflectPass(ctx, agent, config, target, signal);
 	if (reflect.failed) {
@@ -8525,7 +8779,7 @@ async function maybeCompress(ctx, agent, config, signal) {
 		return reflect;
 	}
 	logger.step("反思 pass 结束，观察 pass 开始");
-	const observe = await observePass(ctx, agent, config, tailCount, target, signal);
+	const observe = await observePass(ctx, agent, config, waitCount, target, signal);
 	logger.step("观察 pass 结束，压缩流程完成");
 	return observe;
 }
@@ -8744,6 +8998,7 @@ const DEFAULT_CONFIG = Object.freeze({
 	rateLimitWaitMs: 6e4,
 	tailMessageCount: 5,
 	compressRetryCount: 5,
+	compressSkipReasoning: true,
 	omEnabled: true,
 	debug: false,
 	recallEnabled: true,
@@ -8785,6 +9040,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);
@@ -9146,8 +9402,9 @@ function buildSemanticRecallTool(options) {
 * dsh-plugin-om 入口（tsdown 打包入口）：导出 name / inject / apply。
 * apply 注册 recall / recall-semantic 工具，并接线 agent/pre-step 自动压缩
 * （先反思后观察，仅主会话生效）。压缩摘要尝试全部耗尽时拒绝本 step 中断当前
-* turn（signal 中止除外）。压缩与检索的实现见 compress.ts / recall.ts /
-* semantic-recall.ts。
+* turn（signal 中止除外），主会话日志记录失败原因与诊断子会话 sessionId（每次
+* 尝试的完整提示词与模型原始输出由 compaction-log.ts 落盘为诊断子会话）。压缩与
+* 检索的实现见 compress.ts / compaction-log.ts / recall.ts / semantic-recall.ts。
 */
 /** 插件名（Loader 识别入口的稳定标识）。 */
 const name = "dsh-plugin-om";
@@ -9187,7 +9444,8 @@ function apply(ctx, config) {
 			logger.warn(`pre-step 处理失败: ${error instanceof Error ? error.message : String(error)}`);
 		}
 		if (outcome.failed && !outcome.aborted) {
-			logger.warn(`上下文压缩失败，拒绝本 step 中断当前 turn：${outcome.error}`);
+			const diagnostic = outcome.diagnosticSessionId === void 0 ? "" : `（诊断子会话 ${outcome.diagnosticSessionId}）`;
+			logger.warn(`上下文压缩失败，拒绝本 step 中断当前 turn：${outcome.error}${diagnostic}`);
 			return { kind: "reject" };
 		}
 		return next();