dsh-plugin-om 0.0.28 → 0.0.30

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import { scopeOf } from "@deepseek-ai/dsh-scope";
 import { renderPrompt } from "@deepseek-ai/dsh-system-prompt";
+import { BlockAssembler, createToolResultMessage } from "@deepseek-ai/dsh-llm";
 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";
@@ -28,6 +29,8 @@ const HISTORY_TIP = "当前块是历史消息的压缩产物，不要复述";
 * 完整消息是摘要日志与 recall 共用的定位单位；首条 index 为 0，按会话顺序递增、全局稳定。
 */
 const COMPLETE_MESSAGE_DEFINITION = "`完整消息`指一条`用户消息`、`系统消息`、`模型输出文本`或`具有result的toolcall`；首条 index 为 0，按会话顺序递增。";
+/** 最终 <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"> 表示被压缩的系统消息，块中为空 -->`;
 /**
 * 压缩因 signal 中止而放弃时 compaction/end 的 error 标识（服务端写入、客户端过滤）：
 * 中止不是失败，客户端据此隐藏失败行（宿主不变量要求无 summary 的 end 必须带 error）。
@@ -39,109 +42,25 @@ 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);
-	}
-}
+//#region src/logger.ts
 /**
-* 解码一条会话事件为 om 私有事件：仅识别 feedback/record 中带 om 信封前缀的
-* text；前缀缺失、JSON 非法、kind 未知或载荷字段缺失时返回 undefined。
+* 插件日志门面：step 为步骤级（debug）日志，按配置开关过滤；info/warn 始终输出。
+* 导出 PluginLogger / makeLogger。
 */
-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;
+/** 构建插件日志门面：统一加 PLUGIN_LABEL 前缀，step 按 debug 开关过滤。 */
+function makeLogger(ctx, debug) {
 	return {
-		kind: omKind,
-		data: rest,
-		seq: event.seq
+		step(message) {
+			if (debug) ctx.logger.debug(`${PLUGIN_LABEL}: ${message}`);
+		},
+		info(message) {
+			ctx.logger.info(`${PLUGIN_LABEL}: ${message}`);
+		},
+		warn(message) {
+			ctx.logger.warn(`${PLUGIN_LABEL}: ${message}`);
+		}
 	};
 }
-/** 编码一条 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 警告事件（借用 feedback/record 的 om 信封，
-*   见 om-event.ts；客户端渲染为「功能降级」警告行）；
-*   同一会话同一问题只报告一次（按日志扫描去重，重启不重复）
-* - 报告动作自身绝不抛错：追加失败只记日志，不阻塞压缩
-* - 辅助函数的普通运行时报错（组装失败、请求头读取失败）不走本模块，仅记日志
-*/
-/** 各降级问题面向用户的简短说明（om/warning 信封载荷 message；客户端警告行直接展示）。 */
-const DEGRADE_PROBLEMS = {
-	"systemPrompt-missing": "系统提示词服务未挂载，上下文压力估算不扣除系统提示词 tokens（压缩触发会偏早）",
-	"tokenMeter-unavailable": "token 计量服务异常，上下文压力估算降级（可能跳过压缩或按 0 计）"
-};
-/**
-* 报告一次挂载失败类降级：console.warn 始终输出到宿主进程外部；同会话同问题首次
-* 出现时，向会话日志追加 log-only om 警告事件（客户端渲染警告行，每会话最多
-* 一次）并输出 logger.warn（避免每个 pre-step 重复刷日志）。
-* 日志扫描/事件追加失败只记日志，绝不抛错、不阻塞压缩。
-*/
-function reportDegrade(session, logger, problem) {
-	const message = DEGRADE_PROBLEMS[problem];
-	let first = true;
-	try {
-		first = !findOmEvents(session, "om/warning").some((om) => om.data.problem === problem);
-	} catch {}
-	if (!first) return;
-	console.warn(`${PLUGIN_LABEL}: ${message}`);
-	logger.warn(message);
-	try {
-		appendOmEvent(session, "om/warning", {
-			problem,
-			message
-		});
-	} catch (error) {
-		const text = error instanceof Error ? error.message : String(error);
-		logger.warn(`om 警告事件追加失败: ${text}`);
-	}
-}
 //#endregion
 //#region src/utils.ts
 /** 判断值是否为普通对象（非 null、非数组）。 */
@@ -202,204 +121,66 @@ function routedTarget(session) {
 	} catch {}
 }
 //#endregion
-//#region src/log-index.ts
-/**
-* 会话日志索引：完整消息索引与渲染。
-* 导出 indexCompleteMessages（完整消息四类折叠索引，recall 与摘要共用同一套编号）、
-* indexMessages / surfaceIndexOf / messageIdOfEvent（消息级定位辅助）、
-* collectImageRefs / renderCompleteMessageParts / renderCompleteMessage（完整消息渲染
-* 与图片附件收集）。事件日志仅追加（被遮蔽的事件仍可读，recall 依赖此性质）。
-*
-* 完整消息分四类：user（用户消息）、sys（系统消息，压缩日志中以 <sys> 空块表示）、
-* 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;
+//#region src/compaction-log.ts
+/** 诊断子会话的 descriptor provider（宿主子代理列表识别用）。 */
+const COMPACTION_LOG_PROVIDER = "om-compaction-log";
+/** 压缩 pass 的中文标签（会话记录 label 用；未知阶段回落「压缩」）。 */
+function phaseLabel(phase) {
+	if (phase === "observe") return "观察";
+	if (phase === "reflect") return "反思";
+	return "压缩";
 }
-/**
-* 完整消息索引：按日志顺序把消息事件折叠为完整消息序列（四类，见文件头）。
-* 工具调用结果按 source.callId 匹配其 tool-call 并入该条；未匹配的 result 独立成条（防御）。
-* 本插件自产消息不占位；压缩在 agent/pre-step 触发（call-result 完备），不存在未闭合调用。
-*/
-function indexCompleteMessages(session) {
-	const cms = [];
-	const pending = /* @__PURE__ */ new Map();
-	const events = session.events;
-	for (let seq = 0; seq < events.length; seq += 1) {
-		const event = events[seq];
-		if (!event) continue;
-		if (event.type === "user/message") {
-			const source = event.data.source;
-			if (isPluginOwnedSource(source)) continue;
-			if (source?.kind === "user") cms.push({
-				index: cms.length,
-				type: "user",
-				seqs: [seq]
-			});
-			else cms.push({
-				index: cms.length,
-				type: "sys",
-				seqs: [seq],
-				...source?.kind === void 0 ? {} : { kind: source.kind }
-			});
-		} else if (event.type === "assistant/message") {
-			const message = event.data.message;
-			if (!message || !Array.isArray(message.content)) continue;
-			let hasText = false;
-			for (const block of message.content) if (block.type === "text") {
-				hasText = true;
-				break;
-			}
-			if (hasText) cms.push({
-				index: cms.length,
-				type: "assistant",
-				seqs: [seq]
-			});
-			for (const block of message.content) {
-				if (block.type !== "tool-call") continue;
-				const callId = String(block.id ?? "");
-				const cm = {
-					index: cms.length,
-					type: "toolcall",
-					seqs: [seq],
-					...callId === "" ? {} : { callId }
-				};
-				cms.push(cm);
-				if (callId !== "") pending.set(callId, cm);
-			}
-		} else if (event.type === "tool/result") {
-			const source = event.data.message?.source;
-			const callId = String(source?.callId ?? "");
-			const cm = callId === "" ? void 0 : pending.get(callId);
-			if (cm) {
-				cm.seqs.push(seq);
-				pending.delete(callId);
-			} else cms.push({
-				index: cms.length,
-				type: "toolcall",
-				seqs: [seq],
-				...callId === "" ? {} : { callId }
-			});
-		}
-	}
-	return cms;
+/** 压缩会话记录 label：成功为会话记录、失败为失败日志，均含压缩阶段与轮数。 */
+function compressionRecordLabel(phase, rounds, success) {
+	return `OM 压缩${success ? "会话记录" : "失败日志"}（${phaseLabel(phase)} · ${rounds} 轮）`;
 }
 /**
-* 递归收集内容块中的图片附件元数据（recall 输出保留图片用）：
-* image 块按附件元数据收集（字段不全则忽略）；tool-result 块递归收集其 content。
+* 把一次压缩工具循环的完整会话消息组落盘为子会话：ctx.sessions.create 创建子会话
+* （header origin 'subagent'、parentSession 指向主会话、delegationDepth = 父 + 1、
+* cwd 继承主会话），追加 one-shot descriptor（provider om-compaction-log，label 含
+* 压缩阶段与轮数），逐消息原样追加（user 指令/提醒与 tool-result 为 user/message，
+* assistant 含 tool-call 块为 assistant/message），flush 持久化，返回子会话 id。
+* 成功与失败均调用；落盘自身绝不抛错，任何失败仅 logger.warn 并返回 undefined。
 */
-function collectImageRefs(content, out) {
-	if (!Array.isArray(content)) return;
-	for (const block of content) {
-		if (!isRecord(block)) continue;
-		if (block.type === "image") {
-			const a = block.attachment;
-			if (isRecord(a) && typeof a.attachmentId === "string" && a.attachmentId !== "" && typeof a.mediaType === "string" && typeof a.bytes === "number" && Number.isFinite(a.bytes) && typeof a.width === "number" && Number.isFinite(a.width) && typeof a.height === "number" && Number.isFinite(a.height)) out.push({
-				attachmentId: a.attachmentId,
-				mediaType: a.mediaType,
-				bytes: a.bytes,
-				width: a.width,
-				height: a.height,
-				...typeof a.name === "string" && a.name !== "" ? { name: a.name } : {}
-			});
-		} else if (block.type === "tool-result") collectImageRefs(block.content, out);
+async function recordCompressionSession(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: compressionRecordLabel(options.phase, options.rounds, options.success)
+		});
+		let step = 0;
+		for (const message of options.messages) {
+			step += 1;
+			if (message.role === "assistant") child.append("assistant/message", {
+				turn: 0,
+				step,
+				message
+			}, { surfaceOp: "append" });
+			else child.append("user/message", message, { surfaceOp: "append" });
+		}
+		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(`压缩会话记录子会话落盘失败: ${message}`);
+		return;
 	}
 }
-/**
-* 渲染一条完整消息为「文本 + 图片」（recall / recall-semantic 输出用）：
-* user/sys 取消息原文，assistant 取文本块，toolcall 为调用块 + 结果文本
-* （pruner 裁剪超大结果）；同时收集该条完整消息携带的图片附件（含 tool-result 嵌套，
-* pruner 裁剪掉的图片不收集）。
-*/
-function renderCompleteMessageParts(session, cm, pruner) {
-	const images = [];
-	if (cm.type === "user" || cm.type === "sys") {
-		const seq = cm.seqs[0];
-		const event = seq === void 0 ? void 0 : session.events[seq];
-		const message = event ? session.deriveEventMessage(event) : null;
-		if (message && Array.isArray(message.content)) collectImageRefs(message.content, images);
-		return {
-			text: message ? renderMessageText(message) : "",
-			images
-		};
-	}
-	if (cm.type === "assistant") {
-		const seq = cm.seqs[0];
-		const event = seq === void 0 ? void 0 : session.events[seq];
-		const message = event ? session.deriveEventMessage(event) : null;
-		if (!message || !Array.isArray(message.content)) return {
-			text: "",
-			images
-		};
-		collectImageRefs(message.content, images);
-		const texts = [];
-		for (const block of message.content) if (block.type === "text") texts.push(String(block.text));
-		return {
-			text: texts.join("\n"),
-			images
-		};
-	}
-	const parts = [];
-	const callSeq = cm.seqs[0];
-	const callEvent = callSeq === void 0 ? void 0 : session.events[callSeq];
-	if (callEvent?.type === "assistant/message") {
-		const message = session.deriveEventMessage(callEvent);
-		if (message && Array.isArray(message.content)) {
-			let call;
-			for (const block of message.content) if (block.type === "tool-call" && String(block.id ?? "") === (cm.callId ?? "")) {
-				call = block;
-				break;
-			}
-			if (call) parts.push(`[tool-call ${String(call.name ?? "")} id=${String(call.id ?? "")}]\n${safeJson(call.arguments)}`);
-		}
-	}
-	const resultSeq = cm.seqs[1];
-	const resultEvent = resultSeq === void 0 ? void 0 : session.events[resultSeq];
-	if (resultEvent?.type === "tool/result") {
-		let message = session.deriveEventMessage(resultEvent);
-		if (message && pruner?.pruneContent) {
-			const pruned = pruner.pruneContent(message.content);
-			if (pruned) message = {
-				...message,
-				content: pruned
-			};
-		}
-		if (message && Array.isArray(message.content)) collectImageRefs(message.content, images);
-		const text = message ? renderMessageText(message) : "";
-		if (text.trim() !== "") parts.push(`[result]\n${text}`);
-	}
-	return {
-		text: parts.join("\n"),
-		images
-	};
-}
-/** 渲染一条完整消息的文本（压缩输入与语义嵌入共用）：renderCompleteMessageParts 的纯文本投影。 */
-function renderCompleteMessage(session, cm, pruner) {
-	return renderCompleteMessageParts(session, cm, pruner).text;
-}
-//#endregion
-//#region src/logger.ts
-/**
-* 插件日志门面：step 为步骤级（debug）日志，按配置开关过滤；info/warn 始终输出。
-* 导出 PluginLogger / makeLogger。
-*/
-/** 构建插件日志门面：统一加 PLUGIN_LABEL 前缀，step 按 debug 开关过滤。 */
-function makeLogger(ctx, debug) {
-	return {
-		step(message) {
-			if (debug) ctx.logger.debug(`${PLUGIN_LABEL}: ${message}`);
-		},
-		info(message) {
-			ctx.logger.info(`${PLUGIN_LABEL}: ${message}`);
-		},
-		warn(message) {
-			ctx.logger.warn(`${PLUGIN_LABEL}: ${message}`);
-		}
-	};
-}
 //#endregion
 //#region node_modules/.pnpm/@xmldom+xmldom@0.9.11/node_modules/@xmldom/xmldom/lib/conventions.js
 var require_conventions = /* @__PURE__ */ __commonJSMin(((exports) => {
@@ -7491,7 +7272,7 @@ var require_dom_parser = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.onWarningStopParsing = onWarningStopParsing;
 }));
 //#endregion
-//#region src/compaction-log.ts
+//#region src/log-index.ts
 var import_lib = (/* @__PURE__ */ __commonJSMin(((exports) => {
 	var conventions = require_conventions();
 	exports.assign = conventions.assign;
@@ -7531,236 +7312,237 @@ 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（不影响压缩流程）。
+* 会话日志索引：完整消息索引与渲染。
+* 导出 indexCompleteMessages（完整消息四类折叠索引，recall 与摘要共用同一套编号）、
+* indexMessages / surfaceIndexOf / messageIdOfEvent（消息级定位辅助）、
+* collectImageRefs / renderCompleteMessageParts / renderCompleteMessage（完整消息渲染
+* 与图片附件收集）。事件日志仅追加（被遮蔽的事件仍可读，recall 依赖此性质）。
+*
+* 完整消息分四类：user（用户消息）、sys（系统消息，压缩日志中以 <sys> 空块表示）、
+* assistant（模型输出文本）、toolcall（单个工具调用及其结果，result 按 callId 匹配并入）。
+* index 从 0 起、按日志顺序递增、只追加不重排（压缩后旧摘要条目引用的 index 仍然有效）。
 */
-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;
-	}
+/** 查找 seq 在表层节点序列中的下标（不在则返回 -1）。 */
+function surfaceIndexOf(nodes, seq) {
+	for (let i = 0; i < nodes.length; i += 1) if (nodes[i] === seq) return i;
+	return -1;
 }
-//#endregion
-//#region src/rate-limit.ts
 /**
-* 全局限流门（插件进程级共享状态）：任一摘要请求遇 429 后进入冷却期，
-* 此后所有摘要请求发出前先等待到「最近一次 429 + rateLimitWaitMs」之后。
-* 等待期间 signal 中止则立即放弃；等待期间的新 429 顺延冷却期。
-* 导出 isRateLimitError / noteRateLimit / gateRateLimit / RATE_LIMIT_WAIT_MS_DEFAULT /
-* resetRateLimitGate。
+* 完整消息索引：按日志顺序把消息事件折叠为完整消息序列（四类，见文件头）。
+* 工具调用结果按 source.callId 匹配其 tool-call 并入该条；未匹配的 result 独立成条（防御）。
+* 本插件自产消息不占位；压缩在 agent/pre-step 触发（call-result 完备），不存在未闭合调用。
 */
-/** 最近一次 429 限流的时间戳（ms；null = 未遇过限流，门直接放行）。 */
-let lastRateLimitAt = null;
-/** 判定错误信息是否为 429 限流（匹配 429 或 rate limit，大小写不敏感）。 */
-function isRateLimitError(message) {
-	return /\b429\b|rate[\s_-]?limit/i.test(message);
-}
-/** 记录一次 429 限流：把冷却期起点更新为当前时间。 */
-function noteRateLimit() {
-	lastRateLimitAt = Date.now();
-}
-/** 可中止延时：等待满 ms 返回 true；等待期间 signal 中止返回 false。 */
-function delay(ms, signal) {
-	return new Promise((resolve) => {
-		if (signal?.aborted) {
-			resolve(false);
-			return;
+function indexCompleteMessages(session) {
+	const cms = [];
+	const pending = /* @__PURE__ */ new Map();
+	const events = session.events;
+	for (let seq = 0; seq < events.length; seq += 1) {
+		const event = events[seq];
+		if (!event) continue;
+		if (event.type === "user/message") {
+			const source = event.data.source;
+			if (isPluginOwnedSource(source)) continue;
+			if (source?.kind === "user") cms.push({
+				index: cms.length,
+				type: "user",
+				seqs: [seq]
+			});
+			else cms.push({
+				index: cms.length,
+				type: "sys",
+				seqs: [seq],
+				...source?.kind === void 0 ? {} : { kind: source.kind }
+			});
+		} else if (event.type === "assistant/message") {
+			const message = event.data.message;
+			if (!message || !Array.isArray(message.content)) continue;
+			let hasText = false;
+			for (const block of message.content) if (block.type === "text") {
+				hasText = true;
+				break;
+			}
+			if (hasText) cms.push({
+				index: cms.length,
+				type: "assistant",
+				seqs: [seq]
+			});
+			for (const block of message.content) {
+				if (block.type !== "tool-call") continue;
+				const callId = String(block.id ?? "");
+				const cm = {
+					index: cms.length,
+					type: "toolcall",
+					seqs: [seq],
+					...callId === "" ? {} : { callId }
+				};
+				cms.push(cm);
+				if (callId !== "") pending.set(callId, cm);
+			}
+		} else if (event.type === "tool/result") {
+			const source = event.data.message?.source;
+			const callId = String(source?.callId ?? "");
+			const cm = callId === "" ? void 0 : pending.get(callId);
+			if (cm) {
+				cm.seqs.push(seq);
+				pending.delete(callId);
+			} else cms.push({
+				index: cms.length,
+				type: "toolcall",
+				seqs: [seq],
+				...callId === "" ? {} : { callId }
+			});
 		}
-		const timer = setTimeout(() => {
-			cleanup();
-			resolve(true);
-		}, ms);
-		const onAbort = () => {
-			cleanup();
-			resolve(false);
-		};
-		const cleanup = () => {
-			clearTimeout(timer);
-			signal?.removeEventListener("abort", onAbort);
-		};
-		signal?.addEventListener("abort", onAbort, { once: true });
-	});
+	}
+	return cms;
 }
 /**
-* 限流等待门：处于 429 冷却期时等待到期限再放行（返回 true）；
-* 等待期间 signal 中止返回 false。未遇过限流或冷却期已过立即放行。waitMs ≤ 0 视为不限流。
+* 递归收集内容块中的图片附件元数据（recall 输出保留图片用）：
+* image 块按附件元数据收集（字段不全则忽略）；tool-result 块递归收集其 content。
 */
-async function gateRateLimit(waitMs, signal) {
-	if (waitMs <= 0) return true;
-	while (lastRateLimitAt !== null) {
-		const remaining = lastRateLimitAt + waitMs - Date.now();
-		if (remaining <= 0) return true;
-		if (!await delay(remaining, signal)) return false;
+function collectImageRefs(content, out) {
+	if (!Array.isArray(content)) return;
+	for (const block of content) {
+		if (!isRecord(block)) continue;
+		if (block.type === "image") {
+			const a = block.attachment;
+			if (isRecord(a) && typeof a.attachmentId === "string" && a.attachmentId !== "" && typeof a.mediaType === "string" && typeof a.bytes === "number" && Number.isFinite(a.bytes) && typeof a.width === "number" && Number.isFinite(a.width) && typeof a.height === "number" && Number.isFinite(a.height)) out.push({
+				attachmentId: a.attachmentId,
+				mediaType: a.mediaType,
+				bytes: a.bytes,
+				width: a.width,
+				height: a.height,
+				...typeof a.name === "string" && a.name !== "" ? { name: a.name } : {}
+			});
+		} else if (block.type === "tool-result") collectImageRefs(block.content, out);
 	}
-	return true;
 }
-//#endregion
-//#region src/summarize.ts
 /**
-* 共享压缩提示词（观察/反思同一套）：定义 history 块（模型消息 + index 的表达形式）、
-* 完整消息定义、压缩要求、输出格式与数据源说明。
-* skipReasoning=true（默认，与 compressSkipReasoning 默认一致）时压缩输入不含
-* <reasoning> 参考条目，提示词相应省略 <reasoning> 的说明两行。
+* 渲染一条完整消息为「文本 + 图片」（recall / recall-semantic 输出用）：
+* user/sys 取消息原文，assistant 取文本块，toolcall 为调用块 + 结果文本
+* （pruner 裁剪超大结果）；同时收集该条完整消息携带的图片附件（含 tool-result 嵌套，
+* pruner 裁剪掉的图片不收集）。
 */
-function buildHistoryPrompt(skipReasoning = true) {
-	return [
-		"压缩 <history> 消息记录。你应当输出**单个**合法的 <history> 块。",
-		"",
-		"【history 块定义】",
-		"- <history> 是历史消息的记录块。",
-		"- <user_message index=\"N\">：用户消息条目。",
-		"- <sys type=\"(kind)\" index=\"N\">：系统消息条目。",
-		...skipReasoning ? [] : ["- <reasoning>：模型的思考过程，仅作压缩参考，产物中不要出现。"],
-		"- <assistant index=\"N\">：单条完整消息（模型输出文本，或 toolcall 及其 result）。",
-		"- <assistant start=\"A\" end=\"B\">：多条连续完整消息聚合的模块（A/B 为模块首尾完整消息的 index）。",
-		"",
-		"【压缩要求】",
-		"- <user_message> <sys> 条目从输入中逐条保留，不做任何处理。",
-		...skipReasoning ? [] : ["- <reasoning> 只作参考，输出产物中不包含 <reasoning> 块。"],
-		"- 将具有关联性的 <assistant> 消息按内在逻辑连贯性划分为连续模块，聚合为 <assistant start=\"\" end=\"\"> 块",
-		"- 单条重要的完整消息以 <assistant index=\"\"> 单独呈现",
-		"- 压缩后的 <assistant> 块内，应当描述**行为逻辑**，强调关键的**结论、产出和任务**；涉及到的具体文件保留完整路径",
-		"- 加载的 skill 属于**关键信息**：应当产出独立块且不过多省略。",
-		"- 压缩后的消息，区间边界与输入的消息必须完全相同，内部 index/start/end 必须连续，相邻区间的左右界必须相邻，",
-		"",
-		"【摘要粒度】",
-		"- 越往后越细：靠近末尾（最近）的完整消息保留更多细节（关键文件、改动与结论），开头（较早）的完整消息可适当从简。",
-		"- 用户消息不受此约束：始终逐条保留原文，不做概括与省略。",
-		"",
-		"【输出格式】输出单个合法的 <history> 块，**不包含其他任何内容**：",
-		`<${HISTORY_TAG}>`,
-		"<user_message index=\"(index)\">",
-		"(user 消息原文)",
-		"</user_message>",
-		"<sys type=\"(kind)\" index=\"(index)\"></sys>",
-		"<assistant start=\"(起始 index)\" end=\"(结束 index)\">",
-		"(模块的目的、行为与结果摘要)",
-		"</assistant>",
-		"<assistant index=\"(index)\">",
-		"(单条完整消息的模块摘要)",
-		"</assistant>",
-		`</${HISTORY_TAG}>`,
-		"",
-		"【数据源】下方的 <history> 消息记录是本次要压缩的全部消息；压缩结果作为一个新的 <history> 块输出。"
-	].join("\n");
+function renderCompleteMessageParts(session, cm, pruner) {
+	const images = [];
+	if (cm.type === "user" || cm.type === "sys") {
+		const seq = cm.seqs[0];
+		const event = seq === void 0 ? void 0 : session.events[seq];
+		const message = event ? session.deriveEventMessage(event) : null;
+		if (message && Array.isArray(message.content)) collectImageRefs(message.content, images);
+		return {
+			text: message ? renderMessageText(message) : "",
+			images
+		};
+	}
+	if (cm.type === "assistant") {
+		const seq = cm.seqs[0];
+		const event = seq === void 0 ? void 0 : session.events[seq];
+		const message = event ? session.deriveEventMessage(event) : null;
+		if (!message || !Array.isArray(message.content)) return {
+			text: "",
+			images
+		};
+		collectImageRefs(message.content, images);
+		const texts = [];
+		for (const block of message.content) if (block.type === "text") texts.push(String(block.text));
+		return {
+			text: texts.join("\n"),
+			images
+		};
+	}
+	const parts = [];
+	const callSeq = cm.seqs[0];
+	const callEvent = callSeq === void 0 ? void 0 : session.events[callSeq];
+	if (callEvent?.type === "assistant/message") {
+		const message = session.deriveEventMessage(callEvent);
+		if (message && Array.isArray(message.content)) {
+			let call;
+			for (const block of message.content) if (block.type === "tool-call" && String(block.id ?? "") === (cm.callId ?? "")) {
+				call = block;
+				break;
+			}
+			if (call) parts.push(`[tool-call ${String(call.name ?? "")} id=${String(call.id ?? "")}]\n${safeJson(call.arguments)}`);
+		}
+	}
+	const resultSeq = cm.seqs[1];
+	const resultEvent = resultSeq === void 0 ? void 0 : session.events[resultSeq];
+	if (resultEvent?.type === "tool/result") {
+		let message = session.deriveEventMessage(resultEvent);
+		if (message && pruner?.pruneContent) {
+			const pruned = pruner.pruneContent(message.content);
+			if (pruned) message = {
+				...message,
+				content: pruned
+			};
+		}
+		if (message && Array.isArray(message.content)) collectImageRefs(message.content, images);
+		const text = message ? renderMessageText(message) : "";
+		if (text.trim() !== "") parts.push(`[result]\n${text}`);
+	}
+	return {
+		text: parts.join("\n"),
+		images
+	};
 }
-/**
-* 静默 DOMParser：非致命解析问题不再走 xmldom 默认的 console.error 输出
-* （模型输出非法 XML 时避免刷 console），fatalError 仍抛 ParseError、解析语义不变。
-*/
+/** 渲染一条完整消息的文本（压缩输入与语义嵌入共用）：renderCompleteMessageParts 的纯文本投影。 */
+function renderCompleteMessage(session, cm, pruner) {
+	return renderCompleteMessageParts(session, cm, pruner).text;
+}
+//#endregion
+//#region src/compress-view.ts
+/** 静默 DOMParser：非致命解析问题不刷 console，fatalError 仍抛 ParseError、解析语义不变。 */
 function newQuietParser() {
 	return new import_lib.DOMParser({ onError: () => {} });
 }
-/** 渲染用户消息条目（DOM 元素）：文本块原样；图片/文件等非文本块以注释补充。 */
-function renderUserEntry(doc, session, cm) {
+/**
+* 提取用户消息条目的文本与注释（文本块拼接为原文；图片/其他块降级为注释文本，
+* 渲染时输出为 XML 注释）。无任何内容返回 null（该 index 在视图中不占条目）。
+*/
+function userEntryParts(session, cm) {
 	const seq = cm.seqs[0];
 	const event = seq === void 0 ? void 0 : session.events[seq];
 	const message = event ? session.deriveEventMessage(event) : null;
 	if (!message || !Array.isArray(message.content)) return null;
-	const el = doc.createElement("user_message");
-	el.setAttribute("index", String(cm.index));
-	let hasContent = false;
-	for (const block of message.content) if (block.type === "text") {
-		el.appendChild(doc.createTextNode(String(block.text)));
-		hasContent = true;
-	} else if (block.type === "image") {
+	const texts = [];
+	const notes = [];
+	for (const block of message.content) if (block.type === "text") texts.push(String(block.text));
+	else if (block.type === "image") {
 		const ref = block.attachment;
 		const name = ref?.name ? `：${ref.name}` : "";
 		const meta = ref ? `（${String(ref.mediaType ?? "")} ${String(ref.width ?? "")}×${String(ref.height ?? "")}，${String(ref.bytes ?? "")} bytes）` : "";
-		el.appendChild(doc.createComment(` 图片附件${name}${meta} `));
-		hasContent = true;
-	} else {
-		el.appendChild(doc.createComment(` ${String(block.type)} 块 `));
-		hasContent = true;
-	}
-	if (!hasContent) return null;
-	return el;
+		notes.push(` 图片附件${name}${meta} `);
+	} else notes.push(` ${String(block.type)} 块 `);
+	if (texts.length === 0 && notes.length === 0) return null;
+	return {
+		text: texts.join("\n"),
+		notes
+	};
 }
 /**
-* 渲染完整消息记录（观察输入）：输出一个合法的 <history> 块——
-* user → <user_message>（文本原样、图片注释）、sys → <sys> 空块、
-* assistant/toolcall → <assistant>（原样文本）；skipReasoning=false 时另把
-* assistant 的 reasoning → <reasoning>（参考条目）。
-* 文本经 XML 序列化自动转义；仅渲染 seqs 全部落在给定集合内的完整消息。
+* 提取 toolcall 完整消息的工具名（按 callId 在所属 assistant 消息中定位 tool-call 块）。
+* 找不到返回 undefined。
 */
-function renderMessages(session, seqs, skipReasoning = true) {
+function toolCallNameOf(session, cm) {
+	if (cm.type !== "toolcall") return void 0;
+	const seq = cm.seqs[0];
+	const event = seq === void 0 ? void 0 : session.events[seq];
+	if (event?.type !== "assistant/message") return void 0;
+	const message = event.data.message;
+	if (!message || !Array.isArray(message.content)) return void 0;
+	for (const block of message.content) if (block.type === "tool-call" && String(block.id ?? "") === (cm.callId ?? "")) return String(block.name ?? "");
+}
+/**
+* 观察视图：被压缩区间（表层 seq 集合）内的完整消息投影为条目——
+* user → 原文（图片等非文本块为注释）、sys → 空条目、assistant/toolcall → 原文渲染，
+* reasoning 作为参考条目置于其所属 assistant 条目之前（每条 assistant 消息输出一次；
+* skipReasoning 时省略）。
+* 要求区间为区间内完整消息的首尾 index。
+*/
+function buildObserveView(session, seqs, options = {}) {
 	const shadowed = new Set(seqs);
 	const reasoningBySeq = /* @__PURE__ */ new Map();
-	if (!skipReasoning) for (const seq of seqs) {
+	for (const seq of seqs) {
 		const event = session.events[seq];
 		if (event?.type !== "assistant/message") continue;
 		const message = event.data.message;
@@ -7769,76 +7551,661 @@ function renderMessages(session, seqs, skipReasoning = true) {
 		for (const block of message.content) if (block.type === "reasoning" && typeof block.text === "string") reasonings.push(block.text);
 		if (reasonings.length > 0) reasoningBySeq.set(seq, reasonings);
 	}
-	const emittedReasoning = /* @__PURE__ */ new Set();
-	const doc = newQuietParser().parseFromString(`<${HISTORY_TAG} />`, "text/xml");
 	const entries = [];
+	const emittedReasoning = /* @__PURE__ */ new Set();
 	for (const cm of indexCompleteMessages(session)) {
 		if (!cm.seqs.every((seq) => shadowed.has(seq))) continue;
 		if (cm.type === "sys") {
-			const sysEl = doc.createElement("sys");
-			sysEl.setAttribute("type", cm.kind ?? "");
-			sysEl.setAttribute("index", String(cm.index));
-			sysEl.appendChild(doc.createTextNode(""));
-			entries.push(sysEl);
+			entries.push({
+				kind: "sys",
+				lo: cm.index,
+				hi: cm.index,
+				text: "",
+				...cm.kind === void 0 ? {} : { sysKind: cm.kind }
+			});
 			continue;
 		}
 		if (cm.type === "user") {
-			const rendered = renderUserEntry(doc, session, cm);
-			if (rendered === null) continue;
-			entries.push(rendered);
-		} else {
+			const parts = userEntryParts(session, cm);
+			if (parts === null) continue;
+			entries.push({
+				kind: "user",
+				lo: cm.index,
+				hi: cm.index,
+				text: parts.text,
+				...parts.notes.length === 0 ? {} : { notes: parts.notes }
+			});
+			continue;
+		}
+		if (options.skipReasoning !== true) {
 			const callSeq = cm.seqs[0];
 			const reasonings = callSeq === void 0 ? void 0 : reasoningBySeq.get(callSeq);
-			if (!skipReasoning && callSeq !== void 0 && reasonings !== void 0 && !emittedReasoning.has(callSeq)) {
+			if (callSeq !== void 0 && reasonings !== void 0 && !emittedReasoning.has(callSeq)) {
 				emittedReasoning.add(callSeq);
-				for (const text of reasonings) {
-					const re = doc.createElement("reasoning");
-					re.appendChild(doc.createTextNode(text));
-					entries.push(re);
-				}
+				for (const text of reasonings) entries.push({
+					kind: "reasoning",
+					lo: cm.index,
+					hi: cm.index,
+					text
+				});
 			}
-			const text = renderCompleteMessage(session, cm);
-			if (text.trim() === "") continue;
-			const el = doc.createElement("assistant");
-			el.setAttribute("index", String(cm.index));
-			el.appendChild(doc.createTextNode(text));
-			entries.push(el);
 		}
+		const text = renderCompleteMessage(session, cm);
+		if (text.trim() === "") continue;
+		const toolName = cm.type === "toolcall" ? toolCallNameOf(session, cm) : void 0;
+		entries.push({
+			kind: "assistant",
+			lo: cm.index,
+			hi: cm.index,
+			text,
+			...toolName === void 0 ? {} : { toolName }
+		});
+	}
+	return {
+		entries,
+		...viewBounds(entries)
+	};
+}
+/** 提取视图要求区间：全部可定位条目的最小 lo 与最大 hi（无可定位条目时均 undefined）。 */
+function viewBounds(entries) {
+	let minIndex;
+	let maxIndex;
+	for (const entry of entries) {
+		if (entry.lo === void 0 || entry.hi === void 0) continue;
+		if (minIndex === void 0 || entry.lo < minIndex) minIndex = entry.lo;
+		if (maxIndex === void 0 || entry.hi > maxIndex) maxIndex = entry.hi;
 	}
+	return {
+		...minIndex === void 0 ? {} : { minIndex },
+		...maxIndex === void 0 ? {} : { maxIndex }
+	};
+}
+/** 提取 <history> 块的内文（去开/闭标签；非块文本原样返回）。 */
+function historyInner(text) {
+	const closeTag = `</${HISTORY_TAG}>`;
+	const close = text.lastIndexOf(closeTag);
+	if (close === -1) return text;
+	const open = text.indexOf(`<${HISTORY_TAG}`);
+	if (open === -1) return text;
+	const gt = text.indexOf(">", open);
+	if (gt === -1 || gt >= close) return text;
+	return text.slice(gt + 1, close);
+}
+/** 读取元素整数属性（非负整数；缺失 / 非数字返回 undefined）。 */
+function intAttr(el, name) {
+	const raw = el.getAttribute(name);
+	if (raw === null || raw === "") return void 0;
+	if (!/^\d+$/.test(raw)) return void 0;
+	return Number(raw);
+}
+/**
+* 解析一个已有 <history> 块的内条目（反思视图）：user_message / sys / assistant
+* （index 单条或 start/end 区间）/ reasoning。整块无法解析或根非 <history> 时降级为
+* 单条不可定位的历史遗留条目（text 为块内文原文，构建最终块时原样保留）。
+*/
+function parseBlockEntries(blockText, blockSeq) {
+	const opaque = () => [{
+		kind: "assistant",
+		text: historyInner(blockText),
+		blockSeq
+	}];
+	let doc;
+	try {
+		doc = newQuietParser().parseFromString(blockText, "text/xml");
+	} catch {
+		return opaque();
+	}
+	const root = doc.documentElement;
+	if (!root || root.nodeName !== "history") return opaque();
+	const entries = [];
+	const children = root.childNodes;
+	for (let i = 0; i < children.length; i += 1) {
+		const node = children[i];
+		if (node?.nodeType !== 1) continue;
+		const el = node;
+		const text = el.textContent ?? "";
+		if (el.nodeName === "user_message") {
+			const index = intAttr(el, "index");
+			if (index === void 0) continue;
+			entries.push({
+				kind: "user",
+				lo: index,
+				hi: index,
+				text,
+				blockSeq
+			});
+		} else if (el.nodeName === "sys") {
+			const index = intAttr(el, "index");
+			if (index === void 0) continue;
+			const type = el.getAttribute("type");
+			entries.push({
+				kind: "sys",
+				lo: index,
+				hi: index,
+				text: "",
+				...type === null ? {} : { sysKind: type },
+				blockSeq
+			});
+		} else if (el.nodeName === "assistant") {
+			const index = intAttr(el, "index");
+			if (index !== void 0) {
+				entries.push({
+					kind: "assistant",
+					lo: index,
+					hi: index,
+					text,
+					blockSeq
+				});
+				continue;
+			}
+			const start = intAttr(el, "start");
+			const end = intAttr(el, "end");
+			if (start !== void 0 && end !== void 0) entries.push({
+				kind: "assistant",
+				lo: start,
+				hi: end,
+				text,
+				blockSeq
+			});
+		} else if (el.nodeName === "reasoning") entries.push({
+			kind: "reasoning",
+			text,
+			blockSeq
+		});
+	}
+	if (entries.length === 0) return opaque();
+	return entries;
+}
+/**
+* 反思视图：全部 <history> 块（historySection 收集，按表层顺序）的内条目投影为条目。
+* 要求区间为全部块内条目引用的最小 / 最大 index；块解析失败降级为不可定位遗留条目；
+* skipReasoning 时不含 <reasoning> 参考条目。
+*/
+function buildReflectView(blocks, options = {}) {
+	const entries = [];
+	for (const block of blocks) entries.push(...parseBlockEntries(block.text, block.seq));
+	const filtered = options.skipReasoning === true ? entries.filter((entry) => entry.kind !== "reasoning") : entries;
+	return {
+		entries: filtered,
+		...viewBounds(filtered)
+	};
+}
+/**
+* 把一个视图条目构建为 XML 元素（文本经 DOM 文本节点自动转义；user 条目的注释
+* 输出为 XML 注释节点）。getHistory 输出与最终 <history> 块共用。
+*/
+function entryToElement(doc, entry) {
+	if (entry.kind === "user") {
+		const el = doc.createElement("user_message");
+		if (entry.lo !== void 0) el.setAttribute("index", String(entry.lo));
+		el.appendChild(doc.createTextNode(entry.text));
+		for (const note of entry.notes ?? []) el.appendChild(doc.createComment(note));
+		return el;
+	}
+	if (entry.kind === "sys") {
+		const el = doc.createElement("sys");
+		el.setAttribute("type", entry.sysKind ?? "");
+		if (entry.lo !== void 0) el.setAttribute("index", String(entry.lo));
+		el.appendChild(doc.createTextNode(""));
+		return el;
+	}
+	if (entry.kind === "reasoning") {
+		const el = doc.createElement("reasoning");
+		el.appendChild(doc.createTextNode(entry.text));
+		return el;
+	}
+	const el = doc.createElement("assistant");
+	if (entry.lo !== void 0 && entry.hi !== void 0 && entry.lo === entry.hi) el.setAttribute("index", String(entry.lo));
+	else if (entry.lo !== void 0 && entry.hi !== void 0) {
+		el.setAttribute("start", String(entry.lo));
+		el.setAttribute("end", String(entry.hi));
+	}
+	el.appendChild(doc.createTextNode(entry.text));
+	return el;
+}
+/**
+* 渲染条目序列为 XML 文本（无 <history> 包裹，条目逐行拼接）——getHistory 的输出形式。
+*/
+function renderEntriesXml(entries) {
+	if (entries.length === 0) return "";
+	const doc = newQuietParser().parseFromString("<root />", "text/xml");
 	const serializer = new import_lib.XMLSerializer();
-	return `<${HISTORY_TAG}>\n${entries.map((el) => serializer.serializeToString(el)).join("\n")}\n</${HISTORY_TAG}>`;
+	return entries.map((entry) => serializer.serializeToString(entryToElement(doc, entry))).join("\n");
+}
+/** 压缩会话的工具状态：视图 + 替换记录 + skill 二次确认标记 + 完成标记。 */
+var CompressionState = class CompressionState {
+	view;
+	replacements = [];
+	challengedSkills = /* @__PURE__ */ new Set();
+	_completed = false;
+	/**
+	* @param view 压缩视图（观察或反思），工具校验与最终块构建的数据源。
+	*/
+	constructor(view) {
+		this.view = view;
+	}
+	/** 已成功应用的替换次数（0 表示空提交）。 */
+	get replacementCount() {
+		return this.replacements.length;
+	}
+	/** 是否已调用 completeCompression。 */
+	get completed() {
+		return this._completed;
+	}
+	/**
+	* 执行一次压缩工具调用：解析 JSON 参数并按工具名分发。
+	* 未知工具名或参数非法 JSON 返回错误结果，不抛出。
+	*/
+	executeCall(name, rawArgs) {
+		if (name === "getHistory" || name === "compressHistory" || name === "completeCompression") {
+			let args;
+			if (typeof rawArgs === "string" && rawArgs.trim() === "") args = {};
+			else try {
+				args = JSON.parse(rawArgs);
+			} catch {
+				return {
+					text: `参数不是合法的 JSON：${rawArgs.slice(0, 200)}`,
+					isError: true
+				};
+			}
+			const record = args ?? {};
+			if (name === "getHistory") return this.getHistory(record);
+			if (name === "compressHistory") return this.compressHistory(record);
+			return this.complete();
+		}
+		return {
+			text: `未知工具 ${name}（可用：getHistory / compressHistory / completeCompression）`,
+			isError: true
+		};
+	}
+	/** 解析可选数值参数（缺省 undefined；非有限数返回 NaN）。 */
+	optionalNumber(value) {
+		if (value === void 0 || value === null) return void 0;
+		if (typeof value !== "number" || !Number.isFinite(value)) return NaN;
+		return Math.floor(value);
+	}
+	/**
+	* getHistory：返回 [start..end] 区间内的条目（压缩视图，无 <history> 包裹）。
+	* start/end 缺省为要求区间首尾；越界或 start > end 返回错误。区间切入已有压缩
+	* 块（反思视图）时返回该块全部条目。
+	*/
+	getHistory(args) {
+		const { minIndex, maxIndex } = this.view;
+		if (minIndex === void 0 || maxIndex === void 0) return {
+			text: "当前压缩区间没有可定位的条目",
+			isError: true
+		};
+		const startRaw = this.optionalNumber(args.start);
+		const endRaw = this.optionalNumber(args.end);
+		if (startRaw !== void 0 && Number.isNaN(startRaw)) return {
+			text: "start 必须是数字",
+			isError: true
+		};
+		if (endRaw !== void 0 && Number.isNaN(endRaw)) return {
+			text: "end 必须是数字",
+			isError: true
+		};
+		const start = startRaw ?? minIndex;
+		const end = endRaw ?? maxIndex;
+		if (start < minIndex || start > maxIndex) return {
+			text: `start ${start} 越界（要求区间 [${minIndex}..${maxIndex}]）`,
+			isError: true
+		};
+		if (end < minIndex || end > maxIndex) return {
+			text: `end ${end} 越界（要求区间 [${minIndex}..${maxIndex}]）`,
+			isError: true
+		};
+		if (start > end) return {
+			text: `start ${start} 不能大于 end ${end}`,
+			isError: true
+		};
+		const intersects = (entry) => entry.lo !== void 0 && entry.hi !== void 0 && entry.lo <= end && entry.hi >= start;
+		const expandedBlocks = /* @__PURE__ */ new Set();
+		for (const entry of this.view.entries) if (entry.blockSeq !== void 0 && intersects(entry)) expandedBlocks.add(entry.blockSeq);
+		const selected = this.view.entries.filter((entry) => entry.blockSeq !== void 0 ? expandedBlocks.has(entry.blockSeq) : intersects(entry));
+		if (selected.length === 0) return {
+			text: `区间 [${start}..${end}] 没有条目`,
+			isError: false
+		};
+		return {
+			text: `<!-- 完整消息区间 [${start}..${end}]，共 ${selected.length} 条 -->\n${renderEntriesXml(selected)}`,
+			isError: false
+		};
+	}
+	/** 区间的简短描述（单条 index / 区间 start..end）。 */
+	static spanLabel(lo, hi) {
+		return lo === hi ? `完整消息 index ${lo}` : `完整消息区间 [${lo}..${hi}]`;
+	}
+	/**
+	* compressHistory：把 index 单条或 start..end 连续区间的 assistant 条目替换为
+	* content 摘要。校验失败返回错误结果（不应用）；skill 块首次被覆盖返回要求
+	* 重新思考的错误结果（不应用，标记已挑战）；通过后记录替换并覆盖被完全包含
+	* 的旧替换。
+	*/
+	compressHistory(args) {
+		const { minIndex, maxIndex } = this.view;
+		if (minIndex === void 0 || maxIndex === void 0) return {
+			text: "当前压缩区间没有可定位的条目",
+			isError: true
+		};
+		const content = args.content;
+		if (typeof content !== "string" || content.trim() === "") return {
+			text: "content 必须是非空摘要文本",
+			isError: true
+		};
+		const hasIndex = args.index !== void 0 && args.index !== null;
+		const hasStart = args.start !== void 0 && args.start !== null;
+		const hasEnd = args.end !== void 0 && args.end !== null;
+		if (hasIndex && (hasStart || hasEnd)) return {
+			text: "index 与 start/end 不能同时提供",
+			isError: true
+		};
+		if (hasStart !== hasEnd) return {
+			text: "start 与 end 必须成对提供",
+			isError: true
+		};
+		let lo;
+		let hi;
+		if (hasIndex) {
+			const index = args.index;
+			if (typeof index !== "number" || !Number.isInteger(index) || index < 0) return {
+				text: "index 必须是非负整数",
+				isError: true
+			};
+			lo = index;
+			hi = index;
+		} else if (hasStart) {
+			const start = args.start;
+			const end = args.end;
+			if (typeof start !== "number" || typeof end !== "number" || !Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < 0) return {
+				text: "start 与 end 必须是非负整数",
+				isError: true
+			};
+			if (start > end) return {
+				text: `start ${start} 不能大于 end ${end}`,
+				isError: true
+			};
+			lo = start;
+			hi = end;
+		} else return {
+			text: "index 与 start/end 至少提供一个",
+			isError: true
+		};
+		if (lo < minIndex || hi > maxIndex) return {
+			text: `${CompressionState.spanLabel(lo, hi)} 超出要求的压缩区间 [${minIndex}..${maxIndex}]`,
+			isError: true
+		};
+		let insideCount = 0;
+		for (const entry of this.view.entries) {
+			if (entry.lo === void 0 || entry.hi === void 0) continue;
+			if (entry.lo > hi || entry.hi < lo) continue;
+			if (entry.kind === "user") return {
+				text: `${CompressionState.spanLabel(lo, hi)} 覆盖用户消息（index ${entry.lo}），用户消息不可压缩`,
+				isError: true
+			};
+			if (entry.kind === "sys") return {
+				text: `${CompressionState.spanLabel(lo, hi)} 覆盖系统消息（index ${entry.lo}），系统消息不可压缩`,
+				isError: true
+			};
+			if (entry.kind === "assistant" && !(entry.lo >= lo && entry.hi <= hi)) return {
+				text: `${CompressionState.spanLabel(lo, hi)} 与 assistant 条目 [${entry.lo}..${entry.hi}] 部分重叠，需完整包含或不相交`,
+				isError: true
+			};
+			if (entry.kind === "assistant") insideCount += 1;
+		}
+		if (insideCount === 0) return {
+			text: `${CompressionState.spanLabel(lo, hi)} 内没有可压缩的 assistant 条目`,
+			isError: true
+		};
+		for (const rep of this.replacements) if (rep.lo <= hi && rep.hi >= lo && !(rep.lo >= lo && rep.hi <= hi)) return {
+			text: `${CompressionState.spanLabel(lo, hi)} 与已有替换区间 [${rep.lo}..${rep.hi}] 部分重叠，只能完全包含或不相交`,
+			isError: true
+		};
+		const unchallenged = [];
+		for (const entry of this.view.entries) {
+			if (entry.kind !== "assistant" || entry.toolName !== "skill") continue;
+			if (entry.lo === void 0 || entry.lo < lo || entry.lo > hi) continue;
+			if (!this.challengedSkills.has(entry.lo)) unchallenged.push(entry.lo);
+		}
+		if (unchallenged.length > 0) {
+			for (const index of unchallenged) this.challengedSkills.add(index);
+			return {
+				text: `${CompressionState.spanLabel(lo, hi)} 包含 skill 加载（完整消息 index ${unchallenged.join("、")}）。请重新思考该 skill 是否确定与后续任务无关：确定不相关时再次调用 compressHistory 压缩该区间；不确定或相关时不要压缩该区间，保持原样即可`,
+				isError: true
+			};
+		}
+		for (let i = this.replacements.length - 1; i >= 0; i -= 1) {
+			const rep = this.replacements[i];
+			if (rep === void 0) continue;
+			if (rep.lo >= lo && rep.hi <= hi) this.replacements.splice(i, 1);
+		}
+		this.replacements.push({
+			lo,
+			hi,
+			content
+		});
+		return {
+			text: `已压缩${CompressionState.spanLabel(lo, hi)}（${insideCount} 条 assistant 条目）`,
+			isError: false
+		};
+	}
+	/** completeCompression：标记压缩完成（调用后压缩会话立即停止）。 */
+	complete() {
+		this._completed = true;
+		return {
+			text: "压缩完成",
+			isError: false
+		};
+	}
+	/**
+	* 构建最终 <history> 块：按 index 顺序合并视图条目与替换记录——user / sys 条目
+	* 原样、被替换区间生成 <assistant index|start end> 摘要条目（content 转义嵌入）、
+	* 未替换 assistant 条目原样保留、reasoning 不进产物；块首为格式说明注释，开标签
+	* 携带 tip 属性。产物为合法 XML，无需校验。
+	*/
+	buildFinalBlock() {
+		const doc = new import_lib.DOMParser({ onError: () => {} }).parseFromString(`<${HISTORY_TAG} />`, "text/xml");
+		const root = doc.documentElement;
+		if (!root) return "";
+		const coveredBy = (entry) => entry.lo !== void 0 && entry.hi !== void 0 && this.replacements.some((rep) => entry.lo !== void 0 && entry.hi !== void 0 && entry.lo >= rep.lo && entry.hi <= rep.hi);
+		const reps = [...this.replacements].sort((a, b) => a.lo - b.lo);
+		let nextRep = 0;
+		const emitReplacement = (rep) => {
+			const el = doc.createElement("assistant");
+			if (rep.lo === rep.hi) el.setAttribute("index", String(rep.lo));
+			else {
+				el.setAttribute("start", String(rep.lo));
+				el.setAttribute("end", String(rep.hi));
+			}
+			el.appendChild(doc.createTextNode(rep.content));
+			root.appendChild(el);
+		};
+		const flushReplacementsBefore = (lo) => {
+			while (nextRep < reps.length) {
+				const rep = reps[nextRep];
+				if (rep === void 0) break;
+				if (lo !== void 0 && rep.lo >= lo) break;
+				emitReplacement(rep);
+				nextRep += 1;
+			}
+		};
+		for (const entry of this.view.entries) {
+			if (entry.kind === "reasoning") continue;
+			if (coveredBy(entry)) continue;
+			flushReplacementsBefore(entry.lo);
+			root.appendChild(entryToElement(doc, entry));
+		}
+		flushReplacementsBefore(void 0);
+		const serializer = new import_lib.XMLSerializer();
+		const inner = Array.from(root.childNodes).map((node) => serializer.serializeToString(node)).join("\n");
+		return `<${HISTORY_TAG} tip="${HISTORY_TIP}">\n${HISTORY_FORMAT_NOTE}\n${inner}\n</${HISTORY_TAG}>`;
+	}
+};
+/** 压缩会话工具的 wire 定义（GenerateOptions.tools）。 */
+const COMPRESSION_TOOL_SCHEMAS = [
+	{
+		name: "getHistory",
+		description: "查看压缩区间内的历史条目。返回压缩视图：已被压缩的内容以摘要条目呈现，区间切入已压缩块时返回该块全部条目。start/end 缺省为要求区间的第一个/最后一个完整消息 index，必须在要求区间内。",
+		parameters: {
+			type: "object",
+			properties: {
+				start: {
+					type: "number",
+					description: "区间起始完整消息 index（缺省为要求区间第一个）"
+				},
+				end: {
+					type: "number",
+					description: "区间结束完整消息 index（缺省为要求区间最后一个）"
+				}
+			}
+		}
+	},
+	{
+		name: "compressHistory",
+		description: "把 index 单条或 start..end 连续区间的 assistant 类条目（模型输出文本、工具调用）替换为 content 摘要。index 与 start/end 二选一，start 与 end 成对提供且 start==end 等同 index。区间不得覆盖用户消息或系统消息，不得与已有替换区间部分重叠（完全包含则覆盖）。用户消息与系统消息保持原样，无需处理。",
+		parameters: {
+			type: "object",
+			properties: {
+				index: {
+					type: "number",
+					description: "单条完整消息 index"
+				},
+				start: {
+					type: "number",
+					description: "区间起始完整消息 index（与 end 成对提供）"
+				},
+				end: {
+					type: "number",
+					description: "区间结束完整消息 index（与 start 成对提供）"
+				},
+				content: {
+					type: "string",
+					description: "替换后的摘要文本（纯文本）"
+				}
+			},
+			required: ["content"]
+		}
+	},
+	{
+		name: "completeCompression",
+		description: "全部压缩完成后调用，立即结束压缩会话。未压缩的条目将原样保留，允许不压缩任何内容直接完成。",
+		parameters: {
+			type: "object",
+			properties: {}
+		}
+	}
+];
+//#endregion
+//#region src/rate-limit.ts
+/**
+* 全局限流门（插件进程级共享状态）：任一摘要请求遇 429 后进入冷却期，
+* 此后所有摘要请求发出前先等待到「最近一次 429 + rateLimitWaitMs」之后。
+* 等待期间 signal 中止则立即放弃；等待期间的新 429 顺延冷却期。
+* 导出 isRateLimitError / noteRateLimit / gateRateLimit / RATE_LIMIT_WAIT_MS_DEFAULT /
+* resetRateLimitGate。
+*/
+/** 最近一次 429 限流的时间戳（ms；null = 未遇过限流，门直接放行）。 */
+let lastRateLimitAt = null;
+/** 判定错误信息是否为 429 限流（匹配 429 或 rate limit，大小写不敏感）。 */
+function isRateLimitError(message) {
+	return /\b429\b|rate[\s_-]?limit/i.test(message);
+}
+/** 记录一次 429 限流：把冷却期起点更新为当前时间。 */
+function noteRateLimit() {
+	lastRateLimitAt = Date.now();
+}
+/** 可中止延时：等待满 ms 返回 true；等待期间 signal 中止返回 false。 */
+function delay(ms, signal) {
+	return new Promise((resolve) => {
+		if (signal?.aborted) {
+			resolve(false);
+			return;
+		}
+		const timer = setTimeout(() => {
+			cleanup();
+			resolve(true);
+		}, ms);
+		const onAbort = () => {
+			cleanup();
+			resolve(false);
+		};
+		const cleanup = () => {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", onAbort);
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/**
+* 限流等待门：处于 429 冷却期时等待到期限再放行（返回 true）；
+* 等待期间 signal 中止返回 false。未遇过限流或冷却期已过立即放行。waitMs ≤ 0 视为不限流。
+*/
+async function gateRateLimit(waitMs, signal) {
+	if (waitMs <= 0) return true;
+	while (lastRateLimitAt !== null) {
+		const remaining = lastRateLimitAt + waitMs - Date.now();
+		if (remaining <= 0) return true;
+		if (!await delay(remaining, signal)) return false;
+	}
+	return true;
+}
+//#endregion
+//#region src/compress-loop.ts
+/**
+* 工具驱动的压缩循环：以新会话方式直连 ctx.llm.stream()，模型通过 getHistory /
+* compressHistory / completeCompression 三个工具完成压缩，替代直出 <history> 块。
+* 导出 runCompressionLoop / buildCompressionPrompt / buildCompressionTaskText /
+* CompressionLoopOptions / CompressionOutcome / COMPRESSION_NUDGE_TEXT。
+*
+* - 首条 user 消息仅含压缩指令与 start/end 区间（buildCompressionTaskText），不含
+*   历史消息内容；共享压缩提示词作为 system
+* - 每轮请求携带压缩工具 schemas（purpose='compaction'，maxTokens 沿用配置）；流经
+*   BlockAssembler 组装为 assistant 消息，工具执行结果以 tool-result 消息回填
+* - completeCompression 调用后立即停止（同轮后续工具调用不再执行），最终 <history>
+*   块由 CompressionState 构建，全程无需整块校验
+* - 模型输出纯文本（无工具调用）时追加提醒消息继续，连续 2 轮仍无工具调用判失败
+* - 429 限流走全局限流等待门（gateRateLimit / noteRateLimit）；其余请求级错误依赖
+*   dsh 运行时重试，插件不做整体重试，错误直接判失败
+* - signal 中止标记 aborted；token usage 汇总全部轮次
+* - 成功与失败均把循环消息组原样落盘为子会话（recordCompressionSession），成功记
+*   录 sessionId 于日志，失败记录作为诊断子会话 id 向上传播
+*/
+/**
+* 共享压缩提示词（观察/反思同一套）：完整消息定义、工具语义、压缩要求、skill 规则
+* 与提交方式。作为压缩会话的 system；skipReasoning=true 时省略 <reasoning> 说明行。
+*/
+function buildCompressionPrompt(skipReasoning) {
+	return [
+		"压缩历史消息为摘要。你应当通过工具查看、压缩并完成提交。",
+		"",
+		`【完整消息定义】${COMPLETE_MESSAGE_DEFINITION}`,
+		"",
+		"【工具】",
+		"- getHistory(option?: {start?, end?})：查看压缩区间内的历史条目。start/end 缺省为要求区间的第一个/最后一个完整消息 index，必须在要求区间内。返回压缩视图：已压缩内容以摘要条目呈现，区间切入已压缩块时返回整块，不带 <history> 包裹。",
+		"- compressHistory(option?: {index?, start?, end?, content})：把 index 单条或 start..end 连续区间的 assistant 类条目替换为 content 摘要（纯文本）。index 与 start/end 二选一，start==end 等同 index。区间不得覆盖用户消息或系统消息；与已有替换区间部分重叠会被拒绝，完全包含则覆盖。",
+		"- completeCompression()：全部压缩完成后调用，立即结束。",
+		"",
+		"【压缩要求】",
+		"- 先用 getHistory 查看区间内容，再划分模块分批压缩；用户消息与系统消息不可压缩、保持原样，无需处理。",
+		...skipReasoning ? [] : ["- <reasoning> 仅作压缩参考，不进产物。"],
+		"- 将具有关联性的 assistant 消息按内在逻辑连贯性划分为连续模块，聚合为区间压缩（start..end）：content 描述模块的目的、行为与结果；涉及的具体文件保留在内容中，多个前缀相同的路径合并简写。",
+		"- 单条重要的完整消息以 index 单独压缩，内容不受限制。",
+		"- 摘要粒度越往后越细：靠近末尾（最近）的完整消息保留更多细节（关键文件、改动与结论），开头（较早）的完整消息可适当从简。",
+		"- 加载的 skill 属于关键信息（通过工具名为 skill 的调用识别）。不能判断该 skill 是否与后续任务相关时，不要压缩它：首次尝试压缩 skill 块会被要求再次思考，确定不相关才继续，其余情况保持原样。",
+		"- 未压缩的条目将原样保留；宁可保留也不要强行压缩不确定的内容。",
+		"- 全部完成后调用 completeCompression 结束；不要输出与工具调用无关的文本。"
+	].join("\n");
 }
-/** 流收集器：提取文本输出 + usage + finish（不依赖宿主 BlockAssembler）。 */
-var StreamCollector = class {
-	textBuf = "";
-	_usage;
-	_finish;
-	/** 喂入一个流 chunk（仅消费文本/usage/finish，其余忽略）。 */
-	push(chunk) {
-		switch (chunk.type) {
-			case "text-delta":
-				this.textBuf += chunk.text;
-				break;
-			case "usage":
-				this._usage = chunk.usage;
-				break;
-			case "finish": this._finish = chunk.reason;
-		}
-	}
-	/** 拼接后的文本输出。 */
-	get text() {
-		return this.textBuf;
-	}
-	/** 摘要 token usage（无则 undefined）。 */
-	get usage() {
-		return this._usage;
-	}
-	/** 终止原因（流未给出 finish 时视为 stop）。 */
-	get finish() {
-		return this._finish ?? { kind: "stop" };
-	}
-};
-/** 构造插件自产 user 消息（摘要调用的输入消息；id 为品牌类型 MessageId）。 */
+/**
+* 构建压缩会话首条 user 消息文本（压缩指令 + start/end 区间，不含历史消息内容）。
+*/
+function buildCompressionTaskText(phase, start, end) {
+	if (phase === "reflect") return `合并压缩全部 <history> 块，完整消息区间 [${start}..${end}]：用 getHistory 查看已有块条目，用 compressHistory 重新压缩合并 assistant 条目，完成后调用 completeCompression。`;
+	return `压缩完整消息区间 [${start}..${end}]：用 getHistory 查看条目，用 compressHistory 分批压缩 assistant 条目，完成后调用 completeCompression。`;
+}
+/** 模型输出纯文本（无工具调用）时追加的提醒消息文本。 */
+const COMPRESSION_NUDGE_TEXT = "请通过工具执行压缩：用 getHistory 查看区间条目，用 compressHistory 压缩 assistant 条目，完成后调用 completeCompression。不要输出与工具调用无关的文本。";
+/** 构造插件自产 user 消息（压缩指令/提醒；id 为品牌类型 MessageId）。 */
 function makePluginUserMessage(text) {
 	return {
 		id: uuid(),
@@ -7853,351 +8220,277 @@ function makePluginUserMessage(text) {
 		}
 	};
 }
+/** 把工具执行结果封装为 tool-result 消息（回填到压缩会话）。 */
+function toolResultOf(call, result) {
+	return createToolResultMessage({
+		callId: call.id,
+		content: [{
+			type: "text",
+			text: result.text
+		}],
+		isError: result.isError
+	});
+}
 /**
-* 构建摘要请求选项：指令作为 system，渲染输入作为唯一的 user 消息，
-* 不沿用主会话请求前缀（前缀复用需模型自行计数，导致索引异常）。
+* 把本轮已组装的部分 assistant 输出计入会话记录（error 终态时的诊断价值）。
+* 无任何文本/工具调用块（空流）时不追加。
 */
-function buildSummaryOptions(session, instruction, contextText, maxTokens, target, signal) {
-	return {
+function pushPartialAssistant(assembler, messages, target) {
+	const blocks = assembler.blocks();
+	if (blocks.length === 0) return;
+	if (blocks.every((block) => block.type === "text" && block.text.trim() === "")) return;
+	messages.push(assembler.message({
+		kind: "model",
 		provider: target.provider,
-		model: target.model,
-		...maxTokens === void 0 ? {} : { maxTokens },
-		sessionId: session.id,
-		purpose: "compaction",
-		...signal === void 0 ? {} : { signal },
-		system: instruction,
-		messages: [makePluginUserMessage(contextText ?? "")]
-	};
+		model: target.model
+	}));
 }
-/** 产出日志后插入首个 <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+/, "");
+/** 累加两份 token usage（可选字段任一存在即求和保留）。 */
+function addUsage(total, add) {
+	if (total === void 0) return { ...add };
+	const sum = (a, b) => a === void 0 && b === void 0 ? void 0 : (a ?? 0) + (b ?? 0);
+	const usage = {
+		inputTokens: total.inputTokens + add.inputTokens,
+		outputTokens: total.outputTokens + add.outputTokens
+	};
+	const cacheRead = sum(total.cacheReadTokens, add.cacheReadTokens);
+	const cacheWrite = sum(total.cacheWriteTokens, add.cacheWriteTokens);
+	const reasoning = sum(total.reasoningTokens, add.reasoningTokens);
+	if (cacheRead !== void 0) usage.cacheReadTokens = cacheRead;
+	if (cacheWrite !== void 0) usage.cacheWriteTokens = cacheWrite;
+	if (reasoning !== void 0) usage.reasoningTokens = reasoning;
+	return usage;
 }
-/** 读取元素整数属性（非负整数；缺失 / 非数字返回 undefined）。 */
-function intAttr(el, name) {
-	const raw = el.getAttribute(name);
-	if (raw === null || raw === "") return void 0;
-	if (!/^\d+$/.test(raw)) return void 0;
-	return Number(raw);
+/** 是否为 429 限流失败（异常消息或终态 failure 载荷）。 */
+function isRateLimitFailure(message, status) {
+	return status === 429 || isRateLimitError(message);
 }
 /**
-* 用 XML 解析器解析一个 <history> 块（结构合法性校验）：
-* 非法 XML / 根非 <history> / 顶层出现未定义元素 / 条目属性缺失或非法 → null；
-* 出现 <reasoning> 元素时标记 hasReasoning（产物不允许）。
+* 运行工具驱动的压缩循环：直到模型调用 completeCompression（成功）、连续 2 轮无
+* 工具调用、请求级错误或 signal 中止（失败）。成功与失败均落盘循环会话记录。
 */
-function parseHistoryBlock(xml) {
-	let doc;
-	try {
-		doc = newQuietParser().parseFromString(xml, "text/xml");
-	} catch {
-		return null;
-	}
-	const root = doc.documentElement;
-	if (!root || root.nodeName !== "history") return null;
-	const entries = [];
-	let hasReasoning = false;
-	const children = root.childNodes;
-	for (let i = 0; i < children.length; i += 1) {
-		const node = children[i];
-		if (node?.nodeType !== 1) continue;
-		const el = node;
-		const tag = el.nodeName;
-		if (tag === "reasoning") {
-			hasReasoning = true;
+async function runCompressionLoop(ctx, session, options) {
+	const logger = makeLogger(ctx, options.debug);
+	const state = new CompressionState(options.view);
+	const messages = [makePluginUserMessage(options.taskText)];
+	let rounds = 0;
+	let nudges = 0;
+	let usage;
+	const recordSessionId = async (success) => recordCompressionSession(ctx, session, {
+		phase: options.phase,
+		target: options.target,
+		messages,
+		rounds,
+		success,
+		debug: options.debug
+	});
+	const failWith = async (error, aborted) => {
+		const id = await recordSessionId(false);
+		return {
+			ok: false,
+			error,
+			aborted,
+			...id === void 0 ? {} : { recordSessionId: id }
+		};
+	};
+	logger.step(`压缩循环开始（${options.phase === "reflect" ? "反思" : "观察"}，provider ${options.target.provider}，model ${options.target.model}，maxTokens ${options.maxTokens === void 0 ? "未设置" : String(options.maxTokens)}）`);
+	for (;;) {
+		if (options.signal?.aborted) {
+			logger.warn("压缩循环中止（signal 已中止），放弃本次压缩");
+			return await failWith(COMPACTION_ABORTED_ERROR, true);
+		}
+		if (!await gateRateLimit(options.rateLimitWaitMs, options.signal)) {
+			logger.warn("压缩循环中止（限流等待被 signal 中止），放弃本次压缩");
+			return await failWith(COMPACTION_ABORTED_ERROR, true);
+		}
+		const requestOptions = {
+			provider: options.target.provider,
+			model: options.target.model,
+			...options.maxTokens === void 0 ? {} : { maxTokens: options.maxTokens },
+			sessionId: session.id,
+			purpose: "compaction",
+			...options.signal === void 0 ? {} : { signal: options.signal },
+			system: buildCompressionPrompt(options.skipReasoning),
+			messages: [...messages],
+			tools: COMPRESSION_TOOL_SCHEMAS
+		};
+		const assembler = new BlockAssembler();
+		try {
+			for await (const chunk of ctx.llm.stream(requestOptions)) assembler.push(chunk);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			if (isRateLimitFailure(message)) {
+				noteRateLimit();
+				logger.warn(`压缩循环触发限流（429），等待 ${options.rateLimitWaitMs}ms 后重试`);
+				continue;
+			}
+			logger.warn(`压缩循环请求失败: ${message}`);
+			return await failWith(message, false);
+		}
+		const finish = assembler.finish;
+		if (finish.kind === "aborted") {
+			logger.warn("压缩循环中止（流以 aborted 结束），放弃本次压缩");
+			return await failWith(COMPACTION_ABORTED_ERROR, true);
+		}
+		if (finish.kind === "error") {
+			const failureMessage = typeof finish.failure?.message === "string" && finish.failure.message !== "" ? finish.failure.message : "流以 error 终态结束（无失败详情）";
+			if (isRateLimitFailure(failureMessage, typeof finish.failure?.status === "number" ? finish.failure.status : void 0)) {
+				noteRateLimit();
+				logger.warn(`压缩循环触发限流（429），等待 ${options.rateLimitWaitMs}ms 后重试`);
+				continue;
+			}
+			logger.warn(`压缩循环请求失败: ${failureMessage}`);
+			pushPartialAssistant(assembler, messages, options.target);
+			return await failWith(failureMessage, false);
+		}
+		rounds += 1;
+		if (assembler.usage !== void 0) usage = addUsage(usage, assembler.usage);
+		const assistantMessage = assembler.message({
+			kind: "model",
+			provider: options.target.provider,
+			model: options.target.model
+		});
+		messages.push(assistantMessage);
+		const calls = assembler.blocks().filter((block) => block.type === "tool-call");
+		if (calls.length === 0) {
+			nudges += 1;
+			if (nudges >= 2) {
+				const error = "模型连续 2 轮未调用压缩工具，放弃本次压缩";
+				logger.warn(error);
+				return await failWith(error, false);
+			}
+			logger.warn("模型未调用压缩工具（输出纯文本），追加提醒后继续");
+			messages.push(makePluginUserMessage(COMPRESSION_NUDGE_TEXT));
 			continue;
 		}
-		if (tag === "user_message") {
-			const index = intAttr(el, "index");
-			if (index === void 0) return null;
-			entries.push({
-				kind: "user",
-				index
-			});
-		} else if (tag === "sys") {
-			const index = intAttr(el, "index");
-			if (index === void 0) return null;
-			entries.push({
-				kind: "sys",
-				index
-			});
-		} else if (tag === "assistant") {
-			const index = intAttr(el, "index");
-			if (index !== void 0) entries.push({
-				kind: "assistant",
-				index
-			});
-			else {
-				const start = intAttr(el, "start");
-				const end = intAttr(el, "end");
-				if (start === void 0 || end === void 0) return null;
-				entries.push({
-					kind: "assistant",
-					start,
-					end
-				});
+		nudges = 0;
+		let completed = false;
+		for (const call of calls) {
+			if (call.name === "completeCompression") {
+				messages.push(toolResultOf(call, state.complete()));
+				completed = true;
+				break;
 			}
-		} else return null;
+			messages.push(toolResultOf(call, state.executeCall(call.name, call.arguments)));
+		}
+		if (completed) {
+			const text = state.buildFinalBlock();
+			if (state.replacementCount === 0) logger.warn("压缩完成但未执行任何压缩替换（空提交）");
+			logger.info(`压缩循环完成（${rounds} 轮，${state.replacementCount} 次压缩替换，输出 ${text.length} 字符）`);
+			const id = await recordSessionId(true);
+			return {
+				ok: true,
+				text,
+				rounds,
+				...usage === void 0 ? {} : { usage },
+				...id === void 0 ? {} : { recordSessionId: id }
+			};
+		}
 	}
-	return {
-		entries,
-		hasReasoning
-	};
 }
-/**
-* 解析文本中全部 <history> 块内的条目（逐块解析提取，兼容多块拼接文本）。
-* 非法块跳过；仅提取不校验顺序（连续性由 historyContinuity 校验）。
-*/
-function parseHistoryEntries(text) {
-	const out = [];
-	for (const m of text.matchAll(/<history[\s\S]*?<\/history>/g)) {
-		const parsed = parseHistoryBlock(m[0]);
-		if (parsed === null) continue;
-		out.push(...parsed.entries);
+//#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);
 	}
-	return out;
 }
 /**
-* 校验条目 index/start/end 连续性：每条给出覆盖区间，按出现顺序相邻条目必须首尾相接，
-* 返回整体覆盖区间；空条目 / 非法范围 / 跳号、重叠或乱序 → 返回 null。
+* 解码一条会话事件为 om 私有事件：仅识别 feedback/record 中带 om 信封前缀的
+* text；前缀缺失、JSON 非法、kind 未知或载荷字段缺失时返回 undefined。
 */
-function historyContinuity(entries) {
-	if (entries.length === 0) return null;
-	const ranges = [];
-	for (const e of entries) {
-		const lo = e.kind === "assistant" && e.start !== void 0 ? e.start : e.index ?? 0;
-		const hi = e.kind === "assistant" && e.end !== void 0 ? e.end : e.index ?? 0;
-		if (lo > hi) return null;
-		ranges.push({
-			lo,
-			hi
-		});
-	}
-	for (let i = 1; i < ranges.length; i += 1) {
-		const prev = ranges[i - 1];
-		const curr = ranges[i];
-		if (prev === void 0 || curr === void 0) return null;
-		if (curr.lo !== prev.hi + 1) return null;
+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;
 	}
-	const first = ranges[0];
-	const last = ranges[ranges.length - 1];
-	if (first === void 0 || last === void 0) return null;
+	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 {
-		start: first.lo,
-		end: last.hi
+		kind: omKind,
+		data: rest,
+		seq: event.seq
 	};
 }
-/** <history> 开标签（允许携带属性）：模糊定位输出中日志块起点。 */
-const HISTORY_OPEN_TAG_RE = /<history(\s[^>]*)?>/;
-/** history 块内条目标签的 token 正则（开 / 闭 / 自闭合）：模糊提取按标签逐个扫描配对。 */
-const HISTORY_ENTRY_TOKEN_RE = /<(\/)?(user_message|sys|assistant|reasoning)\b([^>]*?)(\/)?>/g;
-/** 解析标签属性串为键值对（支持双引号 / 单引号 / 无引号取值；非法片段忽略）。 */
-function parseTagAttrs(raw) {
-	const attrs = {};
-	for (const m of raw.matchAll(/([^\s=/]+)\s*=\s*("([^"]*)"|'([^']*)'|([^\s"'>]+))/g)) {
-		const key = m[1] ?? "";
-		const value = m[3] ?? m[4] ?? m[5] ?? "";
-		if (key !== "") attrs[key] = value;
-	}
-	return attrs;
+/** 编码一条 om 私有事件为 feedback/record 的 text 信封。 */
+function encodeOmEvent(kind, data) {
+	return `${OM_EVENT_PREFIX}${JSON.stringify({
+		kind,
+		...data
+	})}`;
 }
-/**
-* 解码 XML 预定义实体（&amp; 最后解码，避免 &amp;lt; 之类被二次解码）。
-* 模糊提取的条目文本解码后经 XML 序列化重新转义，已有转义形式不发生二次转义。
-*/
-function decodeXmlEntities(text) {
-	return text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+/** 追加一条 om 私有事件（借用 feedback/record，log-only，不进 surface），返回事件 seq。 */
+function appendOmEvent(session, kind, data) {
+	return session.append("feedback/record", { text: encodeOmEvent(kind, data) }).seq;
 }
-/**
-* 模糊重建 <history> 块（xmldom 原生无模糊匹配，按条目标签做字符串级扫描配对）：
-* 依次提取 user_message / sys / assistant / reasoning 条目——开闭标签就近配对、
-* 自闭合直接成条、未闭合条目以文本末尾收口；未知元素与其间杂文忽略；条目文本
-* 解码后重新序列化为合法 XML。扫描不到任何条目返回 null。
-*/
-function rebuildHistoryBlock(inner) {
-	const entries = [];
-	const stack = [];
-	for (const m of inner.matchAll(HISTORY_ENTRY_TOKEN_RE)) {
-		const tag = m[2] ?? "";
-		if (m[1] === "/") for (let i = stack.length - 1; i >= 0; i -= 1) {
-			const open = stack[i];
-			if (open?.tag === tag) {
-				entries.push({
-					tag,
-					attrs: open.attrs,
-					content: inner.slice(open.contentFrom, m.index)
-				});
-				stack.splice(i, 1);
-				break;
-			}
-		}
-		else if (m[4] === "/") entries.push({
-			tag,
-			attrs: parseTagAttrs(m[3] ?? ""),
-			content: ""
-		});
-		else stack.push({
-			tag,
-			attrs: parseTagAttrs(m[3] ?? ""),
-			contentFrom: m.index + m[0].length
-		});
+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);
 	}
-	for (const open of stack) entries.push({
-		tag: open.tag,
-		attrs: open.attrs,
-		content: inner.slice(open.contentFrom)
-	});
-	if (entries.length === 0) return null;
-	const doc = newQuietParser().parseFromString(`<${HISTORY_TAG} />`, "text/xml");
-	const root = doc.documentElement;
-	if (!root) return null;
-	for (const e of entries) {
-		const el = doc.createElement(e.tag);
-		for (const [key, value] of Object.entries(e.attrs)) el.setAttribute(key, decodeXmlEntities(value));
-		el.appendChild(doc.createTextNode(decodeXmlEntities(e.content)));
-		root.appendChild(el);
-	}
-	return new import_lib.XMLSerializer().serializeToString(root);
+	return result;
 }
+//#endregion
+//#region src/degrade.ts
 /**
-* 从 AI 摘要输出中提取合法日志（不信任 AI 的总结结果）：
-* 取首个 <history> 开标签（允许带属性）到最后一个 </history> 切为候选块，
-* 找不到或内容过短返回具体原因；候选块经 XML 结构校验，整块非法时按条目模糊
-* 提取重建为合法块（不要求模型输出整体合法 XML）；随后统一校验：无 reasoning、
-* index 连续且与 expected 覆盖区间一致；通过后统一改写为带 tip 属性的开标签
-* 并在块顶插入格式说明注释。所有失败原因均为说明性描述，不携带解析器原始报错。
+* 降级报告：压缩流程中的挂载失败统一出口。
+* 导出 reportDegrade / DEGRADE_PROBLEMS / DegradedProblem。
+*
+* - 挂载失败类问题（服务缺失、服务调用异常）始终 console.warn 到宿主进程外部输出，
+*   并向会话日志追加 log-only 的 om 警告事件（借用 feedback/record 的 om 信封，
+*   见 om-event.ts；客户端渲染为「功能降级」警告行）；
+*   同一会话同一问题只报告一次（按日志扫描去重，重启不重复）
+* - 报告动作自身绝不抛错：追加失败只记日志，不阻塞压缩
+* - 辅助函数的普通运行时报错（组装失败、请求头读取失败）不走本模块，仅记日志
 */
-function extractSummaryDetailed(raw, expected) {
-	const closeTag = `</${HISTORY_TAG}>`;
-	const openMatch = HISTORY_OPEN_TAG_RE.exec(raw);
-	const open = openMatch?.index ?? -1;
-	const close = raw.lastIndexOf(closeTag);
-	if (openMatch === null || close === -1 || close < open) return { error: "输出中找不到完整的 <history> 块（缺少 <history> 开标签或 </history> 闭标签）" };
-	const inner = raw.slice(open + openMatch[0].length, close);
-	if (inner.trim().length < 10) return { error: "输出中 <history> 块内容过短（少于 10 字符）" };
-	const block = raw.slice(open, close + closeTag.length);
-	const candidate = parseHistoryBlock(block) === null ? rebuildHistoryBlock(inner) : block;
-	if (candidate === null) return { error: "输出不是合法的 <history> 块（XML 结构非法，按条目模糊提取也未找到有效条目）" };
-	const parsed = parseHistoryBlock(candidate);
-	if (parsed === null) return { error: "输出不是合法的 <history> 块（条目结构非法：属性缺失或包含未定义元素）" };
-	if (parsed.hasReasoning) return { error: "输出包含 <reasoning> 条目（产物不允许携带思考过程）" };
-	const span = historyContinuity(parsed.entries);
-	if (span === null) return { error: "输出条目 index/start/end 不连续（跳号、重叠或乱序）" };
-	if (expected?.start !== void 0 && span.start !== expected.start) return { error: `输出覆盖区间从 ${span.start} 开始，与期望起始 ${expected.start} 不一致` };
-	if (expected?.end !== void 0 && span.end !== expected.end) return { error: `输出覆盖区间止于 ${span.end}，与期望结束 ${expected.end} 不一致` };
-	const candidateInner = candidate.slice(candidate.indexOf(">") + 1, candidate.length - closeTag.length).trim();
-	return { log: `<${HISTORY_TAG} tip="${HISTORY_TIP}">\n${HISTORY_FORMAT_NOTE}\n${candidateInner}\n</${HISTORY_TAG}>` };
-}
+/** 各降级问题面向用户的简短说明（om/warning 信封载荷 message；客户端警告行直接展示）。 */
+const DEGRADE_PROBLEMS = {
+	"systemPrompt-missing": "系统提示词服务未挂载，上下文压力估算不扣除系统提示词 tokens（压缩触发会偏早）",
+	"tokenMeter-unavailable": "token 计量服务异常，上下文压力估算降级（可能跳过压缩或按 0 计）"
+};
 /**
-* 直连 LLM 执行一次摘要（观察或反思），返回文本与可选 token usage。
-* 每次实际发出的 LLM 调用（无论成功、校验不通过、非 stop 结束还是异常）完成后，
-* 立即把该次尝试的完整提示词与模型原始输出原样落盘为诊断子会话（phase 标注观察
-* 或反思），子会话 id 写入该次尝试的主会话日志；请求发出前被中止的尝试（无实际
-* 调用）不落盘。失败（抛异常 / 空输出 / 非 stop 结束 / 校验不通过）记录日志并重试；
-* 全部尝试耗尽返回失败结果（携带最后一次尝试的实际报错/具体问题与其诊断子会话 id）。
-* signal 中止（含限流等待被中止）立即放弃并标记 aborted。每次请求发出前先过全局
-* 限流等待门。
+* 报告一次挂载失败类降级：console.warn 始终输出到宿主进程外部；同会话同问题首次
+* 出现时，向会话日志追加 log-only om 警告事件（客户端渲染警告行，每会话最多
+* 一次）并输出 logger.warn（避免每个 pre-step 重复刷日志）。
+* 日志扫描/事件追加失败只记日志，绝不抛错、不阻塞压缩。
 */
-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 = {};
-	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-		if (signal?.aborted) {
-			logger.warn(`摘要调用中止（第 ${attempt}/${maxAttempts} 次尝试前 signal 已中止），放弃本次压缩`);
-			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 {
-				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
+function reportDegrade(session, logger, problem) {
+	const message = DEGRADE_PROBLEMS[problem];
+	let first = true;
+	try {
+		first = !findOmEvents(session, "om/warning").some((om) => om.data.problem === problem);
+	} catch {}
+	if (!first) return;
+	console.warn(`${PLUGIN_LABEL}: ${message}`);
+	logger.warn(message);
+	try {
+		appendOmEvent(session, "om/warning", {
+			problem,
+			message
 		});
-		try {
-			const requestOptions = buildSummaryOptions(session, instruction, contextText, maxTokens, target, signal);
-			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)} 结束（非正常完成）`,
-					...diagnosticSessionId === void 0 ? {} : { diagnosticSessionId }
-				};
-				logger.warn(`摘要未完成（第 ${attempt}/${maxAttempts} 次，${lastFailure.reason}，子会话 ${diagnosticSessionId ?? "未落盘"}）` + (attempt < maxAttempts ? "，将重试" : "，重试耗尽，放弃本次压缩"));
-				continue;
-			}
-			if ("error" in extracted) {
-				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`) + `，子会话 ${diagnosticSessionId ?? "未落盘"}）`);
-			return {
-				ok: true,
-				text,
-				attemptCount: attempt,
-				...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,
-				...diagnosticSessionId === void 0 ? {} : { diagnosticSessionId }
-			};
-			logger.warn(`摘要调用失败（第 ${attempt}/${maxAttempts} 次，${message}，子会话 ${diagnosticSessionId ?? "未落盘"}）` + (attempt < maxAttempts ? "，将重试" : "，重试耗尽，放弃本次压缩"));
-		}
+	} catch (error) {
+		const text = error instanceof Error ? error.message : String(error);
+		logger.warn(`om 警告事件追加失败: ${text}`);
 	}
-	const lastError = lastFailure.error ?? lastFailure.reason ?? "未知原因";
-	logger.warn(`摘要调用最终失败（已尝试 ${maxAttempts} 次，最后错误：${lastError}），拒绝放行本轮 step`);
-	return {
-		ok: false,
-		error: lastError,
-		aborted: false,
-		...lastFailure.diagnosticSessionId === void 0 ? {} : { diagnosticSessionId: lastFailure.diagnosticSessionId }
-	};
 }
 //#endregion
 //#region src/compress.ts
@@ -8206,21 +8499,27 @@ async function runSummarySubagent(ctx, agent, instruction, contextText, maxToken
 * 导出 estimateTextTokens / isPairBalancedAfter / computeCompressRange / historySection /
 * findObservePending / reflectPass / observePass / maybeCompress。
 *
-* - 反思：全部 <history> 块 token 合计 ≥ reflectThresholdTokens 时，块内文拼合为单个
-*   <history> 块输入摘要，合并为一条
+* - 摘要生成走工具驱动的压缩循环（compress-loop.ts runCompressionLoop）：首条 user
+*   消息仅含压缩指令与 start/end 区间，模型经 getHistory / compressHistory /
+*   completeCompression 工具完成压缩；最终 <history> 块由插件从视图与替换记录构建，
+*   全程无需整块校验
+* - 反思：全部 <history> 块 token 合计 ≥ reflectThresholdTokens 时，把全部块条目作为
+*   压缩视图重新压缩合并（视图无条目时跳过，如全部为不可解析的历史遗留块）
 * - 观察（触发 → 待定 → 延迟执行）：净压力（上下文压力 − 已压缩块 token 合计 − 系统提示词
 *   token 估算 − 工具定义 token 估算）首次 ≥ observeThresholdTokens 时记录待定标记
 *   （触发点 = 当时的最后一条完整消息 index），本次不压缩；待定后新增完整消息数 ≥
-*   tailMessageCount 时，把压缩边界至触发点的全部消息摘要为新 <history> 块并精确替换
-*   被压缩区间（旧块保留），等待期间的新消息成为下一轮未压缩尾部（延迟窗口内压力允许
+*   tailMessageCount 时，把压缩边界至触发点的全部消息作为压缩视图替换为新 <history>
+*   块（旧块保留），等待期间的新消息成为下一轮未压缩尾部（延迟窗口内压力允许
 *   短暂超阈值）；tailMessageCount=0 时触发当轮直接执行（不落待定标记）
 * - 待定标记以 log-only om 信封事件（借用 feedback/record，kind 为 om/observe-pending /
 *   om/observe-invalidate，见 om-event.ts）持久化在会话日志中（重启后从日志恢复）；
-*   摘要失败保留待定，下个 pre-step 直接重试执行
+*   压缩失败保留待定，下个 pre-step 直接重试执行
 * - 两级在 pre-step 阻塞串行执行（先反思后观察）；仅主会话生效；omEnabled=false 关闭
 * - 压缩边界：最后一个合法 <history> 块之后的消息视为未压缩，其前不重复压缩
-* - 摘要尝试全部耗尽时 pass 返回失败结果（携带最后一次尝试的实际报错），压缩流程
-*   向上传播，pre-step 据此拒绝本 step 中断当前 turn；signal 中止标记 aborted（不中断）
+* - 压缩循环最终失败（连续无工具调用 / 请求级错误）时 pass 返回失败结果（携带最后一次
+*   错误），压缩流程向上传播，pre-step 据此拒绝本 step 中断当前 turn；signal 中止标记
+*   aborted（不中断）；成功与失败均落盘压缩会话记录子会话（失败时其 id 随结果传播为
+*   诊断子会话 id）
 * - 提交走宿主 compaction/* 生命周期事件（start 带 phase → summary → 替换消息 → end），
 *   失败补 end(error，实际报错 + 诊断子会话 sessionId)；替换消息 source 标记插件标识供 UI 认领
 * - 挂载失败类问题（systemPrompt/tokenMeter 服务异常）始终 console 到外部进程，并追加
@@ -8234,16 +8533,20 @@ function estimateTextTokens(text) {
 	return Math.ceil(text.length / 4);
 }
 /**
-* 反思输入块引用的最大完整消息 index（解析全部条目取最大 end；无条目返回 -1）。
-* 反思输出必须覆盖输入引用的完整 index 区间（0..max），连续性校验据此约束。
+* 运行压缩循环并归一化结果：失败统一追加 compaction/end(error)（携带诊断子会话 id），
+* 成功记会话记录日志；返回循环结果（成功时由调用方提交）。
 */
-function reflectExpectedEnd(contextText) {
-	let max = -1;
-	for (const e of parseHistoryEntries(contextText)) {
-		const hi = e.kind === "assistant" && e.end !== void 0 ? e.end : e.index ?? 0;
-		if (hi > max) max = hi;
+async function runPassLoop(ctx, session, lifecycle, options, logger, phase) {
+	const outcome = await runCompressionLoop(ctx, session, options);
+	if (!outcome.ok) {
+		logger.warn(`${phase === "reflect" ? "反思" : "观察"}：压缩循环失败（${outcome.error}），诊断子会话 ${outcome.recordSessionId ?? "未落盘"}，追加 compaction/end(error)`);
+		try {
+			appendCompactionEnd(session, lifecycle, outcome.error, outcome.recordSessionId);
+		} catch {}
+		return outcome;
 	}
-	return max;
+	if (outcome.recordSessionId !== void 0) logger.step(`压缩会话记录子会话 ${outcome.recordSessionId}`);
+	return outcome;
 }
 /**
 * 判定消息是否为本插件的压缩日志消息并提取日志文本（按 source 标记判断，兼容旧宿主
@@ -8273,14 +8576,6 @@ 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 与其结果切到两侧）。
 */
@@ -8462,9 +8757,10 @@ function appendHistoryMessage(session, content, sourceEventSeqs, surfaceOp, comp
 	});
 }
 /**
-* 反思：全部 <history> 块 token 合计 ≥ reflectThresholdTokens 时，全部块内文拼合为
-* 单个 <history> 块送入摘要调用，整个块区段合并替换为一条更紧凑的摘要。失败不产生
-* 部分替换；摘要尝试全部耗尽返回失败结果（error = 最后一次尝试的实际报错/具体问题）。
+* 反思：全部 <history> 块 token 合计 ≥ reflectThresholdTokens 时，把全部块内条目作为
+* 压缩视图送入工具压缩循环，整个块区段合并替换为一条更紧凑的摘要。视图无条目（全部
+* 为不可解析的历史遗留块）时跳过。失败不产生部分替换；最终失败返回失败结果
+* （error = 最后一次错误）。
 */
 async function reflectPass(ctx, agent, config, target, signal) {
 	const session = agent.session;
@@ -8489,43 +8785,41 @@ async function reflectPass(ctx, agent, config, target, signal) {
 		logger.step("反思：块区段缺失，跳过");
 		return { failed: false };
 	}
+	const view = buildReflectView(blocks, { skipReasoning: config.compressSkipReasoning });
+	if (view.minIndex === void 0 || view.maxIndex === void 0) {
+		logger.step("反思：块内无可定位条目（历史遗留块），跳过");
+		return { failed: false };
+	}
 	const blockSeqs = blocks.map((block) => block.seq);
-	const instruction = buildHistoryPrompt(config.compressSkipReasoning);
-	const contextText = mergeHistoryBlocks(blocks);
-	const expectedEnd = reflectExpectedEnd(contextText);
 	const lifecycle = {
 		compactionId: newCompactionId(),
 		turn: openTurnOf(session)
 	};
 	try {
-		logger.step("反思：追加 compaction/start（摘要调用前开启压缩中提示）");
+		logger.step("反思：追加 compaction/start（压缩循环前开启压缩中提示）");
 		appendCompactionStart(session, lifecycle, "reflect");
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		logger.warn(`反思压缩启动失败: ${message}`);
 		return { failed: false };
 	}
-	const summaryResult = await runSummarySubagent(ctx, agent, instruction, contextText, config.compressMaxTokens, target, config.debug, signal, {
-		maxAttempts: config.compressRetryCount + 1,
-		expected: expectedEnd < 0 ? { start: 0 } : {
-			start: 0,
-			end: expectedEnd
-		},
+	const summaryResult = await runPassLoop(ctx, session, lifecycle, {
+		view,
+		phase: "reflect",
+		taskText: buildCompressionTaskText("reflect", view.minIndex, view.maxIndex),
+		target,
+		maxTokens: config.compressMaxTokens,
 		rateLimitWaitMs: config.rateLimitWaitMs,
-		phase: "reflect"
-	});
-	if (!summaryResult.ok) {
-		logger.warn(`反思：摘要调用失败（${summaryResult.error}），诊断子会话 ${summaryResult.diagnosticSessionId ?? "未落盘"}，追加 compaction/end(error)`);
-		try {
-			appendCompactionEnd(session, lifecycle, summaryResult.error, summaryResult.diagnosticSessionId);
-		} catch {}
-		return {
-			failed: true,
-			error: summaryResult.error,
-			aborted: summaryResult.aborted,
-			...summaryResult.diagnosticSessionId === void 0 ? {} : { diagnosticSessionId: summaryResult.diagnosticSessionId }
-		};
-	}
+		skipReasoning: config.compressSkipReasoning,
+		debug: config.debug,
+		...signal === void 0 ? {} : { signal }
+	}, logger, "reflect");
+	if (!summaryResult.ok) return {
+		failed: true,
+		error: summaryResult.error,
+		aborted: summaryResult.aborted,
+		...summaryResult.recordSessionId === void 0 ? {} : { diagnosticSessionId: summaryResult.recordSessionId }
+	};
 	const report = summaryResult.text;
 	try {
 		logger.step("反思提交：追加 compaction/summary（影子价格认领）");
@@ -8542,7 +8836,7 @@ async function reflectPass(ctx, agent, config, target, signal) {
 			provider: target.provider,
 			model: target.model,
 			maxTokens: config.compressMaxTokens,
-			attemptCount: summaryResult.attemptCount - 1,
+			attemptCount: summaryResult.rounds,
 			...summaryResult.usage === void 0 ? {} : { usage: summaryResult.usage }
 		});
 		logger.step("反思提交：替换整个 <history> 块区段为合并摘要");
@@ -8552,7 +8846,7 @@ async function reflectPass(ctx, agent, config, target, signal) {
 			end: last.seq
 		}, lifecycle.compactionId);
 		logger.step("反思提交：追加 compaction/end");
-		appendCompactionEnd(session, lifecycle, void 0, summaryResult.diagnosticSessionId);
+		appendCompactionEnd(session, lifecycle, void 0, summaryResult.recordSessionId);
 		logger.info(`反思完成（摘要 ${tokens} tokens ≥ 阈值 ${threshold}，合并 ${blocks.length} 个块为一条）`);
 		return { failed: false };
 	} catch (error) {
@@ -8627,9 +8921,9 @@ function measurePressureTokens(ctx, session, logger) {
 * observeThresholdTokens 时记录待定标记（触发点 = 当时的最后一条完整消息 index），本次
 * 不压缩（tailMessageCount=0 当轮直接执行，不落待定标记）；已有待定标记时按新增完整
 * 消息数 ≥ tailMessageCount 决定执行，压缩区间截至触发点（新增消息成为新未压缩尾部，
-* 延迟窗口内压力允许短暂超阈值）。执行成功（或无可行区间）后写待定失效标记；摘要
-* 失败保留待定，下个 pre-step 直接重试执行。摘要尝试全部耗尽返回失败结果
-* （error = 最后一次尝试的实际报错/具体问题）。
+* 延迟窗口内压力允许短暂超阈值）。执行成功（或无可行区间）后写待定失效标记；压缩
+* 失败保留待定，下个 pre-step 直接重试执行。最终失败返回失败结果
+* （error = 最后一次错误）。
 */
 async function observePass(ctx, agent, config, waitCount, target, signal) {
 	const session = agent.session;
@@ -8706,52 +9000,48 @@ async function observePass(ctx, agent, config, waitCount, target, signal) {
 		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) {
+	if (indexCompleteMessages(session).filter((cm) => cm.seqs.every((seq) => shadowedSet.has(seq))).length === 0) {
 		logger.step("观察：区间内无完整消息，清除待定标记视为完成");
 		clearPending();
 		return { failed: false };
 	}
-	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(config.compressSkipReasoning);
-	const contextText = renderMessages(session, replaceSeqs, config.compressSkipReasoning);
+	const view = buildObserveView(session, replaceSeqs, { skipReasoning: config.compressSkipReasoning });
+	if (view.minIndex === void 0 || view.maxIndex === void 0) {
+		logger.step("观察：区间内无可定位条目，清除待定标记视为完成");
+		clearPending();
+		return { failed: false };
+	}
+	logger.step(`观察：保留旧块 ${blocks.length} 条，替换 [${replaceStart}..${range.end}]（${replaceSeqs.length} 个表层节点，压缩至${triggerNote}），视图区间 ${view.minIndex}..${view.maxIndex}`);
 	const lifecycle = {
 		compactionId: newCompactionId(),
 		turn: openTurnOf(session)
 	};
 	try {
-		logger.step("观察：追加 compaction/start（摘要调用前开启压缩中提示）");
+		logger.step("观察：追加 compaction/start（压缩循环前开启压缩中提示）");
 		appendCompactionStart(session, lifecycle, "observe");
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		logger.warn(`观察压缩启动失败: ${message}`);
 		return { failed: false };
 	}
-	const summaryResult = await runSummarySubagent(ctx, agent, instruction, contextText, config.compressMaxTokens, target, config.debug, signal, {
-		maxAttempts: config.compressRetryCount + 1,
-		expected: {
-			start: startIndex,
-			end: endIndex
-		},
+	const summaryResult = await runPassLoop(ctx, session, lifecycle, {
+		view,
+		phase: "observe",
+		taskText: buildCompressionTaskText("observe", view.minIndex, view.maxIndex),
+		target,
+		maxTokens: config.compressMaxTokens,
 		rateLimitWaitMs: config.rateLimitWaitMs,
-		phase: "observe"
-	});
-	if (!summaryResult.ok) {
-		logger.warn(`观察：摘要调用失败（${summaryResult.error}），诊断子会话 ${summaryResult.diagnosticSessionId ?? "未落盘"}，追加 compaction/end(error)`);
-		try {
-			appendCompactionEnd(session, lifecycle, summaryResult.error, summaryResult.diagnosticSessionId);
-		} catch {}
-		return {
-			failed: true,
-			error: summaryResult.error,
-			aborted: summaryResult.aborted,
-			...summaryResult.diagnosticSessionId === void 0 ? {} : { diagnosticSessionId: summaryResult.diagnosticSessionId }
-		};
-	}
+		skipReasoning: config.compressSkipReasoning,
+		debug: config.debug,
+		...signal === void 0 ? {} : { signal }
+	}, logger, "observe");
+	if (!summaryResult.ok) return {
+		failed: true,
+		error: summaryResult.error,
+		aborted: summaryResult.aborted,
+		...summaryResult.recordSessionId === void 0 ? {} : { diagnosticSessionId: summaryResult.recordSessionId }
+	};
 	const report = summaryResult.text;
-	const attemptCount = summaryResult.attemptCount - 1;
 	const usage = summaryResult.usage;
 	const shadowedTokenCount = replaceSeqs.reduce((total, seq) => {
 		const event = session.events[seq];
@@ -8784,7 +9074,7 @@ async function observePass(ctx, agent, config, waitCount, target, signal) {
 			provider: target.provider,
 			model: target.model,
 			maxTokens: config.compressMaxTokens,
-			attemptCount,
+			attemptCount: summaryResult.rounds,
 			...usage === void 0 ? {} : { usage }
 		});
 		logger.step("观察提交：替换被压缩新消息区间为 <history>（旧块保留）");
@@ -8794,7 +9084,7 @@ async function observePass(ctx, agent, config, waitCount, target, signal) {
 			end: range.end
 		}, lifecycle.compactionId);
 		logger.step("观察提交：追加 compaction/end");
-		appendCompactionEnd(session, lifecycle, void 0, summaryResult.diagnosticSessionId);
+		appendCompactionEnd(session, lifecycle, void 0, summaryResult.recordSessionId);
 		clearPending();
 		logger.info(`观察压缩完成（替换 ${replaceSeqs.length} 个表层节点，约 ${shadowedTokenCount} tokens，压缩至${triggerNote}）`);
 		return { failed: false };
@@ -9051,7 +9341,6 @@ const DEFAULT_CONFIG = Object.freeze({
 	compressMaxTokens: void 0,
 	rateLimitWaitMs: 6e4,
 	tailMessageCount: 5,
-	compressRetryCount: 5,
 	compressSkipReasoning: true,
 	omEnabled: true,
 	debug: false,
@@ -9065,8 +9354,7 @@ const NUMBER_KEYS = [
 	["reflectThresholdTokens", true],
 	["compressMaxTokens", true],
 	["rateLimitWaitMs", true],
-	["tailMessageCount", true],
-	["compressRetryCount", true]
+	["tailMessageCount", true]
 ];
 /** 归一化原始配置输入：缺省 / null / 空串 / 非对象视为空对象。 */
 function normalizeConfigInput(raw) {
@@ -9455,10 +9743,12 @@ function buildSemanticRecallTool(options) {
 /**
 * dsh-plugin-om 入口（tsdown 打包入口）：导出 name / inject / apply。
 * apply 注册 recall / recall-semantic 工具，并接线 agent/pre-step 自动压缩
-* （先反思后观察，仅主会话生效）。压缩摘要尝试全部耗尽时拒绝本 step 中断当前
-* turn（signal 中止除外），主会话日志记录失败原因与诊断子会话 sessionId（每次
-* 尝试的完整提示词与模型原始输出由 compaction-log.ts 落盘为诊断子会话）。压缩与
-* 检索的实现见 compress.ts / compaction-log.ts / recall.ts / semantic-recall.ts。
+* （先反思后观察，仅主会话生效）。压缩走工具驱动的压缩循环（模型经 getHistory /
+* compressHistory / completeCompression 工具完成，见 compress-loop.ts）；最终失败
+* （连续无工具调用 / 请求级错误）时拒绝本 step 中断当前 turn（signal 中止除外），
+* 主会话日志记录失败原因与诊断子会话 sessionId（完整循环会话由 compaction-log.ts
+* 落盘为子会话）。压缩与检索的实现见 compress.ts / compress-loop.ts /
+* compaction-log.ts / recall.ts / semantic-recall.ts。
 */
 /** 插件名（Loader 识别入口的稳定标识）。 */
 const name = "dsh-plugin-om";