dsh-plugin-om 0.0.6 → 0.0.9

package/dist/index.mjs

@@ -13,75 +13,6 @@ const HISTORY_TAG = "om-history";
 /** 宿主压缩 checkpoint 标记的 plugin 名（dsh-compaction-basic 的 COMPACT_CHECKPOINT_MARKER.plugin）。 */
 const COMPACT_CHECKPOINT_PLUGIN = "compact";
 //#endregion
-//#region src/log-index.ts
-/**
-* 查找 seq 在表层节点序列中的下标（不在则返回 -1）。
-* 表层节点按日志顺序排列，用于压缩边界定位与遮蔽范围计算。
-*/
-function surfaceIndexOf(nodes, seq) {
-	for (let i = 0; i < nodes.length; i += 1) if (nodes[i] === seq) return i;
-	return -1;
-}
-/** 提取一条消息事件的 message_id（user/assistant/tool-result 消息均有稳定 id；其余事件无）。 */
-function messageIdOfEvent(event) {
-	if (!event) return void 0;
-	if (event.type === "user/message") return String(event.data.id ?? "");
-	if (event.type === "assistant/message") return String(event.data.message.id ?? "");
-	if (event.type === "tool/result") return String(event.data.message.id ?? "");
-}
-/** 消息索引：按日志顺序列出全部消息事件，并按 message_id 定位其在消息序列中的下标。 */
-function indexMessages(session) {
-	/** 按日志顺序的消息事件列表。 */
-	const messages = [];
-	/** message_id → 序列下标映射。 */
-	const byId = /* @__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" && event.type !== "assistant/message" && event.type !== "tool/result") continue;
-		/** 消息 id（缺失则跳过该事件）。 */
-		const id = messageIdOfEvent(event);
-		if (!id) continue;
-		/** 本条消息在消息序列中的下标。 */
-		const index = messages.length;
-		messages.push({
-			seq,
-			id,
-			type: event.type
-		});
-		byId.set(id, index);
-	}
-	return {
-		messages,
-		byId
-	};
-}
-//#endregion
-//#region src/logger.ts
-/**
-* 日志辅助：步骤级（debug）日志默认仅 dev（非 production）输出，便于开发调试；
-* 失败等关键日志始终输出（不受 debug 开关影响）。
-* 开关配置键 debug：true 强制开启、false 强制关闭，缺省按 NODE_ENV !== 'production' 判定
-* （默认值由 resolveConfig 解析，见 config.ts）。
-*/
-/** 构建插件日志门面：统一加 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 src/utils.ts
 /** 判断值是否为普通对象：typeof object 且非 null 且非数组（类型收窄用）。 */
 function isRecord(value) {
@@ -153,24 +84,188 @@ function routedTarget(session) {
 	} catch {}
 }
 //#endregion
+//#region src/log-index.ts
+/**
+* 查找 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 独立成条（防御）。
+*/
+function indexCompleteMessages(session) {
+	/** 完整消息序列（index = 数组下标，0 起）。 */
+	const cms = [];
+	/** 等待结果的 toolcall 完整消息（callId → cm）。 */
+	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") {
+			if (event.data.source?.kind === "plugin") continue;
+			cms.push({
+				index: cms.length,
+				type: "user",
+				seqs: [seq]
+			});
+		} else if (event.type === "assistant/message") {
+			/** 助手消息（含文本与 tool-call 块）。 */
+			const message = event.data.message;
+			if (!message || !Array.isArray(message.content)) continue;
+			/** 是否存在文本块（有则先产出 assistant 条）。 */
+			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;
+				/** 工具调用 id（匹配 result 用）。 */
+				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") {
+			/** 结果消息的 source（callId 关联调用）。 */
+			const source = event.data.message?.source;
+			/** 关联的调用 id。 */
+			const callId = String(source?.callId ?? "");
+			/** 匹配到的 toolcall 完整消息（无则独立成条）。 */
+			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;
+}
+/**
+* 渲染一条完整消息的文本（recall 输出 / new 模式输入共用）：
+*  - user：消息原文；
+*  - assistant：仅文本块；
+*  - toolcall：调用块（工具名 + 参数）+ 结果文本（pruner 裁剪超大结果）。
+*/
+function renderCompleteMessage(session, cm, pruner) {
+	if (cm.type === "user") {
+		/** 用户消息事件（seq 缺失则无法渲染）。 */
+		const seq = cm.seqs[0];
+		const event = seq === void 0 ? void 0 : session.events[seq];
+		/** 派生的消息对象。 */
+		const message = event ? session.deriveEventMessage(event) : null;
+		return message ? renderMessageText(message) : "";
+	}
+	if (cm.type === "assistant") {
+		/** 助手消息事件（seq 缺失则无法渲染）。 */
+		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 "";
+		/** 文本块拼接缓冲。 */
+		const texts = [];
+		for (const block of message.content) if (block.type === "text") texts.push(String(block.text));
+		return texts.join("\n");
+	}
+	/** 渲染缓冲。 */
+	const parts = [];
+	/** 承载调用块的 assistant 事件（seq 缺失则跳过调用块）。 */
+	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)) {
+			/** 匹配的 tool-call 块。 */
+			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)}`);
+		}
+	}
+	/** 结果事件 seq（无则调用未闭合）。 */
+	const resultSeq = cm.seqs[1];
+	const resultEvent = resultSeq === void 0 ? void 0 : session.events[resultSeq];
+	if (resultEvent?.type === "tool/result") {
+		/** 结果消息对象（pruner 裁剪超大内容后渲染）。 */
+		let message = session.deriveEventMessage(resultEvent);
+		if (message && pruner?.pruneContent) {
+			/** 裁剪后的内容块。 */
+			const pruned = pruner.pruneContent(message.content);
+			if (pruned) message = {
+				...message,
+				content: pruned
+			};
+		}
+		/** 结果文本。 */
+		const text = message ? renderMessageText(message) : "";
+		if (text.trim() !== "") parts.push(`[result]\n${text}`);
+	}
+	return parts.join("\n");
+}
+//#endregion
+//#region src/logger.ts
+/**
+* 日志辅助：步骤级（debug）日志默认仅 dev（非 production）输出，便于开发调试；
+* 失败等关键日志始终输出（不受 debug 开关影响）。
+* 开关配置键 debug：true 强制开启、false 强制关闭，缺省按 NODE_ENV !== 'production' 判定
+* （默认值由 resolveConfig 解析，见 config.ts）。
+*/
+/** 构建插件日志门面：统一加 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 src/summarize.ts
 /** 观察者 persona：只针对未压缩消息产出观察日志，不用工具、不展示思考。 */
-const OBSERVER_PERSONA = "你是 dsh-plugin-om 的上下文观察者（Observer，机制参考 Mastra Observational Memory）：把会话中尚未压缩的消息压缩为一份观察日志。不用工具、不展示思考、不评价代码、不输出多余文字。";
+const OBSERVER_PERSONA = "把会话中尚未压缩的消息压缩为一份观察日志。不用工具、不展示思考、不评价代码、不输出多余文字。";
 /** 反思者 persona：只精简合并当前摘要，不用工具、不展示思考。 */
-const REFLECTOR_PERSONA = "你是 dsh-plugin-om 的上下文反思者（Reflector，机制参考 Mastra Observational Memory）：把当前 <om-history> 压缩日志精简合并为一份更紧凑的日志。不用工具、不展示思考、不输出多余文字。";
+const REFLECTOR_PERSONA = "把当前 <om-history> 压缩日志精简合并为一份更紧凑的日志。不用工具、不展示思考、不输出多余文字。";
 /**
 * 构建观察指令主体：任务声明（fork：停止任务/禁止工具；new：说明总结日志）+ 模式相关
 * 的上下文定位与压缩范围（fork：上方完整会话记录——尾部已在输入中实际截断，提示词不含
-* 尾部规则；new：下方消息即压缩对象）+ 规则（用户消息完整保留原文 / AI 消息模块化压缩
-* ——工具调用按目的聚合——不限于 run_code / 倾向于新消息 / 中断标注 / 未完成写进度与
-* 下一步）+ 输出格式（合法 XML）+ 对照表 + 中断标记 + 追加说明。persona 由调用方拼接
-* 到指令开头。
+* 尾部规则；new：下方消息即压缩对象）+ 完整消息与 index 定义（三类合并规则、起始编号）+
+* 规则（用户消息完整保留原文 / AI 消息按模块压缩 / 本指令不入日志 / index/start/end 连续 /
+* 倾向于新消息 / 未完成写进度与下一步）+ 输出格式（合法 XML）+ 追加说明。
+* persona 由调用方拼接到指令开头。
 */
 function buildObservePrompt(options) {
-	/** 对照表段落（无则标注「无」）。 */
-	const tableSection = options.table.length > 0 ? options.table : ["（无）"];
-	/** 中断标记段落（无则标注「无」）。 */
-	const interruptionSection = options.interruptions.length > 0 ? options.interruptions : ["（无）"];
 	return [
 		options.mode === "fork" ? "停止一切现有任务，禁止调用任何工具，改为将过往消息总结为一份日志。" : "将过往消息总结为一份日志。",
 		"",
@@ -180,28 +275,32 @@ function buildObservePrompt(options) {
 			`如果消息记录里还没有 <${HISTORY_TAG}> 块，则除本指令外的全部消息都是压缩对象。`
 		] : ["下方的消息记录是本次要压缩的全部消息（上一个 <om-history> 块之后的新消息；不含旧压缩日志、不含尾部）。", "你的压缩结果会作为新的 <om-history> 块追加到已有压缩日志之后。"],
 		"",
+		"【完整消息与 index】",
+		"- 完整消息分三类：用户消息占一条；AI 文本占一条；工具调用及其结果占一条（每个 tool-call 与其 result 各一条，同一条 AI 消息里的文本与工具调用拆开）。每条完整消息有一个 index（从 0 起、按会话顺序递增、全局稳定），index 是该条完整消息的序号。",
+		`- 本次要压缩的新消息从 index ${options.startIndex} 开始编号，按日志顺序逐条递增；旧 <${HISTORY_TAG}> 中已有的 index 无需理会，也不要改动旧条目。`,
+		"",
 		"【规则】",
-		"- 用户消息完整保留原文，输出为 <user_message> 条目（id 为该消息的 message_id，内容为消息原文，不概括、不省略）。",
-		"- AI 消息划分模块压缩（与现状一致）：所有工具调用（run_code 与其他工具同等对待，不限于 run_code）按调用目的聚合为一行 toolcall message_id:<该组最后一条消息的 message_id> purpose:<聚合目的> summary:<行为与结果摘要>；目的相同、关联度高的连续行为聚合为一个 <assistant> 模块，模块内最后一条消息的 message_id 作为 last_id；工具组内部细节（参数、完整输出）不保留，需要原文时用 recall 按 message_id 回看。",
+		"- 当前消息仅作为指令，**不得**进入日志。",
+		"- 用户消息完整保留原文，输出为 <user_message index=\"N\"> 条目（N 为该条完整消息的 index，内容为消息原文，不概括、不省略）。",
+		"- 将AI 消息按照内在关联，划分为**连续消息**组成的模块，消息模块的划分方式不受限制，但内部须有足够的**逻辑连贯性**，应当是AI基于某个目的做出了一系列动作或论述",
+		"- 模块内的消息聚合输出为<assistant start=\"\" end=\"\">块，start/end表示当前模块首尾消息的index；块内不描述单条消息的细节，只描述当前模块的**目的、行为、结果**；最后一个<assistant>块，额外包含`下一步计划`",
+		"- 对于模块涉及到的具体文件，应当出现在<assistant>块中，多个前缀相同的路径要合并简写",
+		"- 对于单条重要的AI完整消息，以<assistant index=\"\">单独呈现，其内容不受限制",
+		"- 条目按 index 顺序覆盖本次压缩的全部完整消息，index/start/end 必须连续（区间内 index 连续、相邻条目相接），不跳号、不重叠、不遗漏。",
 		"- 总结时倾向于新消息，旧消息一句话带过即可；新旧消息冲突时强调新消息，不修改旧日志条目。",
-		"- 若【中断标记】非空，在对应位置明确写出中断（例如「被用户打断，因此上一段工作未完成」），帮助后续理解用户为何再次输入消息、为何不延续之前的工作。",
-		"- 若当前工作看起来未完成（最后一次工具调用没有结果、或对话被中断/异常结束），在日志末尾说明当前进度与下一步要做什么。",
 		"【输出格式】只输出一个 <om-history> 包裹的合法 XML 日志块，不要解释、不要复述规则：",
 		`<${HISTORY_TAG}>`,
-		"<user_message id=\"(message_id)\">",
+		"<user_message index=\"(index)\">",
 		"(user 消息原文)",
 		"</user_message>",
-		"<assistant last_id=\"(该组最后一条消息的 message_id)\">",
-		"(压缩模块：toolcall 聚合行等，与现有格式一致)",
+		"<assistant start=\"(起始 index)\" end=\"(结束 index)\">",
+		"(模块的目的、行为与结果摘要)",
+		"</assistant>",
+		"<assistant index=\"(index)\">",
+		"(单条完整消息的模块摘要)",
 		"</assistant>",
 		`</${HISTORY_TAG}>`,
 		"",
-		"【message_id 对照表】（按顺序对应消息记录中的未压缩消息，用于产出正确的 message_id）",
-		...tableSection,
-		"",
-		"【中断标记】",
-		...interruptionSection,
-		"",
 		...options.hasOldHistory ? [`【说明】你的压缩结果会被直接追加到上一次压缩产物（<${HISTORY_TAG}>）的末尾，作为新的 <${HISTORY_TAG}> 块；条目格式与本块一致。`] : [`【说明】你的压缩结果将成为第一条 <${HISTORY_TAG}> 压缩日志。`]
 	].join("\n");
 }
@@ -214,17 +313,25 @@ function buildReflectPrompt(mode) {
 		...mode === "new" ? ["下方的消息记录包含当前的 <om-history> 压缩日志（最后一次 <om-history> 块）。", "只对这份压缩日志做精简合并；不要涉及日志之外的消息。"] : ["上方的消息记录是主会话的完整历史，其中包含当前的 <om-history> 压缩日志（最后一次 <om-history> 块）。", "只对这份压缩日志做精简合并；不要涉及日志之外的消息。"],
 		"",
 		"【规则】",
-		"- 用户消息保留要点与 message_id（格式：<user_message id=\"(message_id)\"> 要点 </user_message>）；可省略的条目删除。",
-		"- toolcall 条目按调用目的进一步聚合，保留组内最后一条消息的 message_id；不重要的条目 summary 写「（略）」。",
-		"- 保留中断说明与未完成说明（若原日志中有）。",
+		"- 当前消息仅作为指令，**不得**进入日志。",
+		"- 完整消息分三类（用户消息 / AI 文本 / 单个工具调用及其结果），各占一个 index（从 0 起、会话内全局稳定），index 是该条完整消息的序号。",
+		"- 将AI 消息按照内在关联，划分为**连续消息**组成的模块，消息模块的划分方式不受限制，但内部须有足够的**逻辑连贯性**，应当是AI基于某个目的做出了一系列动作或论述",
+		"- 模块内的消息聚合输出为<assistant start=\"\" end=\"\">块，start/end表示当前模块首尾消息的index；块内不描述单条消息的细节，只描述当前模块的**目的、行为、结果**；最后一个<assistant>块，额外包含`下一步计划`",
+		"- 对于模块涉及到的具体文件，应当出现在<assistant>块中，多个前缀相同的路径要合并简写",
+		"- 对于单条重要的AI完整消息，以<assistant index=\"\">单独呈现，其内容不受限制",
+		"- 用户消息保留要点与 index（格式：<user_message index=\"(index)\"> 要点 </user_message>）；不重要的内容概括为「（略）」。",
+		"- 条目按 index 顺序覆盖日志中的全部完整消息，index/start/end 必须连续（区间内 index 连续、相邻条目相接），不跳号、不重叠、不遗漏；合并时条目的 index 不重新编号。",
 		"- 过时事实丢弃，不逐字复制旧文本；新旧条目冲突时保留新条目。",
 		"【输出格式】只输出一个 <om-history> 包裹的合法 XML 日志块，不要解释、不要复述规则：",
 		`<${HISTORY_TAG}>`,
-		"<user_message id=\"(message_id)\">",
+		"<user_message index=\"(index)\">",
 		"(user 消息要点)",
 		"</user_message>",
-		"<assistant last_id=\"(该组最后一条消息的 message_id)\">",
-		"(压缩模块：toolcall 聚合行等，与现有格式一致)",
+		"<assistant start=\"(起始 index)\" end=\"(结束 index)\">",
+		"(模块的目的、行为与结果摘要)",
+		"</assistant>",
+		"<assistant index=\"(index)\">",
+		"(单条完整消息的模块摘要)",
 		"</assistant>",
 		`</${HISTORY_TAG}>`,
 		"",
@@ -265,50 +372,25 @@ var StreamCollector = class {
 	}
 };
 /**
-* 渲染表层消息记录（new 模式输入）：按表层顺序分组为合法 XML——
-*  - 用户消息 → <user_message id="(message_id)">(原文)</user_message>；
-*  - 连续 AI 消息（assistant/message 与其后的 tool/result）聚合为一个
-*    <assistant last_id="(组内最后一条消息的 message_id)">(各消息文本)</assistant>。
-* 组内文本沿用 role 头 + message_id + 文本（tool-call 展开参数、tool-result 取文本）。
+* 渲染完整消息记录（new 模式输入）：按完整消息渲染为合法 XML，每条带绝对 index——
+*  - user → <user_message index="N">(原文)</user_message>；
+*  - assistant / toolcall → <assistant index="N">(文本 / 调用参数+结果)</assistant>。
+* 仅渲染 seqs 全部落在给定集合内的完整消息（插件自产消息天然不占位）。
 */
 function renderMessages(session, seqs) {
+	/** 遮蔽 seq 集合。 */
+	const shadowed = new Set(seqs);
 	/** 渲染段缓冲区。 */
 	const parts = [];
-	/** 当前 assistant 组（组内消息文本行 + 最后一条消息 id）。 */
-	let group;
-	/** 结束当前 assistant 组并输出 <assistant> 块。 */
-	const flush = () => {
-		if (!group || group.lines.length === 0) return;
-		/** last_id 属性（组内最后一条消息 id；缺失/空串则省略）。 */
-		const lastAttr = group.lastId ? ` last_id="${group.lastId}"` : "";
-		parts.push(`<assistant${lastAttr}>\n${group.lines.join("\n")}\n</assistant>`);
-		group = void 0;
-	};
-	for (const seq of seqs) {
-		/** 当前待渲染事件。 */
-		const event = session.events[seq];
-		if (!event) continue;
-		/** 消息 id（缺失则省略）。 */
-		const id = messageIdOfEvent(event);
-		/** 消息文本呈现。 */
-		const text = renderMessageText(session.deriveEventMessage(event));
-		if (event.type === "user/message") {
-			flush();
-			/** id 属性（缺失/空串则省略）。 */
-			const idAttr = id ? ` id="${id}"` : "";
-			parts.push(`<user_message${idAttr}>\n${text}\n</user_message>`);
-		} else if (event.type === "assistant/message" || event.type === "tool/result") {
-			if (!group) group = {
-				lines: [],
-				lastId: void 0
-			};
-			/** role 标签（tool/result 属 user 角色但标注为工具结果）。 */
-			const role = event.type === "assistant/message" ? "assistant" : "tool/result";
-			group.lines.push(`--- ${role}${id ? ` message_id=${id}` : ""} ---\n${text}`);
-			if (id) group.lastId = id;
-		}
+	for (const cm of indexCompleteMessages(session)) {
+		if (!cm.seqs.every((seq) => shadowed.has(seq))) continue;
+		/** 该条完整消息的文本（空内容跳过）。 */
+		const text = renderCompleteMessage(session, cm);
+		if (text.trim() === "") continue;
+		/** 标签（user 与 AI 侧分属两种条目）。 */
+		const tag = cm.type === "user" ? "user_message" : "assistant";
+		parts.push(`<${tag} index="${cm.index}">\n${text}\n</${tag}>`);
 	}
-	flush();
 	return parts.join("\n\n");
 }
 /** 构造插件自产 user 消息（指令或 new 模式的输入消息；id 为品牌类型 MessageId）。 */
@@ -360,7 +442,7 @@ function buildSummaryOptions(session, instruction, contextText, maxTokens, mode,
 	};
 }
 /** 产出日志后插入首个 <om-history> 后的格式说明（XML 注释，避免被误读为日志条目）。 */
-const HISTORY_FORMAT_NOTE = "<!-- <user_message>块内包含了用户的原文 id表示该消息的id；<assistant>块是多条ai连续消息的聚合，last_id指向最后一条消息 -->";
+const HISTORY_FORMAT_NOTE = "<!-- 完整消息分三类（用户消息 / AI 文本 / 单个工具调用及其结果），各占一个 index（从 0 起、会话内全局稳定）；<user_message index=\"N\"> 与 <assistant index=\"N\"> 表示单条完整消息，<assistant start=\"A\" end=\"B\"> 表示多条完整消息，start/end是首尾消息的index -->";
 /**
 * 从 AI 摘要输出中提取合法日志（不信任 AI 的总结结果）：
 *  - 取首个 <om-history> 到最后一个 </om-history>（含两个首尾）切为日志；
@@ -457,6 +539,8 @@ async function runSummarySubagent(ctx, agent, instruction, contextText, maxToken
 * 表层长度-1-tailCount（尾部保留 config.tailMessageCount 条不压缩，作为摘要模型的
 * 参考尾部），当前 turn 中已完备的消息同样可压缩；区间终点回退到 tool-call/result
 * 配对平衡点（不切段）。
+* 观察摘要的条目用「完整消息」index 定位（三类定义见 log-index.ts）：新消息起始 index
+* 由插件从日志计算后注入提示词，new 模式输入按完整消息渲染绝对 index。
 * 仅主会话生效。
 */
 /** 历史文本 token 估算：4 字符 ≈ 1 token（与宿主 dsh-token-meter 启发式一致）。 */
@@ -533,7 +617,6 @@ function isPairBalancedAfter(session, seq) {
 * 观察压缩区间：pre-step 触发时日志 call-result 完备，区间不再受 turn/end 封顶——
 * 头部 → 表层长度-1-tailCount（尾部保留 tailCount 条不压缩），当前 turn 中已完备的
 * 消息同样可压缩；区间终点回退到 tool-call/result 配对平衡点（不切段）。
-* lastEndSeq 仅为中断扫描提供最后一个已结束 turn 的边界（无则 -1）。
 */
 function computeCompressRange(session, tailCount) {
 	/** 当前表层节点（按日志顺序）。 */
@@ -558,33 +641,10 @@ function computeCompressRange(session, tailCount) {
 	return {
 		start,
 		end,
-		shadowedSeqs: surface.slice(0, endIdx + 1),
-		lastEndSeq: session.events.findLast((event) => event.type === "turn/end")?.seq ?? -1
+		shadowedSeqs: surface.slice(0, endIdx + 1)
 	};
 }
 /**
-* 中断标记行：范围内 turn/end 以 aborted（含 cause 类型）或 interrupted 结束的轮次
-* （标记用途：让摘要 AI 理解中断原因）。
-*/
-function scanInterruptions(session, fromSeq, toSeq) {
-	/** 标记行缓冲区。 */
-	const marks = [];
-	for (let seq = fromSeq + 1; seq <= toSeq; seq += 1) {
-		/** 当前待检查事件。 */
-		const event = session.events[seq];
-		if (event?.type !== "turn/end") continue;
-		/** 结束原因（判别 kind）。 */
-		const reason = event.data.reason;
-		if (!reason || typeof reason !== "object") continue;
-		if (reason.kind === "aborted") {
-			/** 取消来源（user/parent/hook/disposed；未知标记 unknown）。 */
-			const cause = reason.reason?.kind ?? "unknown";
-			marks.push(`[interrupted] turn ${String(event.data.turn)} 被中断（aborted，原因 ${cause}）`);
-		} else if (reason.kind === "interrupted") marks.push(`[interrupted] turn ${String(event.data.turn)} 因崩溃恢复中断（interrupted）`);
-	}
-	return marks;
-}
-/**
 * 提取遮蔽区间内最后一次 <om-history> 压缩日志（内文 + seq）。
 * 按表层顺序（shadowedSeqs）扫描：单节点替换（反思）后摘要节点 seq 可能大于
 * 被压缩消息的 seq，按 seq 区间扫描会漏（start > end）。
@@ -602,39 +662,6 @@ function extractHistoryText(session, shadowedSeqs) {
 	}
 	return found;
 }
-/**
-* message_id 对照表：遮蔽区间内消息事件按表层顺序产出 id 行（插件自产 user/message
-* 如运行时上下文快照与 <om-history> 不入表；观察摘要据此产出正确的 message_id）。
-* 按表层顺序（shadowedSeqs）扫描：与 extractHistoryText 同理，seq 区间扫描会漏。
-*/
-function buildMessageIdTable(session, shadowedSeqs) {
-	/** 对照表行缓冲区。 */
-	const rows = [];
-	for (const seq of shadowedSeqs) {
-		/** 当前待检查事件。 */
-		const event = session.events[seq];
-		if (!event) continue;
-		if (event.type === "user/message") {
-			if (event.data.source?.kind === "plugin") continue;
-			/** 用户消息 id。 */
-			const id = messageIdOfEvent(event);
-			if (id) rows.push(`[user] message_id=${id}`);
-		} else if (event.type === "assistant/message") {
-			/** 助手消息 id。 */
-			const id = messageIdOfEvent(event);
-			if (id) rows.push(`[assistant] message_id=${id}`);
-		} else if (event.type === "tool/result") {
-			/** 结果消息 id。 */
-			const id = messageIdOfEvent(event);
-			if (id) {
-				/** 关联调用 id（供摘要模型按 callId 定位代码与结果）。 */
-				const callId = String(event.data.message.source.callId ?? "");
-				rows.push(`[tool/result callId=${callId}] message_id=${id}`);
-			}
-		}
-	}
-	return rows;
-}
 /** 当前打开中的 turn 号（最近 turn/start 且未被 turn/end 关闭）；无则 null（跨轮次场景）。 */
 function openTurnOf(session) {
 	/** 折叠结果（turn/start 打开、turn/end 关闭）。 */
@@ -812,21 +839,20 @@ async function observePass(ctx, agent, config, window, tailCount, target, signal
 	logger.step(`观察：压缩区间 [${range.start}..${range.end}]，遮蔽 ${range.shadowedSeqs.length} 个表层节点`);
 	/** 区间内旧摘要（追加基准；无则首次压缩）。 */
 	const history = extractHistoryText(session, range.shadowedSeqs);
-	/** 中断标记行。 */
-	const interruptions = scanInterruptions(session, Math.min(...range.shadowedSeqs), range.lastEndSeq);
-	/** message_id 对照表行。 */
-	const table = buildMessageIdTable(session, range.shadowedSeqs);
 	const actualTailCount = [...session.surface.nodes].length - range.shadowedSeqs.length;
-	logger.step(`观察：实际保留尾部 ${actualTailCount} 条（不压缩、不进日志），中断标记 ${interruptions.length} 条，message_id 对照表 ${table.length} 行`);
+	/** 遮蔽 seq 集合（计算新消息起始 index）。 */
+	const shadowedSet = new Set(range.shadowedSeqs);
+	/** 压缩区间内第一个完整消息的 index（新消息起始编号；区间内无完整消息则 0）。 */
+	const startIndex = indexCompleteMessages(session).find((cm) => cm.seqs.every((seq) => shadowedSet.has(seq)))?.index ?? 0;
+	logger.step(`观察：实际保留尾部 ${actualTailCount} 条（不压缩、不进日志），新消息起始 index ${startIndex}`);
 	/** 观察指令（persona + 规则主体）。 */
 	const prompt = buildObservePrompt({
-		table,
-		interruptions,
+		startIndex,
 		hasOldHistory: history !== void 0,
 		mode: config.summaryMode
 	});
 	/** 观察摘要结果（null 表示失败/跳过）。 */
-	const summaryResult = await runSummarySubagent(ctx, agent, `${OBSERVER_PERSONA}\n\n${prompt}`, config.summaryMode === "new" ? renderMessages(session, range.shadowedSeqs.filter((seq) => historyTextOf(session.events[seq]) === void 0)) : void 0, config.compressMaxTokens, config.summaryMode, actualTailCount, target, config.debug, signal);
+	const summaryResult = await runSummarySubagent(ctx, agent, `${OBSERVER_PERSONA}\n\n${prompt}`, config.summaryMode === "new" ? renderMessages(session, range.shadowedSeqs) : void 0, config.compressMaxTokens, config.summaryMode, actualTailCount, target, config.debug, signal);
 	if (summaryResult === null || summaryResult.text.trim().length === 0) {
 		logger.step("观察：摘要调用失败/无输出，不产生替换");
 		return;
@@ -1082,7 +1108,7 @@ function ensureModelReady(modelDir = BUNDLED_MODEL_DIR, warn = () => {}, fetchIm
 			fetchImpl,
 			log: () => {}
 		}).then(() => {}).catch((err) => {
-			warn("[download-model] 下载失败：" + (err instanceof Error ? err.message : String(err)));
+			warn(`[download-model] 下载失败：${err instanceof Error ? err.message : String(err)}`);
 		}).finally(() => {
 			inflightDownloads.delete(modelDir);
 		});
@@ -1211,22 +1237,24 @@ function resolveConfig(raw) {
 //#endregion
 //#region src/recall.ts
 /**
-* recall 工具：按 message_id 回看原始会话（start_id/end_id 为消息 id，offset 为相对
-* start_id 的消息步数）。recall 自身不设输出上限：超大的工具结果由 tool-result-pruner
-* 裁剪（pruneContent），输出 token 由 pruner 配置控制。
+* recall 工具：按「完整消息」序号（index）回看原始会话（start/end 为完整消息 index，
+* offset 为相对 start 的完整消息步数）。完整消息分三类（用户消息 / AI 文本 / 单个工具
+* 调用及其结果），各占一个 index（从 0 起、会话内全局稳定），与摘要日志条目同一套编号。
+* recall 自身不设输出上限：超大的工具结果由 tool-result-pruner 裁剪（pruneContent），
+* 输出 token 由 pruner 配置控制。
 *
-* 参数由 zod schema（recallArgsSchema）在 execute 入口校验：start_id 必填且非空，
-* end_id/offset 至少提供一个；非法参数抛出可读错误。
+* 参数由 zod schema（recallArgsSchema）在 execute 入口校验：start 必填（number），
+* end/offset 至少提供一个；非法参数抛出可读错误。
 */
 /**
-* recall 工具参数 schema：start_id 必填且非空；end_id 与 offset 至少提供一个
-* （二者同时给出时 end_id 优先，与 execute 语义一致）；未知键自动剥离。
+* recall 工具参数 schema：start 必填（number）；end 与 offset 至少提供一个
+* （二者同时给出时 end 优先，与 execute 语义一致）；未知键自动剥离。
 */
 const recallArgsSchema = z.object({
-	start_id: z.string(),
-	end_id: z.string().optional(),
+	start: z.number(),
+	end: z.number().optional(),
 	offset: z.number().optional()
-}).refine((args) => args.end_id !== void 0 || args.offset !== void 0, { message: "end_id 与 offset 至少提供一个" });
+}).refine((args) => args.end !== void 0 || args.offset !== void 0, { message: "end 与 offset 至少提供一个" });
 /**
 * 解析并校验 recall 调用参数：校验失败时抛出首个校验问题的可读消息
 * （普通 Error 而非 ZodError，兼容 SDK 展示）。
@@ -1238,26 +1266,26 @@ function parseRecallArgs(raw) {
 	return result.data;
 }
 /**
-* 构建 recall 工具定义：按 start_id/end_id/offset 定位消息区间并渲染原始内容。
+* 构建 recall 工具定义：按 start/end/offset 定位完整消息区间并渲染原始内容（标 index）。
 * getPruner 返回 tool-result-pruner（可选），用于裁剪超大工具结果。
 */
 function buildRecallTool(getPruner) {
 	return {
 		name: "recall",
-		description: "根据message_id，回看指定区间的过往消息。start_id必须传入，是区间的基准。end_id 和 offset 二选一，end_id 用于指定另一个边界，offset用于指定区间包含的消息数量。",
+		description: "根据完整消息序号（index），回看指定区间的过往消息。完整消息是定位单位，分三类：用户消息、AI 文本、单个工具调用及其结果（每个 tool-call 与其 result 一条），各占一个 index（从 0 起、会话内全局稳定）。start 必须传入，是区间的基准；end 和 offset 二选一：end 指定另一个边界（含两端，与 start 的位置关系不影响结果），offset 指定区间包含的完整消息数量（正数向后、负数向前）。",
 		parameters: {
-			start_id: {
-				type: "string",
-				description: "message_id(uuid)，区间的基准边界",
+			start: {
+				type: "number",
+				description: "完整消息序号（index），区间的基准边界",
 				required: true
 			},
-			end_id: {
-				type: "string",
-				description: "message_id(uuid)，与 offset 互斥，指定区间的另一个边界。与 start_id 的位置关系不影响结果。"
+			end: {
+				type: "number",
+				description: "与 offset 互斥，指定区间的另一个边界（含）。与 start 的位置关系不影响结果。"
 			},
 			offset: {
 				type: "number",
-				description: "与 end_id 互斥，指定区间包含的消息数量。传入正数查看start_id之后的若干条消息，负数则是之前的。"
+				description: "与 end 互斥，指定区间包含的完整消息数量。传入正数查看 start 之后的若干条，负数则是之前的。"
 			}
 		},
 		output: {
@@ -1269,23 +1297,23 @@ function buildRecallTool(getPruner) {
 		},
 		async execute(args, exec) {
 			/** 解析并校验后的调用参数（不满足 schema 时抛出可读错误）。 */
-			const { start_id, end_id, offset } = parseRecallArgs(args);
+			const { start, end, offset } = parseRecallArgs(args);
 			/** 当前会话（缺失则无法回看）。 */
 			const session = exec.agent?.session;
 			if (!session) return "会话异常";
 			if (!isMainSession(session)) return "recall 仅主会话可用";
-			/** 会话消息索引（序列 + byId 映射）。 */
-			const { messages, byId } = indexMessages(session);
-			/** start_id 在消息序列中的下标。 */
-			const startIndex = byId.get(start_id);
-			if (startIndex === void 0) return `start_id "${start_id}" 不存在`;
-			/** 终点下标（end_id 优先，否则 startIndex + offset）。 */
+			/** 完整消息索引（index = 数组下标，0 起）。 */
+			const cms = indexCompleteMessages(session);
+			/** 起始下标（非整数 floor；越界返回提示）。 */
+			const startIndex = Number.isFinite(start) ? Math.floor(start) : 0;
+			if (startIndex < 0 || startIndex >= cms.length) return `start ${start} 越界（完整消息共 ${cms.length} 条，index 范围 0..${cms.length - 1}）`;
+			/** 终点下标（end 优先，否则 startIndex + offset）。 */
 			let endIndex;
-			if (end_id !== void 0) {
-				/** end_id 在消息序列中的下标。 */
-				const found = byId.get(end_id);
-				if (found === void 0) return `end_id "${end_id}" 不存在`;
-				endIndex = found;
+			if (end !== void 0) {
+				/** end 取整（非整数 floor）。 */
+				const e = Number.isFinite(end) ? Math.floor(end) : 0;
+				if (e < 0 || e >= cms.length) return `end ${end} 越界（完整消息共 ${cms.length} 条，index 范围 0..${cms.length - 1}）`;
+				endIndex = e;
 			} else {
 				/** offset 数值（refine 保证此分支 offset 已提供，schema 保证为 number）。 */
 				const raw = offset ?? 0;
@@ -1294,36 +1322,25 @@ function buildRecallTool(getPruner) {
 			/** 区间下界（钳制到 [0, len-1]）。 */
 			const lo = Math.max(0, Math.min(startIndex, endIndex));
 			/** 区间上界（钳制到 [0, len-1]）。 */
-			const hi = Math.min(messages.length - 1, Math.max(startIndex, endIndex));
+			const hi = Math.min(cms.length - 1, Math.max(startIndex, endIndex));
 			/** tool-result-pruner（可选，裁剪超大工具结果）。 */
 			const pruner = getPruner?.();
-			/** 渲染结果缓冲（每条消息一段）。 */
+			/** 渲染结果缓冲（每条完整消息一段，标 index + 类型）。 */
 			const parts = [];
 			for (let i = lo; i <= hi; i += 1) {
-				/** 当前消息节点。 */
-				const node = messages[i];
-				if (!node) continue;
-				/** 节点对应的会话事件。 */
-				const event = session.events[node.seq];
-				if (!event) continue;
-				/** 本条消息的呈现文本。 */
+				/** 当前完整消息。 */
+				const cm = cms[i];
+				if (!cm) continue;
+				/** 该条完整消息的呈现文本（pruner 裁剪超大结果；单条失败不影响整体）。 */
 				let text = "";
 				try {
-					/** 从事件派生的消息对象。 */
-					let message = session.deriveEventMessage(event);
-					if (message && event.type === "tool/result" && pruner?.pruneContent) {
-						/** 裁剪后的内容块（返回 null 表示不裁剪）。 */
-						const pruned = pruner.pruneContent(message.content);
-						if (pruned) message = {
-							...message,
-							content: pruned
-						};
-					}
-					text = message ? renderMessageText(message) : "";
+					text = renderCompleteMessage(session, cm, pruner);
 				} catch {}
-				parts.push(`-- [seq ${node.seq}] ${event.type} --\n${text}`);
+				/** 类型标注（toolcall 附调用 id，便于模型关联）。 */
+				const callAttr = cm.type === "toolcall" && cm.callId ? ` callId=${cm.callId}` : "";
+				parts.push(`-- [index ${cm.index}] ${cm.type}${callAttr} --\n${text}`);
 			}
-			if (parts.length === 0) return "指定区间没有消息";
+			if (parts.length === 0) return "指定区间没有完整消息";
 			return parts.join("\n\n");
 		}
 	};
@@ -1331,15 +1348,15 @@ function buildRecallTool(getPruner) {
 //#endregion
 //#region src/semantic-recall.ts
 /**
-* recall-semantic 工具：按自然语言 query 对会话全部消息日志（含被压缩/遮蔽的
-* user/assistant/tool-result 事件）做语义检索，返回最匹配的完整消息与匹配说明。
+* recall-semantic 工具：按自然语言 query 对会话全部完整消息（含被压缩/遮蔽的）做语义
+* 检索，返回最匹配的完整消息与匹配说明。
 *
-* - 参数：query 必填；top_k（默认 3，1-10）；start_id/end_id/offset 限定检索区间
-*   （意义同 recall：start_id 为基准边界，end_id 与 offset 二选一；end_id 优先）。
-* - 区间缺省（start_id 未提供）→ 检索全部消息；区间不合法（id 不存在等）→
+* - 参数：query 必填；top_k（默认 3，1-10）；start/end/offset 限定检索区间
+*   （意义同 recall：start 为基准边界，end 与 offset 二选一；end 优先）。
+* - 区间缺省（start 未提供）→ 检索全部消息；区间不合法（start/end 越界等）→
 *   不报错，回退全量检索并在输出中明确告知（模型可见）。
 * - 向量：本地 ONNX embedding（embedding.ts，懒加载 + 批量）；相似度 = cosine。
-* - 输出：命中消息的 message_id/seq/类型 + 完整渲染文本 + 匹配说明（相似度、
+* - 输出：命中消息的 index/类型（toolcall 附调用 id）+ 完整渲染文本 + 匹配说明（相似度、
 *   命中的关键词）；超大结果由 tool-result-pruner 裁剪（同 recall）。
 * - 仅主会话可用（subagent 拒绝，与 recall 一致）。
 */
@@ -1347,8 +1364,8 @@ function buildRecallTool(getPruner) {
 const semanticRecallArgsSchema = z.object({
 	query: z.string(),
 	top_k: z.number().int().min(1).max(10).optional(),
-	start_id: z.string().optional(),
-	end_id: z.string().optional(),
+	start: z.number().optional(),
+	end: z.number().optional(),
 	offset: z.number().optional()
 }).refine((args) => args.query.trim().length > 0, { message: "query 不能为空" });
 /** 解析并校验参数：失败时抛出可读错误（普通 Error 而非 ZodError）。 */
@@ -1359,36 +1376,35 @@ function parseSemanticRecallArgs(raw) {
 	return result.data;
 }
 /**
-* 解析检索区间（消息序列下标，含端点）。
-* - start_id 未提供 → 全量（fallback=false）。
-* - start_id 提供：end_id/offset 计算终点（语义同 recall，end_id 优先）；
-*   start_id/end_id 不存在或区间为空 → fallback=true（全量 + 提示）。
+* 解析检索区间（完整消息 index，含端点）。
+* - start 未提供 → 全量（fallback=false）。
+* - start 提供：end/offset 计算终点（语义同 recall，end 优先）；
+*   start/end 越界或区间为空 → fallback=true（全量 + 提示）。
 */
-function resolveSemanticRange(index, args) {
-	const total = index.messages.length;
-	if (total === 0) return {
+function resolveSemanticRange(total, args) {
+	if (total <= 0) return {
 		lo: 0,
 		hi: -1,
 		fallback: false
 	};
-	if (args.start_id === void 0) return {
+	if (args.start === void 0) return {
 		lo: 0,
 		hi: total - 1,
 		fallback: false
 	};
-	/** start_id 在消息序列中的下标。 */
-	const start = index.byId.get(args.start_id);
-	if (start === void 0) return {
+	/** start 取整（非有限数按 -1 处理，走越界回退）。 */
+	const start = Number.isFinite(args.start) ? Math.floor(args.start) : -1;
+	if (start < 0 || start >= total) return {
 		lo: 0,
 		hi: total - 1,
 		fallback: true
 	};
-	/** 终点下标（end_id 优先；否则 start + offset 取整）。 */
+	/** 终点 index（end 优先；否则 start + offset 取整）。 */
 	let end;
-	if (args.end_id !== void 0) {
-		/** end_id 在消息序列中的下标。 */
-		const found = index.byId.get(args.end_id);
-		if (found === void 0) return {
+	if (args.end !== void 0) {
+		/** end 取整（非有限数按 -1 处理，走越界回退）。 */
+		const found = Number.isFinite(args.end) ? Math.floor(args.end) : -1;
+		if (found < 0 || found >= total) return {
 			lo: 0,
 			hi: total - 1,
 			fallback: true
@@ -1435,7 +1451,7 @@ function matchExplanation(query, text, score) {
 	return `相似度 ${score.toFixed(3)}${keywords}`;
 }
 /** 模型未就绪时返回给模型的文案（告知即可；下载完成后无需另行通知，直接再次调用）。 */
-const SEMANTIC_MODEL_NOT_READY_MESSAGE = "语义检索暂不可用：本地嵌入模型尚未就绪（正在后台下载约 113MB；下载完成后无需提示，直接再次调用本工具即可。若下载失败，下次调用会自动重试）。可稍后重试，或先用 recall 工具按 message_id 精确检索。";
+const SEMANTIC_MODEL_NOT_READY_MESSAGE = "语义检索暂不可用：本地嵌入模型尚未就绪（正在后台下载约 113MB；下载完成后无需提示，直接再次调用本工具即可。若下载失败，下次调用会自动重试）。可稍后重试，或先用 recall 工具按完整消息 index 精确检索。";
 /** 构建 recall-semantic 工具定义（embedder/modelStatus 可注入，测试传替身；缺省用本地模型）。 */
 function buildSemanticRecallTool(options) {
 	/** pruner 获取器（可选，裁剪超大工具结果）。 */
@@ -1444,7 +1460,7 @@ function buildSemanticRecallTool(options) {
 	const embed = options?.embedder ?? ((texts) => getEmbedder().then((fn) => fn(texts)));
 	return {
 		name: "recall-semantic",
-		description: "按语义（自然语言含义）在会话全部消息中检索：用一句话描述你要找的内容（可混用中英文与代码术语）。返回最匹配的若干条完整消息、message_id 与匹配说明；如需精确定位某个 message_id 周边的消息，请再用 recall 工具。",
+		description: "按语义（自然语言含义）在会话全部完整消息中检索：用一句话描述你要找的内容（可混用中英文与代码术语）。返回最匹配的若干条完整消息、index 与匹配说明；如需精确定位某个 index 周边的消息，请再用 recall 工具。",
 		parameters: {
 			query: {
 				type: "string",
@@ -1453,19 +1469,19 @@ function buildSemanticRecallTool(options) {
 			},
 			top_k: {
 				type: "number",
-				description: "返回最匹配的消息条数（1-10，默认 3）。"
+				description: "返回最匹配的完整消息条数（1-10，默认 3）。"
 			},
-			start_id: {
-				type: "string",
-				description: "message_id(uuid)，可选。限定检索区间：以该消息为基准边界（意义同 recall）。缺省检索全部消息。区间不合法时自动回退全量检索并在结果中说明。"
+			start: {
+				type: "number",
+				description: "完整消息序号（index），可选。限定检索区间：以该条为基准边界（意义同 recall）。缺省检索全部消息。区间不合法（越界）时自动回退全量检索并在结果中说明。"
 			},
-			end_id: {
-				type: "string",
-				description: "message_id(uuid)，可选，与 offset 互斥，限定区间的另一个边界（意义同 recall）。"
+			end: {
+				type: "number",
+				description: "与 offset 互斥，限定区间的另一个边界（含；意义同 recall）。"
 			},
 			offset: {
 				type: "number",
-				description: "可选，与 end_id 互斥。相对 start_id 的步数：正数向后、负数向前（意义同 recall）。"
+				description: "与 end 互斥。相对 start 的步数：正数向后、负数向前（意义同 recall）。"
 			}
 		},
 		output: {
@@ -1477,39 +1493,34 @@ function buildSemanticRecallTool(options) {
 		},
 		async execute(args, exec) {
 			/** 解析并校验后的调用参数。 */
-			const { query, top_k, start_id, end_id, offset } = parseSemanticRecallArgs(args);
+			const { query, top_k, start, end, offset } = parseSemanticRecallArgs(args);
 			/** 当前会话。 */
 			const session = exec.agent?.session;
 			if (!session) return "会话异常";
 			if (!isMainSession(session)) return "recall-semantic 仅主会话可用";
 			if ((await options?.modelStatus?.() ?? "ready") !== "ready") return SEMANTIC_MODEL_NOT_READY_MESSAGE;
-			/** 会话消息索引（全部消息事件，含被压缩/遮蔽）。 */
-			const index = indexMessages(session);
-			if (index.messages.length === 0) return "会话中没有可检索的消息";
-			/** 检索区间（消息序列下标；区间不合法时回退全量并标记）。 */
-			const range = resolveSemanticRange(index, {
-				start_id,
-				end_id,
+			/** 完整消息索引（全部事件，含被压缩/遮蔽）。 */
+			const cms = indexCompleteMessages(session);
+			if (cms.length === 0) return "会话中没有可检索的消息";
+			/** 检索区间（完整消息 index；区间不合法时回退全量并标记）。 */
+			const range = resolveSemanticRange(cms.length, {
+				start,
+				end,
 				offset
 			});
-			/** 候选消息渲染文本（区间内；跳过渲染失败/空文本）。 */
+			/** 候选完整消息渲染文本（区间内；跳过渲染失败/空文本）。 */
 			const candidates = [];
 			for (let i = range.lo; i <= range.hi; i += 1) {
-				/** 当前消息节点。 */
-				const node = index.messages[i];
-				if (!node) continue;
-				/** 节点对应的会话事件。 */
-				const event = session.events[node.seq];
-				if (!event) continue;
-				/** 事件派生的消息对象。 */
-				let message = null;
+				/** 当前完整消息。 */
+				const cm = cms[i];
+				if (!cm) continue;
+				/** 渲染文本（嵌入用完整文本，输出时再裁剪）。 */
+				let text = "";
 				try {
-					message = session.deriveEventMessage(event);
+					text = renderCompleteMessage(session, cm);
 				} catch {}
-				/** 渲染文本。 */
-				const text = message ? renderMessageText(message) : "";
 				if (text.trim().length > 0) candidates.push({
-					node,
+					cm,
 					text
 				});
 			}
@@ -1521,7 +1532,7 @@ function buildSemanticRecallTool(options) {
 			const vectors = await embed(candidates.map((c) => c.text));
 			/** 打分结果（相似度 + 候选）。 */
 			const scored = candidates.map((c, i) => ({
-				node: c.node,
+				cm: c.cm,
 				text: c.text,
 				score: cosineSimilarity(queryVec, vectors[i] ?? /* @__PURE__ */ new Float32Array(0))
 			}));
@@ -1532,7 +1543,7 @@ function buildSemanticRecallTool(options) {
 			/** 结果缓冲。 */
 			const parts = [];
 			/** 范围描述（回退时明确告知模型）。 */
-			const rangeNote = range.fallback ? "指定区间不合法（start_id/end_id 不存在等），已回退检索全部消息" : start_id === void 0 ? `检索全部消息（${candidates.length} 条可嵌入）` : `检索区间 [${range.lo}..${range.hi}]（${candidates.length} 条可嵌入）`;
+			const rangeNote = range.fallback ? "指定区间不合法（start/end 越界等），已回退检索全部消息" : start === void 0 ? `检索全部消息（${candidates.length} 条可嵌入）` : `检索区间 [${range.lo}..${range.hi}]（${candidates.length} 条可嵌入）`;
 			parts.push(`查询: ${query}`);
 			parts.push(rangeNote);
 			parts.push(`匹配 TOP-${hits.length}（共 ${scored.length} 条候选）:`);
@@ -1540,30 +1551,16 @@ function buildSemanticRecallTool(options) {
 				/** 当前命中。 */
 				const hit = hits[i];
 				if (!hit) continue;
-				/** 消息事件（用于类型与 pruner）。 */
-				const event = session.events[hit.node.seq];
-				/** 命中消息的 id（缺失则省略）。 */
-				const id = event ? messageIdOfEvent(event) ?? "" : "";
-				/** 命中消息文本（pruner 裁剪超大内容后渲染）。 */
+				/** 类型标注（toolcall 附调用 id，与 recall 输出一致）。 */
+				const callAttr = hit.cm.type === "toolcall" && hit.cm.callId ? ` callId=${hit.cm.callId}` : "";
+				/** 输出文本（pruner 裁剪超大内容；裁剪失败保留嵌入用文本）。 */
 				let text = hit.text;
-				/** pruner（可选）。 */
-				const pruner = getPruner();
-				if (pruner?.pruneContent && event) {
-					/** 事件派生的消息对象（裁剪用）。 */
-					let message = null;
-					try {
-						message = session.deriveEventMessage(event);
-					} catch {}
-					if (message) {
-						/** 裁剪后的内容块。 */
-						const pruned = pruner.pruneContent(message.content);
-						if (pruned) text = renderMessageText({
-							...message,
-							content: pruned
-						});
-					}
-				}
-				parts.push(`-- [${i + 1}] seq ${hit.node.seq} ${hit.node.type} message_id=${id} — ${matchExplanation(query, hit.text, hit.score)} --`);
+				try {
+					/** tool-result-pruner（可选）。 */
+					const pruner = getPruner();
+					text = renderCompleteMessage(session, hit.cm, pruner);
+				} catch {}
+				parts.push(`-- [${i + 1}] index ${hit.cm.index} ${hit.cm.type}${callAttr} — ${matchExplanation(query, hit.text, hit.score)} --`);
 				parts.push(text);
 			}
 			return parts.join("\n\n");
@@ -1577,9 +1574,9 @@ function buildSemanticRecallTool(options) {
 * 不依赖特定 tool mode（native / code / both 均可运行）。
 *
 * 模块：
-*  - recall.ts  recall({ start_id, end_id?, offset? }) 工具：按 message_id 回看原始会话
-*  - semantic-recall.ts  recall-semantic({ query, top_k?, start_id?, end_id?, offset? }) 工具：
-*    按语义在全部消息日志（含被压缩/遮蔽）中检索，返回最匹配的完整消息与匹配说明
+*  - recall.ts  recall({ start, end?, offset? }) 工具：按完整消息 index 回看原始会话
+*  - semantic-recall.ts  recall-semantic({ query, top_k?, start?, end?, offset? }) 工具：
+*    按语义在全部完整消息（含被压缩/遮蔽）中检索，返回最匹配的完整消息与匹配说明
 *    （本地 ONNX embedding，模型随插件打包，懒加载）
 *  - compress.ts 自动压缩（OM 观察/反思两级阈值）：pre-step 阻塞串行执行——
 *    反思（摘要 ≥ 窗口 × historyMergeRatio 时摘要调用精简合并 <om-history>）、
@@ -1611,7 +1608,7 @@ function apply(ctx, config) {
 	logger.step(`apply 启动：thresholdRatio=${String(resolved.thresholdRatio)} historyMergeRatio=${String(resolved.historyMergeRatio)} compressMaxTokens=${String(resolved.compressMaxTokens)} tailMessageCount=${String(resolved.tailMessageCount)} summaryMode=${resolved.summaryMode} debug=${String(resolved.debug)}`);
 	if (resolved.recallEnabled) ctx.tools.register(buildRecallTool(() => ctx.get("toolResultPruner")));
 	if (resolved.semanticRecallEnabled) {
-		const warnModel = (message) => ctx.logger.warn("dsh-plugin-om: " + message);
+		const warnModel = (message) => ctx.logger.warn(`dsh-plugin-om: ${message}`);
 		ensureModelReady(resolved.modelDir, warnModel);
 		ctx.tools.register(buildSemanticRecallTool({
 			getPruner: () => ctx.get("toolResultPruner"),