dsh-plugin-om 0.0.56 → 0.0.58

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (71) hide show
  1. package/README.md +73 -17
  2. package/dist/client/OmCompactionCard.d.ts.map +1 -1
  3. package/dist/client/OmEvalModelPanel.d.ts +22 -0
  4. package/dist/client/OmEvalModelPanel.d.ts.map +1 -0
  5. package/dist/client/OmRecompressMenu.d.ts +3 -3
  6. package/dist/client/OmRecompressMenu.d.ts.map +1 -1
  7. package/dist/client/compaction-eval-jump.d.ts +20 -0
  8. package/dist/client/compaction-eval-jump.d.ts.map +1 -0
  9. package/dist/client/definition.d.ts +2 -2
  10. package/dist/client/definition.d.ts.map +1 -1
  11. package/dist/client/eval-model-panel.d.ts +57 -0
  12. package/dist/client/eval-model-panel.d.ts.map +1 -0
  13. package/dist/client/eval-model-register.d.ts +10 -0
  14. package/dist/client/eval-model-register.d.ts.map +1 -0
  15. package/dist/client/index.d.ts +2 -1
  16. package/dist/client/index.d.ts.map +1 -1
  17. package/dist/client/locales.d.ts +13 -2
  18. package/dist/client/locales.d.ts.map +1 -1
  19. package/dist/client/om-config-controller.d.ts +4 -1
  20. package/dist/client/om-config-controller.d.ts.map +1 -1
  21. package/dist/client/recompress-run.d.ts +23 -2
  22. package/dist/client/recompress-run.d.ts.map +1 -1
  23. package/dist/client.js +675 -116
  24. package/dist/client.js.map +1 -1
  25. package/dist/compaction-eval-command.d.ts +54 -0
  26. package/dist/compaction-eval-command.d.ts.map +1 -0
  27. package/dist/compaction-log.d.ts +31 -9
  28. package/dist/compaction-log.d.ts.map +1 -1
  29. package/dist/compress-loop.d.ts +21 -10
  30. package/dist/compress-loop.d.ts.map +1 -1
  31. package/dist/compress-tools.d.ts +16 -8
  32. package/dist/compress-tools.d.ts.map +1 -1
  33. package/dist/compress-view.d.ts +1 -3
  34. package/dist/compress-view.d.ts.map +1 -1
  35. package/dist/compress.d.ts +117 -8
  36. package/dist/compress.d.ts.map +1 -1
  37. package/dist/config.d.ts +4 -0
  38. package/dist/config.d.ts.map +1 -1
  39. package/dist/constants.d.ts +3 -1
  40. package/dist/constants.d.ts.map +1 -1
  41. package/dist/eval-session-text.d.ts +28 -0
  42. package/dist/eval-session-text.d.ts.map +1 -0
  43. package/dist/index.d.ts +4 -1
  44. package/dist/index.d.ts.map +1 -1
  45. package/dist/index.mjs +1390 -478
  46. package/dist/log-index.d.ts +2 -2
  47. package/dist/log-index.d.ts.map +1 -1
  48. package/dist/om-event.d.ts +26 -2
  49. package/dist/om-event.d.ts.map +1 -1
  50. package/dist/precompress.d.ts +100 -0
  51. package/dist/precompress.d.ts.map +1 -0
  52. package/dist/recall-xml.d.ts +2 -1
  53. package/dist/recall-xml.d.ts.map +1 -1
  54. package/dist/recompress-gate.d.ts +11 -0
  55. package/dist/recompress-gate.d.ts.map +1 -0
  56. package/dist/recompress.d.ts +20 -4
  57. package/dist/recompress.d.ts.map +1 -1
  58. package/dist/skill/compaction-eval/SKILL.md +72 -0
  59. package/dist/skill/compaction-eval/references/facts-prompt.md +42 -0
  60. package/dist/skill/compaction-eval/references/judge-prompt.md +48 -0
  61. package/dist/skill/compaction-eval/references/rules.md +56 -0
  62. package/dist/skill/compaction-eval/scripts/aggregate.mjs +372 -0
  63. package/dist/skill/compaction-eval/scripts/compress.mjs +15675 -0
  64. package/dist/skill/compaction-eval/scripts/merge.mjs +287 -0
  65. package/dist/skill/compaction-eval/scripts/prepare.mjs +1620 -0
  66. package/dist/skill/compaction-eval/scripts/view.mjs +15983 -0
  67. package/dist/thinking-binding.d.ts +28 -0
  68. package/dist/thinking-binding.d.ts.map +1 -0
  69. package/dist/types.d.ts +9 -6
  70. package/dist/types.d.ts.map +1 -1
  71. package/package.json +47 -40
package/dist/index.mjs CHANGED
@@ -1,20 +1,296 @@
1
+ import { copyFileSync, existsSync, mkdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
2
+ import { fileURLToPath } from "node:url";
3
+ import { brandString } from "@deepseek-ai/dsh-brand";
1
4
  import { CompactionId } from "@deepseek-ai/dsh-compaction";
2
- import { BlockAssembler, createAssistantMessage, createToolResultMessage, createUserMessage } from "@deepseek-ai/dsh-llm";
5
+ import { BlockAssembler, createAssistantMessage, createSystemMessage, createToolResultMessage, createUserMessage, freezeMessage, isAgentLoopRequest, markAgentLoopRequest } from "@deepseek-ai/dsh-llm";
3
6
  import { scopeOf } from "@deepseek-ai/dsh-scope";
4
7
  import { SessionId, SessionSeq } from "@deepseek-ai/dsh-session";
5
8
  import { renderPrompt } from "@deepseek-ai/dsh-system-prompt";
6
9
  import { SUBAGENT_DESCRIPTOR_VERSION } from "@deepseek-ai/dsh-subagent";
7
10
  import { z } from "zod";
8
11
  import Schema from "@deepseek-ai/schemastery";
9
- import { copyFileSync, existsSync, mkdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
10
12
  import { homedir } from "node:os";
11
13
  import path from "node:path";
12
- import { fileURLToPath } from "node:url";
13
14
  import { toJSONSchema } from "zod/v4/core";
14
15
  import { AttachmentId } from "@deepseek-ai/dsh-attachment";
15
16
  //#region \0rolldown/runtime.js
16
17
  var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
17
18
  //#endregion
19
+ //#region src/eval-session-text.ts
20
+ /**
21
+ * /om-compaction-eval 的文本契约:命令名与描述、新会话首条消息、成功文本及其反解。
22
+ * 宿主命令与客户端跳转共用本模块,因此不得引入 Node 专有依赖(客户端 bundle 会内联它)。
23
+ * 导出 EVAL_COMMAND_NAME / EVAL_COMMAND_DESCRIPTION / EvalPromptInput / buildEvalPrompt /
24
+ * evalStartedText / parseEvalSessionId。
25
+ */
26
+ /** 命令名(无参数,裸调用即执行)。 */
27
+ const EVAL_COMMAND_NAME = "om-compaction-eval";
28
+ /** 命令描述(斜杠菜单与命令目录展示)。 */
29
+ const EVAL_COMMAND_DESCRIPTION = "ai分析OM结果";
30
+ /** 新会话首条消息:只给文档路径与会话标识,评估步骤全部由文档决定。 */
31
+ function buildEvalPrompt(input) {
32
+ const workspaceId = input.workspaceId === void 0 ? "" : ` workspace_id ${input.workspaceId}`;
33
+ return `按照 ${input.docPath} 分析会话。workspace ${input.cwd}${workspaceId} session_id ${input.sessionId}`;
34
+ }
35
+ /** 成功文本前缀;客户端按同一格式反解新会话 id 用于跳转。 */
36
+ const STARTED_PREFIX = "已启动 OM 结果分析会话 ";
37
+ /** 命令成功文本。 */
38
+ function evalStartedText(sessionId) {
39
+ return `${STARTED_PREFIX}${sessionId}`;
40
+ }
41
+ //#endregion
42
+ //#region src/utils.ts
43
+ /** 判断值是否为普通对象(非 null、非数组)。 */
44
+ function isRecord$1(value) {
45
+ return typeof value === "object" && value !== null && !Array.isArray(value);
46
+ }
47
+ /** 生成 uuid:优先 crypto.randomUUID,回退为时间戳+随机串拼接。 */
48
+ function uuid() {
49
+ const cryptoObj = globalThis.crypto;
50
+ if (cryptoObj && typeof cryptoObj.randomUUID === "function") return cryptoObj.randomUUID();
51
+ return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}`;
52
+ }
53
+ /** 提取 content 数组中的纯文本块(type === 'text' 的 block.text 拼接)。 */
54
+ function blocksToText(blocks) {
55
+ if (!Array.isArray(blocks)) return "";
56
+ const out = [];
57
+ for (const block of blocks) if (isRecord$1(block) && block.type === "text" && typeof block.text === "string") out.push(block.text);
58
+ return out.join("");
59
+ }
60
+ /** 消息内容的字符数:递归计入 text 块与 tool-result 内嵌文本。 */
61
+ function textCharCount(message) {
62
+ if (!message || !Array.isArray(message.content)) return 0;
63
+ let total = 0;
64
+ for (const block of message.content) if (block.type === "text") total += block.text.length;
65
+ else if (block.type === "tool-result") total += blocksToText(block.content).length;
66
+ return total;
67
+ }
68
+ /** 一组表层事件 seq 派生消息的字符数之和(OM 卡片「原始字符」口径)。 */
69
+ function seqsCharCount(session, seqs) {
70
+ const events = session.snapshotEvents();
71
+ return seqs.reduce((total, seq) => {
72
+ const event = events[seq];
73
+ return total + textCharCount(event ? session.deriveEventMessage(event) : null);
74
+ }, 0);
75
+ }
76
+ /** 面向 recall 的完整消息呈现:text 原样;tool-call 展开(参数=代码);tool-result 取文本。 */
77
+ function renderMessageText(message) {
78
+ if (!message || !Array.isArray(message.content)) return "";
79
+ const parts = [];
80
+ for (const block of message.content) if (block.type === "text") parts.push(block.text);
81
+ else if (block.type === "tool-call") parts.push(`[tool-call ${block.name} id=${String(block.id)}]
82
+ ${toolArgsJson(block.arguments)}`);
83
+ else if (block.type === "tool-result") parts.push(blocksToText(block.content));
84
+ return parts.join("\n");
85
+ }
86
+ /** 安全 JSON 序列化:序列化失败时退回 String 呈现。 */
87
+ function safeJson(value) {
88
+ try {
89
+ return JSON.stringify(value, null, 2);
90
+ } catch {
91
+ return String(value);
92
+ }
93
+ }
94
+ /**
95
+ * 工具调用参数的 JSON 文本(CDATA 内保持只有一层 JSON 转义):
96
+ * 字符串参数是模型产出的原始 JSON 串,原样返回(本身即合法 JSON,不再二次序列化);
97
+ * 其余结构 JSON.stringify 序列化一次。
98
+ */
99
+ function toolArgsJson(args) {
100
+ if (typeof args === "string") return args;
101
+ return safeJson(args);
102
+ }
103
+ /**
104
+ * 向元素追加 CDATA 正文:正文统一以 CDATA 包裹(逐字原样,不做实体转义)。
105
+ * 正文含 ]]> 时拆为相邻多个 CDATA 段,拼接后逐字还原原文,对读取方透明。
106
+ */
107
+ function appendCdataText(doc, el, text) {
108
+ const parts = text.split("]]>");
109
+ for (let i = 0; i < parts.length; i += 1) if (i === 0) el.appendChild(doc.createCDATASection(parts[0] ?? ""));
110
+ else {
111
+ el.appendChild(doc.createCDATASection("]]"));
112
+ el.appendChild(doc.createCDATASection(`>${parts[i] ?? ""}`));
113
+ }
114
+ }
115
+ /** 主会话判定:subagent 会话 header.origin === 'subagent'。 */
116
+ function isMainSession(session) {
117
+ return session.header?.origin !== "subagent";
118
+ }
119
+ /** 解析会话路由目标(provider/model),未路由时返回 undefined。 */
120
+ function routedTarget(session) {
121
+ try {
122
+ const config = session.requestHeader()?.config;
123
+ if (config?.provider && config.model) return {
124
+ provider: config.provider,
125
+ model: config.model
126
+ };
127
+ } catch {}
128
+ }
129
+ //#endregion
130
+ //#region src/compaction-eval-command.ts
131
+ /**
132
+ * /om-compaction-eval 命令:在被分析会话所属工作区新建一个会话,由它按随包发布的
133
+ * compaction-eval 文档分析当前会话的 OM 压缩结果,本会话上下文不受影响。
134
+ * 文档路径由本模块自身位置推出:发布产物优先,仓库源码兜底。
135
+ * 新会话的模型与思考等级默认沿用当前会话,可由命令参数 `provider/model [思考等级]` 指定。
136
+ * 导出 skillDocCandidates / skillDocPath / EvalModel / parseEvalModelInput /
137
+ * StartEvalResult / startEvalSession / buildCompactionEvalCommand。
138
+ */
139
+ const MODEL_USAGE = "用法:/om-compaction-eval [provider/model [思考等级]]";
140
+ /**
141
+ * 解析命令参数 `provider/model [思考等级]`:以第一个 `/` 切分 provider 与 model,空白分隔等级。
142
+ * @returns 无参数时 model 为 undefined(沿用当前会话);格式错误返回用法说明。
143
+ */
144
+ function parseEvalModelInput(rawInput) {
145
+ const parts = rawInput.split(/\s+/).filter((part) => part !== "");
146
+ if (parts.length === 0) return {
147
+ ok: true,
148
+ model: void 0
149
+ };
150
+ const [route, reasoningEffort] = parts;
151
+ const slash = route?.indexOf("/") ?? -1;
152
+ if (route === void 0 || slash <= 0 || slash === route.length - 1 || parts.length > 2) return {
153
+ ok: false,
154
+ error: MODEL_USAGE
155
+ };
156
+ return {
157
+ ok: true,
158
+ model: {
159
+ provider: route.slice(0, slash),
160
+ model: route.slice(slash + 1),
161
+ ...reasoningEffort === void 0 ? {} : { reasoningEffort }
162
+ }
163
+ };
164
+ }
165
+ /** 当前会话最近一次请求使用的模型与思考等级;尚未请求过时 undefined。 */
166
+ function currentModel(session) {
167
+ try {
168
+ const config = session.requestHeader()?.config;
169
+ if (!config?.provider || !config.model) return void 0;
170
+ return {
171
+ provider: config.provider,
172
+ model: config.model,
173
+ ...config.reasoningEffort === void 0 ? {} : { reasoningEffort: config.reasoningEffort }
174
+ };
175
+ } catch {
176
+ return;
177
+ }
178
+ }
179
+ /**
180
+ * skill 文档候选绝对路径,按优先级排列:
181
+ * 1. 发布产物 dist/skill/compaction-eval/SKILL.md(脚本为自包含 .mjs);
182
+ * 2. 仓库源码 .agents/skills/compaction-eval/SKILL.md(开发时 dist 未构建)。
183
+ * @param fromUrl - 入口模块 URL,缺省为本模块(打包后即 dist/index.mjs)。
184
+ */
185
+ function skillDocCandidates(fromUrl = import.meta.url) {
186
+ return [fileURLToPath(new URL("./skill/compaction-eval/SKILL.md", fromUrl)), fileURLToPath(new URL("../.agents/skills/compaction-eval/SKILL.md", fromUrl))];
187
+ }
188
+ /**
189
+ * 第一个存在的 skill 文档路径。
190
+ * @param fromUrl - 入口模块 URL,缺省为本模块。
191
+ * @returns 文档绝对路径;都不存在时 undefined。
192
+ */
193
+ function skillDocPath(fromUrl = import.meta.url) {
194
+ return skillDocCandidates(fromUrl).find((candidate) => existsSync(candidate));
195
+ }
196
+ /** 当前会话所属工作区 id;宿主无 workspaceRegistry 或会话未归属时 undefined。 */
197
+ function workspaceOf(ctx, sessionId) {
198
+ const registry = ctx.get("workspaceRegistry");
199
+ if (registry === void 0) return void 0;
200
+ return registry.list().find((workspace) => workspace.sessionIds.includes(sessionId))?.id;
201
+ }
202
+ /**
203
+ * 新建同工作区会话并投递首条消息。
204
+ * 非主会话、会话无 cwd、文档缺失或宿主缺 sessionController 时返回失败且不建会话;
205
+ * 建会话与投递的异常归一为失败原因。
206
+ * @param ctx - 宿主上下文(经 ctx.get 容错读取 sessionController 与 workspaceRegistry)。
207
+ * @param agent - 命令所针对的会话,其 id 与 cwd 决定分析目标与新会话位置。
208
+ * @param signal - 命令取消信号,透传给投递。
209
+ * @param model - 新会话模型;缺省沿用当前会话,当前会话尚未请求过时用宿主默认。
210
+ */
211
+ async function startEvalSession(ctx, agent, signal, model) {
212
+ const session = agent.session;
213
+ if (!isMainSession(session)) return {
214
+ ok: false,
215
+ error: "OM 结果分析仅支持主会话"
216
+ };
217
+ const cwd = session.header?.cwd;
218
+ if (cwd === void 0 || cwd === "") return {
219
+ ok: false,
220
+ error: "当前会话没有工作区信息"
221
+ };
222
+ const docPath = skillDocPath();
223
+ if (docPath === void 0) return {
224
+ ok: false,
225
+ error: "找不到 compaction-eval 文档"
226
+ };
227
+ const controller = ctx.get("sessionController");
228
+ if (controller === void 0) return {
229
+ ok: false,
230
+ error: "宿主未提供 sessionController 服务"
231
+ };
232
+ const workspaceId = workspaceOf(ctx, session.id);
233
+ const preset = session.header?.agentPreset;
234
+ try {
235
+ const created = await controller.create({
236
+ ...workspaceId === void 0 ? { cwd } : { workspaceId },
237
+ ...preset === void 0 ? {} : { agentPreset: preset }
238
+ });
239
+ const selected = model ?? currentModel(session);
240
+ if (selected !== void 0) await controller.selectModel({
241
+ sessionId: created.sessionId,
242
+ ...selected
243
+ });
244
+ await controller.prompt({
245
+ requestId: brandString(uuid()),
246
+ sessionId: created.sessionId,
247
+ mode: "queue",
248
+ content: [{
249
+ type: "text",
250
+ text: buildEvalPrompt({
251
+ docPath,
252
+ cwd,
253
+ ...workspaceId === void 0 ? {} : { workspaceId },
254
+ sessionId: session.id
255
+ })
256
+ }]
257
+ }, signal);
258
+ return {
259
+ ok: true,
260
+ sessionId: created.sessionId,
261
+ text: evalStartedText(created.sessionId)
262
+ };
263
+ } catch (error) {
264
+ return {
265
+ ok: false,
266
+ error: error instanceof Error ? error.message : String(error)
267
+ };
268
+ }
269
+ }
270
+ /** 构造 /om-compaction-eval 命令定义:可选参数指定新会话的模型与思考等级。 */
271
+ function buildCompactionEvalCommand(ctx) {
272
+ return {
273
+ name: EVAL_COMMAND_NAME,
274
+ description: EVAL_COMMAND_DESCRIPTION,
275
+ input: { hint: "[provider/model [思考等级]]" },
276
+ handler: async ({ agent, rawInput, signal }) => {
277
+ const parsed = parseEvalModelInput(rawInput);
278
+ if (!parsed.ok) return {
279
+ kind: "error",
280
+ text: parsed.error
281
+ };
282
+ const result = await startEvalSession(ctx, agent, signal, parsed.model);
283
+ return result.ok ? {
284
+ kind: "success",
285
+ text: result.text
286
+ } : {
287
+ kind: "error",
288
+ text: result.error
289
+ };
290
+ }
291
+ };
292
+ }
293
+ //#endregion
18
294
  //#region src/format.ts
19
295
  /**
20
296
  * 紧凑数字格式化(压缩卡片、重压缩记录与压缩日志共用)。零依赖,服务端与浏览器均可引用。导出 formatCompactCount / formatSeconds。
@@ -59,7 +335,7 @@ const HISTORY_TIP = "当前块是历史消息的压缩产物,不要复述";
59
335
  * 「完整消息」定义(压缩提示词、recall 工具描述与 <history> 块顶注释共用)。
60
336
  * 完整消息是摘要日志与 recall 共用的定位单位;首条 index 为 0,按会话顺序递增、全局稳定。
61
337
  */
62
- const COMPLETE_MESSAGE_DEFINITION = "`完整消息`指一条`用户消息`、`模型输出文本`或`具有result的toolcall`;首条 index 为 0,按会话顺序递增。";
338
+ const COMPLETE_MESSAGE_DEFINITION = "`完整消息`指一条`用户消息`、`模型输出文本`、`具有result的toolcall`或`手动加载的skill`;首条 index 为 0,按会话顺序递增。";
63
339
  /**
64
340
  * 最终 <history> 块内文块首的格式说明注释(XML 注释)。通用部分(条目标签语义 +
65
341
  * CDATA 约定 + toolcall 结构)始终保留;<user_message> /
@@ -69,7 +345,7 @@ function historyFormatNote(sections = {}) {
69
345
  const parts = [
70
346
  COMPLETE_MESSAGE_DEFINITION,
71
347
  "<TAG index=\"N\">表示单条完整消息,<TAG start=\"A\" end=\"B\"> 表示多条连续消息,start/end 是首尾完整消息的 index;消息块的内容是用CDATA包裹的纯文本",
72
- "<assistant type=\"toolcall\" tool-name=\"T\" callId=\"C\" index=\"N\"> 表示工具调用,内含 <tool-args> 与 <tool-result> 两个CDATA子元素(调用参数与工具返回内容)"
348
+ "<assistant type=\"toolcall\" tool-name=\"T\" index=\"N\"> 表示工具调用,内含 <tool-args> 与 <tool-result> 两个CDATA子元素(调用参数与工具返回内容)"
73
349
  ];
74
350
  if (sections.user) parts.push("<user_message index=\"N\"> 表示用户消息原文");
75
351
  if (sections.skill) parts.push("<skill_content name=\"S\" index=\"N\"> 表示未压缩的原始 skill");
@@ -120,94 +396,6 @@ function makeLogger(ctx, debug) {
120
396
  };
121
397
  }
122
398
  //#endregion
123
- //#region src/utils.ts
124
- /** 判断值是否为普通对象(非 null、非数组)。 */
125
- function isRecord(value) {
126
- return typeof value === "object" && value !== null && !Array.isArray(value);
127
- }
128
- /** 生成 uuid:优先 crypto.randomUUID,回退为时间戳+随机串拼接。 */
129
- function uuid() {
130
- const cryptoObj = globalThis.crypto;
131
- if (cryptoObj && typeof cryptoObj.randomUUID === "function") return cryptoObj.randomUUID();
132
- return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}`;
133
- }
134
- /** 提取 content 数组中的纯文本块(type === 'text' 的 block.text 拼接)。 */
135
- function blocksToText(blocks) {
136
- if (!Array.isArray(blocks)) return "";
137
- const out = [];
138
- for (const block of blocks) if (isRecord(block) && block.type === "text" && typeof block.text === "string") out.push(block.text);
139
- return out.join("");
140
- }
141
- /** 消息内容的字符数:递归计入 text 块与 tool-result 内嵌文本。 */
142
- function textCharCount(message) {
143
- if (!message || !Array.isArray(message.content)) return 0;
144
- let total = 0;
145
- for (const block of message.content) if (block.type === "text") total += block.text.length;
146
- else if (block.type === "tool-result") total += blocksToText(block.content).length;
147
- return total;
148
- }
149
- /** 一组表层事件 seq 派生消息的字符数之和(OM 卡片「原始字符」口径)。 */
150
- function seqsCharCount(session, seqs) {
151
- const events = session.snapshotEvents();
152
- return seqs.reduce((total, seq) => {
153
- const event = events[seq];
154
- return total + textCharCount(event ? session.deriveEventMessage(event) : null);
155
- }, 0);
156
- }
157
- /** 面向 recall 的完整消息呈现:text 原样;tool-call 展开(参数=代码);tool-result 取文本。 */
158
- function renderMessageText(message) {
159
- if (!message || !Array.isArray(message.content)) return "";
160
- const parts = [];
161
- for (const block of message.content) if (block.type === "text") parts.push(block.text);
162
- else if (block.type === "tool-call") parts.push(`[tool-call ${block.name} id=${String(block.id)}]
163
- ${toolArgsJson(block.arguments)}`);
164
- else if (block.type === "tool-result") parts.push(blocksToText(block.content));
165
- return parts.join("\n");
166
- }
167
- /** 安全 JSON 序列化:序列化失败时退回 String 呈现。 */
168
- function safeJson(value) {
169
- try {
170
- return JSON.stringify(value, null, 2);
171
- } catch {
172
- return String(value);
173
- }
174
- }
175
- /**
176
- * 工具调用参数的 JSON 文本(CDATA 内保持只有一层 JSON 转义):
177
- * 字符串参数是模型产出的原始 JSON 串,原样返回(本身即合法 JSON,不再二次序列化);
178
- * 其余结构 JSON.stringify 序列化一次。
179
- */
180
- function toolArgsJson(args) {
181
- if (typeof args === "string") return args;
182
- return safeJson(args);
183
- }
184
- /**
185
- * 向元素追加 CDATA 正文:正文统一以 CDATA 包裹(逐字原样,不做实体转义)。
186
- * 正文含 ]]> 时拆为相邻多个 CDATA 段,拼接后逐字还原原文,对读取方透明。
187
- */
188
- function appendCdataText(doc, el, text) {
189
- const parts = text.split("]]>");
190
- for (let i = 0; i < parts.length; i += 1) if (i === 0) el.appendChild(doc.createCDATASection(parts[0] ?? ""));
191
- else {
192
- el.appendChild(doc.createCDATASection("]]"));
193
- el.appendChild(doc.createCDATASection(`>${parts[i] ?? ""}`));
194
- }
195
- }
196
- /** 主会话判定:subagent 会话 header.origin === 'subagent'。 */
197
- function isMainSession(session) {
198
- return session.header?.origin !== "subagent";
199
- }
200
- /** 解析会话路由目标(provider/model),未路由时返回 undefined。 */
201
- function routedTarget(session) {
202
- try {
203
- const config = session.requestHeader()?.config;
204
- if (config?.provider && config.model) return {
205
- provider: config.provider,
206
- model: config.model
207
- };
208
- } catch {}
209
- }
210
- //#endregion
211
399
  //#region src/compaction-log.ts
212
400
  /** 诊断子会话的 descriptor provider(宿主子代理列表识别用)。 */
213
401
  const COMPACTION_LOG_PROVIDER = "om-compaction-log";
@@ -218,17 +406,22 @@ function phaseLabel(phase) {
218
406
  return "压缩";
219
407
  }
220
408
  /**
221
- * 压缩会话记录 label:成功为会话记录、失败为失败日志,均含压缩阶段与轮数;
222
- * 换模型重压缩传入 retryTarget,label 末尾追加「重压缩 provider/model」以区分。
409
+ * 压缩会话记录 label:`OM会话(起点-终点)-观察/反思`,区间缺失省略括号段;
410
+ * 重压缩追加 `-重压缩`,失败追加 `-失败`。
223
411
  */
224
- function compressionRecordLabel(phase, rounds, success, retryTarget) {
225
- const retry = retryTarget === void 0 ? "" : ` · 重压缩 ${retryTarget.provider}/${retryTarget.model}`;
226
- return `OM 压缩${success ? "会话记录" : "失败日志"}(${phaseLabel(phase)} · ${rounds} 轮${retry})`;
412
+ function compressionRecordLabel(phase, range, success, retry) {
413
+ return `OM会话${range.min === void 0 || range.max === void 0 ? "" : `(${range.min}-${range.max})`}-${phaseLabel(phase)}${retry ? "-重压缩" : ""}${success ? "" : "-失败"}`;
414
+ }
415
+ /** 失败产物文本:`无(压缩失败[:原因[;最后一轮 finish=…[,输出 N tokens]]])`。 */
416
+ function failureText(failure) {
417
+ if (failure === void 0) return "无(压缩失败)";
418
+ const last = failure.finish === void 0 ? "" : `;最后一轮 finish=${failure.finish}${failure.outputTokens === void 0 ? "" : `,输出 ${failure.outputTokens} tokens`}`;
419
+ return `无(压缩失败:${failure.reason}${last})`;
227
420
  }
228
421
  /** 生成模型信息:压缩模型、思考等级、原始消息与压缩产物的字符数(k 单位)。 */
229
422
  function compressionInfo(info) {
230
423
  const effort = info.reasoningEffort ?? "默认思考等级";
231
- const result = info.resultChars === void 0 ? "无(压缩失败)" : `${formatCompactCount(info.resultChars)} 字符`;
424
+ const result = info.resultChars === void 0 ? failureText(info.failure) : `${formatCompactCount(info.resultChars)} 字符`;
232
425
  return {
233
426
  text: `压缩使用模型 ${info.target.provider}/${info.target.model}(${effort}),原始消息 ${formatCompactCount(info.originalChars)} 字符,压缩产物 ${result}`,
234
427
  provider: info.target.provider,
@@ -258,7 +451,7 @@ function seedEvent(type, seq, time, data, surfaceOp) {
258
451
  * 时间全程单调不减;轮次数组短于 assistant 数时(流错误注入的部分 assistant)回落上一
259
452
  * 轮结束时刻与循环结束时刻。
260
453
  */
261
- function buildCompressionSeed(messages, stats, label, info) {
454
+ function buildCompressionSeed(messages, stats, label, info, system) {
262
455
  const seed = [];
263
456
  const push = (type, time, data, surfaceOp) => {
264
457
  seed.push(seedEvent(type, seed.length, time, data, surfaceOp));
@@ -276,12 +469,13 @@ function buildCompressionSeed(messages, stats, label, info) {
276
469
  label
277
470
  });
278
471
  push("turn/start", at(stats.startedAt), { turn: 1 });
279
- let step = 0;
472
+ let step = 1;
280
473
  let assistantIndex = 0;
281
474
  let stepTime = stats.startedAt;
475
+ let stepOpen = false;
282
476
  let pending = [];
283
477
  const closeStep = () => {
284
- if (step === 0) return;
478
+ if (!stepOpen) return;
285
479
  for (const call of pending) {
286
480
  if (executed.has(call.id)) continue;
287
481
  const repair = createToolResultMessage({
@@ -310,6 +504,7 @@ function buildCompressionSeed(messages, stats, label, info) {
310
504
  step
311
505
  });
312
506
  pending = [];
507
+ stepOpen = false;
313
508
  };
314
509
  for (const message of messages) if (message.role === "assistant") {
315
510
  closeStep();
@@ -322,6 +517,7 @@ function buildCompressionSeed(messages, stats, label, info) {
322
517
  turn: 1,
323
518
  step
324
519
  });
520
+ stepOpen = true;
325
521
  const assistant = message;
326
522
  const assistantTime = at(completedAt);
327
523
  push("assistant/message", assistantTime, {
@@ -348,7 +544,26 @@ function buildCompressionSeed(messages, stats, label, info) {
348
544
  step,
349
545
  message
350
546
  }, "append");
351
- else push("user/message", at(step === 0 ? stats.startedAt : stepTime), message, "append");
547
+ else if (!stepOpen) {
548
+ const user = message;
549
+ push("step/start", at(stats.startedAt), {
550
+ turn: 1,
551
+ step
552
+ });
553
+ stepOpen = true;
554
+ if (system !== void 0 && system !== "") push("system/message", at(stats.startedAt), {
555
+ turn: 1,
556
+ step,
557
+ message: createSystemMessage(system)
558
+ }, "append");
559
+ push("user/message", at(stats.startedAt), {
560
+ ...user,
561
+ source: { kind: "user" }
562
+ }, "append");
563
+ } else {
564
+ const user = message;
565
+ push("user/message", at(stepTime), user, "append");
566
+ }
352
567
  closeStep();
353
568
  if (info !== void 0) {
354
569
  step += 1;
@@ -386,7 +601,7 @@ function buildCompressionSeed(messages, stats, label, info) {
386
601
  * 把一次压缩工具循环的完整会话消息组落盘为子会话:以重建时间线的 seed 事件经
387
602
  * ctx.sessions.create 构造子会话(header origin 'subagent'、parentSession 指向主会话、
388
603
  * delegationDepth = 父 + 1、cwd 继承主会话;首事件 one-shot descriptor,provider
389
- * om-compaction-log,label 含压缩阶段与轮数;info 存在时尾部追加一条模型文本),flush 持久化,在父会话登记
604
+ * om-compaction-log,label 含完整消息区间与阶段;info 存在时尾部追加一条模型文本),flush 持久化,在父会话登记
390
605
  * subagent/catalog,返回子会话 id。成功与失败均调用;落盘自身绝不抛错,任何失败仅
391
606
  * logger.warn 并返回 undefined。
392
607
  */
@@ -394,9 +609,14 @@ async function recordCompressionSession(ctx, parentSession, options) {
394
609
  const logger = makeLogger(ctx, options.debug);
395
610
  try {
396
611
  const header = parentSession.header;
397
- const label = compressionRecordLabel(options.phase, options.stats.rounds.length, options.success, options.retryTarget);
398
- const seed = buildCompressionSeed(options.messages, options.stats, label, options.info);
399
- const child = ctx.sessions.create(SessionId(`om-compaction-log-${uuid()}`), {
612
+ const label = compressionRecordLabel(options.phase, options.range ?? {}, options.success, options.retry === true);
613
+ const seed = buildCompressionSeed(options.messages, options.stats, label, options.info, options.system);
614
+ const sessions = ctx.get("sessions");
615
+ if (sessions === void 0) {
616
+ logger.warn("sessions 服务未挂载,跳过压缩会话记录落盘");
617
+ return;
618
+ }
619
+ const child = sessions.create(SessionId(`om-compaction-log-${uuid()}`), {
400
620
  seed,
401
621
  meta: {
402
622
  ...header.cwd === void 0 ? {} : { cwd: header.cwd },
@@ -421,7 +641,7 @@ async function recordCompressionSession(ctx, parentSession, options) {
421
641
  mode: "one-shot",
422
642
  label
423
643
  });
424
- await ctx.sessions.flush(parentSession);
644
+ await sessions.flush(parentSession);
425
645
  return child.id;
426
646
  } catch (error) {
427
647
  const message = error instanceof Error ? error.message : String(error);
@@ -7569,8 +7789,9 @@ var import_lib = (/* @__PURE__ */ __commonJSMin(((exports) => {
7569
7789
  * renderCompleteMessage(完整消息渲染与图片附件收集)。事件日志仅追加(被遮蔽的事件仍可读,
7570
7790
  * recall 依赖此性质)。
7571
7791
  *
7572
- * 完整消息分三类:user(用户消息)、assistant(模型输出文本)、
7573
- * toolcall(单个工具调用及其结果,result 按 callId 匹配并入)。系统消息不占位。
7792
+ * 完整消息分四类:user(用户消息)、assistant(模型输出文本)、
7793
+ * toolcall(单个工具调用及其结果,result 按 callId 匹配并入)、
7794
+ * skill(手动加载的 skill,source.kind 为 skill-invocation 的系统消息)。其余系统消息不占位。
7574
7795
  * index 从 0 起、按日志顺序递增、只追加不重排(压缩后旧摘要条目引用的 index 仍然有效)。
7575
7796
  */
7576
7797
  /** 查找 seq 在表层节点序列中的下标(不在则返回 -1)。 */
@@ -7579,7 +7800,16 @@ function surfaceIndexOf(nodes, seq) {
7579
7800
  return -1;
7580
7801
  }
7581
7802
  /**
7582
- * 完整消息索引:按日志顺序把消息事件折叠为完整消息序列(三类,见文件头)。
7803
+ * 手动加载 skill 的名称:source.kind 为 skill-invocation 且 name 为非空字符串时返回,否则 undefined。
7804
+ * 当前宿主类型未声明该 kind,故以宽松结构读取。
7805
+ */
7806
+ function skillInvocationName(source) {
7807
+ if (source?.kind !== "skill-invocation") return void 0;
7808
+ const name = source.name;
7809
+ return typeof name === "string" && name !== "" ? name : void 0;
7810
+ }
7811
+ /**
7812
+ * 完整消息索引:按日志顺序把消息事件折叠为完整消息序列(四类,见文件头)。
7583
7813
  * 工具调用结果按 source.callId 匹配其 tool-call 并入该条;未匹配的 result 独立成条(防御)。
7584
7814
  * 本插件自产消息不占位;压缩在 agent/pre-step 触发(call-result 完备),不存在未闭合调用。
7585
7815
  */
@@ -7593,11 +7823,18 @@ function indexCompleteMessages(session) {
7593
7823
  if (event.type === "user/message") {
7594
7824
  const source = event.data.source;
7595
7825
  if (isPluginOwnedSource(source)) continue;
7826
+ const skillName = skillInvocationName(source);
7596
7827
  if (source?.kind === "user") cms.push({
7597
7828
  index: cms.length,
7598
7829
  type: "user",
7599
7830
  seqs: [seq]
7600
7831
  });
7832
+ else if (skillName !== void 0) cms.push({
7833
+ index: cms.length,
7834
+ type: "skill",
7835
+ seqs: [seq],
7836
+ skillName
7837
+ });
7601
7838
  } else if (event.type === "assistant/message") {
7602
7839
  const message = event.data.message;
7603
7840
  if (!message || !Array.isArray(message.content)) continue;
@@ -7647,10 +7884,10 @@ function indexCompleteMessages(session) {
7647
7884
  function collectImageRefs(content, out) {
7648
7885
  if (!Array.isArray(content)) return;
7649
7886
  for (const block of content) {
7650
- if (!isRecord(block)) continue;
7887
+ if (!isRecord$1(block)) continue;
7651
7888
  if (block.type === "image") {
7652
7889
  const a = block.attachment;
7653
- 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({
7890
+ if (isRecord$1(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({
7654
7891
  attachmentId: a.attachmentId,
7655
7892
  mediaType: a.mediaType,
7656
7893
  bytes: a.bytes,
@@ -7697,13 +7934,13 @@ function renderToolResultText(session, cm, pruner) {
7697
7934
  return message ? renderMessageText(message) : "";
7698
7935
  }
7699
7936
  /** 渲染一条完整消息为「文本 + 图片」(recall 输出用):
7700
- * user 取消息原文,assistant 取文本块,toolcall 为调用块 + 结果文本
7937
+ * user / skill 取消息原文,assistant 取文本块,toolcall 为调用块 + 结果文本
7701
7938
  * (pruner 裁剪超大结果);同时收集该条完整消息携带的图片附件(含 tool-result 嵌套,
7702
7939
  * pruner 裁剪掉的图片不收集)。
7703
7940
  */
7704
7941
  function renderCompleteMessageParts(session, cm, pruner) {
7705
7942
  const images = [];
7706
- if (cm.type === "user") {
7943
+ if (cm.type === "user" || cm.type === "skill") {
7707
7944
  const seq = cm.seqs[0];
7708
7945
  const event = seq === void 0 ? void 0 : session.snapshotEvents()[seq];
7709
7946
  const message = event ? session.deriveEventMessage(event) : null;
@@ -7808,7 +8045,7 @@ function skillNameOf(session, cm) {
7808
8045
  for (const block of message.content) if (block.type === "tool-call" && String(block.id ?? "") === (cm.callId ?? "")) {
7809
8046
  try {
7810
8047
  const args = JSON.parse(String(block.arguments ?? ""));
7811
- if (isRecord(args) && typeof args.name === "string") return args.name;
8048
+ if (isRecord$1(args) && typeof args.name === "string") return args.name;
7812
8049
  } catch {}
7813
8050
  return "";
7814
8051
  }
@@ -7918,6 +8155,19 @@ function buildObserveView(session, seqs, options = {}) {
7918
8155
  });
7919
8156
  continue;
7920
8157
  }
8158
+ if (cm.type === "skill") {
8159
+ const text = renderCompleteMessage(session, cm);
8160
+ if (text.trim() === "") continue;
8161
+ entries.push({
8162
+ kind: "assistant",
8163
+ lo: cm.index,
8164
+ hi: cm.index,
8165
+ text,
8166
+ toolName: SKILL_TOOL_NAME,
8167
+ ...cm.skillName === void 0 ? {} : { skillName: cm.skillName }
8168
+ });
8169
+ continue;
8170
+ }
7921
8171
  if (options.skipReasoning !== true) {
7922
8172
  const callSeq = cm.seqs[0];
7923
8173
  const reasonings = callSeq === void 0 ? void 0 : reasoningBySeq.get(callSeq);
@@ -7953,7 +8203,6 @@ function buildObserveView(session, seqs, options = {}) {
7953
8203
  text,
7954
8204
  ...toolName === void 0 ? {} : { toolName },
7955
8205
  ...skillName === void 0 ? {} : { skillName },
7956
- ...cm.callId === void 0 || toolArgs === void 0 ? {} : { callId: cm.callId },
7957
8206
  ...toolArgs === void 0 ? {} : { toolArgs },
7958
8207
  ...toolResult === void 0 ? {} : { toolResult },
7959
8208
  ...ask === null ? {} : { ask }
@@ -8103,14 +8352,12 @@ function parseBlockEntries(blockText, blockSeq) {
8103
8352
  if (toolArgs !== void 0) {
8104
8353
  const toolResult = childText(el, "tool-result");
8105
8354
  const toolName = el.getAttribute("tool-name");
8106
- const callId = el.getAttribute("callId");
8107
8355
  entries.push({
8108
8356
  kind: "assistant",
8109
8357
  lo: index,
8110
8358
  hi: index,
8111
8359
  text,
8112
8360
  ...toolName === null || toolName === "" ? {} : { toolName },
8113
- ...callId === null || callId === "" ? {} : { callId },
8114
8361
  toolArgs,
8115
8362
  ...toolResult === void 0 ? {} : { toolResult },
8116
8363
  blockSeq
@@ -8223,7 +8470,6 @@ function entryToElement(doc, entry) {
8223
8470
  el.setAttribute("index", String(entry.lo));
8224
8471
  el.setAttribute("type", "toolcall");
8225
8472
  if (entry.toolName !== void 0 && entry.toolName !== "") el.setAttribute("tool-name", entry.toolName);
8226
- if (entry.callId !== void 0 && entry.callId !== "") el.setAttribute("callId", entry.callId);
8227
8473
  const args = doc.createElement("tool-args");
8228
8474
  appendCdataText(doc, args, entry.toolArgs);
8229
8475
  el.appendChild(args);
@@ -8315,13 +8561,13 @@ function isAskEntry(entry) {
8315
8561
  }
8316
8562
  /** 压缩会话的工具状态:视图 + 替换记录 + 二次确认标记(skill / ask_user_question)+ 完成标记。 */
8317
8563
  var CompressionState = class CompressionState {
8318
- view;
8319
8564
  replacements = [];
8320
8565
  challengedSkills = /* @__PURE__ */ new Set();
8321
8566
  viewedAsks = /* @__PURE__ */ new Set();
8322
8567
  undeliveredAsks = /* @__PURE__ */ new Set();
8323
8568
  rewrittenAsks = /* @__PURE__ */ new Map();
8324
8569
  _completed = false;
8570
+ view;
8325
8571
  /**
8326
8572
  * @param view 压缩视图(观察或反思),工具校验与最终块构建的数据源。
8327
8573
  */
@@ -8387,9 +8633,10 @@ var CompressionState = class CompressionState {
8387
8633
  return Math.floor(value);
8388
8634
  }
8389
8635
  /**
8390
- * getHistory:返回 [start..end] 区间内的条目(压缩视图,无 <history> 包裹)。
8391
- * start/end 缺省为要求区间首尾;越界或 start > end 返回错误。区间切入已有压缩
8392
- * 块(反思视图)时返回该块全部条目。
8636
+ * getHistory:返回 [start..end] 区间内的当前条目(无 <history> 包裹)。
8637
+ * start/end 缺省为要求区间首尾;越界或 start > end 返回错误。本次替换的区间显示为
8638
+ * 摘要条目,与查询区间相交即整条返回;区间切入已有压缩块(反思视图)时返回该块当前
8639
+ * 全部条目,跨块摘要连带展开其覆盖的块。
8393
8640
  */
8394
8641
  getHistory(args) {
8395
8642
  const { minIndex, maxIndex } = this.view;
@@ -8422,15 +8669,26 @@ var CompressionState = class CompressionState {
8422
8669
  isError: true
8423
8670
  };
8424
8671
  const intersects = (entry) => entry.lo !== void 0 && entry.hi !== void 0 && entry.lo <= end && entry.hi >= start;
8425
- const expandedBlocks = /* @__PURE__ */ new Set();
8426
- for (const entry of this.view.entries) if (entry.blockSeq !== void 0 && intersects(entry)) expandedBlocks.add(entry.blockSeq);
8427
- const selected = this.view.entries.filter((entry) => entry.blockSeq !== void 0 ? expandedBlocks.has(entry.blockSeq) : intersects(entry));
8672
+ const projected = this.project();
8673
+ const expanded = /* @__PURE__ */ new Set();
8674
+ for (let grown = true; grown;) {
8675
+ grown = false;
8676
+ for (const item of projected) {
8677
+ if (!intersects(item.entry) && !item.blocks.some((seq) => expanded.has(seq))) continue;
8678
+ for (const seq of item.blocks) {
8679
+ if (expanded.has(seq)) continue;
8680
+ expanded.add(seq);
8681
+ grown = true;
8682
+ }
8683
+ }
8684
+ }
8685
+ const selected = projected.filter((item) => item.blocks.length > 0 ? item.blocks.some((seq) => expanded.has(seq)) : intersects(item.entry));
8428
8686
  if (selected.length === 0) return {
8429
8687
  text: `区间 [${start}..${end}] 没有条目`,
8430
8688
  isError: false
8431
8689
  };
8432
- const text = `<!-- 完整消息区间 [${start}..${end}],共 ${selected.length} 条 -->\n${renderEntriesXml(selected)}`;
8433
- for (const entry of selected) if (entry.ask !== void 0 && entry.lo !== void 0) this.undeliveredAsks.add(entry.lo);
8690
+ const text = renderEntriesXml(selected.map((item) => item.entry));
8691
+ for (const { entry } of selected) if (entry.ask !== void 0 && entry.lo !== void 0) this.undeliveredAsks.add(entry.lo);
8434
8692
  return {
8435
8693
  text,
8436
8694
  isError: false
@@ -8522,7 +8780,7 @@ var CompressionState = class CompressionState {
8522
8780
  isError: true
8523
8781
  };
8524
8782
  for (const rep of this.replacements) if (rep.lo <= hi && rep.hi >= lo && !(rep.lo >= lo && rep.hi <= hi)) return {
8525
- text: `${CompressionState.spanLabel(lo, hi)} 与已有替换区间 [${rep.lo}..${rep.hi}] 部分重叠,只能完全包含或不相交`,
8783
+ text: `${CompressionState.spanLabel(lo, hi)} 与已有替换区间 [${rep.lo}..${rep.hi}] 部分重叠,只能完全包含或不相交。[${rep.lo}..${rep.hi}] 已生效,修改其摘要时用相同或更大的区间重新提交`,
8526
8784
  isError: true
8527
8785
  };
8528
8786
  const unchallenged = [];
@@ -8565,9 +8823,60 @@ var CompressionState = class CompressionState {
8565
8823
  isError: false
8566
8824
  };
8567
8825
  }
8826
+ /** 完全包含该条目的替换记录;替换区间两两不相交,至多一条。 */
8827
+ replacementFor(entry) {
8828
+ const { lo, hi } = entry;
8829
+ if (lo === void 0 || hi === void 0) return void 0;
8830
+ return this.replacements.find((rep) => lo >= rep.lo && hi <= rep.hi);
8831
+ }
8568
8832
  /** 条目是否已被成功直接压缩完全覆盖。 */
8569
8833
  coveredBy(entry) {
8570
- return 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);
8834
+ return this.replacementFor(entry) !== void 0;
8835
+ }
8836
+ /**
8837
+ * 当前状态投影:按视图顺序,被替换条目由一条摘要条目代替,摘要位于首个被替换条目处。
8838
+ * reasoning 带 index 时按自身区间取舍,无 index 时跟随其后第一条非 reasoning 条目。
8839
+ */
8840
+ project() {
8841
+ const entries = this.view.entries;
8842
+ const reps = new Array(entries.length);
8843
+ let next;
8844
+ for (let i = entries.length - 1; i >= 0; i -= 1) {
8845
+ const entry = entries[i];
8846
+ if (entry === void 0) continue;
8847
+ const own = this.replacementFor(entry);
8848
+ if (entry.kind !== "reasoning") next = own;
8849
+ reps[i] = entry.kind === "reasoning" && entry.lo === void 0 ? next : own;
8850
+ }
8851
+ const projected = [];
8852
+ const summaries = /* @__PURE__ */ new Map();
8853
+ entries.forEach((entry, i) => {
8854
+ const rep = reps[i];
8855
+ if (rep === void 0) {
8856
+ projected.push({
8857
+ entry,
8858
+ blocks: entry.blockSeq === void 0 ? [] : [entry.blockSeq]
8859
+ });
8860
+ return;
8861
+ }
8862
+ let summary = summaries.get(rep);
8863
+ if (summary === void 0) {
8864
+ summary = {
8865
+ entry: {
8866
+ kind: "assistant",
8867
+ lo: rep.lo,
8868
+ hi: rep.hi,
8869
+ text: rep.content
8870
+ },
8871
+ blocks: [],
8872
+ replacement: rep
8873
+ };
8874
+ summaries.set(rep, summary);
8875
+ projected.push(summary);
8876
+ }
8877
+ if (entry.blockSeq !== void 0 && !summary.blocks.includes(entry.blockSeq)) summary.blocks.push(entry.blockSeq);
8878
+ });
8879
+ return projected;
8571
8880
  }
8572
8881
  /** 重写已查看、尚未压缩覆盖的原始 ask,一次提交全部题。 */
8573
8882
  rewriteAskUserQuestion(args) {
@@ -8657,62 +8966,31 @@ var CompressionState = class CompressionState {
8657
8966
  };
8658
8967
  }
8659
8968
  /**
8660
- * 构建最终 <history> 块:按 index 顺序合并视图条目与替换记录——user 条目
8661
- * 原样、被替换区间生成 <assistant index|start end> 摘要条目(content 以 CDATA 包裹嵌入)、
8662
- * 未替换普通与历史条目原样保留,原始 ask 使用重写后的 q/a;reasoning 不进产物。
8663
- * 块首按最终条目动态生成格式说明注释,开标签携带 tip 属性。
8969
+ * 构建最终 <history> 块:取当前状态投影并去掉 reasoning——user 条目原样、被替换区间为
8970
+ * <assistant index|start end> 摘要条目、未替换普通与历史条目原样保留,原始 ask 使用
8971
+ * 重写后的 q/a。块首按最终条目动态生成格式说明注释,开标签携带 tip 属性。
8664
8972
  */
8665
8973
  buildFinalBlock() {
8666
8974
  const pending = this.unprocessedAskIndices();
8667
8975
  if (pending.length > 0) throw new Error(`原始 ask 尚未处理:index ${pending.join("、")}`);
8668
- const doc = new import_lib.DOMParser({ onError: () => {} }).parseFromString(`<${HISTORY_TAG} />`, "text/xml");
8669
- const root = doc.documentElement;
8670
- if (!root) return "";
8671
- const coveredBy = (entry) => this.coveredBy(entry);
8672
- const reps = [...this.replacements].sort((a, b) => a.lo - b.lo);
8673
- let nextRep = 0;
8674
- const emitReplacement = (rep) => {
8675
- const el = doc.createElement("assistant");
8676
- if (rep.lo === rep.hi) el.setAttribute("index", String(rep.lo));
8677
- else {
8678
- el.setAttribute("start", String(rep.lo));
8679
- el.setAttribute("end", String(rep.hi));
8680
- }
8681
- appendCdataText(doc, el, rep.content);
8682
- root.appendChild(el);
8683
- };
8684
- const flushReplacementsBefore = (lo) => {
8685
- while (nextRep < reps.length) {
8686
- const rep = reps[nextRep];
8687
- if (rep === void 0) break;
8688
- if (lo !== void 0 && rep.lo >= lo) break;
8689
- emitReplacement(rep);
8690
- nextRep += 1;
8691
- }
8692
- };
8693
- for (const entry of this.view.entries) {
8694
- if (entry.kind === "reasoning") continue;
8695
- if (coveredBy(entry)) continue;
8696
- flushReplacementsBefore(entry.lo);
8976
+ const entries = this.project().flatMap(({ entry }) => {
8977
+ if (entry.kind === "reasoning") return [];
8697
8978
  const qa = entry.lo === void 0 ? void 0 : this.rewrittenAsks.get(entry.lo);
8698
- const output = entry.ask !== void 0 && qa !== void 0 && entry.lo !== void 0 ? {
8979
+ if (entry.ask === void 0 || qa === void 0 || entry.lo === void 0) return [entry];
8980
+ return [{
8699
8981
  kind: "assistant",
8700
8982
  lo: entry.lo,
8701
8983
  hi: entry.lo,
8702
8984
  toolName: ASK_USER_QUESTION_TOOL_NAME,
8703
8985
  text: `<ask-user-question>${qa.map((item) => `q:${item.q}\na:${item.a}`).join("\n")}</ask-user-question>`
8704
- } : entry;
8705
- root.appendChild(entryToElement(doc, output));
8706
- }
8707
- flushReplacementsBefore(void 0);
8986
+ }];
8987
+ });
8708
8988
  const note = historyFormatNote({
8709
- user: this.view.entries.some((e) => e.kind === "user"),
8710
- skill: this.view.entries.some((e) => e.kind === "assistant" && e.toolName === "skill" && !coveredBy(e)),
8711
- askUserQuestion: this.view.entries.some((e) => isAskEntry(e) && !coveredBy(e))
8989
+ user: entries.some((e) => e.kind === "user"),
8990
+ skill: entries.some((e) => e.kind === "assistant" && e.toolName === "skill"),
8991
+ askUserQuestion: entries.some(isAskEntry)
8712
8992
  });
8713
- const serializer = new import_lib.XMLSerializer();
8714
- const inner = Array.from(root.childNodes).map((node) => serializer.serializeToString(node)).join("\n");
8715
- return `<${HISTORY_TAG} tip="${HISTORY_TIP}">\n${note}\n${inner}\n</${HISTORY_TAG}>`;
8993
+ return `<${HISTORY_TAG} tip="${HISTORY_TIP}">\n${note}\n${renderEntriesXml(entries)}\n</${HISTORY_TAG}>`;
8716
8994
  }
8717
8995
  };
8718
8996
  /** 仅含原始合法 ask 的压缩会话使用的重写工具。 */
@@ -8767,7 +9045,7 @@ const REWRITE_ASK_TOOL_SCHEMA = {
8767
9045
  const COMPRESSION_TOOL_SCHEMAS = [
8768
9046
  {
8769
9047
  name: "getHistory",
8770
- description: "查看压缩区间内的历史条目。返回压缩视图:已被压缩的内容以摘要条目呈现,区间切入已压缩块时返回该块全部条目。start/end 缺省为要求区间的第一个/最后一个完整消息 index,必须在要求区间内。",
9048
+ description: "查看压缩区间内的历史条目,返回当前状态:本次已压缩的区间显示为摘要条目;区间切入已有 <history> 块时返回该块全部条目。start/end 缺省为要求区间的第一个/最后一个完整消息 index,必须在要求区间内。",
8771
9049
  parameters: {
8772
9050
  type: "object",
8773
9051
  properties: {
@@ -8784,7 +9062,7 @@ const COMPRESSION_TOOL_SCHEMAS = [
8784
9062
  },
8785
9063
  {
8786
9064
  name: "compressHistory",
8787
- description: "把 index 单条或 start..end 连续区间的 assistant 类条目(模型输出文本、工具调用)替换为 content 摘要。index 与 start/end 二选一,start 与 end 成对提供且 start==end 等同 index。区间不得覆盖用户消息,不得与已有替换区间部分重叠(完全包含则覆盖)。用户消息保持原样,无需处理。",
9065
+ description: "把 index 单条或 start..end 连续区间的 assistant 类条目(模型输出文本、工具调用)替换为 content 摘要。index 与 start/end 二选一,start 与 end 成对提供且 start==end 等同 index。区间不得覆盖用户消息,不得与已有替换区间部分重叠(完全包含则覆盖)。返回成功即已生效,无需查看验证,不要用单条 index 试探;修改已提交的摘要时用相同或更大的区间重新提交。用户消息保持原样,无需处理。",
8788
9066
  parameters: {
8789
9067
  type: "object",
8790
9068
  properties: {
@@ -8877,21 +9155,24 @@ async function gateRateLimit(waitMs, signal) {
8877
9155
  * 工具驱动的压缩循环:以新会话方式直连 ctx.llm.stream(),模型通过 getHistory /
8878
9156
  * compressHistory / completeCompression 完成压缩,存在原始合法提问时加入重写工具。
8879
9157
  * 导出 runCompressionLoop / buildCompressionPrompt / buildCompressionTaskText /
8880
- * ASK_COMPRESSION_PROMPT / CompressionLoopOptions / CompressionOutcome / CompressionStats / COMPRESSION_NUDGE_TEXT。
9158
+ * REFLECT_COMPRESSION_PROMPT / ASK_COMPRESSION_PROMPT / CompressionLoopOptions / CompressionOutcome / CompressionStats / COMPRESSION_NUDGE_TEXT / TRUNCATION_NUDGE_TEXT。
8881
9159
  *
8882
9160
  * - 首条 user 消息仅含压缩指令与 start/end 区间(buildCompressionTaskText),不含
8883
- * 历史消息内容;共享压缩提示词作为 system
9161
+ * 历史消息内容;共享压缩提示词作为 system,反思 pass 追加反思合并约束
8884
9162
  * - 每轮请求携带压缩工具 schemas(purpose='compaction',maxTokens 沿用配置);流经
8885
9163
  * BlockAssembler 组装为 assistant 消息,工具执行结果以 tool-result 消息回填
8886
9164
  * - completeCompression 校验通过后立即停止(同轮后续工具调用不再执行),最终 <history>
8887
9165
  * 块由 CompressionState 构建,全程无需整块校验
8888
- * - 模型输出纯文本(无工具调用)时追加提醒消息继续,连续 2 轮仍无工具调用判失败
8889
- * - 429 限流走全局限流等待门(gateRateLimit / noteRateLimit);其余请求级错误依赖
8890
- * dsh 运行时重试,插件不做整体重试,错误直接判失败
9166
+ * - 模型输出纯文本(无工具调用)时追加提醒消息继续,连续 3 轮仍无工具调用判失败
9167
+ * - 输出被 max-tokens 截断且无工具调用时单独计数:该轮 assistant 消息仅落盘、不进入后续
9168
+ * 请求,追加截断专用提醒,连续 3 轮截断判失败;任一轮有工具调用则两个计数清零
9169
+ * - 429 限流走全局限流等待门(gateRateLimit / noteRateLimit);瞬时错误(5xx、网络类)
9170
+ * 同样经限流门等待后重试,连续最多重试 3 次,任一轮成功响应后清零;重试轮不计入轮数;
9171
+ * 其余请求级错误(含 4xx)直接判失败
8891
9172
  * - signal 中止标记 aborted;token usage 汇总全部轮次;统计循环起止时间戳、总耗时
8892
9173
  * 与逐轮请求统计(CompressionStats),随结果返回并随会话记录落盘
8893
- * - 成功与失败均把循环消息组原样落盘为子会话(recordCompressionSession),成功记
8894
- * 录 sessionId 于日志,失败记录作为诊断子会话 id 向上传播
9174
+ * - 成功与失败均把循环消息组落盘为子会话(recordCompressionSession,system 一并落盘
9175
+ * 为 system/message),成功记录 sessionId 于日志,失败记录作为诊断子会话 id 向上传播
8895
9176
  */
8896
9177
  /**
8897
9178
  * 共享压缩提示词(观察/反思同一套):完整消息定义、工具语义、压缩要求、skill 与
@@ -8905,8 +9186,8 @@ function buildCompressionPrompt(skipReasoning) {
8905
9186
  `【完整消息定义】${COMPLETE_MESSAGE_DEFINITION}`,
8906
9187
  "",
8907
9188
  "【工具】",
8908
- "- getHistory(option?: {start?, end?}):查看压缩区间内的历史条目。start/end 缺省为要求区间的第一个/最后一个完整消息 index,必须在要求区间内。返回压缩视图:已压缩内容以摘要条目呈现,区间切入已压缩块时返回整块,不带 <history> 包裹。",
8909
- "- compressHistory(option?: {index?, start?, end?, content}):把 index 单条或 start..end 连续区间的 assistant 类条目替换为 content 摘要(纯文本,不要包含 CDATA 包裹,插件自动包裹)。index 与 start/end 二选一,start==end 等同 index。区间不得覆盖用户消息;与已有替换区间部分重叠会被拒绝,完全包含则覆盖。",
9189
+ "- getHistory(option?: {start?, end?}):查看压缩区间内的历史条目。start/end 缺省为要求区间的第一个/最后一个完整消息 index,必须在要求区间内。返回当前状态,不带 <history> 包裹:本次已压缩的区间显示为摘要条目;区间切入已有 <history> 块时返回整块。",
9190
+ "- compressHistory(option?: {index?, start?, end?, content}):把 index 单条或 start..end 连续区间的 assistant 类条目替换为 content 摘要(纯文本,不要包含 CDATA 包裹,插件自动包裹)。index 与 start/end 二选一,start==end 等同 index。区间不得覆盖用户消息;与已有替换区间部分重叠会被拒绝,完全包含则覆盖。返回成功即已生效,无需查看验证,不要用单条 index 试探;修改已提交的摘要时用相同或更大的区间重新提交。",
8910
9191
  "- completeCompression():全部压缩完成后调用,立即结束。",
8911
9192
  "",
8912
9193
  "【压缩要求】",
@@ -8915,9 +9196,13 @@ function buildCompressionPrompt(skipReasoning) {
8915
9196
  "- 将具有关联性的 assistant 消息按内在逻辑连贯性划分为连续模块,聚合为区间压缩(start..end)",
8916
9197
  "- 单条重要的完整消息以 index 单独压缩",
8917
9198
  "- 压缩后的 assistant 消息内,应当描述**行为逻辑**,强调关键的**结论、产出和任务**;涉及到的具体文件保留完整路径",
8918
- "- 摘要粒度越往后越细:靠近末尾(最近)的消息保留更多细节,开头(较早)的消息简写。",
9199
+ "- 摘要粒度按后续用途分配,与消息位置无关:",
9200
+ " - 未完成的任务、当前状态、待办与未解决的问题保留细节;涉及的文件写明最新状态。",
9201
+ " - 已完成的子任务只保留结果、决策及理由、排除的方案及原因。",
9202
+ " - 不可再生的信息不论早晚都要保留:用户提出的约束与偏好、做出的决策、报错原文、外部返回的关键数据、验证过的结论。",
9203
+ " - 可以低成本重新获取的内容(文件内容、命令输出、搜索结果)只记来源与要点。",
8919
9204
  "- <history> 条目正文以 CDATA 包裹,CDATA 内为逐字原样内容。",
8920
- "- 工具调用条目为 <assistant index=\"N\" type=\"toolcall\" tool-name=\"…\" callId=\"…\">,内含 <tool-args>(调用参数 JSON)与 <tool-result>(工具返回内容)两个 CDATA 子元素。",
9205
+ "- 工具调用条目为 <assistant index=\"N\" type=\"toolcall\" tool-name=\"…\">,内含 <tool-args>(调用参数 JSON)与 <tool-result>(工具返回内容)两个 CDATA 子元素。",
8921
9206
  "- 加载的 skill 以 <skill_content name=\"…\" index=\"N\"> 条目呈现,内含 <skill_resources> 与 <skill_instructions> 两段,内文为加载的 skill 内容,属于关键信息。仅在你明确判断该 skill 与后续任务无关时,压缩它;如果该 skill 与后续任务相关,或者你无法判断,不要压缩,**保持原文**。",
8922
9207
  "- 已有 <history> 块中的 ask_user_question 以 <ask-user-question index=\"N\"> 呈现,CDATA 内为逐题成对的 q:(问题文本)与 a:(用户回答)行,未作答的题记为 a:(未回答)。这些提问已经处理;仅在明确判断与后续任务无关时压缩,否则保持原样。原始提问按本会话的专用处理规则执行。",
8923
9208
  "- 除原始提问外,未压缩的条目将原样保留;宁可保留也不要强行压缩不确定的内容。",
@@ -8931,6 +9216,8 @@ function buildCompressionTaskText(phase, start, end) {
8931
9216
  if (phase === "reflect") return `合并压缩全部 <history> 块,完整消息区间 [${start}..${end}]:用 getHistory 查看已有块条目,用 compressHistory 重新压缩合并 assistant 条目,完成后调用 completeCompression。`;
8932
9217
  return `压缩完整消息区间 [${start}..${end}]:用 getHistory 查看条目,用 compressHistory 分批压缩 assistant 条目,完成后调用 completeCompression。`;
8933
9218
  }
9219
+ /** 反思合并的额外约束,只在反思 pass 注入。 */
9220
+ const REFLECT_COMPRESSION_PROMPT = ["【反思合并】", "- 重新压缩已有摘要条目时,保留其中的不可再生信息,不要逐轮缩减。"].join("\n");
8934
9221
  /** 原始合法 ask 的处理约束,只在视图含待处理原始提问时注入。 */
8935
9222
  const ASK_COMPRESSION_PROMPT = [
8936
9223
  "【原始提问处理】",
@@ -8945,6 +9232,12 @@ const ASK_COMPRESSION_PROMPT = [
8945
9232
  ].join("\n");
8946
9233
  /** 模型输出纯文本(无工具调用)时追加的提醒消息文本。 */
8947
9234
  const COMPRESSION_NUDGE_TEXT = "请通过工具执行压缩:用 getHistory 查看区间条目,用 compressHistory 压缩 assistant 条目,完成后调用 completeCompression。不要输出与工具调用无关的文本。";
9235
+ /** 输出被 max-tokens 截断且无工具调用时追加的提醒消息文本。 */
9236
+ const TRUNCATION_NUDGE_TEXT = "上一轮输出因长度上限被截断,其中的工具调用未被接收。请缩短思考,直接分批调用 compressHistory(每次覆盖较小区间),最后调用 completeCompression。";
9237
+ /** 连续无工具调用、连续截断各自允许的最大轮数。 */
9238
+ const MAX_CONSECUTIVE_FAILURES = 3;
9239
+ /** 瞬时请求错误的连续最大重试次数。 */
9240
+ const MAX_TRANSIENT_RETRIES = 3;
8948
9241
  /** 视图原始消息字符数估算:非 reasoning 条目之和;工具调用条目的 text 已含参数与结果,不重复计入。 */
8949
9242
  function viewCharCount(view) {
8950
9243
  return view.entries.reduce((total, entry) => entry.kind === "reasoning" ? total : total + entry.text.length, 0);
@@ -9003,18 +9296,43 @@ function addUsage(total, add) {
9003
9296
  function isRateLimitFailure(message, status) {
9004
9297
  return status === 429 || isRateLimitError(message);
9005
9298
  }
9299
+ /** 是否为可重试的瞬时失败:有 status 时按 5xx 判定,否则匹配 5xx 状态码或常见网络类错误文案。 */
9300
+ function isTransientFailure(message, status) {
9301
+ if (status !== void 0) return status >= 500 && status <= 599;
9302
+ return /\b5\d{2}\b|econnreset|etimedout|econnrefused|epipe|socket hang up|fetch failed|network|overloaded|timed? ?out/i.test(message);
9303
+ }
9304
+ /** skipReasoning=true 时去掉视图中的 reasoning 条目(兑现 getHistory 不输出 reasoning 的契约);否则原样返回。 */
9305
+ function withoutReasoning(view, skipReasoning) {
9306
+ if (!skipReasoning) return view;
9307
+ return {
9308
+ ...view,
9309
+ entries: view.entries.filter((entry) => entry.kind !== "reasoning")
9310
+ };
9311
+ }
9006
9312
  /**
9007
- * 运行工具驱动的压缩循环:直到模型调用 completeCompression(成功)、连续 2 轮无
9313
+ * 运行工具驱动的压缩循环:直到模型调用 completeCompression(成功)、连续 3 轮无
9008
9314
  * 工具调用、请求级错误或 signal 中止(失败)。成功与失败均落盘循环会话记录。
9009
9315
  */
9010
9316
  async function runCompressionLoop(ctx, session, options) {
9011
9317
  const logger = makeLogger(ctx, options.debug);
9012
- const state = new CompressionState(options.view);
9318
+ const view = withoutReasoning(options.view, options.skipReasoning);
9319
+ const state = new CompressionState(view);
9013
9320
  const tools = state.hasPendingAsks ? [...COMPRESSION_TOOL_SCHEMAS, REWRITE_ASK_TOOL_SCHEMA] : COMPRESSION_TOOL_SCHEMAS;
9014
- const system = [buildCompressionPrompt(options.skipReasoning), ...state.hasPendingAsks ? [ASK_COMPRESSION_PROMPT] : []].join("\n\n");
9321
+ const system = [
9322
+ buildCompressionPrompt(options.skipReasoning),
9323
+ ...options.phase === "reflect" ? [REFLECT_COMPRESSION_PROMPT] : [],
9324
+ ...state.hasPendingAsks ? [ASK_COMPRESSION_PROMPT] : []
9325
+ ].join("\n\n");
9015
9326
  const messages = [makePluginUserMessage(options.taskText)];
9016
9327
  let rounds = 0;
9017
9328
  let nudges = 0;
9329
+ let truncations = 0;
9330
+ let transientRetries = 0;
9331
+ /** 最后一个收到终态的请求的 finish 类型与输出 token 数(失败日志用)。 */
9332
+ let lastFinish;
9333
+ let lastOutputTokens;
9334
+ /** 仅落盘、不进入后续请求的消息(截断轮的 assistant 消息)。 */
9335
+ const omitted = /* @__PURE__ */ new Set();
9018
9336
  let usage;
9019
9337
  const startedAt = Date.now();
9020
9338
  const roundStats = [];
@@ -9028,23 +9346,33 @@ async function runCompressionLoop(ctx, session, options) {
9028
9346
  rounds: roundStats
9029
9347
  };
9030
9348
  };
9031
- const recordSessionId = async (success, stats, resultChars) => recordCompressionSession(ctx, session, {
9349
+ const recordSessionId = async (success, stats, resultChars, failure) => recordCompressionSession(ctx, session, {
9032
9350
  phase: options.phase,
9351
+ range: {
9352
+ ...view.minIndex === void 0 ? {} : { min: view.minIndex },
9353
+ ...view.maxIndex === void 0 ? {} : { max: view.maxIndex }
9354
+ },
9033
9355
  messages,
9034
9356
  stats,
9357
+ system,
9035
9358
  success,
9036
9359
  debug: options.debug,
9037
9360
  info: compressionInfo({
9038
9361
  target: options.target,
9039
- originalChars: options.originalChars ?? viewCharCount(options.view),
9362
+ originalChars: options.originalChars ?? viewCharCount(view),
9040
9363
  ...options.reasoningEffort === void 0 ? {} : { reasoningEffort: options.reasoningEffort },
9041
- ...resultChars === void 0 ? {} : { resultChars }
9364
+ ...resultChars === void 0 ? {} : { resultChars },
9365
+ ...failure === void 0 ? {} : { failure }
9042
9366
  }),
9043
- ...options.retryTarget === void 0 ? {} : { retryTarget: options.retryTarget }
9367
+ ...options.retry === void 0 ? {} : { retry: options.retry }
9044
9368
  });
9045
9369
  const failWith = async (error, aborted) => {
9046
9370
  const stats = buildStats();
9047
- const id = await recordSessionId(false, stats);
9371
+ const id = await recordSessionId(false, stats, void 0, {
9372
+ reason: error,
9373
+ ...lastFinish === void 0 ? {} : { finish: lastFinish },
9374
+ ...lastOutputTokens === void 0 ? {} : { outputTokens: lastOutputTokens }
9375
+ });
9048
9376
  return {
9049
9377
  ok: false,
9050
9378
  error,
@@ -9054,6 +9382,14 @@ async function runCompressionLoop(ctx, session, options) {
9054
9382
  };
9055
9383
  };
9056
9384
  logger.step(`压缩循环开始(${options.phase === "reflect" ? "反思" : "观察"},provider ${options.target.provider},model ${options.target.model},maxTokens ${options.maxTokens === void 0 ? "未设置" : String(options.maxTokens)})`);
9385
+ /** 瞬时失败且未超重试额度时记入限流门并返回 true(调用方 continue 重试)。 */
9386
+ const retryTransient = (message, status) => {
9387
+ if (!isTransientFailure(message, status) || transientRetries >= MAX_TRANSIENT_RETRIES) return false;
9388
+ transientRetries += 1;
9389
+ noteRateLimit();
9390
+ logger.warn(`压缩循环请求瞬时失败(${message}),等待 ${options.rateLimitWaitMs}ms 后重试(${transientRetries}/${MAX_TRANSIENT_RETRIES})`);
9391
+ return true;
9392
+ };
9057
9393
  for (;;) {
9058
9394
  if (options.signal?.aborted) {
9059
9395
  logger.warn("压缩循环中止(signal 已中止),放弃本次压缩");
@@ -9073,7 +9409,7 @@ async function runCompressionLoop(ctx, session, options) {
9073
9409
  purpose: "compaction",
9074
9410
  ...options.signal === void 0 ? {} : { signal: options.signal },
9075
9411
  system,
9076
- messages: [...messages],
9412
+ messages: messages.filter((message) => !omitted.has(message)),
9077
9413
  tools
9078
9414
  };
9079
9415
  const assembler = new BlockAssembler();
@@ -9087,25 +9423,31 @@ async function runCompressionLoop(ctx, session, options) {
9087
9423
  logger.warn(`压缩循环触发限流(429),等待 ${options.rateLimitWaitMs}ms 后重试`);
9088
9424
  continue;
9089
9425
  }
9426
+ if (retryTransient(message)) continue;
9090
9427
  logger.warn(`压缩循环请求失败: ${message}`);
9091
9428
  return await failWith(message, false);
9092
9429
  }
9093
9430
  const finish = assembler.finish;
9431
+ lastFinish = finish.kind;
9432
+ lastOutputTokens = assembler.usage?.outputTokens;
9094
9433
  if (finish.kind === "aborted") {
9095
9434
  logger.warn("压缩循环中止(流以 aborted 结束),放弃本次压缩");
9096
9435
  return await failWith(COMPACTION_ABORTED_ERROR, true);
9097
9436
  }
9098
9437
  if (finish.kind === "error") {
9099
9438
  const failureMessage = typeof finish.failure?.message === "string" && finish.failure.message !== "" ? finish.failure.message : "流以 error 终态结束(无失败详情)";
9100
- if (isRateLimitFailure(failureMessage, typeof finish.failure?.status === "number" ? finish.failure.status : void 0)) {
9439
+ const failureStatus = typeof finish.failure?.status === "number" ? finish.failure.status : void 0;
9440
+ if (isRateLimitFailure(failureMessage, failureStatus)) {
9101
9441
  noteRateLimit();
9102
9442
  logger.warn(`压缩循环触发限流(429),等待 ${options.rateLimitWaitMs}ms 后重试`);
9103
9443
  continue;
9104
9444
  }
9445
+ if (retryTransient(failureMessage, failureStatus)) continue;
9105
9446
  logger.warn(`压缩循环请求失败: ${failureMessage}`);
9106
9447
  pushPartialAssistant(assembler, messages, options.target);
9107
9448
  return await failWith(failureMessage, false);
9108
9449
  }
9450
+ transientRetries = 0;
9109
9451
  rounds += 1;
9110
9452
  if (assembler.usage !== void 0) usage = addUsage(usage, assembler.usage);
9111
9453
  roundStats.push({
@@ -9121,9 +9463,21 @@ async function runCompressionLoop(ctx, session, options) {
9121
9463
  messages.push(assistantMessage);
9122
9464
  const calls = assembler.blocks().filter((block) => block.type === "tool-call");
9123
9465
  if (calls.length === 0) {
9466
+ if (finish.kind === "max-tokens") {
9467
+ truncations += 1;
9468
+ if (truncations >= MAX_CONSECUTIVE_FAILURES) {
9469
+ const error = `模型连续 ${MAX_CONSECUTIVE_FAILURES} 轮输出被 max-tokens 截断,放弃本次压缩`;
9470
+ logger.warn(error);
9471
+ return await failWith(error, false);
9472
+ }
9473
+ logger.warn("模型输出被 max-tokens 截断且无工具调用,丢弃该轮输出并追加提醒后继续");
9474
+ omitted.add(assistantMessage);
9475
+ messages.push(makePluginUserMessage(TRUNCATION_NUDGE_TEXT));
9476
+ continue;
9477
+ }
9124
9478
  nudges += 1;
9125
- if (nudges >= 2) {
9126
- const error = "模型连续 2 轮未调用压缩工具,放弃本次压缩";
9479
+ if (nudges >= MAX_CONSECUTIVE_FAILURES) {
9480
+ const error = `模型连续 ${MAX_CONSECUTIVE_FAILURES} 轮未调用压缩工具,放弃本次压缩`;
9127
9481
  logger.warn(error);
9128
9482
  return await failWith(error, false);
9129
9483
  }
@@ -9132,6 +9486,7 @@ async function runCompressionLoop(ctx, session, options) {
9132
9486
  continue;
9133
9487
  }
9134
9488
  nudges = 0;
9489
+ truncations = 0;
9135
9490
  for (const call of calls) {
9136
9491
  messages.push(toolResultOf(call, state.executeCall(call.name, call.arguments)));
9137
9492
  if (state.completed) break;
@@ -9205,9 +9560,64 @@ function readOmEvent(event) {
9205
9560
  seq: event.seq
9206
9561
  };
9207
9562
  }
9563
+ case "om/observe-summary": {
9564
+ const { pendingSeq, report, provider, model, startedAt, completedAt, durationMs, recordSessionId, usage, reasoningEffort } = rest;
9565
+ if (typeof pendingSeq !== "number" || !Number.isSafeInteger(pendingSeq)) return void 0;
9566
+ if (typeof report !== "string") return void 0;
9567
+ if (typeof provider !== "string" || typeof model !== "string") return void 0;
9568
+ if (!isFiniteNumber(startedAt) || !isFiniteNumber(completedAt) || !isFiniteNumber(durationMs)) return void 0;
9569
+ if (recordSessionId !== void 0 && typeof recordSessionId !== "string") return void 0;
9570
+ if (reasoningEffort !== void 0 && typeof reasoningEffort !== "string") return void 0;
9571
+ const parsedUsage = readTokenUsage(usage);
9572
+ if (parsedUsage === null) return void 0;
9573
+ return {
9574
+ kind,
9575
+ data: {
9576
+ pendingSeq,
9577
+ report,
9578
+ provider,
9579
+ model,
9580
+ startedAt,
9581
+ completedAt,
9582
+ durationMs,
9583
+ ...recordSessionId === void 0 ? {} : { recordSessionId },
9584
+ ...parsedUsage === void 0 ? {} : { usage: parsedUsage },
9585
+ ...reasoningEffort === void 0 ? {} : { reasoningEffort }
9586
+ },
9587
+ seq: event.seq
9588
+ };
9589
+ }
9208
9590
  default: return;
9209
9591
  }
9210
9592
  }
9593
+ /** 校验有限数值字段(时间戳/耗时)。 */
9594
+ function isFiniteNumber(value) {
9595
+ return typeof value === "number" && Number.isFinite(value);
9596
+ }
9597
+ /** 校验可选 token usage 字段:缺省返回 undefined,非法返回 null,合法返回仅含已知数值字段的对象。 */
9598
+ function readTokenUsage(value) {
9599
+ if (value === void 0) return void 0;
9600
+ if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
9601
+ const usage = value;
9602
+ const { inputTokens, outputTokens } = usage;
9603
+ if (!isFiniteNumber(inputTokens) || !isFiniteNumber(outputTokens)) return null;
9604
+ const result = {
9605
+ inputTokens,
9606
+ outputTokens
9607
+ };
9608
+ for (const key of [
9609
+ "totalTokens",
9610
+ "cacheReadTokens",
9611
+ "cacheWriteTokens",
9612
+ "reasoningTokens"
9613
+ ]) {
9614
+ const field = usage[key];
9615
+ if (field === void 0) continue;
9616
+ if (!isFiniteNumber(field)) return null;
9617
+ result[key] = field;
9618
+ }
9619
+ return result;
9620
+ }
9211
9621
  /** 编码一条 om 私有事件为 feedback/record 的 text 信封。 */
9212
9622
  function encodeOmEvent(kind, data) {
9213
9623
  return `${OM_EVENT_PREFIX}${JSON.stringify({
@@ -9272,28 +9682,204 @@ function reportDegrade(session, logger, problem) {
9272
9682
  }
9273
9683
  }
9274
9684
  //#endregion
9685
+ //#region src/precompress.ts
9686
+ /** 进程内注册表:session.id → 任务(重启即清空,由对账阶段恢复)。 */
9687
+ const jobs = /* @__PURE__ */ new Map();
9688
+ /**
9689
+ * 查询与活跃待定标记匹配的任务:pendingSeq 或会话对象不一致视为过期,
9690
+ * 中止并移除后返回 undefined(过期任务的信封写入落在已脱钩对象上,无保留价值)。
9691
+ */
9692
+ function findPrecompressionJob(session, pendingSeq) {
9693
+ const job = jobs.get(session.id);
9694
+ if (job === void 0) return void 0;
9695
+ if (job.session === session && job.pendingSeq === pendingSeq) return job;
9696
+ disposePrecompression(session.id);
9697
+ }
9698
+ /**
9699
+ * 启动后台预压缩:同步准备区间/视图;无可行区间时失效待定标记并返回原因。
9700
+ * 同会话已有匹配任务时幂等返回;标记不同则中止旧任务后替换。
9701
+ */
9702
+ function startPrecompression(options) {
9703
+ const { ctx, session, config, pendingSeq, triggerMessageIndex } = options;
9704
+ const logger = makeLogger(ctx, config.debug);
9705
+ const existing = jobs.get(session.id);
9706
+ if (existing !== void 0) {
9707
+ if (existing.session === session && existing.pendingSeq === pendingSeq) return {
9708
+ ok: true,
9709
+ job: existing
9710
+ };
9711
+ disposePrecompression(session.id);
9712
+ }
9713
+ const prepare = prepareObserveCompression(session, triggerMessageIndex, config);
9714
+ if (!prepare.ok) {
9715
+ logger.step(`预压缩:${prepare.reason},失效待定标记视为完成`);
9716
+ try {
9717
+ appendOmEvent(session, "om/observe-invalidate", { pendingSeq });
9718
+ } catch (error) {
9719
+ const message = error instanceof Error ? error.message : String(error);
9720
+ logger.warn(`预压缩:待定失效标记追加失败: ${message}`);
9721
+ }
9722
+ return {
9723
+ ok: false,
9724
+ reason: prepare.reason
9725
+ };
9726
+ }
9727
+ const controller = new AbortController();
9728
+ let settle;
9729
+ const promise = new Promise((resolve) => {
9730
+ settle = resolve;
9731
+ });
9732
+ const job = {
9733
+ pendingSeq,
9734
+ triggerMessageIndex,
9735
+ session,
9736
+ prepared: prepare.prepared,
9737
+ controller,
9738
+ promise,
9739
+ state: "running"
9740
+ };
9741
+ jobs.set(session.id, job);
9742
+ runJobBody(ctx, job, options, logger).then(settle, settle);
9743
+ logger.step(`预压缩:任务启动(pendingSeq ${pendingSeq},区间 [${prepare.prepared.range.start}..${prepare.prepared.range.end}],遮蔽 ${prepare.prepared.replaceSeqs.length} 个表层节点)`);
9744
+ return {
9745
+ ok: true,
9746
+ job
9747
+ };
9748
+ }
9749
+ /** 任务主体:压缩循环 → 成功持久化结果信封 + flush → 状态登记;异常按失败处理。 */
9750
+ async function runJobBody(ctx, job, options, logger) {
9751
+ const { config, target, reasoningEffort } = options;
9752
+ const { prepared } = job;
9753
+ try {
9754
+ const outcome = await runCompressionLoop(ctx, job.session, {
9755
+ view: prepared.view,
9756
+ originalChars: prepared.shadowedCharCount,
9757
+ phase: "observe",
9758
+ taskText: buildCompressionTaskText("observe", prepared.view.minIndex, prepared.view.maxIndex),
9759
+ target,
9760
+ maxTokens: config.compressMaxTokens,
9761
+ rateLimitWaitMs: config.rateLimitWaitMs,
9762
+ skipReasoning: config.compressSkipReasoning,
9763
+ debug: config.debug,
9764
+ ...reasoningEffort === void 0 ? {} : { reasoningEffort },
9765
+ signal: job.controller.signal
9766
+ });
9767
+ if (!outcome.ok) {
9768
+ job.state = "failed";
9769
+ job.failure = {
9770
+ error: outcome.error,
9771
+ aborted: outcome.aborted,
9772
+ ...outcome.recordSessionId === void 0 ? {} : { diagnosticSessionId: outcome.recordSessionId }
9773
+ };
9774
+ logger.info(`预压缩失败(pendingSeq ${job.pendingSeq}): ${outcome.error}`);
9775
+ return;
9776
+ }
9777
+ appendOmEvent(job.session, "om/observe-summary", {
9778
+ pendingSeq: job.pendingSeq,
9779
+ report: outcome.text,
9780
+ provider: target.provider,
9781
+ model: target.model,
9782
+ startedAt: outcome.stats.startedAt,
9783
+ completedAt: outcome.stats.completedAt,
9784
+ durationMs: outcome.stats.durationMs,
9785
+ ...outcome.recordSessionId === void 0 ? {} : { recordSessionId: outcome.recordSessionId },
9786
+ ...outcome.usage === void 0 ? {} : { usage: outcome.usage },
9787
+ ...reasoningEffort === void 0 ? {} : { reasoningEffort }
9788
+ });
9789
+ await flushSession(ctx, job.session, logger);
9790
+ job.state = "done";
9791
+ job.result = outcome;
9792
+ logger.info(`预压缩完成(pendingSeq ${job.pendingSeq},${outcome.stats.durationMs}ms),等待到期注入`);
9793
+ } catch (error) {
9794
+ const message = error instanceof Error ? error.message : String(error);
9795
+ job.state = "failed";
9796
+ job.failure = {
9797
+ error: message,
9798
+ aborted: job.controller.signal.aborted
9799
+ };
9800
+ logger.warn(`预压缩任务异常(pendingSeq ${job.pendingSeq}): ${message}`);
9801
+ }
9802
+ }
9803
+ /** 结果信封落盘:sessions.flush 失败仅记日志(内存日志仍在,turn 结束时宿主兜底 flush)。 */
9804
+ async function flushSession(ctx, session, logger) {
9805
+ try {
9806
+ const sessions = ctx.get("sessions");
9807
+ if (sessions === void 0) {
9808
+ logger.warn("预压缩:sessions 服务未挂载,结果信封跳过即时 flush");
9809
+ return;
9810
+ }
9811
+ await sessions.flush(session);
9812
+ } catch (error) {
9813
+ const message = error instanceof Error ? error.message : String(error);
9814
+ logger.warn(`预压缩:结果信封 flush 失败: ${message}`);
9815
+ }
9816
+ }
9817
+ /**
9818
+ * 采纳持久化的 om/observe-summary 信封为压缩成功结果(重启恢复路径)。
9819
+ * 轮数信息未持久化:rounds 按 0 与空数组重建(仅诊断记录使用,注入不依赖)。
9820
+ */
9821
+ function adoptPersistedSummary(data) {
9822
+ return {
9823
+ result: {
9824
+ ok: true,
9825
+ text: data.report,
9826
+ rounds: 0,
9827
+ stats: {
9828
+ startedAt: data.startedAt,
9829
+ completedAt: data.completedAt,
9830
+ durationMs: data.durationMs,
9831
+ rounds: []
9832
+ },
9833
+ ...data.usage === void 0 ? {} : { usage: data.usage },
9834
+ ...data.recordSessionId === void 0 ? {} : { recordSessionId: data.recordSessionId }
9835
+ },
9836
+ provider: data.provider,
9837
+ model: data.model,
9838
+ ...data.reasoningEffort === void 0 ? {} : { reasoningEffort: data.reasoningEffort }
9839
+ };
9840
+ }
9841
+ /** 中止并移除会话的后台任务(session/disposed 或过期清理)。 */
9842
+ function disposePrecompression(sessionId) {
9843
+ const job = jobs.get(sessionId);
9844
+ if (job === void 0) return;
9845
+ jobs.delete(sessionId);
9846
+ job.controller.abort();
9847
+ }
9848
+ /** 中止并移除全部后台任务(插件卸载)。 */
9849
+ function disposeAllPrecompressions() {
9850
+ for (const sessionId of [...jobs.keys()]) disposePrecompression(sessionId);
9851
+ }
9852
+ //#endregion
9275
9853
  //#region src/compress.ts
9276
9854
  /**
9277
9855
  * 两级自动压缩(观察/反思)与 compaction 生命周期提交。
9278
9856
  * 导出 estimateTextTokens / isPairBalancedAfter / computeCompressRange / historySection /
9279
- * historyTextOf / findObservePending / reflectPass / observePass / maybeCompress。
9857
+ * historyTextOf / findObservePending / prepareObserveCompression / commitObserveCompression /
9858
+ * reflectPass / observePass / maybeCompress。
9280
9859
  *
9281
9860
  * - 摘要生成走工具驱动的压缩循环(compress-loop.ts runCompressionLoop):首条 user
9282
9861
  * 消息仅含压缩指令与 start/end 区间,模型经 getHistory / compressHistory /
9283
9862
  * completeCompression 工具完成压缩;最终 <history> 块由插件从视图与替换记录构建,
9284
9863
  * 全程无需整块校验
9285
- * - 反思:全部 <history> 块 token 合计 ≥ reflectThresholdTokens 时,把全部块条目作为
9286
- * 压缩视图重新压缩合并(视图无条目时跳过,如全部为不可解析的历史遗留块)
9287
- * - 观察(触发 → 待定 → 延迟执行):净压力(上下文压力 − 已压缩块 token 合计 − 系统提示词
9288
- * token 估算 − 工具定义 token 估算)首次 ≥ observeThresholdTokens 时记录待定标记
9289
- * (触发点 = 当时的最后一条完整消息 index),本次不压缩;待定后新增完整消息数 ≥
9290
- * tailMessageCount 时,把压缩边界至触发点的全部消息作为压缩视图替换为新 <history>
9291
- * 块(旧块保留),等待期间的新消息成为下一轮未压缩尾部(延迟窗口内压力允许
9292
- * 短暂超阈值);tailMessageCount=0 时触发当轮直接执行(不落待定标记)
9293
- * - 待定标记以 log-only om 信封事件(借用 feedback/record,kind 为 om/observe-pending /
9294
- * om/observe-invalidate,见 om-event.ts)持久化在会话日志中(重启后从日志恢复);
9295
- * 压缩失败保留待定,下个 pre-step 直接重试执行
9296
- * - 两级在 pre-step 阻塞串行执行(先反思后观察);仅主会话生效;omEnabled=false 关闭
9864
+ * - 反思:全部 <history> 块 token 合计(估算 × 换算系数)≥ reflectThresholdTokens 时,
9865
+ * 把全部块条目作为压缩视图重新压缩合并(视图无条目时跳过,如全部为不可解析的历史
9866
+ * 遗留块)
9867
+ * - 观察(打标记 → 对账 → 到期注入):净压力(换算系数 × 未压缩表层估算,未压缩 =
9868
+ * 表层 − 已压缩块 − 系统提示词估算)首次 ≥ observeThresholdTokens 时记录待定标记
9869
+ * (触发点 = 当时的最后一条完整消息 index),并立即开始后台预压缩(precompress.ts,
9870
+ * 结果写 om/observe-summary 信封、不做替换);每个 pre-step 对账保证活跃标记对应任务
9871
+ * 或持久化结果(重启恢复直接采纳信封、不重压缩;失败任务丢弃重启);新增完整消息数 ≥
9872
+ * tailMessageCount 时到期,把压缩边界至触发点的全部消息作为压缩视图注入为新 <history>
9873
+ * 块(旧块保留),等待期间的新消息成为下一轮未压缩尾部(延迟窗口内压力允许短暂超
9874
+ * 阈值);到期未完成时阻塞等待后台任务(turn 取消则放行不注入,任务继续后台);
9875
+ * tailMessageCount=0 时触发当轮即到期,阻塞等待注入
9876
+ * - 两个阈值都按主模型真实 token 计;换算系数 = 上次请求真实用量基线 ÷ 锚点估算
9877
+ * (工具定义估算 + 锚点表层),无真实用量基线或计量失败按 1 计
9878
+ * - 待定标记与压缩结果以 log-only om 信封事件(借用 feedback/record,kind 为
9879
+ * om/observe-pending / om/observe-invalidate / om/observe-summary,见 om-event.ts)
9880
+ * 持久化在会话日志中(重启后从日志恢复);压缩失败保留待定,下个 pre-step 重启任务重试
9881
+ * - 两级在 pre-step 串行执行(先反思后观察;观察的压缩主体在后台运行,pre-step 仅在
9882
+ * 到期结果未就绪时阻塞等待);仅主会话生效;omEnabled=false 关闭
9297
9883
  * - 压缩目标默认跟随会话路由;compressProvider + compressModel 成对配置时覆盖路由
9298
9884
  * (成对配置下未路由会话也执行压缩);compressReasoningEffort 配置时压缩前经
9299
9885
  * ctx.llm.resolveModelInfo 校验目标模型 reasoning.efforts(按 provider+model 缓存),
@@ -9308,8 +9894,8 @@ function reportDegrade(session, logger, problem) {
9308
9894
  * - 挂载失败类问题(systemPrompt/tokenMeter 服务异常)始终 console 到外部进程,并追加
9309
9895
  * log-only om 警告事件(借用 feedback/record,客户端渲染功能降级警告行,每会话同一
9310
9896
  * 问题至多一次);
9311
- * 辅助估算的普通运行时报错仅记日志。降级与报错都不阻塞压缩(tokenMeter 压力数据
9312
- * 缺失时本轮跳过观察)
9897
+ * 辅助估算的普通运行时报错仅记日志。降级与报错都不阻塞压缩(tokenMeter 计量失败时
9898
+ * 本轮跳过观察,反思换算系数按 1 计)
9313
9899
  */
9314
9900
  /** 历史文本 token 估算:4 字符 ≈ 1 token(与宿主 dsh-token-meter 启发式一致)。 */
9315
9901
  function estimateTextTokens(text) {
@@ -9608,13 +10194,16 @@ async function reflectPass(ctx, agent, config, target, signal, reasoningEffort)
9608
10194
  return { failed: false };
9609
10195
  }
9610
10196
  const threshold = config.reflectThresholdTokens;
9611
- const tokens = blocks.reduce((total, block) => total + estimateTextTokens(block.text), 0);
10197
+ const estimatedTokens = blocks.reduce((total, block) => total + estimateTextTokens(block.text), 0);
10198
+ const measurement = measurePressure(ctx, session, logger);
10199
+ const ratio = measurement === void 0 ? 1 : conversionRatio(measurement, estimateToolsTokens(session, logger));
10200
+ const tokens = Math.round(ratio * estimatedTokens);
9612
10201
  const shadowedCharCount = blocks.reduce((total, block) => total + historyInnerText(block.text).length, 0);
9613
10202
  if (tokens < threshold) {
9614
- logger.step(`反思:摘要 ${tokens} tokens < 阈值 ${threshold},跳过`);
10203
+ logger.step(`反思:摘要 ${tokens} tokens(估算 ${estimatedTokens} × 换算系数 ${ratio.toFixed(2)})< 阈值 ${threshold},跳过`);
9615
10204
  return { failed: false };
9616
10205
  }
9617
- logger.step(`反思:摘要 ${tokens} tokens ≥ 阈值 ${threshold},触发精简合并(${blocks.length} 个块)`);
10206
+ logger.step(`反思:摘要 ${tokens} tokens(估算 ${estimatedTokens} × 换算系数 ${ratio.toFixed(2)})≥ 阈值 ${threshold},触发精简合并(${blocks.length} 个块)`);
9618
10207
  const first = blocks[0];
9619
10208
  const last = blocks[blocks.length - 1];
9620
10209
  if (first === void 0 || last === void 0) {
@@ -9669,7 +10258,7 @@ async function reflectPass(ctx, agent, config, target, signal, reasoningEffort)
9669
10258
  end: last.seq
9670
10259
  },
9671
10260
  shadowedSeqs: blockSeqs,
9672
- shadowedTokenCount: tokens,
10261
+ shadowedTokenCount: estimatedTokens,
9673
10262
  shadowedCharCount,
9674
10263
  provider: target.provider,
9675
10264
  model: target.model,
@@ -9690,250 +10279,368 @@ async function reflectPass(ctx, agent, config, target, signal, reasoningEffort)
9690
10279
  return { failed: false };
9691
10280
  } catch (error) {
9692
10281
  const message = error instanceof Error ? error.message : String(error);
9693
- logger.warn(`反思提交失败: ${message}`);
10282
+ logger.warn(`反思提交失败: ${message}`);
10283
+ try {
10284
+ appendCompactionEnd(session, lifecycle, message, void 0, summaryResult.stats.durationMs);
10285
+ } catch {}
10286
+ return { failed: false };
10287
+ }
10288
+ }
10289
+ /**
10290
+ * 估算系统提示词 tokens:按 agent 作用域组装并渲染系统提示词,按长度/4 启发式计。
10291
+ * systemPrompt 服务经 ctx.get 容错读取(ctx 属性访问在服务未挂载时抛错);服务缺失
10292
+ * 或组装/渲染失败时按 0 计——只影响观察触发时机(偏早触发),不阻塞压缩。
10293
+ * 服务缺失属挂载失败:console 外部 + om 警告事件每会话报告一次;组装失败仅记日志。
10294
+ */
10295
+ async function estimateSystemPromptTokens(ctx, agent, logger, signal) {
10296
+ const systemPrompt = ctx.get("systemPrompt");
10297
+ if (systemPrompt === void 0 || typeof systemPrompt.assemble !== "function") {
10298
+ reportDegrade(agent.session, logger, "systemPrompt-missing");
10299
+ return 0;
10300
+ }
10301
+ try {
10302
+ const agentCtx = agent.ctx;
10303
+ const scope = agentCtx === void 0 ? void 0 : scopeOf(agentCtx);
10304
+ const assembleContext = { agent };
10305
+ if (scope !== void 0) assembleContext.scope = scope;
10306
+ if (signal !== void 0) assembleContext.signal = signal;
10307
+ const assembly = await systemPrompt.assemble(assembleContext);
10308
+ return estimateTextTokens(renderPrompt(assembly));
10309
+ } catch (error) {
10310
+ const message = error instanceof Error ? error.message : String(error);
10311
+ logger.warn(`系统提示词 tokens 估算失败,按 0 计: ${message}`);
10312
+ return 0;
10313
+ }
10314
+ }
10315
+ /**
10316
+ * 估算请求工具定义 tokens:按会话请求头 tools(assembled tool schemas)JSON 序列化
10317
+ * 长度/4 启发式计(与宿主 dsh-token-meter 对工具 schema 的启发式一致)。请求头读取
10318
+ * 失败或缺 tools 时按 0 计——只影响观察触发时机(偏早触发),不阻塞压缩。
10319
+ */
10320
+ function estimateToolsTokens(session, logger) {
10321
+ try {
10322
+ const header = session.requestHeader();
10323
+ if (header?.tools === void 0 || header.tools.length === 0) return 0;
10324
+ return estimateTextTokens(JSON.stringify(header.tools));
10325
+ } catch (error) {
10326
+ const message = error instanceof Error ? error.message : String(error);
10327
+ logger.warn(`工具定义 tokens 估算失败,按 0 计: ${message}`);
10328
+ return 0;
10329
+ }
10330
+ }
10331
+ /**
10332
+ * 读取压力计量(tokenMeter.measure)。调用异常时记日志并报告降级(console 外部 +
10333
+ * om 警告事件每会话一次),返回 undefined——观察本轮跳过(无压力数据不触发),
10334
+ * 反思换算系数按 1 计;都不阻塞 turn。
10335
+ */
10336
+ function measurePressure(ctx, session, logger) {
10337
+ try {
10338
+ const measurement = ctx.tokenMeter.measure(session);
10339
+ return {
10340
+ surfaceTokens: measurement.surfaceTokens,
10341
+ surfaceDeltaTokens: measurement.surfaceDeltaTokens,
10342
+ baselineUsageTokens: measurement.baseline.kind === "usage" ? measurement.baseline.tokens : void 0
10343
+ };
10344
+ } catch (error) {
10345
+ const message = error instanceof Error ? error.message : String(error);
10346
+ logger.warn(`上下文压力读取失败(tokenMeter.measure 抛错): ${message}`);
10347
+ reportDegrade(session, logger, "tokenMeter-unavailable");
10348
+ return;
10349
+ }
10350
+ }
10351
+ /**
10352
+ * 换算系数:上次请求真实用量基线 ÷ 锚点估算量(工具定义估算 + 锚点表层 =
10353
+ * 当前表层 − 表层增量),把字符/4 估算换算为主模型真实 token 单位。无真实用量
10354
+ * 基线或锚点估算量非正时按 1 计;结果恒 ≥ 1(真实用量低于估算时宿主已回退估算基线)。
10355
+ */
10356
+ function conversionRatio(measurement, toolsTokens) {
10357
+ if (measurement.baselineUsageTokens === void 0) return 1;
10358
+ const anchorTokens = toolsTokens + measurement.surfaceTokens - measurement.surfaceDeltaTokens;
10359
+ if (anchorTokens <= 0) return 1;
10360
+ return Math.max(1, measurement.baselineUsageTokens / anchorTokens);
10361
+ }
10362
+ /**
10363
+ * 准备观察压缩:计算区间 [压缩边界..触发点]、校验可行性并构建压缩视图。
10364
+ * 不写任何事件;供延迟执行与后台预压缩共用。
10365
+ */
10366
+ function prepareObserveCompression(session, triggerMessageIndex, config) {
10367
+ const range = computeCompressRange(session, triggerMessageIndex);
10368
+ if (!range) return {
10369
+ ok: false,
10370
+ reason: "无可行压缩区间(边界后无消息、触发点已被压缩或配对无法平衡)"
10371
+ };
10372
+ const replaceSeqs = range.shadowedSeqs;
10373
+ const replaceStart = replaceSeqs[0];
10374
+ if (replaceStart === void 0) return {
10375
+ ok: false,
10376
+ reason: "区间内无新消息(全部为压缩日志块)"
10377
+ };
10378
+ const shadowedSet = new Set(replaceSeqs);
10379
+ if (indexCompleteMessages(session).filter((cm) => cm.seqs.every((seq) => shadowedSet.has(seq))).length === 0) return {
10380
+ ok: false,
10381
+ reason: "区间内无完整消息"
10382
+ };
10383
+ const shadowedCharCount = seqsCharCount(session, replaceSeqs);
10384
+ const view = buildObserveView(session, replaceSeqs, { skipReasoning: config.compressSkipReasoning });
10385
+ if (view.minIndex === void 0 || view.maxIndex === void 0) return {
10386
+ ok: false,
10387
+ reason: "区间内无可定位条目"
10388
+ };
10389
+ return {
10390
+ ok: true,
10391
+ prepared: {
10392
+ range,
10393
+ replaceSeqs,
10394
+ replaceStart,
10395
+ shadowedCharCount,
10396
+ view: {
10397
+ ...view,
10398
+ minIndex: view.minIndex,
10399
+ maxIndex: view.maxIndex
10400
+ }
10401
+ }
10402
+ };
10403
+ }
10404
+ /**
10405
+ * 提交观察压缩结果:compaction/summary(影子价格认领)→ 替换被压缩区间为 <history>
10406
+ * 块(旧块保留)→ compaction/end → 清除待定标记。调用前须已追加 compaction/start
10407
+ * (同一开放 turn 内满足宿主括号不变量)。提交失败为局部异常(压缩已成功):记日志、
10408
+ * 补 end(error) 后返回不失败结果,不中断 turn;待定标记保留,边界后移后由
10409
+ * findObservePending 判定过期。
10410
+ */
10411
+ function commitObserveCompression(ctx, session, lifecycle, prepared, summaryResult, opts) {
10412
+ const { logger, clearPending, target, triggerNote } = opts;
10413
+ const { range, replaceSeqs, replaceStart, shadowedCharCount } = prepared;
10414
+ const report = summaryResult.text;
10415
+ const usage = summaryResult.usage;
10416
+ const shadowedTokenCount = replaceSeqs.reduce((total, seq) => {
10417
+ const event = session.snapshotEvents()[seq];
10418
+ const message = event ? session.deriveEventMessage(event) : null;
10419
+ let tokens = 0;
10420
+ if (message) try {
10421
+ tokens = ctx.tokenMeter.estimateMessage(message);
10422
+ } catch {
10423
+ reportDegrade(session, logger, "tokenMeter-unavailable");
10424
+ }
10425
+ return total + tokens;
10426
+ }, 0);
10427
+ try {
10428
+ logger.step("观察提交:追加 compaction/summary(影子价格认领)");
10429
+ const summarySeq = appendCompactionSummary(session, {
10430
+ lifecycle,
10431
+ summary: report,
10432
+ shadowedRange: {
10433
+ start: replaceStart,
10434
+ end: range.end
10435
+ },
10436
+ shadowedSeqs: replaceSeqs,
10437
+ shadowedTokenCount,
10438
+ shadowedCharCount,
10439
+ provider: target.provider,
10440
+ model: target.model,
10441
+ maxTokens: opts.maxTokens,
10442
+ stats: summaryResult.stats,
10443
+ ...usage === void 0 ? {} : { usage },
10444
+ ...opts.reasoningEffort === void 0 ? {} : { reasoningEffort: opts.reasoningEffort }
10445
+ });
10446
+ logger.step("观察提交:替换被压缩新消息区间为 <history>(旧块保留)");
10447
+ appendHistoryMessage(session, report, [summarySeq, ...replaceSeqs], {
10448
+ op: "replace",
10449
+ startSeq: replaceStart,
10450
+ endSeq: range.end
10451
+ }, lifecycle.compactionId);
10452
+ logger.step("观察提交:追加 compaction/end");
10453
+ appendCompactionEnd(session, lifecycle, void 0, summaryResult.recordSessionId);
10454
+ clearPending();
10455
+ logger.info(`观察压缩完成(替换 ${replaceSeqs.length} 个表层节点,约 ${shadowedTokenCount} tokens,压缩至${triggerNote})`);
10456
+ return { failed: false };
10457
+ } catch (error) {
10458
+ const message = error instanceof Error ? error.message : String(error);
10459
+ logger.warn(`观察压缩提交失败: ${message}`);
9694
10460
  try {
9695
10461
  appendCompactionEnd(session, lifecycle, message, void 0, summaryResult.stats.durationMs);
9696
10462
  } catch {}
9697
10463
  return { failed: false };
9698
10464
  }
9699
10465
  }
9700
- /**
9701
- * 估算系统提示词 tokens:按 agent 作用域组装并渲染系统提示词,按长度/4 启发式计。
9702
- * systemPrompt 服务经 ctx.get 容错读取(ctx 属性访问在服务未挂载时抛错);服务缺失
9703
- * 或组装/渲染失败时按 0 计——只影响观察触发时机(偏早触发),不阻塞压缩。
9704
- * 服务缺失属挂载失败:console 外部 + om 警告事件每会话报告一次;组装失败仅记日志。
9705
- */
9706
- async function estimateSystemPromptTokens(ctx, agent, logger, signal) {
9707
- const systemPrompt = ctx.get("systemPrompt");
9708
- if (systemPrompt === void 0 || typeof systemPrompt.assemble !== "function") {
9709
- reportDegrade(agent.session, logger, "systemPrompt-missing");
9710
- return 0;
9711
- }
9712
- try {
9713
- const agentCtx = agent.ctx;
9714
- const scope = agentCtx === void 0 ? void 0 : scopeOf(agentCtx);
9715
- const assembleContext = { agent };
9716
- if (scope !== void 0) assembleContext.scope = scope;
9717
- if (signal !== void 0) assembleContext.signal = signal;
9718
- const assembly = await systemPrompt.assemble(assembleContext);
9719
- return estimateTextTokens(renderPrompt(assembly));
9720
- } catch (error) {
9721
- const message = error instanceof Error ? error.message : String(error);
9722
- logger.warn(`系统提示词 tokens 估算失败,按 0 计: ${message}`);
9723
- return 0;
9724
- }
9725
- }
9726
- /**
9727
- * 估算请求工具定义 tokens:按会话请求头 tools(assembled tool schemas)JSON 序列化
9728
- * 长度/4 启发式计(与宿主 dsh-token-meter 对工具 schema 的启发式一致)。请求头读取
9729
- * 失败或缺 tools 时按 0 计——只影响观察触发时机(偏早触发),不阻塞压缩。
9730
- */
9731
- function estimateToolsTokens(session, logger) {
9732
- try {
9733
- const header = session.requestHeader();
9734
- if (header?.tools === void 0 || header.tools.length === 0) return 0;
9735
- return estimateTextTokens(JSON.stringify(header.tools));
9736
- } catch (error) {
9737
- const message = error instanceof Error ? error.message : String(error);
9738
- logger.warn(`工具定义 tokens 估算失败,按 0 计: ${message}`);
9739
- return 0;
9740
- }
10466
+ /** 匹配 pendingSeq 的最后一条持久化压缩结果信封(重启恢复采纳;正常每标记至多一条)。 */
10467
+ function findPersistedSummary(session, pendingSeq) {
10468
+ return findOmEvents(session, "om/observe-summary").filter((event) => event.data.pendingSeq === pendingSeq).at(-1);
9741
10469
  }
9742
- /**
9743
- * 读取上下文压力 tokens(tokenMeter.measure 的 totalTokens)。tokenMeter 调用异常时
9744
- * 记日志并报告降级(console 外部 + om 警告事件每会话一次),返回 undefined——本轮
9745
- * 跳过观察压缩(无压力数据不触发),不阻塞 turn。
9746
- */
9747
- function measurePressureTokens(ctx, session, logger) {
9748
- try {
9749
- return ctx.tokenMeter.measure(session).totalTokens;
9750
- } catch (error) {
9751
- const message = error instanceof Error ? error.message : String(error);
9752
- logger.warn(`上下文压力读取失败(tokenMeter.measure 抛错),本轮跳过观察压缩: ${message}`);
9753
- reportDegrade(session, logger, "tokenMeter-unavailable");
9754
- return;
9755
- }
10470
+ /** 等待 signal 中止(无 signal 时返回永不 resolve 的 Promise,race 仅由任务完成决定)。 */
10471
+ function signalAbortedRace(signal) {
10472
+ if (signal === void 0) return new Promise(() => {});
10473
+ if (signal.aborted) return Promise.resolve();
10474
+ return new Promise((resolve) => {
10475
+ signal.addEventListener("abort", () => resolve(), { once: true });
10476
+ });
9756
10477
  }
9757
10478
  /**
9758
- * 观察(触发 → 待定 → 延迟执行):无活跃待定标记时测净压力 tokens(上下文压力 − 已压缩
9759
- * <history> 块 token 合计 − 系统提示词 token 估算 − 工具定义 token 估算),首次 ≥
9760
- * observeThresholdTokens 时记录待定标记(触发点 = 当时的最后一条完整消息 index),本次
9761
- * 不压缩(tailMessageCount=0 当轮直接执行,不落待定标记);已有待定标记时按新增完整
9762
- * 消息数 ≥ tailMessageCount 决定执行,压缩区间截至触发点(新增消息成为新未压缩尾部,
9763
- * 延迟窗口内压力允许短暂超阈值)。执行成功(或无可行区间)后写待定失效标记;压缩
9764
- * 失败保留待定,下个 pre-step 直接重试执行。最终失败返回失败结果
9765
- * (error = 最后一次错误)。
10479
+ * 观察(打标记 → 对账 → 到期注入):每个 pre-step 串行执行三阶段。
10480
+ * 打标记:无活跃待定标记时测净压力 tokens(换算系数 × 未压缩表层估算,未压缩 =
10481
+ * 表层 − 已压缩 <history> 块估算合计 − 系统提示词估算),首次 ≥ observeThresholdTokens
10482
+ * 写 om/observe-pending(触发点 = 当时的最后一条完整消息 index)。
10483
+ * 对账:活跃标记必须对应后台任务或持久化结果——匹配 pendingSeq 的 om/observe-summary
10484
+ * 信封直接采纳(重启恢复,不重压缩);无结果且无任务(或任务已失败)时启动后台预压缩
10485
+ * (无可行区间则失效标记视为完成);无活跃标记时清理注册表(边界后移使标记过期的运行中
10486
+ * 任务被中止)。
10487
+ * 到期:新增完整消息数 ≥ tailMessageCount 时注入——已完成结果在同一 pre-step / 同一开放
10488
+ * turn 内一次提交(compaction/start → summary → 替换 → end → 失效标记,满足宿主括号
10489
+ * 不变量);运行中任务等待其完成(turn 被取消则放行不注入,任务继续后台);失败返回
10490
+ * 失败结果(error = 最后一次错误,标记保留,下个 pre-step 重启任务重试)。
9766
10491
  */
9767
10492
  async function observePass(ctx, agent, config, waitCount, target, signal, reasoningEffort) {
9768
10493
  const session = agent.session;
9769
10494
  const logger = makeLogger(ctx, config.debug);
9770
10495
  logger.step(`观察检查(观察阈值 ${config.observeThresholdTokens} tokens,延迟等待 ${waitCount} 条完整消息)`);
9771
- const { blocks } = historySection(session);
9772
10496
  const pending = findObservePending(session);
9773
10497
  let triggerMessageIndex;
9774
10498
  let pendingSeq;
9775
- let triggerNote;
9776
10499
  if (pending === void 0) {
10500
+ disposePrecompression(session.id);
9777
10501
  const threshold = config.observeThresholdTokens;
9778
- const pressureTokens = measurePressureTokens(ctx, session, logger);
9779
- if (pressureTokens === void 0) return { failed: false };
10502
+ const measurement = measurePressure(ctx, session, logger);
10503
+ if (measurement === void 0) return { failed: false };
10504
+ const { blocks } = historySection(session);
9780
10505
  const historyTokens = blocks.reduce((total, block) => total + estimateTextTokens(block.text), 0);
9781
10506
  const systemTokens = await estimateSystemPromptTokens(ctx, agent, logger, signal);
9782
- const toolsTokens = estimateToolsTokens(session, logger);
9783
- const netTokens = pressureTokens - historyTokens - systemTokens - toolsTokens;
10507
+ const ratio = conversionRatio(measurement, estimateToolsTokens(session, logger));
10508
+ const uncompressedTokens = Math.max(0, measurement.surfaceTokens - historyTokens - systemTokens);
10509
+ const netTokens = Math.round(ratio * uncompressedTokens);
10510
+ const formula = `换算系数 ${ratio.toFixed(2)} ×(表层 ${measurement.surfaceTokens} − 已压缩块 ${historyTokens} − 系统提示词 ${systemTokens})`;
9784
10511
  if (netTokens < threshold) {
9785
- logger.step(`观察:净压力 ${netTokens} tokens(上下文压力 ${pressureTokens} − 已压缩块 ${historyTokens} − 系统提示词 ${systemTokens} − 工具定义 ${toolsTokens})< 阈值 ${threshold},跳过`);
10512
+ logger.step(`观察:净压力 ${netTokens} tokens(${formula})< 阈值 ${threshold},跳过`);
9786
10513
  return { failed: false };
9787
10514
  }
9788
- logger.step(`观察:净压力 ${netTokens} tokens(上下文压力 ${pressureTokens} − 已压缩块 ${historyTokens} − 系统提示词 ${systemTokens} − 工具定义 ${toolsTokens})≥ 阈值 ${threshold},触发压缩`);
10515
+ logger.step(`观察:净压力 ${netTokens} tokens(${formula})≥ 阈值 ${threshold},触发压缩`);
9789
10516
  const lastMessageIndex = indexCompleteMessages(session).length - 1;
9790
10517
  if (lastMessageIndex < 0) {
9791
10518
  logger.step("观察:会话尚无完整消息,跳过");
9792
10519
  return { failed: false };
9793
10520
  }
9794
10521
  triggerMessageIndex = lastMessageIndex;
9795
- if (waitCount > 0) {
9796
- try {
9797
- pendingSeq = appendObservePending(session, triggerMessageIndex);
9798
- } catch (error) {
9799
- const message = error instanceof Error ? error.message : String(error);
9800
- logger.warn(`观察:待定标记追加失败,本轮跳过(下轮重新评估): ${message}`);
9801
- return { failed: false };
9802
- }
9803
- logger.step(`观察:记录待定标记(触发点完整消息 index ${triggerMessageIndex}),等待 ${waitCount} 条新完整消息后压缩`);
10522
+ try {
10523
+ pendingSeq = appendObservePending(session, triggerMessageIndex);
10524
+ } catch (error) {
10525
+ const message = error instanceof Error ? error.message : String(error);
10526
+ logger.warn(`观察:待定标记追加失败,本轮跳过(下轮重新评估): ${message}`);
9804
10527
  return { failed: false };
9805
10528
  }
9806
- triggerNote = `触发点完整消息 index ${triggerMessageIndex}`;
10529
+ logger.step(`观察:记录待定标记(触发点完整消息 index ${triggerMessageIndex}),开始后台预压缩,等待 ${waitCount} 条新完整消息后注入`);
9807
10530
  } else {
9808
- const arrived = indexCompleteMessages(session).length - 1 - pending.triggerMessageIndex;
9809
- if (arrived < waitCount) {
9810
- logger.step(`观察:待定标记等待中(触发点完整消息 index ${pending.triggerMessageIndex},新增 ${arrived}/${waitCount} 条),跳过`);
9811
- return { failed: false };
9812
- }
9813
- logger.step(`观察:待定标记延迟到期(触发点完整消息 index ${pending.triggerMessageIndex},新增 ${arrived} ≥ ${waitCount} 条),执行压缩`);
9814
10531
  triggerMessageIndex = pending.triggerMessageIndex;
9815
10532
  pendingSeq = pending.seq;
9816
- triggerNote = `待定标记触发点完整消息 index ${pending.triggerMessageIndex}`;
9817
10533
  }
10534
+ /** 注入成功后失效待定标记并清理注册表(done 任务的 abort 无副作用)。 */
9818
10535
  const clearPending = () => {
9819
- if (pendingSeq === void 0) return;
9820
10536
  try {
9821
10537
  appendObserveInvalidate(session, pendingSeq);
9822
10538
  } catch (error) {
9823
10539
  const message = error instanceof Error ? error.message : String(error);
9824
10540
  logger.warn(`观察:待定失效标记追加失败: ${message}`);
9825
10541
  }
10542
+ disposePrecompression(session.id);
9826
10543
  };
9827
- const range = computeCompressRange(session, triggerMessageIndex);
9828
- if (!range) {
9829
- logger.step("观察:无可行压缩区间(边界后无消息、触发点已被压缩或配对无法平衡),清除待定标记视为完成");
9830
- clearPending();
9831
- return { failed: false };
10544
+ const persisted = findPersistedSummary(session, pendingSeq);
10545
+ let adopted;
10546
+ let job = findPrecompressionJob(session, pendingSeq);
10547
+ if (persisted !== void 0) {
10548
+ adopted = adoptPersistedSummary(persisted.data);
10549
+ if (job !== void 0 && job.state === "running") disposePrecompression(session.id);
10550
+ job = void 0;
10551
+ logger.step(`观察:采纳持久化压缩结果(om/observe-summary seq ${persisted.seq})`);
10552
+ } else if (job === void 0 || job.state === "failed") {
10553
+ if (job !== void 0) {
10554
+ logger.step(`观察:后台任务失败(${job.failure?.error ?? "未知错误"}),丢弃并重启`);
10555
+ disposePrecompression(session.id);
10556
+ }
10557
+ const started = startPrecompression({
10558
+ ctx,
10559
+ session,
10560
+ config,
10561
+ target,
10562
+ pendingSeq,
10563
+ triggerMessageIndex,
10564
+ ...reasoningEffort === void 0 ? {} : { reasoningEffort }
10565
+ });
10566
+ if (!started.ok) return { failed: false };
10567
+ job = started.job;
9832
10568
  }
9833
- logger.step(`观察:压缩区间 [${range.start}..${range.end}],遮蔽 ${range.shadowedSeqs.length} 个表层节点`);
9834
- const replaceSeqs = range.shadowedSeqs;
9835
- const replaceStart = replaceSeqs[0];
9836
- if (replaceStart === void 0) {
9837
- logger.step("观察:区间内无新消息(全部为压缩日志块),清除待定标记视为完成");
9838
- clearPending();
10569
+ const arrived = indexCompleteMessages(session).length - 1 - triggerMessageIndex;
10570
+ if (arrived < waitCount) {
10571
+ logger.step(`观察:待定标记等待中(触发点完整消息 index ${triggerMessageIndex},新增 ${arrived}/${waitCount}),后台${adopted !== void 0 ? "已有持久化结果待注入" : `任务${job?.state ?? "未知"}`}`);
9839
10572
  return { failed: false };
9840
10573
  }
9841
- const shadowedSet = new Set(replaceSeqs);
9842
- if (indexCompleteMessages(session).filter((cm) => cm.seqs.every((seq) => shadowedSet.has(seq))).length === 0) {
9843
- logger.step("观察:区间内无完整消息,清除待定标记视为完成");
9844
- clearPending();
9845
- return { failed: false };
10574
+ logger.step(`观察:待定标记延迟到期(触发点完整消息 index ${triggerMessageIndex},新增 ${arrived} ≥ ${waitCount}),执行注入`);
10575
+ let summaryResult;
10576
+ let prepared;
10577
+ let commitTarget = target;
10578
+ let commitEffort = reasoningEffort;
10579
+ if (adopted !== void 0) {
10580
+ summaryResult = adopted.result;
10581
+ commitTarget = {
10582
+ provider: adopted.provider,
10583
+ model: adopted.model
10584
+ };
10585
+ commitEffort = adopted.reasoningEffort;
10586
+ const prepare = prepareObserveCompression(session, triggerMessageIndex, config);
10587
+ if (!prepare.ok) {
10588
+ logger.step(`观察:${prepare.reason},清除待定标记视为完成`);
10589
+ clearPending();
10590
+ return { failed: false };
10591
+ }
10592
+ prepared = prepare.prepared;
10593
+ } else if (job !== void 0) {
10594
+ if (job.state === "running") {
10595
+ if (signal?.aborted) {
10596
+ logger.step("观察:pre-step 已中止,放行不注入(后台任务继续)");
10597
+ return { failed: false };
10598
+ }
10599
+ logger.step("观察:到期未完成预压缩,阻塞等待后台任务");
10600
+ await Promise.race([job.promise, signalAbortedRace(signal)]);
10601
+ }
10602
+ if (job.state === "failed") {
10603
+ const failure = job.failure;
10604
+ return {
10605
+ failed: true,
10606
+ error: failure?.error ?? "后台预压缩失败",
10607
+ aborted: failure?.aborted ?? false,
10608
+ ...failure?.diagnosticSessionId === void 0 ? {} : { diagnosticSessionId: failure.diagnosticSessionId }
10609
+ };
10610
+ }
10611
+ if (job.state === "running") {
10612
+ logger.step("观察:等待期间 turn 被取消,放行不注入(后台任务继续)");
10613
+ return { failed: false };
10614
+ }
10615
+ summaryResult = job.result;
10616
+ prepared = job.prepared;
9846
10617
  }
9847
- const shadowedCharCount = seqsCharCount(session, replaceSeqs);
9848
- const view = buildObserveView(session, replaceSeqs, { skipReasoning: config.compressSkipReasoning });
9849
- if (view.minIndex === void 0 || view.maxIndex === void 0) {
9850
- logger.step("观察:区间内无可定位条目,清除待定标记视为完成");
9851
- clearPending();
10618
+ if (summaryResult === void 0 || prepared === void 0) {
10619
+ logger.warn("观察:到期但无可注入的压缩结果,本轮跳过(下轮对账重试)");
9852
10620
  return { failed: false };
9853
10621
  }
9854
- logger.step(`观察:保留旧块 ${blocks.length} 条,替换 [${replaceStart}..${range.end}](${replaceSeqs.length} 个表层节点,压缩至${triggerNote}),视图区间 ${view.minIndex}..${view.maxIndex}`);
10622
+ const triggerNote = `触发点完整消息 index ${triggerMessageIndex}`;
10623
+ logger.step(`观察:压缩区间 [${prepared.range.start}..${prepared.range.end}],遮蔽 ${prepared.replaceSeqs.length} 个表层节点,压缩至${triggerNote}`);
9855
10624
  const lifecycle = {
9856
10625
  compactionId: newCompactionId(),
9857
10626
  turn: openTurnOf(session)
9858
10627
  };
9859
10628
  try {
9860
- logger.step("观察:追加 compaction/start(压缩循环前开启压缩中提示)");
10629
+ logger.step("观察:追加 compaction/start(注入开始)");
9861
10630
  appendCompactionStart(session, lifecycle, "observe");
9862
10631
  } catch (error) {
9863
10632
  const message = error instanceof Error ? error.message : String(error);
9864
10633
  logger.warn(`观察压缩启动失败: ${message}`);
9865
10634
  return { failed: false };
9866
10635
  }
9867
- const summaryResult = await runPassLoop(ctx, session, lifecycle, {
9868
- view,
9869
- originalChars: shadowedCharCount,
9870
- phase: "observe",
9871
- taskText: buildCompressionTaskText("observe", view.minIndex, view.maxIndex),
9872
- target,
10636
+ return commitObserveCompression(ctx, session, lifecycle, prepared, summaryResult, {
10637
+ target: commitTarget,
9873
10638
  maxTokens: config.compressMaxTokens,
9874
- rateLimitWaitMs: config.rateLimitWaitMs,
9875
- skipReasoning: config.compressSkipReasoning,
9876
- debug: config.debug,
9877
- ...reasoningEffort === void 0 ? {} : { reasoningEffort },
9878
- ...signal === void 0 ? {} : { signal }
9879
- }, logger, "observe");
9880
- if (!summaryResult.ok) return {
9881
- failed: true,
9882
- error: summaryResult.error,
9883
- aborted: summaryResult.aborted,
9884
- ...summaryResult.recordSessionId === void 0 ? {} : { diagnosticSessionId: summaryResult.recordSessionId }
9885
- };
9886
- const report = summaryResult.text;
9887
- const usage = summaryResult.usage;
9888
- const shadowedTokenCount = replaceSeqs.reduce((total, seq) => {
9889
- const event = session.snapshotEvents()[seq];
9890
- const message = event ? session.deriveEventMessage(event) : null;
9891
- let tokens = 0;
9892
- if (message) try {
9893
- tokens = ctx.tokenMeter.estimateMessage(message);
9894
- } catch {
9895
- reportDegrade(session, logger, "tokenMeter-unavailable");
9896
- }
9897
- return total + tokens;
9898
- }, 0);
9899
- try {
9900
- logger.step("观察提交:追加 compaction/summary(影子价格认领)");
9901
- const summarySeq = appendCompactionSummary(session, {
9902
- lifecycle,
9903
- summary: report,
9904
- shadowedRange: {
9905
- start: replaceStart,
9906
- end: range.end
9907
- },
9908
- shadowedSeqs: replaceSeqs,
9909
- shadowedTokenCount,
9910
- shadowedCharCount,
9911
- provider: target.provider,
9912
- model: target.model,
9913
- maxTokens: config.compressMaxTokens,
9914
- stats: summaryResult.stats,
9915
- ...usage === void 0 ? {} : { usage },
9916
- ...reasoningEffort === void 0 ? {} : { reasoningEffort }
9917
- });
9918
- logger.step("观察提交:替换被压缩新消息区间为 <history>(旧块保留)");
9919
- appendHistoryMessage(session, report, [summarySeq, ...replaceSeqs], {
9920
- op: "replace",
9921
- startSeq: replaceStart,
9922
- endSeq: range.end
9923
- }, lifecycle.compactionId);
9924
- logger.step("观察提交:追加 compaction/end");
9925
- appendCompactionEnd(session, lifecycle, void 0, summaryResult.recordSessionId);
9926
- clearPending();
9927
- logger.info(`观察压缩完成(替换 ${replaceSeqs.length} 个表层节点,约 ${shadowedTokenCount} tokens,压缩至${triggerNote})`);
9928
- return { failed: false };
9929
- } catch (error) {
9930
- const message = error instanceof Error ? error.message : String(error);
9931
- logger.warn(`观察压缩提交失败: ${message}`);
9932
- try {
9933
- appendCompactionEnd(session, lifecycle, message, void 0, summaryResult.stats.durationMs);
9934
- } catch {}
9935
- return { failed: false };
9936
- }
10639
+ reasoningEffort: commitEffort,
10640
+ triggerNote,
10641
+ logger,
10642
+ clearPending
10643
+ });
9937
10644
  }
9938
10645
  /**
9939
10646
  * 压力检查 + 两级压缩入口:先反思后观察,pre-step 阻塞串行执行;仅主会话生效。
@@ -10185,6 +10892,7 @@ const DEFAULT_CONFIG = Object.freeze({
10185
10892
  reflectThresholdTokens: 4e4,
10186
10893
  compressMaxTokens: void 0,
10187
10894
  rateLimitWaitMs: 6e4,
10895
+ recompressConcurrency: 2,
10188
10896
  tailMessageCount: 20,
10189
10897
  compressSkipReasoning: true,
10190
10898
  omEnabled: true,
@@ -10206,6 +10914,7 @@ const Config = Schema.object({
10206
10914
  reflectThresholdTokens: Schema.number().step(1).default(DEFAULT_CONFIG.reflectThresholdTokens).volatile(),
10207
10915
  compressMaxTokens: Schema.number().step(1).volatile(),
10208
10916
  rateLimitWaitMs: Schema.number().step(1).default(DEFAULT_CONFIG.rateLimitWaitMs).volatile(),
10917
+ recompressConcurrency: Schema.number().step(1).min(1).default(DEFAULT_CONFIG.recompressConcurrency).volatile(),
10209
10918
  tailMessageCount: Schema.number().step(1).default(DEFAULT_CONFIG.tailMessageCount).volatile(),
10210
10919
  compressSkipReasoning: Schema.boolean().default(DEFAULT_CONFIG.compressSkipReasoning).volatile(),
10211
10920
  omEnabled: Schema.boolean().default(DEFAULT_CONFIG.omEnabled).volatile(),
@@ -10223,11 +10932,11 @@ const Config = Schema.object({
10223
10932
  }).default({});
10224
10933
  /** 解析宿主 volatile 引用中的当前值,也兼容直接传入的原始配置对象。 */
10225
10934
  function currentConfig(config) {
10226
- if (!isRecord(config)) return resolveConfig(config);
10935
+ if (!isRecord$1(config)) return resolveConfig(config);
10227
10936
  const values = {};
10228
10937
  for (const key of Object.keys(DEFAULT_CONFIG)) {
10229
10938
  const value = config[key];
10230
- values[key] = isRecord(value) && typeof value.get === "function" ? value.get() : value;
10939
+ values[key] = isRecord$1(value) && typeof value.get === "function" ? value.get() : value;
10231
10940
  }
10232
10941
  return resolveConfig(values);
10233
10942
  }
@@ -10237,6 +10946,11 @@ const NUMBER_KEYS = [
10237
10946
  ["reflectThresholdTokens", true],
10238
10947
  ["compressMaxTokens", true],
10239
10948
  ["rateLimitWaitMs", true],
10949
+ [
10950
+ "recompressConcurrency",
10951
+ true,
10952
+ 1
10953
+ ],
10240
10954
  ["tailMessageCount", true],
10241
10955
  [
10242
10956
  "progressReminderIdleSteps",
@@ -10253,7 +10967,7 @@ const NUMBER_KEYS = [
10253
10967
  function normalizeConfigInput(raw) {
10254
10968
  if (raw === void 0 || raw === null) return {};
10255
10969
  if (typeof raw === "string" && raw.trim() === "") return {};
10256
- if (!isRecord(raw)) return {};
10970
+ if (!isRecord$1(raw)) return {};
10257
10971
  return raw;
10258
10972
  }
10259
10973
  /** 解析布尔配置值:缺省 / null / 空串 / 非 boolean 均回退默认值。 */
@@ -10427,7 +11141,6 @@ function toolcallElement(doc, session, cm, pruner, images) {
10427
11141
  const call = toolCallBlockOf(session, cm);
10428
11142
  const toolName = call === void 0 ? "" : String(call.name ?? "");
10429
11143
  if (toolName !== "") el.setAttribute("tool-name", toolName);
10430
- if (cm.callId) el.setAttribute("callId", cm.callId);
10431
11144
  if (call) {
10432
11145
  const args = doc.createElement("tool-args");
10433
11146
  appendCdataText(doc, args, toolArgsJson(call.arguments));
@@ -10446,13 +11159,14 @@ function toolcallElement(doc, session, cm, pruner, images) {
10446
11159
  appendImageComments(doc, el, images);
10447
11160
  return el;
10448
11161
  }
10449
- /** 按完整消息类别构建元素(user / assistant 文本条目复用 parts 渲染)。 */
11162
+ /** 按完整消息类别构建元素(user / skill / assistant 文本条目复用 parts 渲染)。 */
10450
11163
  function buildElement(doc, session, cm, pruner, images) {
10451
11164
  if (cm.type === "toolcall") return toolcallElement(doc, session, cm, pruner, images);
10452
11165
  const parts = renderCompleteMessageParts(session, cm, pruner);
10453
11166
  images.push(...parts.images);
10454
- const el = doc.createElement(cm.type === "user" ? "user_message" : "assistant");
11167
+ const el = doc.createElement(cm.type === "user" ? "user_message" : cm.type === "skill" ? "skill_content" : "assistant");
10455
11168
  el.setAttribute("index", String(cm.index));
11169
+ if (cm.type === "skill" && cm.skillName !== void 0) el.setAttribute("name", cm.skillName);
10456
11170
  if (cm.type === "assistant") el.setAttribute("type", "text");
10457
11171
  appendBodyText(doc, el, parts.text);
10458
11172
  appendImageComments(doc, el, parts.images);
@@ -10460,6 +11174,13 @@ function buildElement(doc, session, cm, pruner, images) {
10460
11174
  }
10461
11175
  /** 主渲染失败时的回退元素:按完整消息类别输出最简形态,正文为回退文本。 */
10462
11176
  function fallbackElement(doc, cm, text) {
11177
+ if (cm.type === "skill") {
11178
+ const el = doc.createElement("skill_content");
11179
+ el.setAttribute("index", String(cm.index));
11180
+ if (cm.skillName !== void 0) el.setAttribute("name", cm.skillName);
11181
+ appendBodyText(doc, el, text);
11182
+ return el;
11183
+ }
10463
11184
  const el = doc.createElement(cm.type === "user" ? "user_message" : "assistant");
10464
11185
  el.setAttribute("index", String(cm.index));
10465
11186
  if (cm.type !== "user") el.setAttribute("type", cm.type === "toolcall" ? "toolcall" : "text");
@@ -10762,6 +11483,53 @@ function buildRecallTool(options) {
10762
11483
  };
10763
11484
  }
10764
11485
  //#endregion
11486
+ //#region src/recompress-gate.ts
11487
+ /** 当前持有许可的数量。 */
11488
+ let active = 0;
11489
+ /** 排队中的请求(先进先出)。 */
11490
+ const queue = [];
11491
+ /** 按各自上限唤醒队首请求,直到许可用尽。 */
11492
+ function drain() {
11493
+ while (queue.length > 0) {
11494
+ const head = queue[0];
11495
+ if (head === void 0 || active >= Math.max(1, head.limit())) return;
11496
+ queue.shift();
11497
+ head.grant();
11498
+ }
11499
+ }
11500
+ /** 获取一个重压缩许可,返回幂等的 release;signal 中止时拒绝。 */
11501
+ function acquireRecompressSlot(limit, signal) {
11502
+ return new Promise((resolve, reject) => {
11503
+ if (signal?.aborted === true) {
11504
+ reject(signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("aborted"));
11505
+ return;
11506
+ }
11507
+ const grant = () => {
11508
+ signal?.removeEventListener("abort", onAbort);
11509
+ active++;
11510
+ let released = false;
11511
+ resolve(() => {
11512
+ if (released) return;
11513
+ released = true;
11514
+ active--;
11515
+ drain();
11516
+ });
11517
+ };
11518
+ const waiter = {
11519
+ limit,
11520
+ grant
11521
+ };
11522
+ const onAbort = () => {
11523
+ const index = queue.indexOf(waiter);
11524
+ if (index >= 0) queue.splice(index, 1);
11525
+ reject(signal?.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("aborted"));
11526
+ };
11527
+ signal?.addEventListener("abort", onAbort, { once: true });
11528
+ queue.push(waiter);
11529
+ drain();
11530
+ });
11531
+ }
11532
+ //#endregion
10765
11533
  //#region src/recompress.ts
10766
11534
  /** 命令行用法提示。 */
10767
11535
  const USAGE = "用法:/om-recompress <compactionId> <provider> <model> [思考等级]";
@@ -10813,6 +11581,31 @@ function rebuildView(session, phase, shadowedSeqs, skipReasoning) {
10813
11581
  }), { skipReasoning });
10814
11582
  return buildObserveView(session, shadowedSeqs, { skipReasoning });
10815
11583
  }
11584
+ /** 按 compactionId 重建一次已成功压缩的输入视图;不可重放时返回错误文本。 */
11585
+ function compactionView(session, compactionId, skipReasoning) {
11586
+ const lifecycle = findLifecycle(session, compactionId);
11587
+ if (lifecycle.phase === void 0 && lifecycle.summary === void 0) return { error: `未找到压缩 ${compactionId}` };
11588
+ const summary = lifecycle.summary;
11589
+ if (summary === void 0 || lifecycle.end === void 0 || lifecycle.end.error !== void 0) return { error: `压缩 ${compactionId} 未成功完成,无法重压缩` };
11590
+ const shadowedSeqs = (summary.shadowedSeqs ?? []).map(Number);
11591
+ if (shadowedSeqs.length === 0) return { error: `压缩 ${compactionId} 缺少 shadowedSeqs,无法重放` };
11592
+ const firstEvent = session.snapshotEvents()[shadowedSeqs[0] ?? -1];
11593
+ const phase = lifecycle.phase ?? (historyTextOf(firstEvent) === void 0 ? "observe" : "reflect");
11594
+ const view = rebuildView(session, phase, shadowedSeqs, skipReasoning);
11595
+ if (typeof view === "string") return { error: view };
11596
+ const { minIndex, maxIndex } = view;
11597
+ if (minIndex === void 0 || maxIndex === void 0) return { error: `压缩 ${compactionId} 的原内容无可定位条目` };
11598
+ const originalChars = summary.shadowedCharCount ?? (phase === "observe" ? seqsCharCount(session, shadowedSeqs) : viewCharCount(view));
11599
+ return {
11600
+ phase,
11601
+ view: {
11602
+ ...view,
11603
+ minIndex,
11604
+ maxIndex
11605
+ },
11606
+ originalChars
11607
+ };
11608
+ }
10816
11609
  /**
10817
11610
  * 对已成功的 compaction 用目标模型重压缩一次。校验失败、压缩循环失败均以
10818
11611
  * { ok: false } 返回,不抛错;会话本身不被修改(见文件头说明)。
@@ -10823,32 +11616,12 @@ async function recompress(ctx, agent, config, request, signal) {
10823
11616
  ok: false,
10824
11617
  error: "重压缩仅支持主会话"
10825
11618
  };
10826
- const lifecycle = findLifecycle(session, request.compactionId);
10827
- if (lifecycle.phase === void 0 && lifecycle.summary === void 0) return {
10828
- ok: false,
10829
- error: `未找到压缩 ${request.compactionId}`
10830
- };
10831
- const summary = lifecycle.summary;
10832
- if (summary === void 0 || lifecycle.end === void 0 || lifecycle.end.error !== void 0) return {
10833
- ok: false,
10834
- error: `压缩 ${request.compactionId} 未成功完成,无法重压缩`
10835
- };
10836
- const shadowedSeqs = (summary.shadowedSeqs ?? []).map(Number);
10837
- if (shadowedSeqs.length === 0) return {
10838
- ok: false,
10839
- error: `压缩 ${request.compactionId} 缺少 shadowedSeqs,无法重放`
10840
- };
10841
- const firstEvent = session.snapshotEvents()[shadowedSeqs[0] ?? -1];
10842
- const phase = lifecycle.phase ?? (historyTextOf(firstEvent) === void 0 ? "observe" : "reflect");
10843
- const view = rebuildView(session, phase, shadowedSeqs, config.compressSkipReasoning);
10844
- if (typeof view === "string") return {
10845
- ok: false,
10846
- error: view
10847
- };
10848
- if (view.minIndex === void 0 || view.maxIndex === void 0) return {
11619
+ const replay = compactionView(session, request.compactionId, config.compressSkipReasoning);
11620
+ if ("error" in replay) return {
10849
11621
  ok: false,
10850
- error: `压缩 ${request.compactionId} 的原内容无可定位条目`
11622
+ error: replay.error
10851
11623
  };
11624
+ const { phase, view, originalChars } = replay;
10852
11625
  if (signal?.aborted === true) return {
10853
11626
  ok: false,
10854
11627
  error: COMPACTION_ABORTED_ERROR
@@ -10858,7 +11631,6 @@ async function recompress(ctx, agent, config, request, signal) {
10858
11631
  model: request.model
10859
11632
  };
10860
11633
  makeLogger(ctx, config.debug).step(`重压缩:${request.compactionId}(${phase})→ ${target.provider}/${target.model}${request.reasoningEffort === void 0 ? "" : ` · ${request.reasoningEffort}`}`);
10861
- const originalChars = summary.shadowedCharCount ?? (phase === "observe" ? seqsCharCount(session, shadowedSeqs) : viewCharCount(view));
10862
11634
  const outcome = await runCompressionLoop(ctx, session, {
10863
11635
  view,
10864
11636
  originalChars,
@@ -10869,7 +11641,7 @@ async function recompress(ctx, agent, config, request, signal) {
10869
11641
  rateLimitWaitMs: config.rateLimitWaitMs,
10870
11642
  skipReasoning: config.compressSkipReasoning,
10871
11643
  debug: config.debug,
10872
- retryTarget: target,
11644
+ retry: true,
10873
11645
  ...request.reasoningEffort === void 0 ? {} : { reasoningEffort: request.reasoningEffort },
10874
11646
  ...signal === void 0 ? {} : { signal }
10875
11647
  });
@@ -10909,15 +11681,31 @@ function buildRecompressCommand(ctx, getConfig) {
10909
11681
  kind: "error",
10910
11682
  text: parsed.error
10911
11683
  };
10912
- const result = await recompress(ctx, agent, getConfig(), parsed.request, signal);
10913
- const text = describeResult(parsed.request, result);
10914
- return result.ok ? {
10915
- kind: "success",
10916
- text
10917
- } : {
10918
- kind: "error",
10919
- text
10920
- };
11684
+ let release;
11685
+ try {
11686
+ release = await acquireRecompressSlot(() => getConfig().recompressConcurrency, signal);
11687
+ } catch {
11688
+ return {
11689
+ kind: "error",
11690
+ text: describeResult(parsed.request, {
11691
+ ok: false,
11692
+ error: COMPACTION_ABORTED_ERROR
11693
+ })
11694
+ };
11695
+ }
11696
+ try {
11697
+ const result = await recompress(ctx, agent, getConfig(), parsed.request, signal);
11698
+ const text = describeResult(parsed.request, result);
11699
+ return result.ok ? {
11700
+ kind: "success",
11701
+ text
11702
+ } : {
11703
+ kind: "error",
11704
+ text
11705
+ };
11706
+ } finally {
11707
+ release();
11708
+ }
10921
11709
  }
10922
11710
  };
10923
11711
  }
@@ -11040,16 +11828,128 @@ function ensureSystemReminders(session, messages, reminders, idle = DEFAULT_PROG
11040
11828
  return result;
11041
11829
  }
11042
11830
  //#endregion
11831
+ //#region src/thinking-binding.ts
11832
+ /**
11833
+ * Claude thinking 签名前缀绑定修复:Claude 的 thinking 签名绑定其前全部内容,OM 替换后
11834
+ * 保留尾部中压缩前生成的签名失效,请求返回 400。发出请求前剥离这些消息的 reasoning。
11835
+ * 导出 staleAssistantIds / isAnthropicSigned / stripReasoning / sanitizeMessages /
11836
+ * registerThinkingBinding。
11837
+ *
11838
+ * - 分界:表层最后一条 source.kind 为插件 kind 的 user/message,其 seq 恒为 OM 消息最大
11839
+ * - 过期:分界之后 seq 小于分界的 assistant/message,即生成于该次替换之前
11840
+ * - 仅剥离 Anthropic 签名:replayState api 为 Anthropic 协议、模型名含 claude-、
11841
+ * 且带签名或 redacted 的 reasoning;其余模型的签名校验不绑定前缀,保持原样
11842
+ */
11843
+ /** 签名绑定前缀的 Anthropic 协议(pi-ai replayState.response.api)。 */
11844
+ const ANTHROPIC_APIS = /* @__PURE__ */ new Set(["anthropic-messages", "bedrock-converse-stream"]);
11845
+ /** Claude 模型名:匹配 claude-xx,兼容 anthropic/claude-xx 与 us.anthropic.claude-xx。 */
11846
+ const CLAUDE_MODEL = /\bclaude-/i;
11847
+ /** 判定 JSON 值为普通对象(replayState 为宿主声明的 unknown,须逐层收窄)。 */
11848
+ function isRecord(value) {
11849
+ return typeof value === "object" && value !== null && !Array.isArray(value);
11850
+ }
11851
+ /** 返回前缀已被最后一条 OM 消息改写的 assistant 消息 id;无 OM 消息时为空。 */
11852
+ function staleAssistantIds(session) {
11853
+ const stale = /* @__PURE__ */ new Set();
11854
+ const events = session.snapshotEvents();
11855
+ const nodes = session.surface.nodes;
11856
+ let boundary = -1;
11857
+ for (let i = nodes.length - 1; i >= 0; i -= 1) {
11858
+ const seq = nodes[i];
11859
+ const event = seq === void 0 ? void 0 : events[seq];
11860
+ if (event?.type === "user/message" && event.data.source?.kind === "plugin:dsh-plugin-om") {
11861
+ boundary = i;
11862
+ break;
11863
+ }
11864
+ }
11865
+ const boundarySeq = nodes[boundary];
11866
+ if (boundarySeq === void 0) return stale;
11867
+ for (const seq of nodes.slice(boundary + 1)) {
11868
+ const event = events[seq];
11869
+ if (event?.type === "assistant/message" && seq < boundarySeq) stale.add(event.data.message.id);
11870
+ }
11871
+ return stale;
11872
+ }
11873
+ /** 判定 assistant 消息带 Claude 经 Anthropic 协议签名的 reasoning。 */
11874
+ function isAnthropicSigned(message) {
11875
+ const { model, replayState } = message.source;
11876
+ if (!CLAUDE_MODEL.test(model) || !isRecord(replayState)) return false;
11877
+ const { response, blocks } = replayState;
11878
+ if (!isRecord(response) || typeof response.api !== "string") return false;
11879
+ if (!ANTHROPIC_APIS.has(response.api) || !Array.isArray(blocks)) return false;
11880
+ return blocks.some((block) => isRecord(block) && block.type === "reasoning" && (typeof block.thinkingSignature === "string" && block.thinkingSignature.length > 0 || block.redacted === true));
11881
+ }
11882
+ /** 去掉 reasoning 块与 replayState,保留 text 与 tool-call;剥离后无内容返回 undefined。 */
11883
+ function stripReasoning(message) {
11884
+ const content = message.content.filter((block) => block.type !== "reasoning");
11885
+ if (content.length === 0) return void 0;
11886
+ const { provider, model } = message.source;
11887
+ return freezeMessage({
11888
+ ...message,
11889
+ content,
11890
+ source: {
11891
+ kind: "model",
11892
+ provider,
11893
+ model
11894
+ }
11895
+ });
11896
+ }
11897
+ /** 剥离过期消息的 Anthropic 签名 reasoning;无改动返回 undefined。 */
11898
+ function sanitizeMessages(session, messages) {
11899
+ const stale = staleAssistantIds(session);
11900
+ if (stale.size === 0) return void 0;
11901
+ let changed = false;
11902
+ const result = [];
11903
+ for (const message of messages) {
11904
+ if (message.role === "assistant" && stale.has(message.id) && isAnthropicSigned(message)) {
11905
+ changed = true;
11906
+ const stripped = stripReasoning(message);
11907
+ if (stripped !== void 0) result.push(stripped);
11908
+ continue;
11909
+ }
11910
+ result.push(message);
11911
+ }
11912
+ return changed ? result : void 0;
11913
+ }
11914
+ /**
11915
+ * 注册前置 llm/stream 中间件:会话请求需剥离时以新 options 重新调用 llm.stream,
11916
+ * 保留 agent loop 标记;重新进入的请求直接放行。辅助调用(purpose)不处理。
11917
+ */
11918
+ function registerThinkingBinding(ctx, logger) {
11919
+ /** 已剥离并重新发出的请求,再次进入时直接放行。 */
11920
+ const rewritten = /* @__PURE__ */ new WeakSet();
11921
+ ctx.on("llm/stream", (options, next) => {
11922
+ if (rewritten.has(options) || options.sessionId === void 0) return next();
11923
+ if (options.purpose !== void 0) return next();
11924
+ const session = ctx.sessions.get(options.sessionId);
11925
+ if (session === void 0) return next();
11926
+ let messages;
11927
+ try {
11928
+ messages = sanitizeMessages(session, options.messages);
11929
+ } catch (error) {
11930
+ logger.warn(`thinking 签名剥离失败,按原请求发送: ${error instanceof Error ? error.message : String(error)}`);
11931
+ return next();
11932
+ }
11933
+ if (messages === void 0) return next();
11934
+ const request = {
11935
+ ...options,
11936
+ messages
11937
+ };
11938
+ if (isAgentLoopRequest(options)) markAgentLoopRequest(request);
11939
+ rewritten.add(request);
11940
+ logger.step(`剥离压缩前生成的 Claude thinking 签名后重发请求(会话 ${session.id})`);
11941
+ return ctx.llm.stream(request);
11942
+ }, { prepend: true });
11943
+ }
11944
+ //#endregion
11043
11945
  //#region src/index.ts
11044
11946
  /** 插件名(Loader 识别入口的稳定标识)。 */
11045
11947
  const name = "dsh-plugin-om";
11046
- /** 插件注入的服务依赖(tools/llm/tokenMeter/sessions),由宿主按序注入。 */
11047
- const inject = [
11048
- "tools",
11049
- "llm",
11050
- "tokenMeter",
11051
- "sessions"
11052
- ];
11948
+ /**
11949
+ * 插件必需的服务依赖:压缩请求(llm)与上下文压力计量(tokenMeter)。
11950
+ * tools / commands / sessions 等为可选能力,缺失时对应功能自动停用。
11951
+ */
11952
+ const inject = ["llm", "tokenMeter"];
11053
11953
  /** 插件激活入口:解析配置、注册工具、接线 pre-step 自动压缩与提醒补发。 */
11054
11954
  function apply(ctx, config) {
11055
11955
  const resolved = currentConfig(config);
@@ -11057,39 +11957,51 @@ function apply(ctx, config) {
11057
11957
  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)} compressProvider=${resolved.compressProvider ?? "跟随会话路由"} compressModel=${resolved.compressModel ?? "跟随会话路由"} compressReasoningEffort=${resolved.compressReasoningEffort ?? "模型默认"}`);
11058
11958
  const warnModel = (message) => ctx.logger.warn(`dsh-plugin-om: ${message}`);
11059
11959
  const logModel = (message) => logger.info(message);
11060
- let disposeRecall;
11061
- /** 当前已注册 recall 对应的语义增强开关与模型目录。 */
11062
- let registered;
11063
- /** 保持注册的 recall 与当前配置一致;仅语义增强首次生效或更换目录时启动后台预热。 */
11064
- function syncTools() {
11065
- const next = currentConfig(config);
11066
- const semantic = next.recallEnabled && next.semanticRecallEnabled;
11067
- if (disposeRecall && (!next.recallEnabled || registered?.semantic !== semantic || semantic && registered.modelDir !== next.modelDir)) {
11068
- disposeRecall();
11960
+ if (resolved.recallEnabled && ctx.get("tools") === void 0) logger.warn("tools 服务未挂载,recall 暂不可用");
11961
+ if (ctx.get("commands") === void 0) logger.warn("commands 服务未挂载,重压缩与 OM 结果评估命令暂不可用");
11962
+ ctx.inject(["tools"], (inner) => {
11963
+ let disposeRecall;
11964
+ /** 当前已注册 recall 对应的语义增强开关与模型目录。 */
11965
+ let registered;
11966
+ /** 保持注册的 recall 与当前配置一致;仅语义增强首次生效或更换目录时启动后台预热。 */
11967
+ const syncTools = () => {
11968
+ const next = currentConfig(config);
11969
+ const semantic = next.recallEnabled && next.semanticRecallEnabled;
11970
+ if (disposeRecall && (!next.recallEnabled || registered?.semantic !== semantic || semantic && registered.modelDir !== next.modelDir)) {
11971
+ disposeRecall();
11972
+ disposeRecall = void 0;
11973
+ registered = void 0;
11974
+ }
11975
+ if (next.recallEnabled && !disposeRecall) {
11976
+ const directory = next.modelDir;
11977
+ disposeRecall = inner.tools.register(buildRecallTool({
11978
+ getPruner: () => inner.get("toolResultPruner"),
11979
+ ...semantic ? { semantic: {
11980
+ modelStatus: () => ensureModelReady(directory, warnModel, void 0, logModel),
11981
+ embedder: (texts) => getEmbedder(directory).then((embed) => embed(texts))
11982
+ } } : {}
11983
+ }));
11984
+ registered = {
11985
+ semantic,
11986
+ modelDir: directory
11987
+ };
11988
+ if (semantic) ensureModelReady(directory, warnModel, void 0, logModel);
11989
+ }
11990
+ };
11991
+ syncTools();
11992
+ inner.on("loader/volatile-update", () => syncTools());
11993
+ inner.effect(() => () => {
11994
+ disposeRecall?.();
11069
11995
  disposeRecall = void 0;
11070
- registered = void 0;
11071
- }
11072
- if (next.recallEnabled && !disposeRecall) {
11073
- const directory = next.modelDir;
11074
- disposeRecall = ctx.tools.register(buildRecallTool({
11075
- getPruner: () => ctx.get("toolResultPruner"),
11076
- ...semantic ? { semantic: {
11077
- modelStatus: () => ensureModelReady(directory, warnModel, void 0, logModel),
11078
- embedder: (texts) => getEmbedder(directory).then((embed) => embed(texts))
11079
- } } : {}
11080
- }));
11081
- registered = {
11082
- semantic,
11083
- modelDir: directory
11084
- };
11085
- if (semantic) ensureModelReady(directory, warnModel, void 0, logModel);
11086
- }
11087
- }
11088
- syncTools();
11089
- ctx.on("loader/volatile-update", () => syncTools());
11996
+ }, "dsh-plugin-om: recall tool");
11997
+ });
11090
11998
  ctx.inject(["commands"], (inner) => {
11091
11999
  inner.effect(() => inner.commands.register(buildRecompressCommand(ctx, () => currentConfig(config))), "dsh-plugin-om: recompress command");
12000
+ inner.effect(() => inner.commands.register(buildCompactionEvalCommand(ctx)), "dsh-plugin-om: compaction eval command");
11092
12001
  });
12002
+ ctx.inject(["sessions"], (inner) => registerThinkingBinding(inner, logger));
12003
+ ctx.on("session/disposed", (session) => disposePrecompression(session.id));
12004
+ ctx.effect(() => () => disposeAllPrecompressions(), "dsh-plugin-om: precompression registry");
11093
12005
  ctx.on("agent/pre-step", async ({ agent, signal }, next) => {
11094
12006
  let outcome = { failed: false };
11095
12007
  try {