dsh-plugin-om 0.0.22 → 0.0.24

package/dist/index.mjs

@@ -1,3 +1,5 @@
+import { scopeOf } from "@deepseek-ai/dsh-scope";
+import { renderPrompt } from "@deepseek-ai/dsh-system-prompt";
 import { copyFileSync, existsSync, mkdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
@@ -11,7 +13,7 @@ var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).expor
 /**
 * 共享常量：插件级魔法字符串，集中定义避免散落各模块。
 * 导出 PLUGIN_LABEL / HISTORY_TAG / HISTORY_TIP / COMPLETE_MESSAGE_DEFINITION /
-* COMPACT_CHECKPOINT_PLUGIN / isPluginOwnedSource。
+* COMPACT_CHECKPOINT_PLUGIN / COMPACTION_ABORTED_ERROR / isPluginOwnedSource。
 */
 /** 插件标识：压缩消息 source.plugin 取值与日志前缀。 */
 const PLUGIN_LABEL = "dsh-plugin-om";
@@ -23,13 +25,65 @@ const HISTORY_TIP = "当前块是历史消息的压缩产物，不要复述";
 * 「完整消息」定义（提示词 / 工具描述 / 块顶注释共用）。
 * 完整消息是摘要日志与 recall 共用的定位单位；首条 index 为 0，按会话顺序递增、全局稳定。
 */
-const COMPLETE_MESSAGE_DEFINITION = "`完整消息`被定义为`用户消息`，`系统消息`，`模型输出文本`和`具有result的toolcall`的集合。首条`完整消息`的index是0，后续的index递增。";
+const COMPLETE_MESSAGE_DEFINITION = "`完整消息`指一条`用户消息`、`系统消息`、`模型输出文本`或`具有result的toolcall`；首条 index 为 0，按会话顺序递增。";
+/**
+* 压缩因 signal 中止而放弃时 compaction/end 的 error 标识（服务端写入、客户端过滤）：
+* 中止不是失败，客户端据此隐藏失败行（宿主不变量要求无 summary 的 end 必须带 error）。
+*/
+const COMPACTION_ABORTED_ERROR = "压缩已中止（signal aborted）";
 /** 判定 user/message 的 source 是否为本插件自产（压缩日志消息；含旧宿主 checkpoint 标记兼容）。这类消息不占完整消息 index。 */
 function isPluginOwnedSource(source) {
 	if (source?.kind !== "plugin") return false;
 	return source.plugin === "dsh-plugin-om" || source.plugin === "compact";
 }
 //#endregion
+//#region src/degrade.ts
+/**
+* 降级报告：压缩流程中的挂载失败统一出口。
+* 导出 reportDegrade / DEGRADE_PROBLEMS / DegradedProblem。
+*
+* - 挂载失败类问题（服务缺失、服务调用异常）始终 console.warn 到宿主进程外部输出，
+*   并向会话日志追加 log-only 的 `om/warning` 事件（客户端渲染为「功能降级」警告行）；
+*   同一会话同一问题只报告一次（按日志扫描去重，重启不重复）
+* - 报告动作自身绝不抛错：追加失败只记日志，不阻塞压缩
+* - 辅助函数的普通运行时报错（组装失败、请求头读取失败）不走本模块，仅记日志
+*/
+/** 各降级问题面向用户的简短说明（om/warning 载荷 message；客户端警告行直接展示）。 */
+const DEGRADE_PROBLEMS = {
+	"systemPrompt-missing": "系统提示词服务未挂载，上下文压力估算不扣除系统提示词 tokens（压缩触发会偏早）",
+	"tokenMeter-unavailable": "token 计量服务异常，上下文压力估算降级（可能跳过压缩或按 0 计）"
+};
+/** 判定事件是否为指定 problem 的已有 om/warning 记录（会话内去重依据）。 */
+function isWarningFor(event, problem) {
+	if (event.type !== "om/warning") return false;
+	return event.data?.problem === problem;
+}
+/**
+* 报告一次挂载失败类降级：console.warn 始终输出到宿主进程外部；同会话同问题首次
+* 出现时，向会话日志追加 log-only `om/warning` 事件（客户端渲染警告行，每会话最多
+* 一次）并输出 logger.warn（避免每个 pre-step 重复刷日志）。
+* 日志扫描/事件追加失败只记日志，绝不抛错、不阻塞压缩。
+*/
+function reportDegrade(session, logger, problem) {
+	const message = DEGRADE_PROBLEMS[problem];
+	let first = true;
+	try {
+		first = !session.events.some((event) => isWarningFor(event, problem));
+	} catch {}
+	if (!first) return;
+	console.warn(`${PLUGIN_LABEL}: ${message}`);
+	logger.warn(message);
+	try {
+		session.append("om/warning", {
+			problem,
+			message
+		});
+	} catch (error) {
+		const text = error instanceof Error ? error.message : String(error);
+		logger.warn(`om/warning 事件追加失败: ${text}`);
+	}
+}
+//#endregion
 //#region src/utils.ts
 /** 判断值是否为普通对象（非 null、非数组）。 */
 function isRecord(value) {
@@ -7474,27 +7528,24 @@ async function gateRateLimit(waitMs, signal) {
 */
 function buildHistoryPrompt() {
 	return [
-		"把下方的 <history> 消息记录压缩为一份更紧凑的 <history> 压缩日志。不用工具、不展示思考、不输出多余文字。",
+		"压缩 <history> 消息记录。你应当输出**单个**合法的 <history> 块。",
 		"",
 		"【history 块定义】",
-		"- <history> 是历史消息的记录块：输入与输出都是合法的 <history> 块，块内条目是「模型消息 + index」的表达形式。",
-		`- 完整消息：${COMPLETE_MESSAGE_DEFINITION}`,
-		"- <user_message index=\"N\">：用户消息条目（N 为该条完整消息的 index；文本原样，图片/文件等以注释补充）。",
-		"- <sys type=\"(kind)\" index=\"N\">：系统消息条目（user_message 中非 kind:user 的部分，如宿主注入的上下文），块中为空，内容不进入压缩输入。",
+		"- <history> 是历史消息的记录块。",
+		"- <user_message index=\"N\">：用户消息条目。",
+		"- <sys type=\"(kind)\" index=\"N\">：系统消息条目。",
 		"- <reasoning>：模型的思考过程，仅作压缩参考，产物中不要出现。",
 		"- <assistant index=\"N\">：单条完整消息（模型输出文本，或 toolcall 及其 result）。",
 		"- <assistant start=\"A\" end=\"B\">：多条连续完整消息聚合的模块（A/B 为模块首尾完整消息的 index）。",
 		"",
 		"【压缩要求】",
-		"- 完整保留用户消息：<user_message> 条目逐条保留原文，不概括、不省略。",
-		"- 完整保留系统消息：<sys> 条目逐条原样保留（type 与 index 不变），块中为空，不概括、不省略、不填充内容。",
+		"- <user_message> <sys> 条目从输入中逐条保留，不做任何处理。",
 		"- <reasoning> 只作参考，输出产物中不包含 <reasoning> 块。",
 		"- 将具有关联性的 <assistant> 消息按内在逻辑连贯性划分为连续模块，聚合为 <assistant start=\"\" end=\"\"> 块：块内描述模块的目的、行为与结果；涉及的具体文件保留在模块内容中，多个前缀相同的路径合并简写。",
 		"- 单条重要的完整消息以 <assistant index=\"\"> 单独呈现，内容不受限制。",
 		"- 条目按 index 顺序覆盖本次压缩的全部完整消息：index/start/end 必须连续（区间内 index 连续、相邻条目相接），不跳号、不重叠、不遗漏。",
-		"- 条目内容为合法 XML 文本：特殊字符保持转义形式（如 & → &amp;、< → &lt;），用户消息原文的转义形式原样保留，不要反转义。",
 		"",
-		"【输出格式】只输出一个 <history> 包裹的合法 XML 日志块（不要解释、不要复述规则）：",
+		"【输出格式】输出单个合法的 <history> 块，**不包含其他任何内容**：",
 		`<${HISTORY_TAG}>`,
 		"<user_message index=\"(index)\">",
 		"(user 消息原文)",
@@ -7511,6 +7562,13 @@ function buildHistoryPrompt() {
 		"【数据源】下方的 <history> 消息记录是本次要压缩的全部消息；压缩结果作为一个新的 <history> 块输出。"
 	].join("\n");
 }
+/**
+* 静默 DOMParser：非致命解析问题不再走 xmldom 默认的 console.error 输出
+* （模型输出非法 XML 时避免刷 console），fatalError 仍抛 ParseError、解析语义不变。
+*/
+function newQuietParser() {
+	return new import_lib.DOMParser({ onError: () => {} });
+}
 /** 渲染用户消息条目（DOM 元素）：文本块原样；图片/文件等非文本块以注释补充。 */
 function renderUserEntry(doc, session, cm) {
 	const seq = cm.seqs[0];
@@ -7555,7 +7613,7 @@ function renderMessages(session, seqs) {
 		if (reasonings.length > 0) reasoningBySeq.set(seq, reasonings);
 	}
 	const emittedReasoning = /* @__PURE__ */ new Set();
-	const doc = new import_lib.DOMParser().parseFromString(`<${HISTORY_TAG} />`, "text/xml");
+	const doc = newQuietParser().parseFromString(`<${HISTORY_TAG} />`, "text/xml");
 	const entries = [];
 	for (const cm of indexCompleteMessages(session)) {
 		if (!cm.seqs.every((seq) => shadowed.has(seq))) continue;
@@ -7646,7 +7704,7 @@ function buildSummaryOptions(session, instruction, contextText, maxTokens, targe
 	return {
 		provider: target.provider,
 		model: target.model,
-		maxTokens,
+		...maxTokens === void 0 ? {} : { maxTokens },
 		sessionId: session.id,
 		purpose: "compaction",
 		...signal === void 0 ? {} : { signal },
@@ -7671,7 +7729,7 @@ function intAttr(el, name) {
 function parseHistoryBlock(xml) {
 	let doc;
 	try {
-		doc = new import_lib.DOMParser().parseFromString(xml, "text/xml");
+		doc = newQuietParser().parseFromString(xml, "text/xml");
 	} catch {
 		return null;
 	}
@@ -7830,7 +7888,7 @@ function rebuildHistoryBlock(inner) {
 		content: inner.slice(open.contentFrom)
 	});
 	if (entries.length === 0) return null;
-	const doc = new import_lib.DOMParser().parseFromString(`<${HISTORY_TAG} />`, "text/xml");
+	const doc = newQuietParser().parseFromString(`<${HISTORY_TAG} />`, "text/xml");
 	const root = doc.documentElement;
 	if (!root) return null;
 	for (const e of entries) {
@@ -7844,37 +7902,39 @@ function rebuildHistoryBlock(inner) {
 /**
 * 从 AI 摘要输出中提取合法日志（不信任 AI 的总结结果）：
 * 取首个 <history> 开标签（允许带属性）到最后一个 </history> 切为候选块，
-* 找不到或内容过短返回 null；候选块经 XML 结构校验，整块非法时按条目模糊
+* 找不到或内容过短返回具体原因；候选块经 XML 结构校验，整块非法时按条目模糊
 * 提取重建为合法块（不要求模型输出整体合法 XML）；随后统一校验：无 reasoning、
 * index 连续且与 expected 覆盖区间一致；通过后统一改写为带 tip 属性的开标签
-* 并在块顶插入格式说明注释。
+* 并在块顶插入格式说明注释。所有失败原因均为说明性描述，不携带解析器原始报错。
 */
-function extractSummaryLog(raw, expected) {
+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 null;
+	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 null;
+	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 null;
+	if (candidate === null) return { error: "输出不是合法的 <history> 块（XML 结构非法，按条目模糊提取也未找到有效条目）" };
 	const parsed = parseHistoryBlock(candidate);
-	if (parsed === null) return null;
-	if (parsed.hasReasoning) return null;
+	if (parsed === null) return { error: "输出不是合法的 <history> 块（条目结构非法：属性缺失或包含未定义元素）" };
+	if (parsed.hasReasoning) return { error: "输出包含 <reasoning> 条目（产物不允许携带思考过程）" };
 	const span = historyContinuity(parsed.entries);
-	if (span === null) return null;
-	if (expected?.start !== void 0 && span.start !== expected.start) return null;
-	if (expected?.end !== void 0 && span.end !== expected.end) return null;
+	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 `<${HISTORY_TAG} tip="${HISTORY_TIP}">\n${HISTORY_FORMAT_NOTE}\n${candidateInner}\n</${HISTORY_TAG}>`;
+	return { log: `<${HISTORY_TAG} tip="${HISTORY_TIP}">\n${HISTORY_FORMAT_NOTE}\n${candidateInner}\n</${HISTORY_TAG}>` };
 }
 /**
 * 直连 LLM 执行一次摘要（观察或反思），返回文本与可选 token usage。
-* 失败（抛异常 / 空输出 / 非 stop 结束 / 校验不通过）均记录日志并重试，最多尝试
-* options.maxAttempts 次；全部失败返回 null（不产生任何日志变更）。每次请求发出前
-* 先过全局限流等待门。
+* 失败（抛异常 / 空输出 / 非 stop 结束 / 校验不通过）均记录日志并重试，每次尝试的
+* 结果或报错始终写入日志（成功 info / 失败 warn，不受 debug 影响）；全部尝试耗尽
+* 返回失败结果（携带最后一次尝试的实际报错/具体问题，不产生任何日志变更）。
+* signal 中止（含限流等待被中止）立即放弃并标记 aborted。每次请求发出前先过全局
+* 限流等待门。
 */
 async function runSummarySubagent(ctx, agent, instruction, contextText, maxTokens, target, debug, signal, options) {
 	const session = agent.session;
@@ -7883,30 +7943,44 @@ async function runSummarySubagent(ctx, agent, instruction, contextText, maxToken
 	let lastFailure = {};
 	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
 		if (signal?.aborted) {
-			logger.warn(`摘要调用中止（第 ${attempt}/${maxAttempts} 次尝试前 signal 已中止），放弃本次摘要`);
-			return null;
+			logger.warn(`摘要调用中止（第 ${attempt}/${maxAttempts} 次尝试前 signal 已中止），放弃本次压缩`);
+			return {
+				ok: false,
+				error: COMPACTION_ABORTED_ERROR,
+				aborted: true
+			};
 		}
 		const rateLimitWaitMs = options?.rateLimitWaitMs ?? 6e4;
 		if (!await gateRateLimit(rateLimitWaitMs, signal)) {
-			logger.warn(`摘要调用中止（第 ${attempt}/${maxAttempts} 次尝试前限流等待被 signal 中止），放弃本次摘要`);
-			return null;
+			logger.warn(`摘要调用中止（第 ${attempt}/${maxAttempts} 次尝试前限流等待被 signal 中止），放弃本次压缩`);
+			return {
+				ok: false,
+				error: COMPACTION_ABORTED_ERROR,
+				aborted: true
+			};
 		}
-		logger.step(`摘要调用开始（第 ${attempt}/${maxAttempts} 次，provider ${target.provider}，model ${target.model}，maxTokens ${maxTokens}）`);
+		logger.step(`摘要调用开始（第 ${attempt}/${maxAttempts} 次，provider ${target.provider}，model ${target.model}，maxTokens ${maxTokens === void 0 ? "未设置" : String(maxTokens)}）`);
 		try {
 			const requestOptions = buildSummaryOptions(session, instruction, contextText, maxTokens, target, signal);
 			const collector = new StreamCollector();
 			for await (const chunk of ctx.llm.stream(requestOptions)) collector.push(chunk);
-			const text = extractSummaryLog(collector.text, options?.expected);
+			const extracted = extractSummaryDetailed(collector.text, options?.expected);
 			const finish = collector.finish;
-			if (finish.kind !== "stop" || text === null) {
-				const reason = finish.kind === "stop" ? collector.text.trim() === "" ? "无输出" : "缺少合法 <history> 块（含 reasoning 或 index 不连续）" : String(finish.kind);
-				lastFailure = { finish: reason };
-				logger.warn(`摘要未完成（第 ${attempt}/${maxAttempts} 次，${reason}）` + (attempt < maxAttempts ? "，将重试" : "，重试耗尽，忽略本次摘要"));
+			if (finish.kind !== "stop") {
+				lastFailure = { reason: `摘要流以 ${String(finish.kind)} 结束（非正常完成）` };
+				logger.warn(`摘要未完成（第 ${attempt}/${maxAttempts} 次，${lastFailure.reason}）` + (attempt < maxAttempts ? "，将重试" : "，重试耗尽，放弃本次压缩"));
 				continue;
 			}
+			if ("error" in extracted) {
+				lastFailure = { reason: extracted.error };
+				logger.warn(`摘要输出未通过校验（第 ${attempt}/${maxAttempts} 次，${extracted.error}）` + (attempt < maxAttempts ? "，将重试" : "，重试耗尽，放弃本次压缩"));
+				continue;
+			}
+			const text = extracted.log;
 			const usage = collector.usage;
-			logger.step(`摘要调用成功（第 ${attempt}/${maxAttempts} 次，输出 ${text.length} 字符` + (usage === void 0 ? "" : `，input ${String(usage.inputTokens ?? "?")} / output ${String(usage.outputTokens ?? "?")} tokens`) + "）");
+			logger.info(`摘要调用成功（第 ${attempt}/${maxAttempts} 次，输出 ${text.length} 字符` + (usage === void 0 ? "" : `，input ${String(usage.inputTokens ?? "?")} / output ${String(usage.outputTokens ?? "?")} tokens`) + "）");
 			return {
+				ok: true,
 				text,
 				attemptCount: attempt,
 				...usage === void 0 ? {} : { usage }
@@ -7918,11 +7992,16 @@ async function runSummarySubagent(ctx, agent, instruction, contextText, maxToken
 				logger.warn(`摘要调用触发限流（429，第 ${attempt}/${maxAttempts} 次），下一次请求前至少等待 ${rateLimitWaitMs}ms`);
 			}
 			lastFailure = { error: message };
-			logger.warn(`摘要调用失败（第 ${attempt}/${maxAttempts} 次，${message}）` + (attempt < maxAttempts ? "，将重试" : "，重试耗尽，忽略本次摘要"));
+			logger.warn(`摘要调用失败（第 ${attempt}/${maxAttempts} 次，${message}）` + (attempt < maxAttempts ? "，将重试" : "，重试耗尽，放弃本次压缩"));
 		}
 	}
-	logger.warn(`摘要调用最终失败（已尝试 ${maxAttempts} 次` + (lastFailure.error !== void 0 ? `，最后错误：${lastFailure.error}` : "") + (lastFailure.finish !== void 0 ? `，最后结果：${lastFailure.finish}` : "") + "），忽略本次摘要");
-	return null;
+	const lastError = lastFailure.error ?? lastFailure.reason ?? "未知原因";
+	logger.warn(`摘要调用最终失败（已尝试 ${maxAttempts} 次，最后错误：${lastError}），拒绝放行本轮 step`);
+	return {
+		ok: false,
+		error: lastError,
+		aborted: false
+	};
 }
 //#endregion
 //#region src/compress.ts
@@ -7932,12 +8011,19 @@ async function runSummarySubagent(ctx, agent, instruction, contextText, maxToken
 * reflectPass / observePass / maybeCompress。
 *
 * - 反思：全部 <history> 块 token 合计 ≥ reflectThresholdTokens 时，摘要合并为一条
-* - 观察：净压力（上下文压力 − 已压缩块 token 合计）≥ observeThresholdTokens 时，
+* - 观察：净压力（上下文压力 − 已压缩块 token 合计 − 系统提示词 token 估算 − 工具定义
+*   token 估算）≥ observeThresholdTokens 时，
 *   摘要未压缩消息为新 <history> 块并精确替换被压缩区间（旧块保留）
 * - 两级在 pre-step 阻塞串行执行（先反思后观察）；仅主会话生效；omEnabled=false 关闭
 * - 压缩边界：最后一个合法 <history> 块之后的消息视为未压缩，其前不重复压缩
+* - 摘要尝试全部耗尽时 pass 返回失败结果（携带最后一次尝试的实际报错），压缩流程
+*   向上传播，pre-step 据此拒绝本 step 中断当前 turn；signal 中止标记 aborted（不中断）
 * - 提交走宿主 compaction/* 生命周期事件（start 带 phase → summary → 替换消息 → end），
-*   失败补 end(error)；替换消息 source 标记插件标识供 UI 认领
+*   失败补 end(error，实际报错)；替换消息 source 标记插件标识供 UI 认领
+* - 挂载失败类问题（systemPrompt/tokenMeter 服务异常）始终 console 到外部进程，并追加
+*   log-only om/warning 事件（客户端渲染功能降级警告行，每会话同一问题至多一次）；
+*   辅助估算的普通运行时报错仅记日志。降级与报错都不阻塞压缩（tokenMeter 压力数据
+*   缺失时本轮跳过观察）
 */
 /** 历史文本 token 估算：4 字符 ≈ 1 token（与宿主 dsh-token-meter 启发式一致）。 */
 function estimateTextTokens(text) {
@@ -8084,7 +8170,7 @@ function appendCompactionSummary(session, data) {
 		shadowedCharCount: data.shadowedCharCount,
 		provider: data.provider,
 		model: data.model,
-		maxTokens: data.maxTokens,
+		...data.maxTokens === void 0 ? {} : { maxTokens: data.maxTokens },
 		attemptCount: data.attemptCount,
 		...data.usage === void 0 ? {} : { usage: data.usage }
 	};
@@ -8120,7 +8206,8 @@ function appendHistoryMessage(session, content, sourceEventSeqs, surfaceOp, comp
 }
 /**
 * 反思：全部 <history> 块 token 合计 ≥ reflectThresholdTokens 时，摘要调用把整个块
-* 区段合并替换为一条更紧凑的摘要。失败不产生部分替换。
+* 区段合并替换为一条更紧凑的摘要。失败不产生部分替换；摘要尝试全部耗尽返回
+* 失败结果（error = 最后一次尝试的实际报错/具体问题）。
 */
 async function reflectPass(ctx, agent, config, target, signal) {
 	const session = agent.session;
@@ -8129,21 +8216,21 @@ async function reflectPass(ctx, agent, config, target, signal) {
 	const { blocks } = historySection(session);
 	if (blocks.length === 0) {
 		logger.step("反思：无 <history> 压缩日志，跳过");
-		return;
+		return { failed: false };
 	}
 	const threshold = config.reflectThresholdTokens;
 	const tokens = blocks.reduce((total, block) => total + estimateTextTokens(block.text), 0);
 	const shadowedCharCount = blocks.reduce((total, block) => total + historyInnerText(block.text).length, 0);
 	if (tokens < threshold) {
 		logger.step(`反思：摘要 ${tokens} tokens < 阈值 ${threshold}，跳过`);
-		return;
+		return { failed: false };
 	}
 	logger.step(`反思：摘要 ${tokens} tokens ≥ 阈值 ${threshold}，触发精简合并（${blocks.length} 个块）`);
 	const first = blocks[0];
 	const last = blocks[blocks.length - 1];
 	if (first === void 0 || last === void 0) {
 		logger.step("反思：块区段缺失，跳过");
-		return;
+		return { failed: false };
 	}
 	const blockSeqs = blocks.map((block) => block.seq);
 	const instruction = buildHistoryPrompt();
@@ -8159,7 +8246,7 @@ async function reflectPass(ctx, agent, config, target, signal) {
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		logger.warn(`反思压缩启动失败: ${message}`);
-		return;
+		return { failed: false };
 	}
 	const summaryResult = await runSummarySubagent(ctx, agent, instruction, contextText, config.compressMaxTokens, target, config.debug, signal, {
 		maxAttempts: config.compressRetryCount + 1,
@@ -8169,12 +8256,16 @@ async function reflectPass(ctx, agent, config, target, signal) {
 		},
 		rateLimitWaitMs: config.rateLimitWaitMs
 	});
-	if (summaryResult === null || summaryResult.text.trim().length === 0) {
-		logger.step("反思：摘要调用失败/无输出，追加 compaction/end(error)");
+	if (!summaryResult.ok) {
+		logger.warn(`反思：摘要调用失败（${summaryResult.error}），追加 compaction/end(error)`);
 		try {
-			appendCompactionEnd(session, lifecycle, "摘要调用失败/无输出");
+			appendCompactionEnd(session, lifecycle, summaryResult.error);
 		} catch {}
-		return;
+		return {
+			failed: true,
+			error: summaryResult.error,
+			aborted: summaryResult.aborted
+		};
 	}
 	const report = summaryResult.text;
 	try {
@@ -8204,50 +8295,113 @@ async function reflectPass(ctx, agent, config, target, signal) {
 		logger.step("反思提交：追加 compaction/end");
 		appendCompactionEnd(session, lifecycle);
 		logger.info(`反思完成（摘要 ${tokens} tokens ≥ 阈值 ${threshold}，合并 ${blocks.length} 个块为一条）`);
+		return { failed: false };
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		logger.warn(`反思提交失败: ${message}`);
 		try {
 			appendCompactionEnd(session, lifecycle, message);
 		} catch {}
+		return { failed: false };
+	}
+}
+/**
+* 估算系统提示词 tokens：按 agent 作用域组装并渲染系统提示词，按长度/4 启发式计。
+* systemPrompt 服务经 ctx.get 容错读取（ctx 属性访问在服务未挂载时抛错）；服务缺失
+* 或组装/渲染失败时按 0 计——只影响观察触发时机（偏早触发），不阻塞压缩。
+* 服务缺失属挂载失败：console 外部 + om/warning 事件每会话报告一次；组装失败仅记日志。
+*/
+async function estimateSystemPromptTokens(ctx, agent, logger, signal) {
+	const systemPrompt = ctx.get("systemPrompt");
+	if (systemPrompt === void 0 || typeof systemPrompt.assemble !== "function") {
+		reportDegrade(agent.session, logger, "systemPrompt-missing");
+		return 0;
+	}
+	try {
+		const agentCtx = agent.ctx;
+		const scope = agentCtx === void 0 ? void 0 : scopeOf(agentCtx);
+		const assembleContext = { agent };
+		if (scope !== void 0) assembleContext.scope = scope;
+		if (signal !== void 0) assembleContext.signal = signal;
+		const assembly = await systemPrompt.assemble(assembleContext);
+		return estimateTextTokens(renderPrompt(assembly));
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		logger.warn(`系统提示词 tokens 估算失败，按 0 计: ${message}`);
+		return 0;
+	}
+}
+/**
+* 估算请求工具定义 tokens：按会话请求头 tools（assembled tool schemas）JSON 序列化
+* 长度/4 启发式计（与宿主 dsh-token-meter 对工具 schema 的启发式一致）。请求头读取
+* 失败或缺 tools 时按 0 计——只影响观察触发时机（偏早触发），不阻塞压缩。
+*/
+function estimateToolsTokens(session, logger) {
+	try {
+		const header = session.requestHeader();
+		if (header?.tools === void 0 || header.tools.length === 0) return 0;
+		return estimateTextTokens(JSON.stringify(header.tools));
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		logger.warn(`工具定义 tokens 估算失败，按 0 计: ${message}`);
+		return 0;
+	}
+}
+/**
+* 读取上下文压力 tokens（tokenMeter.measure 的 totalTokens）。tokenMeter 调用异常时
+* 记日志并报告降级（console 外部 + om/warning 每会话一次），返回 undefined——本轮
+* 跳过观察压缩（无压力数据不触发），不阻塞 turn。
+*/
+function measurePressureTokens(ctx, session, logger) {
+	try {
+		return ctx.tokenMeter.measure(session).totalTokens;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		logger.warn(`上下文压力读取失败（tokenMeter.measure 抛错），本轮跳过观察压缩: ${message}`);
+		reportDegrade(session, logger, "tokenMeter-unavailable");
+		return;
 	}
 }
 /**
-* 观察：净压力 tokens（上下文压力 − 已压缩 <history> 块 token 合计）≥
-* observeThresholdTokens 时，摘要调用把未压缩消息压缩为观察日志，追加到旧摘要并
-* 替换被压缩消息区间。失败不产生部分替换。
+* 观察：净压力 tokens（上下文压力 − 已压缩 <history> 块 token 合计 − 系统提示词
+* token 估算 − 工具定义 token 估算）≥ observeThresholdTokens 时，摘要调用把未压缩
+* 消息压缩为观察日志，追加到旧摘要并替换被压缩消息区间。失败不产生部分替换；
+* 摘要尝试全部耗尽返回失败结果（error = 最后一次尝试的实际报错/具体问题）。
 */
 async function observePass(ctx, agent, config, tailCount, target, signal) {
 	const session = agent.session;
 	const logger = makeLogger(ctx, config.debug);
 	logger.step(`观察检查（观察阈值 ${config.observeThresholdTokens} tokens，尾部保留 ${tailCount} 条）`);
 	const threshold = config.observeThresholdTokens;
-	const pressureTokens = ctx.tokenMeter.measure(session).totalTokens;
+	const pressureTokens = measurePressureTokens(ctx, session, logger);
+	if (pressureTokens === void 0) return { failed: false };
 	const { blocks } = historySection(session);
 	const historyTokens = blocks.reduce((total, block) => total + estimateTextTokens(block.text), 0);
-	const netTokens = pressureTokens - historyTokens;
+	const systemTokens = await estimateSystemPromptTokens(ctx, agent, logger, signal);
+	const toolsTokens = estimateToolsTokens(session, logger);
+	const netTokens = pressureTokens - historyTokens - systemTokens - toolsTokens;
 	if (netTokens < threshold) {
-		logger.step(`观察：净压力 ${netTokens} tokens（上下文压力 ${pressureTokens} − 已压缩块 ${historyTokens}）< 阈值 ${threshold}，跳过`);
-		return;
+		logger.step(`观察：净压力 ${netTokens} tokens（上下文压力 ${pressureTokens} − 已压缩块 ${historyTokens} − 系统提示词 ${systemTokens} − 工具定义 ${toolsTokens}）< 阈值 ${threshold}，跳过`);
+		return { failed: false };
 	}
-	logger.step(`观察：净压力 ${netTokens} tokens（上下文压力 ${pressureTokens} − 已压缩块 ${historyTokens}）≥ 阈值 ${threshold}，触发压缩`);
+	logger.step(`观察：净压力 ${netTokens} tokens（上下文压力 ${pressureTokens} − 已压缩块 ${historyTokens} − 系统提示词 ${systemTokens} − 工具定义 ${toolsTokens}）≥ 阈值 ${threshold}，触发压缩`);
 	const range = computeCompressRange(session, tailCount);
 	if (!range) {
 		logger.step("观察：无可行压缩区间（边界后消息过短或配对无法平衡），跳过");
-		return;
+		return { failed: false };
 	}
 	logger.step(`观察：压缩区间 [${range.start}..${range.end}]，遮蔽 ${range.shadowedSeqs.length} 个表层节点`);
 	const replaceSeqs = range.shadowedSeqs;
 	const replaceStart = replaceSeqs[0];
 	if (replaceStart === void 0) {
 		logger.step("观察：区间内无新消息（全部为压缩日志块），跳过");
-		return;
+		return { failed: false };
 	}
 	const shadowedSet = new Set(replaceSeqs);
 	const inRangeCms = indexCompleteMessages(session).filter((cm) => cm.seqs.every((seq) => shadowedSet.has(seq)));
 	if (inRangeCms.length === 0) {
 		logger.step("观察：区间内无完整消息，跳过");
-		return;
+		return { failed: false };
 	}
 	const startIndex = inRangeCms[0]?.index ?? 0;
 	const endIndex = inRangeCms[inRangeCms.length - 1]?.index ?? startIndex;
@@ -8264,7 +8418,7 @@ async function observePass(ctx, agent, config, tailCount, target, signal) {
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		logger.warn(`观察压缩启动失败: ${message}`);
-		return;
+		return { failed: false };
 	}
 	const summaryResult = await runSummarySubagent(ctx, agent, instruction, contextText, config.compressMaxTokens, target, config.debug, signal, {
 		maxAttempts: config.compressRetryCount + 1,
@@ -8274,12 +8428,16 @@ async function observePass(ctx, agent, config, tailCount, target, signal) {
 		},
 		rateLimitWaitMs: config.rateLimitWaitMs
 	});
-	if (summaryResult === null || summaryResult.text.trim().length === 0) {
-		logger.step("观察：摘要调用失败/无输出，追加 compaction/end(error)");
+	if (!summaryResult.ok) {
+		logger.warn(`观察：摘要调用失败（${summaryResult.error}），追加 compaction/end(error)`);
 		try {
-			appendCompactionEnd(session, lifecycle, "摘要调用失败/无输出");
+			appendCompactionEnd(session, lifecycle, summaryResult.error);
 		} catch {}
-		return;
+		return {
+			failed: true,
+			error: summaryResult.error,
+			aborted: summaryResult.aborted
+		};
 	}
 	const report = summaryResult.text;
 	const attemptCount = summaryResult.attemptCount - 1;
@@ -8287,7 +8445,13 @@ async function observePass(ctx, agent, config, tailCount, target, signal) {
 	const shadowedTokenCount = replaceSeqs.reduce((total, seq) => {
 		const event = session.events[seq];
 		const message = event ? session.deriveEventMessage(event) : null;
-		return total + (message ? ctx.tokenMeter.estimateMessage(message) : 0);
+		let tokens = 0;
+		if (message) try {
+			tokens = ctx.tokenMeter.estimateMessage(message);
+		} catch {
+			reportDegrade(session, logger, "tokenMeter-unavailable");
+		}
+		return total + tokens;
 	}, 0);
 	const shadowedCharCount = replaceSeqs.reduce((total, seq) => {
 		const event = session.events[seq];
@@ -8321,34 +8485,45 @@ async function observePass(ctx, agent, config, tailCount, target, signal) {
 		logger.step("观察提交：追加 compaction/end");
 		appendCompactionEnd(session, lifecycle);
 		logger.info(`观察压缩完成（净压力 ${netTokens} tokens（上下文压力 ${pressureTokens} − 已压缩块 ${historyTokens}）≥ 阈值 ${threshold}，替换 ${replaceSeqs.length} 个表层节点，约 ${shadowedTokenCount} tokens）`);
+		return { failed: false };
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		logger.warn(`观察压缩提交失败: ${message}`);
 		try {
 			appendCompactionEnd(session, lifecycle, message);
 		} catch {}
+		return { failed: false };
 	}
 }
-/** 压力检查 + 两级压缩入口：先反思后观察，pre-step 阻塞串行执行；仅主会话生效。 */
+/**
+* 压力检查 + 两级压缩入口：先反思后观察，pre-step 阻塞串行执行；仅主会话生效。
+* 反思摘要耗尽失败时直接返回失败结果（观察无需继续，本轮将被拒绝）；观察失败同样
+* 传播失败结果，由 pre-step 拒绝本 step 中断当前 turn。
+*/
 async function maybeCompress(ctx, agent, config, signal) {
 	const session = agent.session;
 	const logger = makeLogger(ctx, config.debug);
 	if (!config.omEnabled) {
 		logger.step("omEnabled=false，跳过压缩");
-		return;
+		return { failed: false };
 	}
 	const target = routedTarget(session);
 	if (target === void 0) {
 		logger.step("会话未路由（无 provider/model），跳过压缩");
-		return;
+		return { failed: false };
 	}
 	logger.step(`会话路由：provider ${target.provider}，model ${target.model}`);
 	const tailCount = config.tailMessageCount;
 	logger.step("反思 pass 开始");
-	await reflectPass(ctx, agent, config, target, signal);
+	const reflect = await reflectPass(ctx, agent, config, target, signal);
+	if (reflect.failed) {
+		logger.step("反思 pass 失败（本轮将被拒绝），跳过观察 pass");
+		return reflect;
+	}
 	logger.step("反思 pass 结束，观察 pass 开始");
-	await observePass(ctx, agent, config, tailCount, target, signal);
+	const observe = await observePass(ctx, agent, config, tailCount, target, signal);
 	logger.step("观察 pass 结束，压缩流程完成");
+	return observe;
 }
 //#endregion
 //#region src/model-download.ts
@@ -8559,9 +8734,9 @@ function cosineSimilarity(a, b) {
 */
 /** 默认配置（冻结对象，resolveConfig 合并的基底；debug 缺省值在解析时按 NODE_ENV 判定）。 */
 const DEFAULT_CONFIG = Object.freeze({
-	observeThresholdTokens: 35e3,
-	reflectThresholdTokens: 4e4,
-	compressMaxTokens: 5e3,
+	observeThresholdTokens: 45e3,
+	reflectThresholdTokens: 12e4,
+	compressMaxTokens: void 0,
 	rateLimitWaitMs: 6e4,
 	tailMessageCount: 5,
 	compressRetryCount: 5,
@@ -8720,9 +8895,9 @@ function renderRecallOutput(value) {
 * 各字段描述经 .describe() 透传到 wire JSON Schema。
 */
 const recallArgsSchema = z.object({
-	start: z.number().describe("完整消息序号（index），作为基准边界，和 end 或 offset 配合，指定区间；end 与 offset 至少提供一个（同时给出时 end 优先）。"),
-	end: z.number().optional().describe("与 offset 互斥，指定区间的另一个边界。"),
-	offset: z.number().optional().describe("与 end 互斥。相对 start 的步数：正数向后、负数向前。")
+	start: z.number().describe("完整消息 index，基准边界，与 end 或 offset 配合指定区间；end 与 offset 至少提供一个（同时给出时 end 优先）。"),
+	end: z.number().optional().describe("与 offset 互斥，指定区间另一边界。"),
+	offset: z.number().optional().describe("与 end 互斥，相对 start 的步数（正向后、负向前）。")
 }).refine((args) => args.end !== void 0 || args.offset !== void 0, { message: "end 与 offset 至少提供一个" });
 /** 解析并校验 recall 调用参数：失败时抛出首个校验问题的可读消息（普通 Error，兼容 SDK 展示）。 */
 function parseRecallArgs(raw) {
@@ -8737,7 +8912,7 @@ function parseRecallArgs(raw) {
 function buildRecallTool(getPruner) {
 	return {
 		name: "recall",
-		description: `${COMPLETE_MESSAGE_DEFINITION}此工具可以精确查询完整消息。用index指定一个区间，返回区间内所有完整消息的内容；完整消息携带的图片附件随结果保留（文本段以 [图片附件：…] 标注，随后附 image 内容块）。`,
+		description: `${COMPLETE_MESSAGE_DEFINITION}按 index 区间精确返回区间内全部完整消息的内容。`,
 		parameters: parametersFromZod(recallArgsSchema),
 		output: {
 			schema: RECALL_OUTPUT_SCHEMA,
@@ -8804,11 +8979,11 @@ function buildRecallTool(getPruner) {
 */
 /** recall-semantic 工具参数 schema：query 必填；top_k 默认 3（1-10）；区间参数均可选。 */
 const semanticRecallArgsSchema = z.object({
-	query: z.string().describe("描述要找的内容的自然语言 query（可混用中英文与代码术语，如 \"修复 retry backoff 的逻辑\"），不能为空。"),
-	top_k: z.number().int().min(1).max(10).optional().describe("返回最匹配的完整消息条数（1-10，默认 3）。"),
-	start: z.number().optional().describe("完整消息序号（index），可选。作为基准边界，和end或offset配合，指定搜索区间。"),
-	end: z.number().optional().describe("必须和start配合使用，与 offset 互斥，指定搜索区间的另一个边界。"),
-	offset: z.number().optional().describe("必须和start配合使用，与 end 互斥。相对 start 的步数：正数向后、负数向前。")
+	query: z.string().describe("要找的内容的自然语言 query（中英文与代码术语皆可，如 \"修复 retry backoff 的逻辑\"），不能为空。"),
+	top_k: z.number().int().min(1).max(10).optional().describe("返回最匹配条数（1-10，默认 3）。"),
+	start: z.number().optional().describe("完整消息 index，基准边界，与 end/offset 配合指定搜索区间；缺省检索全部。"),
+	end: z.number().optional().describe("须与 start 配合，与 offset 互斥，指定搜索区间另一边界。"),
+	offset: z.number().optional().describe("须与 start 配合，与 end 互斥，相对 start 的步数（正向后、负向前）。")
 }).refine((args) => args.query.trim().length > 0, { message: "query 不能为空" });
 /** 解析并校验参数：失败时抛出可读错误（普通 Error 而非 ZodError）。 */
 function parseSemanticRecallArgs(raw) {
@@ -8888,7 +9063,7 @@ function buildSemanticRecallTool(options) {
 	const embed = options?.embedder ?? ((texts) => getEmbedder().then((fn) => fn(texts)));
 	return {
 		name: "recall-semantic",
-		description: `${COMPLETE_MESSAGE_DEFINITION}此工具可以按自然语言含义，检索最符合的完整消息。默认在全消息范围搜索，可以指定区间。注意：语义检索只匹配文本，图片内容不参与匹配（纯图片消息无法命中，也不能按图片内容检索）；命中的完整消息携带的图片附件随结果保留（文本段以 [图片附件：…] 标注，随后附 image 内容块），与 recall 相同。`,
+		description: `${COMPLETE_MESSAGE_DEFINITION}按自然语言含义检索最符合的完整消息，默认全量搜索，可指定区间。注意：只匹配文本。`,
 		parameters: parametersFromZod(semanticRecallArgsSchema),
 		output: {
 			schema: RECALL_OUTPUT_SCHEMA,
@@ -8966,7 +9141,8 @@ function buildSemanticRecallTool(options) {
 /**
 * dsh-plugin-om 入口（tsdown 打包入口）：导出 name / inject / apply。
 * apply 注册 recall / recall-semantic 工具，并接线 agent/pre-step 自动压缩
-* （先反思后观察，仅主会话生效）。压缩与检索的实现见 compress.ts / recall.ts /
+* （先反思后观察，仅主会话生效）。压缩摘要尝试全部耗尽时拒绝本 step 中断当前
+* turn（signal 中止除外）。压缩与检索的实现见 compress.ts / recall.ts /
 * semantic-recall.ts。
 */
 /** 插件名（Loader 识别入口的稳定标识）。 */
@@ -8982,14 +9158,11 @@ const inject = [
 function apply(ctx, config) {
 	const resolved = resolveConfig(config);
 	const logger = makeLogger(ctx, resolved.debug);
-	logger.step(`apply 启动：observeThresholdTokens=${String(resolved.observeThresholdTokens)} reflectThresholdTokens=${String(resolved.reflectThresholdTokens)} compressMaxTokens=${String(resolved.compressMaxTokens)} tailMessageCount=${String(resolved.tailMessageCount)} omEnabled=${String(resolved.omEnabled)} debug=${String(resolved.debug)}`);
+	logger.step(`apply 启动：observeThresholdTokens=${String(resolved.observeThresholdTokens)} reflectThresholdTokens=${String(resolved.reflectThresholdTokens)} compressMaxTokens=${resolved.compressMaxTokens === void 0 ? "未设置" : String(resolved.compressMaxTokens)} tailMessageCount=${String(resolved.tailMessageCount)} omEnabled=${String(resolved.omEnabled)} 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 logModel = (message) => {
-			console.log(message);
-			logger.info(message);
-		};
+		const logModel = (message) => logger.info(message);
 		ensureModelReady(resolved.modelDir, warnModel, void 0, logModel);
 		ctx.tools.register(buildSemanticRecallTool({
 			getPruner: () => ctx.get("toolResultPruner"),
@@ -8998,16 +9171,21 @@ function apply(ctx, config) {
 		}));
 	}
 	ctx.on("agent/pre-step", async ({ agent, signal }, next) => {
+		let outcome = { failed: false };
 		try {
 			if (signal.aborted) logger.step("pre-step 已中止（signal aborted），跳过压缩");
 			else if (!isMainSession(agent.session)) logger.step("subagent 会话，跳过压缩（仅主会话生效）");
 			else {
 				logger.step(`pre-step 触发压缩（会话 ${agent.session.id}）`);
-				await maybeCompress(ctx, agent, resolved, signal);
+				outcome = await maybeCompress(ctx, agent, resolved, signal);
 			}
 		} catch (error) {
 			logger.warn(`pre-step 处理失败: ${error instanceof Error ? error.message : String(error)}`);
 		}
+		if (outcome.failed && !outcome.aborted) {
+			logger.warn(`上下文压缩失败，拒绝本 step 中断当前 turn：${outcome.error}`);
+			return { kind: "reject" };
+		}
 		return next();
 	});
 }