dsh-plugin-om 0.0.58 → 0.0.60

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 (45) hide show
  1. package/README.md +40 -23
  2. package/dist/client/OmConfigCard.d.ts.map +1 -1
  3. package/dist/client/OmWarningCard.d.ts +1 -2
  4. package/dist/client/OmWarningCard.d.ts.map +1 -1
  5. package/dist/client/definition.d.ts +3 -3
  6. package/dist/client/locales.d.ts +3 -5
  7. package/dist/client/locales.d.ts.map +1 -1
  8. package/dist/client/om-config-controller.d.ts +13 -16
  9. package/dist/client/om-config-controller.d.ts.map +1 -1
  10. package/dist/client.js +41 -50
  11. package/dist/client.js.map +1 -1
  12. package/dist/compress-loop.d.ts +12 -8
  13. package/dist/compress-loop.d.ts.map +1 -1
  14. package/dist/compress-tools.d.ts +18 -2
  15. package/dist/compress-tools.d.ts.map +1 -1
  16. package/dist/compress-view.d.ts +37 -4
  17. package/dist/compress-view.d.ts.map +1 -1
  18. package/dist/compress.d.ts +46 -27
  19. package/dist/compress.d.ts.map +1 -1
  20. package/dist/config.d.ts +2 -6
  21. package/dist/config.d.ts.map +1 -1
  22. package/dist/constants.d.ts +16 -2
  23. package/dist/constants.d.ts.map +1 -1
  24. package/dist/degrade.d.ts.map +1 -1
  25. package/dist/index.d.ts.map +1 -1
  26. package/dist/index.mjs +1369 -876
  27. package/dist/om-event-append.d.ts +5 -0
  28. package/dist/om-event-append.d.ts.map +1 -0
  29. package/dist/om-event.d.ts +16 -17
  30. package/dist/om-event.d.ts.map +1 -1
  31. package/dist/precompress.d.ts +1 -1
  32. package/dist/precompress.d.ts.map +1 -1
  33. package/dist/recall.d.ts +12 -20
  34. package/dist/recall.d.ts.map +1 -1
  35. package/dist/recompress.d.ts +1 -1
  36. package/dist/reflect.d.ts +89 -0
  37. package/dist/reflect.d.ts.map +1 -0
  38. package/dist/semantic-recall.d.ts +11 -4
  39. package/dist/semantic-recall.d.ts.map +1 -1
  40. package/dist/skill/compaction-eval/scripts/compress.mjs +170 -37
  41. package/dist/skill/compaction-eval/scripts/prepare.mjs +8 -0
  42. package/dist/skill/compaction-eval/scripts/view.mjs +321 -101
  43. package/dist/types.d.ts +13 -12
  44. package/dist/types.d.ts.map +1 -1
  45. package/package.json +1 -1
package/dist/index.mjs CHANGED
@@ -4,10 +4,10 @@ import { brandString } from "@deepseek-ai/dsh-brand";
4
4
  import { CompactionId } from "@deepseek-ai/dsh-compaction";
5
5
  import { BlockAssembler, createAssistantMessage, createSystemMessage, createToolResultMessage, createUserMessage, freezeMessage, isAgentLoopRequest, markAgentLoopRequest } from "@deepseek-ai/dsh-llm";
6
6
  import { scopeOf } from "@deepseek-ai/dsh-scope";
7
- import { SessionId, SessionSeq } from "@deepseek-ai/dsh-session";
7
+ import { SessionId, SessionSeq, appendPluginRecord } from "@deepseek-ai/dsh-session";
8
8
  import { renderPrompt } from "@deepseek-ai/dsh-system-prompt";
9
- import { SUBAGENT_DESCRIPTOR_VERSION } from "@deepseek-ai/dsh-subagent";
10
9
  import { z } from "zod";
10
+ import { SUBAGENT_DESCRIPTOR_VERSION } from "@deepseek-ai/dsh-subagent";
11
11
  import Schema from "@deepseek-ai/schemastery";
12
12
  import { homedir } from "node:os";
13
13
  import path from "node:path";
@@ -291,388 +291,29 @@ function buildCompactionEvalCommand(ctx) {
291
291
  };
292
292
  }
293
293
  //#endregion
294
- //#region src/format.ts
295
- /**
296
- * 紧凑数字格式化(压缩卡片、重压缩记录与压缩日志共用)。零依赖,服务端与浏览器均可引用。导出 formatCompactCount / formatSeconds。
297
- * <1k 原样;≥1k 用 k;≥1w(万)用 w;≥1M 用 M;保留 1 位小数并去掉末尾 .0。
298
- */
299
- function formatCompactCount(value) {
300
- const trim = (n) => {
301
- const text = String(Math.round(n * 10) / 10);
302
- return text.endsWith(".0") ? text.slice(0, -2) : text;
303
- };
304
- if (value >= 1e6) return `${trim(value / 1e6)}M`;
305
- if (value >= 1e4) return `${trim(value / 1e4)}w`;
306
- if (value >= 1e3) return `${trim(value / 1e3)}k`;
307
- return String(value);
308
- }
309
- /** 毫秒耗时格式化为一位小数的秒数,如 63.1s。 */
310
- function formatSeconds(durationMs) {
311
- return `${(durationMs / 1e3).toFixed(1)}s`;
312
- }
313
- //#endregion
314
- //#region src/constants.ts
315
- /** 插件标识:日志前缀与历史日志的 source.plugin 取值。 */
316
- const PLUGIN_LABEL = "dsh-plugin-om";
317
- /**
318
- * 插件自产消息的 producer-owned source kind(format v4 要求消息 source 为生产者自有
319
- * kind,与宿主 v3→v4 迁移对本插件旧日志的产出一致;types.ts 把它声明进宿主
320
- * MessageSourceMap,使 UserMessage.source 原生接受该形态)。
321
- */
322
- const PLUGIN_SOURCE_KIND = "plugin:dsh-plugin-om";
323
- /** 构造插件自产消息的 source(compactionId 仅替换检查点消息传入)。 */
324
- function omSource(compactionId) {
325
- return {
326
- kind: PLUGIN_SOURCE_KIND,
327
- ...compactionId === void 0 ? {} : { compactionId }
328
- };
329
- }
330
- /** 压缩日志标签名:<history>...</history> 包裹观察/反思日志块。 */
331
- const HISTORY_TAG = "history";
332
- /** 压缩日志块开标签的 tip 属性(对 AI 的提醒:本块是历史压缩产物,不要复述)。 */
333
- const HISTORY_TIP = "当前块是历史消息的压缩产物,不要复述";
334
- /**
335
- * 「完整消息」定义(压缩提示词、recall 工具描述与 <history> 块顶注释共用)。
336
- * 完整消息是摘要日志与 recall 共用的定位单位;首条 index 为 0,按会话顺序递增、全局稳定。
337
- */
338
- const COMPLETE_MESSAGE_DEFINITION = "`完整消息`指一条`用户消息`、`模型输出文本`、`具有result的toolcall`或`手动加载的skill`;首条 index 为 0,按会话顺序递增。";
339
- /**
340
- * 最终 <history> 块内文块首的格式说明注释(XML 注释)。通用部分(条目标签语义 +
341
- * CDATA 约定 + toolcall 结构)始终保留;<user_message> /
342
- * <skill_content> / <ask-user-question> 的条目说明仅在块内存在对应条目时追加。
343
- */
344
- function historyFormatNote(sections = {}) {
345
- const parts = [
346
- COMPLETE_MESSAGE_DEFINITION,
347
- "<TAG index=\"N\">表示单条完整消息,<TAG start=\"A\" end=\"B\"> 表示多条连续消息,start/end 是首尾完整消息的 index;消息块的内容是用CDATA包裹的纯文本",
348
- "<assistant type=\"toolcall\" tool-name=\"T\" index=\"N\"> 表示工具调用,内含 <tool-args> 与 <tool-result> 两个CDATA子元素(调用参数与工具返回内容)"
349
- ];
350
- if (sections.user) parts.push("<user_message index=\"N\"> 表示用户消息原文");
351
- if (sections.skill) parts.push("<skill_content name=\"S\" index=\"N\"> 表示未压缩的原始 skill");
352
- if (sections.askUserQuestion) parts.push("<ask-user-question index=\"N\"> 表示向用户提问,CDATA 内为逐题成对的 q:(提问)与 a:(用户回答)行,未作答的题记为 a:(未回答)");
353
- return `<!-- ${parts.join(";")} -->`;
354
- }
355
- /** skill 工具名:toolcall 条目的工具名为该值时视为 skill 加载,<history> 块中以 <skill_content> 元素呈现。 */
356
- const SKILL_TOOL_NAME = "skill";
357
- /**
358
- * 提问工具名:成功且问题与答案完整配对时视为合法 ask,失败调用按普通 toolcall 处理。
359
- * 合法 ask 直接压缩需二次确认;未直接压缩的原始 ask 重写后以 q/a 形式保留。
360
- */
361
- const ASK_USER_QUESTION_TOOL_NAME = "ask_user_question";
362
- /**
363
- * 压缩因 signal 中止而放弃时 compaction/end 的 error 标识(服务端写入、客户端过滤):
364
- * 中止不是失败,客户端据此隐藏失败行(宿主不变量要求无 summary 的 end 必须带 error)。
365
- */
366
- const COMPACTION_ABORTED_ERROR = "压缩已中止(signal aborted)";
367
- /**
368
- * 判定 user/message 的 source 是否为本插件自产或宿主压缩 checkpoint(压缩日志消息与
369
- * 宿主压缩替换消息)。这类消息不占完整消息 index。宿主迁移前的 v3 信封形态
370
- * (kind 'plugin' + plugin 字段)仅作读取防御保留。
371
- */
372
- function isPluginOwnedSource(source) {
373
- if (source?.kind === "compact-checkpoint") return true;
374
- if (source?.kind === "plugin:dsh-plugin-om") return true;
375
- if (source?.kind !== "plugin") return false;
376
- return source.plugin === "dsh-plugin-om" || source.plugin === "compact";
377
- }
378
- //#endregion
379
- //#region src/logger.ts
380
- /**
381
- * 插件日志门面:step 为步骤级(debug)日志,按配置开关过滤;info/warn 始终输出。
382
- * 导出 PluginLogger / makeLogger。
383
- */
384
- /** 构建插件日志门面:统一加 PLUGIN_LABEL 前缀,step 按 debug 开关过滤。 */
385
- function makeLogger(ctx, debug) {
386
- return {
387
- step(message) {
388
- if (typeof debug === "function" ? debug() : debug) ctx.logger.debug(`${PLUGIN_LABEL}: ${message}`);
389
- },
390
- info(message) {
391
- ctx.logger.info(`${PLUGIN_LABEL}: ${message}`);
392
- },
393
- warn(message) {
394
- ctx.logger.warn(`${PLUGIN_LABEL}: ${message}`);
395
- }
396
- };
397
- }
398
- //#endregion
399
- //#region src/compaction-log.ts
400
- /** 诊断子会话的 descriptor provider(宿主子代理列表识别用)。 */
401
- const COMPACTION_LOG_PROVIDER = "om-compaction-log";
402
- /** 压缩 pass 的中文标签(会话记录 label 用;未知阶段回落「压缩」)。 */
403
- function phaseLabel(phase) {
404
- if (phase === "observe") return "观察";
405
- if (phase === "reflect") return "反思";
406
- return "压缩";
407
- }
408
- /**
409
- * 压缩会话记录 label:`OM会话(起点-终点)-观察/反思`,区间缺失省略括号段;
410
- * 重压缩追加 `-重压缩`,失败追加 `-失败`。
411
- */
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})`;
420
- }
421
- /** 生成模型信息:压缩模型、思考等级、原始消息与压缩产物的字符数(k 单位)。 */
422
- function compressionInfo(info) {
423
- const effort = info.reasoningEffort ?? "默认思考等级";
424
- const result = info.resultChars === void 0 ? failureText(info.failure) : `${formatCompactCount(info.resultChars)} 字符`;
425
- return {
426
- text: `压缩使用模型 ${info.target.provider}/${info.target.model}(${effort}),原始消息 ${formatCompactCount(info.originalChars)} 字符,压缩产物 ${result}`,
427
- provider: info.target.provider,
428
- model: info.target.model
429
- };
430
- }
431
- /**
432
- * 构造一个 seed 事件信封:seq 由调用方按顺序传入,surface 事件附 surfaceOp:'append'。
433
- * 宿主 seed 边界校验信封字段(type/seq/time/data/surfaceOp)与消息形状,并原样保留
434
- * time(append 路径会强制改写为 Date.now()),故诊断记录经 seed 重建时间线。信封为
435
- * 判别联合,泛型构造需一次断言(与 tests/helpers.ts 同法)。
436
- */
437
- function seedEvent(type, seq, time, data, surfaceOp) {
438
- return {
439
- type,
440
- seq,
441
- time,
442
- data,
443
- ...surfaceOp === void 0 ? {} : { surfaceOp }
444
- };
445
- }
446
- /**
447
- * 重建压缩循环的 seed 事件时间线:descriptor + turn/step 生命周期 + 逐消息事件。每个
448
- * 事件携带从循环统计推导的 time——turn 边界取循环起止、第 k 个 assistant 取第 k 轮
449
- * 起止(step/start = startedAt、assistant/message = startedAt + durationMs)、工具调用
450
- * 与结果与其 assistant 同刻(内存工具瞬时)——并把逐轮 usage 附加到 assistant/message。
451
- * 时间全程单调不减;轮次数组短于 assistant 数时(流错误注入的部分 assistant)回落上一
452
- * 轮结束时刻与循环结束时刻。
453
- */
454
- function buildCompressionSeed(messages, stats, label, info, system) {
455
- const seed = [];
456
- const push = (type, time, data, surfaceOp) => {
457
- seed.push(seedEvent(type, seed.length, time, data, surfaceOp));
458
- };
459
- let cursor = stats.startedAt;
460
- const at = (time) => {
461
- cursor = Math.max(cursor, time);
462
- return cursor;
463
- };
464
- const executed = new Set(messages.filter((message) => message.role === "tool").map((message) => message.toolCallId));
465
- push("subagent/descriptor", at(stats.startedAt), {
466
- version: SUBAGENT_DESCRIPTOR_VERSION,
467
- mode: "one-shot",
468
- provider: COMPACTION_LOG_PROVIDER,
469
- label
470
- });
471
- push("turn/start", at(stats.startedAt), { turn: 1 });
472
- let step = 1;
473
- let assistantIndex = 0;
474
- let stepTime = stats.startedAt;
475
- let stepOpen = false;
476
- let pending = [];
477
- const closeStep = () => {
478
- if (!stepOpen) return;
479
- for (const call of pending) {
480
- if (executed.has(call.id)) continue;
481
- const repair = createToolResultMessage({
482
- callId: call.id,
483
- content: [{
484
- type: "text",
485
- text: "压缩循环未执行此工具调用"
486
- }],
487
- isError: true
488
- });
489
- push("tool/result", at(stepTime), {
490
- turn: 1,
491
- step,
492
- message: {
493
- ...repair,
494
- id: `forked-tool-result-${call.id}-${uuid()}`
495
- },
496
- error: {
497
- name: "ToolNotStartedError",
498
- code: "TOOL_NOT_STARTED"
499
- }
500
- }, "append");
501
- }
502
- push("step/end", at(stepTime), {
503
- turn: 1,
504
- step
505
- });
506
- pending = [];
507
- stepOpen = false;
508
- };
509
- for (const message of messages) if (message.role === "assistant") {
510
- closeStep();
511
- step += 1;
512
- const round = stats.rounds[assistantIndex];
513
- assistantIndex += 1;
514
- const startAt = round?.startedAt ?? stepTime;
515
- const completedAt = round === void 0 ? stats.completedAt : round.startedAt + round.durationMs;
516
- push("step/start", at(startAt), {
517
- turn: 1,
518
- step
519
- });
520
- stepOpen = true;
521
- const assistant = message;
522
- const assistantTime = at(completedAt);
523
- push("assistant/message", assistantTime, {
524
- turn: 1,
525
- step,
526
- message: assistant,
527
- stream: [],
528
- ...round?.usage === void 0 ? {} : { usage: round.usage }
529
- }, "append");
530
- stepTime = assistantTime;
531
- pending = assistant.content.filter((block) => block.type === "tool-call");
532
- for (const call of pending) {
533
- if (!executed.has(call.id)) continue;
534
- push("tool/call", at(stepTime), {
535
- turn: 1,
536
- step,
537
- callId: call.id,
538
- name: call.name,
539
- arguments: call.arguments
540
- });
541
- }
542
- } else if (message.role === "tool") push("tool/result", at(stepTime), {
543
- turn: 1,
544
- step,
545
- message
546
- }, "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
- }
567
- closeStep();
568
- if (info !== void 0) {
569
- step += 1;
570
- push("step/start", at(stats.completedAt), {
571
- turn: 1,
572
- step
573
- });
574
- push("assistant/message", at(stats.completedAt), {
575
- turn: 1,
576
- step,
577
- message: createAssistantMessage({
578
- content: [{
579
- type: "text",
580
- text: info.text
581
- }],
582
- source: {
583
- provider: info.provider,
584
- model: info.model
585
- }
586
- }),
587
- stream: []
588
- }, "append");
589
- push("step/end", at(stats.completedAt), {
590
- turn: 1,
591
- step
592
- });
593
- }
594
- push("turn/end", at(stats.completedAt), {
595
- turn: 1,
596
- reason: { kind: "completed" }
597
- });
598
- return seed;
599
- }
600
- /**
601
- * 把一次压缩工具循环的完整会话消息组落盘为子会话:以重建时间线的 seed 事件经
602
- * ctx.sessions.create 构造子会话(header origin 'subagent'、parentSession 指向主会话、
603
- * delegationDepth = 父 + 1、cwd 继承主会话;首事件 one-shot descriptor,provider
604
- * om-compaction-log,label 含完整消息区间与阶段;info 存在时尾部追加一条模型文本),flush 持久化,在父会话登记
605
- * subagent/catalog,返回子会话 id。成功与失败均调用;落盘自身绝不抛错,任何失败仅
606
- * logger.warn 并返回 undefined。
607
- */
608
- async function recordCompressionSession(ctx, parentSession, options) {
609
- const logger = makeLogger(ctx, options.debug);
610
- try {
611
- const header = parentSession.header;
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()}`), {
620
- seed,
621
- meta: {
622
- ...header.cwd === void 0 ? {} : { cwd: header.cwd },
623
- parentSession: parentSession.id,
624
- origin: "subagent",
625
- delegationDepth: (header.delegationDepth ?? 0) + 1
626
- }
627
- });
628
- const persistence = ctx.get("sessionPersistence");
629
- if (persistence === void 0) throw new Error("宿主未提供 sessionPersistence 服务");
630
- const write = await persistence.create(child.header);
631
- try {
632
- await write.append(child.snapshotEvents());
633
- await write.flush();
634
- } finally {
635
- await write.close();
636
- }
637
- parentSession.append("subagent/catalog", {
638
- version: 0,
639
- childId: child.id,
640
- childCreatedAt: child.header.createdAt,
641
- mode: "one-shot",
642
- label
643
- });
644
- await sessions.flush(parentSession);
645
- return child.id;
646
- } catch (error) {
647
- const message = error instanceof Error ? error.message : String(error);
648
- logger.warn(`压缩会话记录子会话落盘失败: ${message}`);
649
- return;
650
- }
651
- }
652
- //#endregion
653
- //#region node_modules/.pnpm/@xmldom+xmldom@0.9.11/node_modules/@xmldom/xmldom/lib/conventions.js
654
- var require_conventions = /* @__PURE__ */ __commonJSMin(((exports) => {
655
- /**
656
- * Ponyfill for `Array.prototype.find` which is only available in ES6 runtimes.
657
- *
658
- * Works with anything that has a `length` property and index access properties,
659
- * including NodeList.
660
- *
661
- * @param {T[] | { length: number; [number]: T }} list
662
- * @param {function (item: T, index: number, list:T[]):boolean} predicate
663
- * @param {Partial<Pick<ArrayConstructor['prototype'], 'find'>>?} ac
664
- * Allows injecting a custom implementation in tests (`Array.prototype` by default).
665
- * @returns {T | undefined}
666
- * @template {unknown} T
667
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find
668
- * @see https://tc39.es/ecma262/multipage/indexed-collections.html#sec-array.prototype.find
669
- */
670
- function find(list, predicate, ac) {
671
- if (ac === void 0) ac = Array.prototype;
672
- if (list && typeof ac.find === "function") return ac.find.call(list, predicate);
673
- for (var i = 0; i < list.length; i++) if (hasOwn(list, i)) {
674
- var item = list[i];
675
- if (predicate.call(void 0, item, i, list)) return item;
294
+ //#region node_modules/.pnpm/@xmldom+xmldom@0.9.11/node_modules/@xmldom/xmldom/lib/conventions.js
295
+ var require_conventions = /* @__PURE__ */ __commonJSMin(((exports) => {
296
+ /**
297
+ * Ponyfill for `Array.prototype.find` which is only available in ES6 runtimes.
298
+ *
299
+ * Works with anything that has a `length` property and index access properties,
300
+ * including NodeList.
301
+ *
302
+ * @param {T[] | { length: number; [number]: T }} list
303
+ * @param {function (item: T, index: number, list:T[]):boolean} predicate
304
+ * @param {Partial<Pick<ArrayConstructor['prototype'], 'find'>>?} ac
305
+ * Allows injecting a custom implementation in tests (`Array.prototype` by default).
306
+ * @returns {T | undefined}
307
+ * @template {unknown} T
308
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find
309
+ * @see https://tc39.es/ecma262/multipage/indexed-collections.html#sec-array.prototype.find
310
+ */
311
+ function find(list, predicate, ac) {
312
+ if (ac === void 0) ac = Array.prototype;
313
+ if (list && typeof ac.find === "function") return ac.find.call(list, predicate);
314
+ for (var i = 0; i < list.length; i++) if (hasOwn(list, i)) {
315
+ var item = list[i];
316
+ if (predicate.call(void 0, item, i, list)) return item;
676
317
  }
677
318
  }
678
319
  /**
@@ -7740,7 +7381,7 @@ var require_dom_parser = /* @__PURE__ */ __commonJSMin(((exports) => {
7740
7381
  exports.onWarningStopParsing = onWarningStopParsing;
7741
7382
  }));
7742
7383
  //#endregion
7743
- //#region src/log-index.ts
7384
+ //#region src/constants.ts
7744
7385
  var import_lib = (/* @__PURE__ */ __commonJSMin(((exports) => {
7745
7386
  var conventions = require_conventions();
7746
7387
  exports.assign = conventions.assign;
@@ -7780,6 +7421,80 @@ var import_lib = (/* @__PURE__ */ __commonJSMin(((exports) => {
7780
7421
  exports.onErrorStopParsing = domParser.onErrorStopParsing;
7781
7422
  exports.onWarningStopParsing = domParser.onWarningStopParsing;
7782
7423
  })))();
7424
+ /** 插件标识:日志前缀与历史日志的 source.plugin 取值。 */
7425
+ const PLUGIN_LABEL = "dsh-plugin-om";
7426
+ /**
7427
+ * 插件自产消息的 producer-owned source kind(format v4 要求消息 source 为生产者自有
7428
+ * kind,与宿主 v3→v4 迁移对本插件旧日志的产出一致;types.ts 把它声明进宿主
7429
+ * MessageSourceMap,使 UserMessage.source 原生接受该形态)。
7430
+ */
7431
+ const PLUGIN_SOURCE_KIND = "plugin:dsh-plugin-om";
7432
+ /** 构造插件自产消息的 source(compactionId 仅替换检查点消息传入)。 */
7433
+ function omSource(compactionId) {
7434
+ return {
7435
+ kind: PLUGIN_SOURCE_KIND,
7436
+ ...compactionId === void 0 ? {} : { compactionId }
7437
+ };
7438
+ }
7439
+ /** 压缩日志标签名:<history>...</history> 包裹观察/反思日志块。 */
7440
+ const HISTORY_TAG = "history";
7441
+ /** 压缩日志块开标签的 tip 属性(对 AI 的提醒:本块是历史压缩产物,不要复述)。 */
7442
+ const HISTORY_TIP = "当前块是历史消息的压缩产物,不要复述";
7443
+ /** 归档块标签名:反思把较早的 <history> 块深度压缩为 <archived-history>。 */
7444
+ const ARCHIVED_HISTORY_TAG = "archived-history";
7445
+ /** 归档块开标签的 tip 属性。 */
7446
+ const ARCHIVED_HISTORY_TIP = "此块已被深度压缩,如需原文细节请用 recall 查看";
7447
+ /**
7448
+ * 「完整消息」定义(压缩提示词、recall 工具描述与 <history> 块顶注释共用)。
7449
+ * 完整消息是摘要日志与 recall 共用的定位单位;首条 index 为 0,按会话顺序递增、全局稳定。
7450
+ */
7451
+ /** 压缩会话首条消息中预注入区间条目的标题行,评估脚本据此提取原文视图。 */
7452
+ const INITIAL_HISTORY_HEADER = "区间当前条目(等同 getHistory 全区间返回):";
7453
+ const COMPLETE_MESSAGE_DEFINITION = "`完整消息`指一条`用户消息`、`模型输出文本`、`具有result的toolcall`或`手动加载的skill`;首条 index 为 0,按会话顺序递增。";
7454
+ /**
7455
+ * 最终 <history> 块内文块首的格式说明注释(XML 注释)。通用部分(条目标签语义 +
7456
+ * CDATA 约定 + toolcall 结构)始终保留;<user_message> /
7457
+ * <skill_content> / <ask-user-question> 的条目说明仅在块内存在对应条目时追加。
7458
+ */
7459
+ function historyFormatNote(sections = {}) {
7460
+ const parts = [
7461
+ COMPLETE_MESSAGE_DEFINITION,
7462
+ "<TAG index=\"N\">表示单条完整消息,<TAG start=\"A\" end=\"B\"> 表示多条连续消息,start/end 是首尾完整消息的 index;消息块的内容是用CDATA包裹的纯文本",
7463
+ "<assistant type=\"toolcall\" tool-name=\"T\" index=\"N\"> 表示工具调用,内含 <tool-args> 与 <tool-result> 两个CDATA子元素(调用参数与工具返回内容)"
7464
+ ];
7465
+ if (sections.user) parts.push("<user_message index=\"N\"> 表示用户消息原文");
7466
+ if (sections.skill) parts.push("<skill_content name=\"S\" index=\"N\"> 表示未压缩的原始 skill");
7467
+ if (sections.askUserQuestion) parts.push("<ask-user-question index=\"N\"> 表示向用户提问,CDATA 内为逐题成对的 q:(提问)与 a:(用户回答)行,未作答的题记为 a:(未回答)");
7468
+ if (sections.keyWord) parts.push("<assistant start=\"A\" end=\"B\" key-word=\"K\"> 的正文是该区间的一句话摘要,K 为供 recall 检索原文的关键词");
7469
+ return `<!-- ${parts.join(";")} -->`;
7470
+ }
7471
+ /** skill 工具名:toolcall 条目的工具名为该值时视为 skill 加载,<history> 块中以 <skill_content> 元素呈现。 */
7472
+ const SKILL_TOOL_NAME = "skill";
7473
+ /** 手动加载 skill 的系统消息 source kind。 */
7474
+ const SKILL_INVOCATION_KIND = "skill-invocation";
7475
+ /**
7476
+ * 提问工具名:成功且问题与答案完整配对时视为合法 ask,失败调用按普通 toolcall 处理。
7477
+ * 合法 ask 直接压缩需二次确认;未直接压缩的原始 ask 重写后以 q/a 形式保留。
7478
+ */
7479
+ const ASK_USER_QUESTION_TOOL_NAME = "ask_user_question";
7480
+ /**
7481
+ * 压缩因 signal 中止而放弃时 compaction/end 的 error 标识(服务端写入、客户端过滤):
7482
+ * 中止不是失败,客户端据此隐藏失败行(宿主不变量要求无 summary 的 end 必须带 error)。
7483
+ */
7484
+ const COMPACTION_ABORTED_ERROR = "压缩已中止(signal aborted)";
7485
+ /**
7486
+ * 判定 user/message 的 source 是否为本插件自产或宿主压缩 checkpoint(压缩日志消息与
7487
+ * 宿主压缩替换消息)。这类消息不占完整消息 index。宿主迁移前的 v3 信封形态
7488
+ * (kind 'plugin' + plugin 字段)仅作读取防御保留。
7489
+ */
7490
+ function isPluginOwnedSource(source) {
7491
+ if (source?.kind === "compact-checkpoint") return true;
7492
+ if (source?.kind === "plugin:dsh-plugin-om") return true;
7493
+ if (source?.kind !== "plugin") return false;
7494
+ return source.plugin === "dsh-plugin-om" || source.plugin === "compact";
7495
+ }
7496
+ //#endregion
7497
+ //#region src/log-index.ts
7783
7498
  /**
7784
7499
  * 会话日志索引:完整消息索引与渲染。
7785
7500
  * 导出 indexCompleteMessages(完整消息三类折叠索引,recall 与摘要共用同一套编号)、
@@ -8375,13 +8090,17 @@ function parseBlockEntries(blockText, blockSeq) {
8375
8090
  }
8376
8091
  const start = intAttr(el, "start");
8377
8092
  const end = intAttr(el, "end");
8378
- if (start !== void 0 && end !== void 0) entries.push({
8379
- kind: "assistant",
8380
- lo: start,
8381
- hi: end,
8382
- text,
8383
- blockSeq
8384
- });
8093
+ if (start !== void 0 && end !== void 0) {
8094
+ const keyWord = el.getAttribute("key-word");
8095
+ entries.push({
8096
+ kind: "assistant",
8097
+ lo: start,
8098
+ hi: end,
8099
+ text,
8100
+ blockSeq,
8101
+ ...keyWord === null || keyWord === "" ? {} : { keyWord }
8102
+ });
8103
+ }
8385
8104
  } else if (el.nodeName === "skill_content") {
8386
8105
  const index = intAttr(el, "index");
8387
8106
  if (index !== void 0) {
@@ -8433,18 +8152,67 @@ function parseBlockEntries(blockText, blockSeq) {
8433
8152
  if (entries.length === 0) return opaque();
8434
8153
  return entries;
8435
8154
  }
8155
+ /** 已处理的 ask 条目(q/a 形态,非失败 toolcall)。 */
8156
+ function isHandledAsk(entry) {
8157
+ return entry.kind === "assistant" && entry.toolName === "ask_user_question" && entry.toolArgs === void 0;
8158
+ }
8159
+ /** 转义 XML 属性值。 */
8160
+ function escapeAttr(value) {
8161
+ return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
8162
+ }
8163
+ /** 把 skill 条目渲染为宿主 skill 引用的注入正文:两段结构按宿主格式重建,已有包裹原样使用。 */
8164
+ function skillInjectionText(name, text) {
8165
+ const sections = skillContentSections(text);
8166
+ const head = `<skill_content name="${escapeAttr(name)}">`;
8167
+ if (sections) return `${head}<skill_resources>${sections.resources}</skill_resources>\n\n<skill_instructions>${sections.instructions}</skill_instructions></skill_content>`;
8168
+ if (/^\s*<skill_content\b[^>]*>[\s\S]*<\/skill_content>\s*$/.test(text)) return text.trim();
8169
+ return `${head}${text}</skill_content>`;
8170
+ }
8436
8171
  /**
8437
- * 反思视图:全部 <history> 块(historySection 收集,按表层顺序)的内条目投影为条目。
8438
- * 要求区间为全部块内条目引用的最小 / 最大 index;块解析失败降级为不可定位遗留条目;
8439
- * skipReasoning 时不含 <reasoning> 参考条目。
8172
+ * 归档视图:被归档 <history> 块的条目去掉 reasoning 与具名 skill。用户条目与已处理
8173
+ * ask 原样保留并作为分隔,其间连续的可定位 assistant 条目构成一个归档段;不可定位的
8174
+ * 遗留条目同样作为分隔原样保留。具名 skill 按名称去重保留最新一份,随结果返回。
8440
8175
  */
8441
- function buildReflectView(blocks, options = {}) {
8176
+ function buildArchiveView(blocks) {
8177
+ const skills = /* @__PURE__ */ new Map();
8442
8178
  const entries = [];
8443
- for (const block of blocks) entries.push(...parseBlockEntries(block.text, block.seq));
8444
- const filtered = options.skipReasoning === true ? entries.filter((entry) => entry.kind !== "reasoning") : entries;
8179
+ const segments = [];
8180
+ let open;
8181
+ const close = () => {
8182
+ if (open !== void 0) segments.push(open);
8183
+ open = void 0;
8184
+ };
8185
+ for (const block of blocks) for (const entry of parseBlockEntries(block.text, block.seq)) {
8186
+ if (entry.kind === "reasoning") continue;
8187
+ if (entry.toolName === "skill" && entry.skillName !== void 0 && entry.skillName !== "" && entry.lo !== void 0) {
8188
+ const name = entry.skillName;
8189
+ skills.delete(name);
8190
+ skills.set(name, {
8191
+ name,
8192
+ index: entry.lo,
8193
+ content: skillInjectionText(name, entry.text)
8194
+ });
8195
+ continue;
8196
+ }
8197
+ entries.push(entry);
8198
+ if (entry.kind === "user" || isHandledAsk(entry) || entry.lo === void 0 || entry.hi === void 0) {
8199
+ close();
8200
+ continue;
8201
+ }
8202
+ if (open === void 0) open = {
8203
+ lo: entry.lo,
8204
+ hi: entry.hi
8205
+ };
8206
+ else open.hi = Math.max(open.hi, entry.hi);
8207
+ }
8208
+ close();
8445
8209
  return {
8446
- entries: filtered,
8447
- ...viewBounds(filtered)
8210
+ view: {
8211
+ entries,
8212
+ ...viewBounds(entries),
8213
+ segments
8214
+ },
8215
+ skills: [...skills.values()].sort((a, b) => a.index - b.index)
8448
8216
  };
8449
8217
  }
8450
8218
  /**
@@ -8537,6 +8305,7 @@ function entryToElement(doc, entry) {
8537
8305
  el.setAttribute("start", String(entry.lo));
8538
8306
  el.setAttribute("end", String(entry.hi));
8539
8307
  }
8308
+ if (entry.keyWord !== void 0) el.setAttribute("key-word", entry.keyWord);
8540
8309
  appendCdataText(doc, el, entry.text);
8541
8310
  return el;
8542
8311
  }
@@ -8550,22 +8319,490 @@ function renderEntriesXml(entries) {
8550
8319
  return entries.map((entry) => serializer.serializeToString(entryToElement(doc, entry))).join("\n");
8551
8320
  }
8552
8321
  //#endregion
8553
- //#region src/compress-tools.ts
8554
- /** 判定 JSON 对象,不接受数组或 null。 */
8555
- function isJsonRecord(value) {
8556
- return value !== null && typeof value === "object" && !Array.isArray(value);
8557
- }
8558
- /** 合法原始 ask 或已处理的历史 ask;普通失败 toolcall 不包含在内。 */
8559
- function isAskEntry(entry) {
8560
- return entry.kind === "assistant" && (entry.ask !== void 0 || entry.toolName === "ask_user_question" && entry.toolArgs === void 0);
8561
- }
8562
- /** 压缩会话的工具状态:视图 + 替换记录 + 二次确认标记(skill / ask_user_question)+ 完成标记。 */
8563
- var CompressionState = class CompressionState {
8564
- replacements = [];
8565
- challengedSkills = /* @__PURE__ */ new Set();
8566
- viewedAsks = /* @__PURE__ */ new Set();
8567
- undeliveredAsks = /* @__PURE__ */ new Set();
8568
- rewrittenAsks = /* @__PURE__ */ new Map();
8322
+ //#region src/om-event.ts
8323
+ /** 各类别对应的 plugin record 类型名(grammar:`plugin:` 后以 `/` 分段)。 */
8324
+ const OM_RECORD_TYPES = {
8325
+ "om/warning": "plugin:dsh-plugin-om/warning",
8326
+ "om/observe-pending": "plugin:dsh-plugin-om/observe-pending",
8327
+ "om/observe-invalidate": "plugin:dsh-plugin-om/observe-invalidate",
8328
+ "om/observe-summary": "plugin:dsh-plugin-om/observe-summary"
8329
+ };
8330
+ /** plugin record 类型名到 om 类别的反查表。 */
8331
+ const KIND_BY_RECORD_TYPE = new Map(Object.entries(OM_RECORD_TYPES).map(([kind, type]) => [type, kind]));
8332
+ /**
8333
+ * 解码一条会话事件为 om 私有事件:仅识别带 ignorable 标记且类型名属于本插件的
8334
+ * plugin record;类型不符、载荷非对象或字段缺失时返回 undefined。
8335
+ */
8336
+ function readOmEvent(event) {
8337
+ if (event === void 0 || event === null || event.ignorable !== true) return void 0;
8338
+ const kind = KIND_BY_RECORD_TYPE.get(event.type);
8339
+ if (kind === void 0) return void 0;
8340
+ const payload = event.data;
8341
+ if (payload === null || typeof payload !== "object" || Array.isArray(payload)) return void 0;
8342
+ const rest = payload;
8343
+ switch (kind) {
8344
+ case "om/warning": {
8345
+ const { problem, message } = rest;
8346
+ if (typeof problem !== "string" || typeof message !== "string") return void 0;
8347
+ return {
8348
+ kind,
8349
+ data: {
8350
+ problem,
8351
+ message
8352
+ },
8353
+ seq: event.seq
8354
+ };
8355
+ }
8356
+ case "om/observe-pending": {
8357
+ const { triggerMessageIndex } = rest;
8358
+ if (typeof triggerMessageIndex !== "number" || !Number.isSafeInteger(triggerMessageIndex)) return void 0;
8359
+ return {
8360
+ kind,
8361
+ data: { triggerMessageIndex },
8362
+ seq: event.seq
8363
+ };
8364
+ }
8365
+ case "om/observe-invalidate": {
8366
+ const { pendingSeq } = rest;
8367
+ if (typeof pendingSeq !== "number" || !Number.isSafeInteger(pendingSeq)) return void 0;
8368
+ return {
8369
+ kind,
8370
+ data: { pendingSeq },
8371
+ seq: event.seq
8372
+ };
8373
+ }
8374
+ case "om/observe-summary": {
8375
+ const { pendingSeq, report, provider, model, startedAt, completedAt, durationMs, recordSessionId, usage, reasoningEffort } = rest;
8376
+ if (typeof pendingSeq !== "number" || !Number.isSafeInteger(pendingSeq)) return void 0;
8377
+ if (typeof report !== "string") return void 0;
8378
+ if (typeof provider !== "string" || typeof model !== "string") return void 0;
8379
+ if (!isFiniteNumber(startedAt) || !isFiniteNumber(completedAt) || !isFiniteNumber(durationMs)) return void 0;
8380
+ if (recordSessionId !== void 0 && typeof recordSessionId !== "string") return void 0;
8381
+ if (reasoningEffort !== void 0 && typeof reasoningEffort !== "string") return void 0;
8382
+ const parsedUsage = readTokenUsage(usage);
8383
+ if (parsedUsage === null) return void 0;
8384
+ return {
8385
+ kind,
8386
+ data: {
8387
+ pendingSeq,
8388
+ report,
8389
+ provider,
8390
+ model,
8391
+ startedAt,
8392
+ completedAt,
8393
+ durationMs,
8394
+ ...recordSessionId === void 0 ? {} : { recordSessionId },
8395
+ ...parsedUsage === void 0 ? {} : { usage: parsedUsage },
8396
+ ...reasoningEffort === void 0 ? {} : { reasoningEffort }
8397
+ },
8398
+ seq: event.seq
8399
+ };
8400
+ }
8401
+ default: return;
8402
+ }
8403
+ }
8404
+ /** 校验有限数值字段(时间戳/耗时)。 */
8405
+ function isFiniteNumber(value) {
8406
+ return typeof value === "number" && Number.isFinite(value);
8407
+ }
8408
+ /** 校验可选 token usage 字段:缺省返回 undefined,非法返回 null,合法返回仅含已知数值字段的对象。 */
8409
+ function readTokenUsage(value) {
8410
+ if (value === void 0) return void 0;
8411
+ if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
8412
+ const usage = value;
8413
+ const { inputTokens, outputTokens } = usage;
8414
+ if (!isFiniteNumber(inputTokens) || !isFiniteNumber(outputTokens)) return null;
8415
+ const result = {
8416
+ inputTokens,
8417
+ outputTokens
8418
+ };
8419
+ for (const key of [
8420
+ "totalTokens",
8421
+ "cacheReadTokens",
8422
+ "cacheWriteTokens",
8423
+ "reasoningTokens"
8424
+ ]) {
8425
+ const field = usage[key];
8426
+ if (field === void 0) continue;
8427
+ if (!isFiniteNumber(field)) return null;
8428
+ result[key] = field;
8429
+ }
8430
+ return result;
8431
+ }
8432
+ function findOmEvents(session, kind) {
8433
+ const result = [];
8434
+ for (const event of session.snapshotEvents()) {
8435
+ const om = readOmEvent(event);
8436
+ if (om !== void 0 && (kind === void 0 || om.kind === kind)) result.push(om);
8437
+ }
8438
+ return result;
8439
+ }
8440
+ //#endregion
8441
+ //#region src/om-event-append.ts
8442
+ /**
8443
+ * om 私有事件写入:经宿主 appendPluginRecord 追加 plugin record。
8444
+ * 导出 appendOmEvent。仅服务端使用,读取侧见 om-event.ts。
8445
+ */
8446
+ /** 追加一条 om 私有事件(ignorable,不进 surface),返回事件 seq。 */
8447
+ function appendOmEvent(session, kind, data) {
8448
+ const type = OM_RECORD_TYPES[kind];
8449
+ return appendPluginRecord(session, type, data);
8450
+ }
8451
+ //#endregion
8452
+ //#region src/degrade.ts
8453
+ /**
8454
+ * 降级报告:压缩流程中的挂载失败统一出口。
8455
+ * 导出 reportDegrade / DEGRADE_PROBLEMS / DegradedProblem。
8456
+ *
8457
+ * - 挂载失败类问题(服务缺失、服务调用异常)始终 console.warn 到宿主进程外部输出,
8458
+ * 并向会话日志追加 ignorable 的 om 警告 plugin record(
8459
+ * 见 om-event.ts;客户端渲染为「功能降级」警告行);
8460
+ * 同一会话同一问题只报告一次(按日志扫描去重,重启不重复)
8461
+ * - 报告动作自身绝不抛错:追加失败只记日志,不阻塞压缩
8462
+ * - 辅助函数的普通运行时报错(组装失败、请求头读取失败)不走本模块,仅记日志
8463
+ */
8464
+ /** 各降级问题面向用户的简短说明(om/warning 信封载荷 message;客户端警告行直接展示)。 */
8465
+ const DEGRADE_PROBLEMS = {
8466
+ "systemPrompt-missing": "系统提示词服务未挂载,上下文压力估算不扣除系统提示词 tokens(压缩触发会偏早)",
8467
+ "tokenMeter-unavailable": "token 计量服务异常,上下文压力估算降级(可能跳过压缩或按 0 计)",
8468
+ "reasoning-effort-unavailable": "配置的压缩思考等级不被压缩目标模型支持,压缩降级为模型默认思考等级"
8469
+ };
8470
+ /**
8471
+ * 报告一次挂载失败类降级:console.warn 始终输出到宿主进程外部;同会话同问题首次
8472
+ * 出现时,向会话日志追加 log-only om 警告事件(客户端渲染警告行,每会话最多
8473
+ * 一次)并输出 logger.warn(避免每个 pre-step 重复刷日志)。
8474
+ * 日志扫描/事件追加失败只记日志,绝不抛错、不阻塞压缩。
8475
+ */
8476
+ function reportDegrade(session, logger, problem) {
8477
+ const message = DEGRADE_PROBLEMS[problem];
8478
+ let first = true;
8479
+ try {
8480
+ first = !findOmEvents(session, "om/warning").some((om) => om.data.problem === problem);
8481
+ } catch {}
8482
+ if (!first) return;
8483
+ console.warn(`${PLUGIN_LABEL}: ${message}`);
8484
+ logger.warn(message);
8485
+ try {
8486
+ appendOmEvent(session, "om/warning", {
8487
+ problem,
8488
+ message
8489
+ });
8490
+ } catch (error) {
8491
+ const text = error instanceof Error ? error.message : String(error);
8492
+ logger.warn(`om 警告事件追加失败: ${text}`);
8493
+ }
8494
+ }
8495
+ //#endregion
8496
+ //#region src/logger.ts
8497
+ /**
8498
+ * 插件日志门面:step 为步骤级(debug)日志,按配置开关过滤;info/warn 始终输出。
8499
+ * 导出 PluginLogger / makeLogger。
8500
+ */
8501
+ /** 构建插件日志门面:统一加 PLUGIN_LABEL 前缀,step 按 debug 开关过滤。 */
8502
+ function makeLogger(ctx, debug) {
8503
+ return {
8504
+ step(message) {
8505
+ if (typeof debug === "function" ? debug() : debug) ctx.logger.debug(`${PLUGIN_LABEL}: ${message}`);
8506
+ },
8507
+ info(message) {
8508
+ ctx.logger.info(`${PLUGIN_LABEL}: ${message}`);
8509
+ },
8510
+ warn(message) {
8511
+ ctx.logger.warn(`${PLUGIN_LABEL}: ${message}`);
8512
+ }
8513
+ };
8514
+ }
8515
+ //#endregion
8516
+ //#region src/format.ts
8517
+ /**
8518
+ * 紧凑数字格式化(压缩卡片、重压缩记录与压缩日志共用)。零依赖,服务端与浏览器均可引用。导出 formatCompactCount / formatSeconds。
8519
+ * <1k 原样;≥1k 用 k;≥1w(万)用 w;≥1M 用 M;保留 1 位小数并去掉末尾 .0。
8520
+ */
8521
+ function formatCompactCount(value) {
8522
+ const trim = (n) => {
8523
+ const text = String(Math.round(n * 10) / 10);
8524
+ return text.endsWith(".0") ? text.slice(0, -2) : text;
8525
+ };
8526
+ if (value >= 1e6) return `${trim(value / 1e6)}M`;
8527
+ if (value >= 1e4) return `${trim(value / 1e4)}w`;
8528
+ if (value >= 1e3) return `${trim(value / 1e3)}k`;
8529
+ return String(value);
8530
+ }
8531
+ /** 毫秒耗时格式化为一位小数的秒数,如 63.1s。 */
8532
+ function formatSeconds(durationMs) {
8533
+ return `${(durationMs / 1e3).toFixed(1)}s`;
8534
+ }
8535
+ //#endregion
8536
+ //#region src/compaction-log.ts
8537
+ /** 诊断子会话的 descriptor provider(宿主子代理列表识别用)。 */
8538
+ const COMPACTION_LOG_PROVIDER = "om-compaction-log";
8539
+ /** 压缩 pass 的中文标签(会话记录 label 用;未知阶段回落「压缩」)。 */
8540
+ function phaseLabel(phase) {
8541
+ if (phase === "observe") return "观察";
8542
+ if (phase === "reflect") return "反思";
8543
+ return "压缩";
8544
+ }
8545
+ /**
8546
+ * 压缩会话记录 label:`OM会话(起点-终点)-观察/反思`,区间缺失省略括号段;
8547
+ * 重压缩追加 `-重压缩`,失败追加 `-失败`。
8548
+ */
8549
+ function compressionRecordLabel(phase, range, success, retry) {
8550
+ return `OM会话${range.min === void 0 || range.max === void 0 ? "" : `(${range.min}-${range.max})`}-${phaseLabel(phase)}${retry ? "-重压缩" : ""}${success ? "" : "-失败"}`;
8551
+ }
8552
+ /** 失败产物文本:`无(压缩失败[:原因[;最后一轮 finish=…[,输出 N tokens]]])`。 */
8553
+ function failureText(failure) {
8554
+ if (failure === void 0) return "无(压缩失败)";
8555
+ const last = failure.finish === void 0 ? "" : `;最后一轮 finish=${failure.finish}${failure.outputTokens === void 0 ? "" : `,输出 ${failure.outputTokens} tokens`}`;
8556
+ return `无(压缩失败:${failure.reason}${last})`;
8557
+ }
8558
+ /** 生成模型信息:压缩模型、思考等级、原始消息与压缩产物的字符数(k 单位)。 */
8559
+ function compressionInfo(info) {
8560
+ const effort = info.reasoningEffort ?? "默认思考等级";
8561
+ const result = info.resultChars === void 0 ? failureText(info.failure) : `${formatCompactCount(info.resultChars)} 字符`;
8562
+ return {
8563
+ text: `压缩使用模型 ${info.target.provider}/${info.target.model}(${effort}),原始消息 ${formatCompactCount(info.originalChars)} 字符,压缩产物 ${result}`,
8564
+ provider: info.target.provider,
8565
+ model: info.target.model
8566
+ };
8567
+ }
8568
+ /**
8569
+ * 构造一个 seed 事件信封:seq 由调用方按顺序传入,surface 事件附 surfaceOp:'append'。
8570
+ * 宿主 seed 边界校验信封字段(type/seq/time/data/surfaceOp)与消息形状,并原样保留
8571
+ * time(append 路径会强制改写为 Date.now()),故诊断记录经 seed 重建时间线。信封为
8572
+ * 判别联合,泛型构造需一次断言(与 tests/helpers.ts 同法)。
8573
+ */
8574
+ function seedEvent(type, seq, time, data, surfaceOp) {
8575
+ return {
8576
+ type,
8577
+ seq,
8578
+ time,
8579
+ data,
8580
+ ...surfaceOp === void 0 ? {} : { surfaceOp }
8581
+ };
8582
+ }
8583
+ /**
8584
+ * 重建压缩循环的 seed 事件时间线:descriptor + turn/step 生命周期 + 逐消息事件。每个
8585
+ * 事件携带从循环统计推导的 time——turn 边界取循环起止、第 k 个 assistant 取第 k 轮
8586
+ * 起止(step/start = startedAt、assistant/message = startedAt + durationMs)、工具调用
8587
+ * 与结果与其 assistant 同刻(内存工具瞬时)——并把逐轮 usage 附加到 assistant/message。
8588
+ * 时间全程单调不减;轮次数组短于 assistant 数时(流错误注入的部分 assistant)回落上一
8589
+ * 轮结束时刻与循环结束时刻。
8590
+ */
8591
+ function buildCompressionSeed(messages, stats, label, info, system) {
8592
+ const seed = [];
8593
+ const push = (type, time, data, surfaceOp) => {
8594
+ seed.push(seedEvent(type, seed.length, time, data, surfaceOp));
8595
+ };
8596
+ let cursor = stats.startedAt;
8597
+ const at = (time) => {
8598
+ cursor = Math.max(cursor, time);
8599
+ return cursor;
8600
+ };
8601
+ const executed = new Set(messages.filter((message) => message.role === "tool").map((message) => message.toolCallId));
8602
+ push("subagent/descriptor", at(stats.startedAt), {
8603
+ version: SUBAGENT_DESCRIPTOR_VERSION,
8604
+ mode: "one-shot",
8605
+ provider: COMPACTION_LOG_PROVIDER,
8606
+ label
8607
+ });
8608
+ push("turn/start", at(stats.startedAt), { turn: 1 });
8609
+ let step = 1;
8610
+ let assistantIndex = 0;
8611
+ let stepTime = stats.startedAt;
8612
+ let stepOpen = false;
8613
+ let pending = [];
8614
+ const closeStep = () => {
8615
+ if (!stepOpen) return;
8616
+ for (const call of pending) {
8617
+ if (executed.has(call.id)) continue;
8618
+ const repair = createToolResultMessage({
8619
+ callId: call.id,
8620
+ content: [{
8621
+ type: "text",
8622
+ text: "压缩循环未执行此工具调用"
8623
+ }],
8624
+ isError: true
8625
+ });
8626
+ push("tool/result", at(stepTime), {
8627
+ turn: 1,
8628
+ step,
8629
+ message: {
8630
+ ...repair,
8631
+ id: `forked-tool-result-${call.id}-${uuid()}`
8632
+ },
8633
+ error: {
8634
+ name: "ToolNotStartedError",
8635
+ code: "TOOL_NOT_STARTED"
8636
+ }
8637
+ }, "append");
8638
+ }
8639
+ push("step/end", at(stepTime), {
8640
+ turn: 1,
8641
+ step
8642
+ });
8643
+ pending = [];
8644
+ stepOpen = false;
8645
+ };
8646
+ for (const message of messages) if (message.role === "assistant") {
8647
+ closeStep();
8648
+ step += 1;
8649
+ const round = stats.rounds[assistantIndex];
8650
+ assistantIndex += 1;
8651
+ const startAt = round?.startedAt ?? stepTime;
8652
+ const completedAt = round === void 0 ? stats.completedAt : round.startedAt + round.durationMs;
8653
+ push("step/start", at(startAt), {
8654
+ turn: 1,
8655
+ step
8656
+ });
8657
+ stepOpen = true;
8658
+ const assistant = message;
8659
+ const assistantTime = at(completedAt);
8660
+ push("assistant/message", assistantTime, {
8661
+ turn: 1,
8662
+ step,
8663
+ message: assistant,
8664
+ stream: [],
8665
+ ...round?.usage === void 0 ? {} : { usage: round.usage }
8666
+ }, "append");
8667
+ stepTime = assistantTime;
8668
+ pending = assistant.content.filter((block) => block.type === "tool-call");
8669
+ for (const call of pending) {
8670
+ if (!executed.has(call.id)) continue;
8671
+ push("tool/call", at(stepTime), {
8672
+ turn: 1,
8673
+ step,
8674
+ callId: call.id,
8675
+ name: call.name,
8676
+ arguments: call.arguments
8677
+ });
8678
+ }
8679
+ } else if (message.role === "tool") push("tool/result", at(stepTime), {
8680
+ turn: 1,
8681
+ step,
8682
+ message
8683
+ }, "append");
8684
+ else if (!stepOpen) {
8685
+ const user = message;
8686
+ push("step/start", at(stats.startedAt), {
8687
+ turn: 1,
8688
+ step
8689
+ });
8690
+ stepOpen = true;
8691
+ if (system !== void 0 && system !== "") push("system/message", at(stats.startedAt), {
8692
+ turn: 1,
8693
+ step,
8694
+ message: createSystemMessage(system)
8695
+ }, "append");
8696
+ push("user/message", at(stats.startedAt), {
8697
+ ...user,
8698
+ source: { kind: "user" }
8699
+ }, "append");
8700
+ } else {
8701
+ const user = message;
8702
+ push("user/message", at(stepTime), user, "append");
8703
+ }
8704
+ closeStep();
8705
+ if (info !== void 0) {
8706
+ step += 1;
8707
+ push("step/start", at(stats.completedAt), {
8708
+ turn: 1,
8709
+ step
8710
+ });
8711
+ push("assistant/message", at(stats.completedAt), {
8712
+ turn: 1,
8713
+ step,
8714
+ message: createAssistantMessage({
8715
+ content: [{
8716
+ type: "text",
8717
+ text: info.text
8718
+ }],
8719
+ source: {
8720
+ provider: info.provider,
8721
+ model: info.model
8722
+ }
8723
+ }),
8724
+ stream: []
8725
+ }, "append");
8726
+ push("step/end", at(stats.completedAt), {
8727
+ turn: 1,
8728
+ step
8729
+ });
8730
+ }
8731
+ push("turn/end", at(stats.completedAt), {
8732
+ turn: 1,
8733
+ reason: { kind: "completed" }
8734
+ });
8735
+ return seed;
8736
+ }
8737
+ /**
8738
+ * 把一次压缩工具循环的完整会话消息组落盘为子会话:以重建时间线的 seed 事件经
8739
+ * ctx.sessions.create 构造子会话(header origin 'subagent'、parentSession 指向主会话、
8740
+ * delegationDepth = 父 + 1、cwd 继承主会话;首事件 one-shot descriptor,provider
8741
+ * om-compaction-log,label 含完整消息区间与阶段;info 存在时尾部追加一条模型文本),flush 持久化,在父会话登记
8742
+ * subagent/catalog,返回子会话 id。成功与失败均调用;落盘自身绝不抛错,任何失败仅
8743
+ * logger.warn 并返回 undefined。
8744
+ */
8745
+ async function recordCompressionSession(ctx, parentSession, options) {
8746
+ const logger = makeLogger(ctx, options.debug);
8747
+ try {
8748
+ const header = parentSession.header;
8749
+ const label = compressionRecordLabel(options.phase, options.range ?? {}, options.success, options.retry === true);
8750
+ const seed = buildCompressionSeed(options.messages, options.stats, label, options.info, options.system);
8751
+ const sessions = ctx.get("sessions");
8752
+ if (sessions === void 0) {
8753
+ logger.warn("sessions 服务未挂载,跳过压缩会话记录落盘");
8754
+ return;
8755
+ }
8756
+ const child = sessions.create(SessionId(`om-compaction-log-${uuid()}`), {
8757
+ seed,
8758
+ meta: {
8759
+ ...header.cwd === void 0 ? {} : { cwd: header.cwd },
8760
+ parentSession: parentSession.id,
8761
+ origin: "subagent",
8762
+ delegationDepth: (header.delegationDepth ?? 0) + 1
8763
+ }
8764
+ });
8765
+ const persistence = ctx.get("sessionPersistence");
8766
+ if (persistence === void 0) throw new Error("宿主未提供 sessionPersistence 服务");
8767
+ const write = await persistence.create(child.header);
8768
+ try {
8769
+ await write.append(child.snapshotEvents());
8770
+ await write.flush();
8771
+ } finally {
8772
+ await write.close();
8773
+ }
8774
+ parentSession.append("subagent/catalog", {
8775
+ version: 0,
8776
+ childId: child.id,
8777
+ childCreatedAt: child.header.createdAt,
8778
+ mode: "one-shot",
8779
+ label
8780
+ });
8781
+ await sessions.flush(parentSession);
8782
+ return child.id;
8783
+ } catch (error) {
8784
+ const message = error instanceof Error ? error.message : String(error);
8785
+ logger.warn(`压缩会话记录子会话落盘失败: ${message}`);
8786
+ return;
8787
+ }
8788
+ }
8789
+ //#endregion
8790
+ //#region src/compress-tools.ts
8791
+ /** 判定 JSON 对象,不接受数组或 null。 */
8792
+ function isJsonRecord(value) {
8793
+ return value !== null && typeof value === "object" && !Array.isArray(value);
8794
+ }
8795
+ /** 合法原始 ask 或已处理的历史 ask;普通失败 toolcall 不包含在内。 */
8796
+ function isAskEntry(entry) {
8797
+ return entry.kind === "assistant" && (entry.ask !== void 0 || entry.toolName === "ask_user_question" && entry.toolArgs === void 0);
8798
+ }
8799
+ /** 压缩会话的工具状态:视图 + 替换记录 + 二次确认标记(skill / ask_user_question)+ 完成标记。 */
8800
+ var CompressionState = class CompressionState {
8801
+ replacements = [];
8802
+ challengedSkills = /* @__PURE__ */ new Set();
8803
+ viewedAsks = /* @__PURE__ */ new Set();
8804
+ undeliveredAsks = /* @__PURE__ */ new Set();
8805
+ rewrittenAsks = /* @__PURE__ */ new Map();
8569
8806
  _completed = false;
8570
8807
  view;
8571
8808
  /**
@@ -8761,6 +8998,11 @@ var CompressionState = class CompressionState {
8761
8998
  text: `${CompressionState.spanLabel(lo, hi)} 超出要求的压缩区间 [${minIndex}..${maxIndex}]`,
8762
8999
  isError: true
8763
9000
  };
9001
+ const archive = this.archiveCheck(lo, hi, content, args.keywords);
9002
+ if (typeof archive === "string") return {
9003
+ text: archive,
9004
+ isError: true
9005
+ };
8764
9006
  let insideCount = 0;
8765
9007
  for (const entry of this.view.entries) {
8766
9008
  if (entry.lo === void 0 || entry.hi === void 0) continue;
@@ -8816,13 +9058,32 @@ var CompressionState = class CompressionState {
8816
9058
  this.replacements.push({
8817
9059
  lo,
8818
9060
  hi,
8819
- content
9061
+ content,
9062
+ ...archive === void 0 ? {} : { keywords: archive }
8820
9063
  });
8821
9064
  return {
8822
9065
  text: `已压缩${CompressionState.spanLabel(lo, hi)}(${insideCount} 条 assistant 条目)`,
8823
9066
  isError: false
8824
9067
  };
8825
9068
  }
9069
+ /**
9070
+ * 归档模式校验:区间须恰为一个归档段,content 为不超过 ARCHIVE_SUMMARY_MAX_CHARS 的单行,
9071
+ * keywords 为 1..ARCHIVE_MAX_KEYWORDS 个非空单行词。非归档模式返回 undefined;
9072
+ * 校验失败返回错误文本,通过返回规整后的关键词。
9073
+ */
9074
+ archiveCheck(lo, hi, content, keywords) {
9075
+ const segments = this.view.segments;
9076
+ if (segments === void 0) return void 0;
9077
+ if (!segments.some((seg) => seg.lo === lo && seg.hi === hi)) return `${CompressionState.spanLabel(lo, hi)} 不是归档段;区间必须恰为一个段:${segments.map((seg) => `[${seg.lo}..${seg.hi}]`).join("、")}`;
9078
+ if (/[\r\n]/.test(content)) return "content 必须是一句话,不能换行";
9079
+ if (content.length > 300) return `content ${content.length} 字符,超过 300 字符上限,请压成一句话`;
9080
+ if (!Array.isArray(keywords) || keywords.length === 0 || keywords.length > 8 || keywords.some((k) => typeof k !== "string" || k.trim() === "" || /[\r\n]/.test(k))) return `keywords 必须是 1..8 个非空单行关键词`;
9081
+ return keywords.map((k) => String(k).trim());
9082
+ }
9083
+ /** 归档模式下尚未被摘要覆盖的段。 */
9084
+ uncoveredSegments() {
9085
+ return (this.view.segments ?? []).filter((seg) => !this.replacements.some((rep) => rep.lo === seg.lo && rep.hi === seg.hi));
9086
+ }
8826
9087
  /** 完全包含该条目的替换记录;替换区间两两不相交,至多一条。 */
8827
9088
  replacementFor(entry) {
8828
9089
  const { lo, hi } = entry;
@@ -8866,7 +9127,8 @@ var CompressionState = class CompressionState {
8866
9127
  kind: "assistant",
8867
9128
  lo: rep.lo,
8868
9129
  hi: rep.hi,
8869
- text: rep.content
9130
+ text: rep.content,
9131
+ ...rep.keywords === void 0 ? {} : { keyWord: rep.keywords.join(", ") }
8870
9132
  },
8871
9133
  blocks: [],
8872
9134
  replacement: rep
@@ -8959,6 +9221,11 @@ var CompressionState = class CompressionState {
8959
9221
  text: `尚未处理原始 ask(index ${pending.join("、")}):请直接压缩,或先查看再调用 rewriteAskUserQuestion 重写后保留`,
8960
9222
  isError: true
8961
9223
  };
9224
+ const uncovered = this.uncoveredSegments();
9225
+ if (uncovered.length > 0) return {
9226
+ text: `尚有归档段未压缩:${uncovered.map((seg) => `[${seg.lo}..${seg.hi}]`).join("、")}。每个段都要用 compressHistory 压成一句话后再完成`,
9227
+ isError: true
9228
+ };
8962
9229
  this._completed = true;
8963
9230
  return {
8964
9231
  text: this.buildFinalBlock(),
@@ -8988,15 +9255,17 @@ var CompressionState = class CompressionState {
8988
9255
  const note = historyFormatNote({
8989
9256
  user: entries.some((e) => e.kind === "user"),
8990
9257
  skill: entries.some((e) => e.kind === "assistant" && e.toolName === "skill"),
8991
- askUserQuestion: entries.some(isAskEntry)
9258
+ askUserQuestion: entries.some(isAskEntry),
9259
+ keyWord: entries.some((e) => e.keyWord !== void 0)
8992
9260
  });
9261
+ if (this.view.segments !== void 0) return `<${ARCHIVED_HISTORY_TAG} tip="${ARCHIVED_HISTORY_TIP}">\n${note}\n${renderEntriesXml(entries)}\n</${ARCHIVED_HISTORY_TAG}>`;
8993
9262
  return `<${HISTORY_TAG} tip="${HISTORY_TIP}">\n${note}\n${renderEntriesXml(entries)}\n</${HISTORY_TAG}>`;
8994
9263
  }
8995
9264
  };
8996
9265
  /** 仅含原始合法 ask 的压缩会话使用的重写工具。 */
8997
9266
  const REWRITE_ASK_TOOL_SCHEMA = {
8998
9267
  name: "rewriteAskUserQuestion",
8999
- description: "重写已用 getHistory 查看且未被 compressHistory 覆盖的原始 ask。按原题序提交全部 q/a,忠实精炼问题与回答,展开选项引用,未回答的题明确写 (未回答)。保留 ask 的产物只含 q/a,不提交 options 或 CDATA 包裹。",
9268
+ description: "重写未被 compressHistory 覆盖的原始 ask。按原题序提交全部 q/a,忠实精炼问题与回答,展开选项引用,未回答的题明确写 (未回答)。保留 ask 的产物只含 q/a,不提交 options 或 CDATA 包裹。",
9000
9269
  parameters: {
9001
9270
  type: "object",
9002
9271
  properties: {
@@ -9080,7 +9349,13 @@ const COMPRESSION_TOOL_SCHEMAS = [
9080
9349
  },
9081
9350
  content: {
9082
9351
  type: "string",
9083
- description: "替换后的摘要文本(纯文本,不要包含 CDATA 包裹,插件自动包裹)"
9352
+ description: [
9353
+ "替换后的摘要文本(纯文本,不要包含 CDATA 包裹,插件自动包裹)。忠实性要求:",
9354
+ "1. 只写本次 index 或 start..end 区间内的条目,区间之后的内容不提前写入。",
9355
+ "2. 数字、错误码、退出码、行号、版本号、事件类型名与文件路径从原文逐字照抄;原文没有或不确定时不写具体值,不推测补全。",
9356
+ "3. 变更日志、文档与注释的表述方向照原文(新增/移除、引入/废弃),不反转;旧记录与现状矛盾时写明出处与矛盾点。",
9357
+ "4. 工具结果为空或仅返回成功时,结合前序条目写明动作对象(哪个文件、哪条命令、哪个会话)。"
9358
+ ].join("\n")
9084
9359
  }
9085
9360
  },
9086
9361
  required: ["content"]
@@ -9095,6 +9370,48 @@ const COMPRESSION_TOOL_SCHEMAS = [
9095
9370
  }
9096
9371
  }
9097
9372
  ];
9373
+ /** 归档模式的工具定义:compressHistory 区间限定为一个归档段并要求 keywords。 */
9374
+ const ARCHIVE_TOOL_SCHEMAS = COMPRESSION_TOOL_SCHEMAS.map((schema) => {
9375
+ if (schema.name === "completeCompression") return {
9376
+ ...schema,
9377
+ description: "全部归档段都已压缩后调用,成功时立即结束压缩会话。"
9378
+ };
9379
+ if (schema.name !== "compressHistory") return schema;
9380
+ return {
9381
+ name: "compressHistory",
9382
+ description: `把一个归档段(start..end 恰为首条消息列出的某个段)压成一句话摘要。content 不换行、不超过 300 字符,写清结论、决策与涉及的文件;keywords 为供 recall 检索原文的关键词。返回成功即已生效;修改时用同一区间重新提交。`,
9383
+ parameters: {
9384
+ type: "object",
9385
+ properties: {
9386
+ start: {
9387
+ type: "number",
9388
+ description: "归档段起始完整消息 index"
9389
+ },
9390
+ end: {
9391
+ type: "number",
9392
+ description: "归档段结束完整消息 index"
9393
+ },
9394
+ content: {
9395
+ type: "string",
9396
+ description: "一句话摘要(纯文本,不换行,不要包含 CDATA 包裹)。数字、路径、版本号与错误码从原文逐字照抄,不推测补全。"
9397
+ },
9398
+ keywords: {
9399
+ type: "array",
9400
+ minItems: 1,
9401
+ maxItems: 8,
9402
+ items: { type: "string" },
9403
+ description: "1.." + String(8) + " 个关键词:文件名、函数名、命令、主题词等原文中出现的词"
9404
+ }
9405
+ },
9406
+ required: [
9407
+ "start",
9408
+ "end",
9409
+ "content",
9410
+ "keywords"
9411
+ ]
9412
+ }
9413
+ };
9414
+ });
9098
9415
  //#endregion
9099
9416
  //#region src/rate-limit.ts
9100
9417
  /**
@@ -9155,14 +9472,16 @@ async function gateRateLimit(waitMs, signal) {
9155
9472
  * 工具驱动的压缩循环:以新会话方式直连 ctx.llm.stream(),模型通过 getHistory /
9156
9473
  * compressHistory / completeCompression 完成压缩,存在原始合法提问时加入重写工具。
9157
9474
  * 导出 runCompressionLoop / buildCompressionPrompt / buildCompressionTaskText /
9158
- * REFLECT_COMPRESSION_PROMPT / ASK_COMPRESSION_PROMPT / CompressionLoopOptions / CompressionOutcome / CompressionStats / COMPRESSION_NUDGE_TEXT / TRUNCATION_NUDGE_TEXT。
9475
+ * REFLECT_COMPRESSION_PROMPT / ASK_COMPRESSION_PROMPT / CompressionLoopOptions / CompressionOutcome / CompressionStats / COMPRESSION_NUDGE_TEXT / TRUNCATION_NUDGE_TEXT / COMPLETION_BLOCKED_TEXT。
9159
9476
  *
9160
- * - 首条 user 消息仅含压缩指令与 start/end 区间(buildCompressionTaskText),不含
9161
- * 历史消息内容;共享压缩提示词作为 system,反思 pass 追加反思合并约束
9477
+ * - 首条 user 消息为压缩指令与 start/end 区间(buildCompressionTaskText),循环附上
9478
+ * 全区间 getHistory 结果,原始提问随之视为已查看;共享压缩提示词作为 system,归档
9479
+ * 视图追加归档深度压缩约束并改用归档工具定义
9162
9480
  * - 每轮请求携带压缩工具 schemas(purpose='compaction',maxTokens 沿用配置);流经
9163
9481
  * BlockAssembler 组装为 assistant 消息,工具执行结果以 tool-result 消息回填
9164
9482
  * - completeCompression 校验通过后立即停止(同轮后续工具调用不再执行),最终 <history>
9165
- * 块由 CompressionState 构建,全程无需整块校验
9483
+ * 块由 CompressionState 构建,全程无需整块校验;同轮有未解决的写入失败时 completeCompression
9484
+ * 不执行并返回 COMPLETION_BLOCKED_TEXT
9166
9485
  * - 模型输出纯文本(无工具调用)时追加提醒消息继续,连续 3 轮仍无工具调用判失败
9167
9486
  * - 输出被 max-tokens 截断且无工具调用时单独计数:该轮 assistant 消息仅落盘、不进入后续
9168
9487
  * 请求,追加截断专用提醒,连续 3 轮截断判失败;任一轮有工具调用则两个计数清零
@@ -9185,17 +9504,12 @@ function buildCompressionPrompt(skipReasoning) {
9185
9504
  "",
9186
9505
  `【完整消息定义】${COMPLETE_MESSAGE_DEFINITION}`,
9187
9506
  "",
9188
- "【工具】",
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 试探;修改已提交的摘要时用相同或更大的区间重新提交。",
9191
- "- completeCompression():全部压缩完成后调用,立即结束。",
9192
- "",
9193
9507
  "【压缩要求】",
9194
- "- 先用 getHistory 查看区间内容,再划分模块分批压缩;用户消息不可压缩、保持原样,无需处理。",
9508
+ "- 区间条目已附在首条消息中,直接划分模块压缩;只在需要查看本次已压缩结果时调用 getHistory。用户消息不可压缩、保持原样,无需处理。",
9195
9509
  ...skipReasoning ? [] : ["- <reasoning> 仅作压缩参考,不进产物。"],
9196
- "- 将具有关联性的 assistant 消息按内在逻辑连贯性划分为连续模块,聚合为区间压缩(start..end)",
9197
- "- 单条重要的完整消息以 index 单独压缩",
9198
- "- 压缩后的 assistant 消息内,应当描述**行为逻辑**,强调关键的**结论、产出和任务**;涉及到的具体文件保留完整路径",
9510
+ "- 将关联的 assistant 消息按内在逻辑划分为连续模块,用 start..end 聚合压缩;单条重要的完整消息以 index 单独压缩。",
9511
+ "- content 的忠实性要求见 compressHistory 参数说明,提交前逐条核对。",
9512
+ "- 摘要描述**行为逻辑**,强调关键的**结论、产出和任务**;涉及的文件保留完整路径。",
9199
9513
  "- 摘要粒度按后续用途分配,与消息位置无关:",
9200
9514
  " - 未完成的任务、当前状态、待办与未解决的问题保留细节;涉及的文件写明最新状态。",
9201
9515
  " - 已完成的子任务只保留结果、决策及理由、排除的方案及原因。",
@@ -9203,28 +9517,42 @@ function buildCompressionPrompt(skipReasoning) {
9203
9517
  " - 可以低成本重新获取的内容(文件内容、命令输出、搜索结果)只记来源与要点。",
9204
9518
  "- <history> 条目正文以 CDATA 包裹,CDATA 内为逐字原样内容。",
9205
9519
  "- 工具调用条目为 <assistant index=\"N\" type=\"toolcall\" tool-name=\"…\">,内含 <tool-args>(调用参数 JSON)与 <tool-result>(工具返回内容)两个 CDATA 子元素。",
9206
- "- 加载的 skill 以 <skill_content name=\"…\" index=\"N\"> 条目呈现,内含 <skill_resources> 与 <skill_instructions> 两段,内文为加载的 skill 内容,属于关键信息。仅在你明确判断该 skill 与后续任务无关时,压缩它;如果该 skill 与后续任务相关,或者你无法判断,不要压缩,**保持原文**。",
9520
+ "- 加载的 skill 以 <skill_content name=\"…\" index=\"N\"> 条目呈现,内含 <skill_resources> 与 <skill_instructions> 两段,属于关键信息。仅在明确判断与后续任务无关时压缩;相关或无法判断时**保持原文**。",
9207
9521
  "- 已有 <history> 块中的 ask_user_question 以 <ask-user-question index=\"N\"> 呈现,CDATA 内为逐题成对的 q:(问题文本)与 a:(用户回答)行,未作答的题记为 a:(未回答)。这些提问已经处理;仅在明确判断与后续任务无关时压缩,否则保持原样。原始提问按本会话的专用处理规则执行。",
9208
9522
  "- 除原始提问外,未压缩的条目将原样保留;宁可保留也不要强行压缩不确定的内容。",
9209
- "- 全部完成后调用 completeCompression 结束;不要输出与工具调用无关的文本。"
9523
+ "",
9524
+ "【提交】",
9525
+ "- 首轮即在同一轮内调用全部 compressHistory,并在该轮最后调用 completeCompression;compressHistory 返回成功即已生效,无需查看验证。",
9526
+ "- 思考只做模块划分与取舍判断,摘要正文直接写进工具参数,不要在思考中起草。",
9527
+ "- 不要输出与工具调用无关的文本。"
9210
9528
  ].join("\n");
9211
9529
  }
9212
9530
  /**
9213
- * 构建压缩会话首条 user 消息文本(压缩指令 + start/end 区间,不含历史消息内容)。
9531
+ * 构建压缩会话首条 user 消息的指令部分(压缩指令 + start/end 区间);区间条目由循环附加。
9214
9532
  */
9215
- function buildCompressionTaskText(phase, start, end) {
9216
- if (phase === "reflect") return `合并压缩全部 <history> 块,完整消息区间 [${start}..${end}]:用 getHistory 查看已有块条目,用 compressHistory 重新压缩合并 assistant 条目,完成后调用 completeCompression。`;
9217
- return `压缩完整消息区间 [${start}..${end}]:用 getHistory 查看条目,用 compressHistory 分批压缩 assistant 条目,完成后调用 completeCompression。`;
9218
- }
9219
- /** 反思合并的额外约束,只在反思 pass 注入。 */
9220
- const REFLECT_COMPRESSION_PROMPT = ["【反思合并】", "- 重新压缩已有摘要条目时,保留其中的不可再生信息,不要逐轮缩减。"].join("\n");
9533
+ function buildCompressionTaskText(phase, start, end, segments = []) {
9534
+ if (phase === "reflect") {
9535
+ const list = segments.map((seg) => `[${seg.lo}..${seg.hi}]`).join("、");
9536
+ return `归档深度压缩 <history> 块,完整消息区间 [${start}..${end}]:区间条目附在下方。归档段共 ${segments.length} 个:${list}。每个段用一次 compressHistory 压成一句话并给出 keywords,全部完成后调用 completeCompression。`;
9537
+ }
9538
+ return `压缩完整消息区间 [${start}..${end}]:区间条目附在下方,用 compressHistory 压缩 assistant 条目,完成后调用 completeCompression。`;
9539
+ }
9540
+ /** 归档深度压缩的额外约束,只在归档视图注入。 */
9541
+ const REFLECT_COMPRESSION_PROMPT = [
9542
+ "【归档深度压缩】",
9543
+ "- 本次产物是归档块,原文可由主模型通过 recall 按 index 找回;此规则优先于上方的粒度要求。",
9544
+ "- 用户消息与已处理的提问原样保留,无需处理。",
9545
+ "- 相邻两条用户消息之间的全部 assistant 条目构成一个归档段,每段压成一句话:写清结论、决策与涉及的文件,不写过程。",
9546
+ "- 一句话不超过 300 字符、不换行;已被段内后续进展取代的信息直接舍弃。",
9547
+ "- keywords 选原文中出现、便于检索的词:文件名、函数名、命令、错误码、主题词。"
9548
+ ].join("\n");
9221
9549
  /** 原始合法 ask 的处理约束,只在视图含待处理原始提问时注入。 */
9222
9550
  const ASK_COMPRESSION_PROMPT = [
9223
9551
  "【原始提问处理】",
9224
- "- 原始合法 ask_user_question 在 getHistory 中以 <ask-user-question index=\"N\"> 展示,每题为 q:问题、o1:选项一、o2:选项二等及 a:回答;选项包含 label 与 description,无选项题省略 oN 行。",
9552
+ "- 原始合法 ask_user_question 以 <ask-user-question index=\"N\"> 展示,每题为 q:问题、o1:选项一、o2:选项二等及 a:回答;选项包含 label 与 description,无选项题省略 oN 行。",
9225
9553
  "- 每个原始提问必须二选一:直接用 compressHistory 压成普通 assistant 摘要;或者保留 ask 标签并用 rewriteAskUserQuestion 重写 q/a。不能原样跳过。",
9226
9554
  "- 直接压缩:仅在明确判断该提问与后续任务无关时执行;首次覆盖会被阻止一次,重新思考后再次调用才执行。不确定或相关时走保留重写路径。",
9227
- "- 保留重写:先用 getHistory 查看该提问及全部选项,收到返回结果后的下一轮再调用 rewriteAskUserQuestion({index, qa:[{ordinal:1,q:\"问题\",a:\"回答\"},...]}),不要与查看同轮提交;ordinal 从 1 开始,按原题序提交全部题,不增删、不重复。",
9555
+ "- 保留重写:首条消息已含该提问及全部选项,直接调用 rewriteAskUserQuestion({index, qa:[{ordinal:1,q:\"问题\",a:\"回答\"},...]});ordinal 从 1 开始,按原题序提交全部题,不增删、不重复。",
9228
9556
  "- q/a 均可忠实精炼,保留语境与用户真实意图。将回答中对选项的编号、标签等引用展开为自足表述;产物仅有 q:/a:,不能保留 oN 选项列表或 options 字段。",
9229
9557
  "- 空答案明确为 (未回答),不得补造用户决定。仅提交纯文本 q/a,不自行拼接 XML 或 CDATA 包裹。",
9230
9558
  "- 允许切换路径;最终成功的直接压缩覆盖优先,已覆盖的 ask 不能再次重写。history 块中的 ask 已处理,不需重写。",
@@ -9234,6 +9562,22 @@ const ASK_COMPRESSION_PROMPT = [
9234
9562
  const COMPRESSION_NUDGE_TEXT = "请通过工具执行压缩:用 getHistory 查看区间条目,用 compressHistory 压缩 assistant 条目,完成后调用 completeCompression。不要输出与工具调用无关的文本。";
9235
9563
  /** 输出被 max-tokens 截断且无工具调用时追加的提醒消息文本。 */
9236
9564
  const TRUNCATION_NUDGE_TEXT = "上一轮输出因长度上限被截断,其中的工具调用未被接收。请缩短思考,直接分批调用 compressHistory(每次覆盖较小区间),最后调用 completeCompression。";
9565
+ /** 同轮有未解决的写入失败时 completeCompression 返回的错误文本。 */
9566
+ const COMPLETION_BLOCKED_TEXT = "本轮有失败的 compressHistory 或 rewriteAskUserQuestion 未在同轮重新提交成功,未执行 completeCompression。请按错误修正后重新提交,再调用 completeCompression。";
9567
+ /** 写入类调用的目标键(压缩区间或重写的 ask index);非写入调用或参数无法解析返回 undefined。 */
9568
+ function writeTargetOf(name, rawArgs) {
9569
+ if (name !== "compressHistory" && name !== "rewriteAskUserQuestion") return void 0;
9570
+ let args;
9571
+ try {
9572
+ args = JSON.parse(rawArgs);
9573
+ } catch {
9574
+ return `${name}:invalid`;
9575
+ }
9576
+ if (name === "rewriteAskUserQuestion") return `ask:${String(args.index)}`;
9577
+ const lo = args.start ?? args.index;
9578
+ const hi = args.end ?? args.index;
9579
+ return `range:${String(lo)}..${String(hi)}`;
9580
+ }
9237
9581
  /** 连续无工具调用、连续截断各自允许的最大轮数。 */
9238
9582
  const MAX_CONSECUTIVE_FAILURES = 3;
9239
9583
  /** 瞬时请求错误的连续最大重试次数。 */
@@ -9301,6 +9645,15 @@ function isTransientFailure(message, status) {
9301
9645
  if (status !== void 0) return status >= 500 && status <= 599;
9302
9646
  return /\b5\d{2}\b|econnreset|etimedout|econnrefused|epipe|socket hang up|fetch failed|network|overloaded|timed? ?out/i.test(message);
9303
9647
  }
9648
+ /**
9649
+ * 首条 user 消息:指令后附全区间 getHistory 结果,原始提问在首轮请求前标记为已查看。
9650
+ * 视图无可定位条目时只返回指令。
9651
+ */
9652
+ function withInitialHistory(taskText, state) {
9653
+ const history = state.getHistory({});
9654
+ if (history.isError) return taskText;
9655
+ return `${taskText}\n\n${INITIAL_HISTORY_HEADER}\n${history.text}`;
9656
+ }
9304
9657
  /** skipReasoning=true 时去掉视图中的 reasoning 条目(兑现 getHistory 不输出 reasoning 的契约);否则原样返回。 */
9305
9658
  function withoutReasoning(view, skipReasoning) {
9306
9659
  if (!skipReasoning) return view;
@@ -9317,13 +9670,14 @@ async function runCompressionLoop(ctx, session, options) {
9317
9670
  const logger = makeLogger(ctx, options.debug);
9318
9671
  const view = withoutReasoning(options.view, options.skipReasoning);
9319
9672
  const state = new CompressionState(view);
9320
- const tools = state.hasPendingAsks ? [...COMPRESSION_TOOL_SCHEMAS, REWRITE_ASK_TOOL_SCHEMA] : COMPRESSION_TOOL_SCHEMAS;
9673
+ const baseTools = view.segments === void 0 ? COMPRESSION_TOOL_SCHEMAS : ARCHIVE_TOOL_SCHEMAS;
9674
+ const tools = state.hasPendingAsks ? [...baseTools, REWRITE_ASK_TOOL_SCHEMA] : baseTools;
9321
9675
  const system = [
9322
9676
  buildCompressionPrompt(options.skipReasoning),
9323
- ...options.phase === "reflect" ? [REFLECT_COMPRESSION_PROMPT] : [],
9677
+ ...view.segments === void 0 ? [] : [REFLECT_COMPRESSION_PROMPT],
9324
9678
  ...state.hasPendingAsks ? [ASK_COMPRESSION_PROMPT] : []
9325
9679
  ].join("\n\n");
9326
- const messages = [makePluginUserMessage(options.taskText)];
9680
+ const messages = [makePluginUserMessage(withInitialHistory(options.taskText, state))];
9327
9681
  let rounds = 0;
9328
9682
  let nudges = 0;
9329
9683
  let truncations = 0;
@@ -9432,265 +9786,104 @@ async function runCompressionLoop(ctx, session, options) {
9432
9786
  lastOutputTokens = assembler.usage?.outputTokens;
9433
9787
  if (finish.kind === "aborted") {
9434
9788
  logger.warn("压缩循环中止(流以 aborted 结束),放弃本次压缩");
9435
- return await failWith(COMPACTION_ABORTED_ERROR, true);
9436
- }
9437
- if (finish.kind === "error") {
9438
- const failureMessage = typeof finish.failure?.message === "string" && finish.failure.message !== "" ? finish.failure.message : "流以 error 终态结束(无失败详情)";
9439
- const failureStatus = typeof finish.failure?.status === "number" ? finish.failure.status : void 0;
9440
- if (isRateLimitFailure(failureMessage, failureStatus)) {
9441
- noteRateLimit();
9442
- logger.warn(`压缩循环触发限流(429),等待 ${options.rateLimitWaitMs}ms 后重试`);
9443
- continue;
9444
- }
9445
- if (retryTransient(failureMessage, failureStatus)) continue;
9446
- logger.warn(`压缩循环请求失败: ${failureMessage}`);
9447
- pushPartialAssistant(assembler, messages, options.target);
9448
- return await failWith(failureMessage, false);
9449
- }
9450
- transientRetries = 0;
9451
- rounds += 1;
9452
- if (assembler.usage !== void 0) usage = addUsage(usage, assembler.usage);
9453
- roundStats.push({
9454
- round: rounds,
9455
- startedAt: roundStartedAt,
9456
- durationMs: Date.now() - roundStartedAt,
9457
- ...assembler.usage === void 0 ? {} : { usage: assembler.usage }
9458
- });
9459
- const assistantMessage = assembler.message({
9460
- provider: options.target.provider,
9461
- model: options.target.model
9462
- });
9463
- messages.push(assistantMessage);
9464
- const calls = assembler.blocks().filter((block) => block.type === "tool-call");
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
- }
9478
- nudges += 1;
9479
- if (nudges >= MAX_CONSECUTIVE_FAILURES) {
9480
- const error = `模型连续 ${MAX_CONSECUTIVE_FAILURES} 轮未调用压缩工具,放弃本次压缩`;
9481
- logger.warn(error);
9482
- return await failWith(error, false);
9483
- }
9484
- logger.warn("模型未调用压缩工具(输出纯文本),追加提醒后继续");
9485
- messages.push(makePluginUserMessage(COMPRESSION_NUDGE_TEXT));
9486
- continue;
9487
- }
9488
- nudges = 0;
9489
- truncations = 0;
9490
- for (const call of calls) {
9491
- messages.push(toolResultOf(call, state.executeCall(call.name, call.arguments)));
9492
- if (state.completed) break;
9493
- }
9494
- if (state.completed) {
9495
- if (options.signal?.aborted) return await failWith(COMPACTION_ABORTED_ERROR, true);
9496
- const text = state.buildFinalBlock();
9497
- if (state.replacementCount === 0 && state.rewriteCount === 0) logger.warn("压缩完成但未执行任何压缩替换(空提交)");
9498
- logger.info(`压缩循环完成(${rounds} 轮,${state.replacementCount} 次压缩替换,${state.rewriteCount} 条提问重写,输出 ${text.length} 字符)`);
9499
- const stats = buildStats();
9500
- const id = await recordSessionId(true, stats, text.length);
9501
- return {
9502
- ok: true,
9503
- text,
9504
- rounds,
9505
- stats,
9506
- ...usage === void 0 ? {} : { usage },
9507
- ...id === void 0 ? {} : { recordSessionId: id }
9508
- };
9509
- }
9510
- }
9511
- }
9512
- //#endregion
9513
- //#region src/om-event.ts
9514
- /** om 信封 text 前缀:标识该 feedback/record 记录由本插件写入。 */
9515
- const OM_EVENT_PREFIX = "om:1:";
9516
- /**
9517
- * 解码一条会话事件为 om 私有事件:仅识别 feedback/record 中带 om 信封前缀的
9518
- * text;前缀缺失、JSON 非法、kind 未知或载荷字段缺失时返回 undefined。
9519
- */
9520
- function readOmEvent(event) {
9521
- if (event === void 0 || event === null || event.type !== "feedback/record") return void 0;
9522
- const text = event.data.text;
9523
- if (typeof text !== "string" || !text.startsWith("om:1:")) return void 0;
9524
- let envelope;
9525
- try {
9526
- envelope = JSON.parse(text.slice(5));
9527
- } catch {
9528
- return;
9529
- }
9530
- if (envelope === null || typeof envelope !== "object" || Array.isArray(envelope)) return void 0;
9531
- const { kind, ...rest } = envelope;
9532
- switch (kind) {
9533
- case "om/warning": {
9534
- const { problem, message } = rest;
9535
- if (typeof problem !== "string" || typeof message !== "string") return void 0;
9536
- return {
9537
- kind,
9538
- data: {
9539
- problem,
9540
- message
9541
- },
9542
- seq: event.seq
9543
- };
9544
- }
9545
- case "om/observe-pending": {
9546
- const { triggerMessageIndex } = rest;
9547
- if (typeof triggerMessageIndex !== "number" || !Number.isSafeInteger(triggerMessageIndex)) return void 0;
9548
- return {
9549
- kind,
9550
- data: { triggerMessageIndex },
9551
- seq: event.seq
9552
- };
9553
- }
9554
- case "om/observe-invalidate": {
9555
- const { pendingSeq } = rest;
9556
- if (typeof pendingSeq !== "number" || !Number.isSafeInteger(pendingSeq)) return void 0;
9557
- return {
9558
- kind,
9559
- data: { pendingSeq },
9560
- seq: event.seq
9561
- };
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
- }
9590
- default: return;
9591
- }
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
- }
9621
- /** 编码一条 om 私有事件为 feedback/record 的 text 信封。 */
9622
- function encodeOmEvent(kind, data) {
9623
- return `${OM_EVENT_PREFIX}${JSON.stringify({
9624
- kind,
9625
- ...data
9626
- })}`;
9627
- }
9628
- /** 追加一条 om 私有事件(借用 feedback/record,log-only,不进 surface),返回事件 seq。 */
9629
- function appendOmEvent(session, kind, data) {
9630
- return session.append("feedback/record", { text: encodeOmEvent(kind, data) }).seq;
9631
- }
9632
- function findOmEvents(session, kind) {
9633
- const result = [];
9634
- for (const event of session.snapshotEvents()) {
9635
- const om = readOmEvent(event);
9636
- if (om !== void 0 && (kind === void 0 || om.kind === kind)) result.push(om);
9637
- }
9638
- return result;
9639
- }
9640
- //#endregion
9641
- //#region src/degrade.ts
9642
- /**
9643
- * 降级报告:压缩流程中的挂载失败统一出口。
9644
- * 导出 reportDegrade / DEGRADE_PROBLEMS / DegradedProblem。
9645
- *
9646
- * - 挂载失败类问题(服务缺失、服务调用异常)始终 console.warn 到宿主进程外部输出,
9647
- * 并向会话日志追加 log-only 的 om 警告事件(借用 feedback/record 的 om 信封,
9648
- * 见 om-event.ts;客户端渲染为「功能降级」警告行);
9649
- * 同一会话同一问题只报告一次(按日志扫描去重,重启不重复)
9650
- * - 报告动作自身绝不抛错:追加失败只记日志,不阻塞压缩
9651
- * - 辅助函数的普通运行时报错(组装失败、请求头读取失败)不走本模块,仅记日志
9652
- */
9653
- /** 各降级问题面向用户的简短说明(om/warning 信封载荷 message;客户端警告行直接展示)。 */
9654
- const DEGRADE_PROBLEMS = {
9655
- "systemPrompt-missing": "系统提示词服务未挂载,上下文压力估算不扣除系统提示词 tokens(压缩触发会偏早)",
9656
- "tokenMeter-unavailable": "token 计量服务异常,上下文压力估算降级(可能跳过压缩或按 0 计)",
9657
- "reasoning-effort-unavailable": "配置的压缩思考等级不被压缩目标模型支持,压缩降级为模型默认思考等级"
9658
- };
9659
- /**
9660
- * 报告一次挂载失败类降级:console.warn 始终输出到宿主进程外部;同会话同问题首次
9661
- * 出现时,向会话日志追加 log-only om 警告事件(客户端渲染警告行,每会话最多
9662
- * 一次)并输出 logger.warn(避免每个 pre-step 重复刷日志)。
9663
- * 日志扫描/事件追加失败只记日志,绝不抛错、不阻塞压缩。
9664
- */
9665
- function reportDegrade(session, logger, problem) {
9666
- const message = DEGRADE_PROBLEMS[problem];
9667
- let first = true;
9668
- try {
9669
- first = !findOmEvents(session, "om/warning").some((om) => om.data.problem === problem);
9670
- } catch {}
9671
- if (!first) return;
9672
- console.warn(`${PLUGIN_LABEL}: ${message}`);
9673
- logger.warn(message);
9674
- try {
9675
- appendOmEvent(session, "om/warning", {
9676
- problem,
9677
- message
9789
+ return await failWith(COMPACTION_ABORTED_ERROR, true);
9790
+ }
9791
+ if (finish.kind === "error") {
9792
+ const failureMessage = typeof finish.failure?.message === "string" && finish.failure.message !== "" ? finish.failure.message : "流以 error 终态结束(无失败详情)";
9793
+ const failureStatus = typeof finish.failure?.status === "number" ? finish.failure.status : void 0;
9794
+ if (isRateLimitFailure(failureMessage, failureStatus)) {
9795
+ noteRateLimit();
9796
+ logger.warn(`压缩循环触发限流(429),等待 ${options.rateLimitWaitMs}ms 后重试`);
9797
+ continue;
9798
+ }
9799
+ if (retryTransient(failureMessage, failureStatus)) continue;
9800
+ logger.warn(`压缩循环请求失败: ${failureMessage}`);
9801
+ pushPartialAssistant(assembler, messages, options.target);
9802
+ return await failWith(failureMessage, false);
9803
+ }
9804
+ transientRetries = 0;
9805
+ rounds += 1;
9806
+ if (assembler.usage !== void 0) usage = addUsage(usage, assembler.usage);
9807
+ roundStats.push({
9808
+ round: rounds,
9809
+ startedAt: roundStartedAt,
9810
+ durationMs: Date.now() - roundStartedAt,
9811
+ ...assembler.usage === void 0 ? {} : { usage: assembler.usage }
9678
9812
  });
9679
- } catch (error) {
9680
- const text = error instanceof Error ? error.message : String(error);
9681
- logger.warn(`om 警告事件追加失败: ${text}`);
9813
+ const assistantMessage = assembler.message({
9814
+ provider: options.target.provider,
9815
+ model: options.target.model
9816
+ });
9817
+ messages.push(assistantMessage);
9818
+ const calls = assembler.blocks().filter((block) => block.type === "tool-call");
9819
+ if (calls.length === 0) {
9820
+ if (finish.kind === "max-tokens") {
9821
+ truncations += 1;
9822
+ if (truncations >= MAX_CONSECUTIVE_FAILURES) {
9823
+ const error = `模型连续 ${MAX_CONSECUTIVE_FAILURES} 轮输出被 max-tokens 截断,放弃本次压缩`;
9824
+ logger.warn(error);
9825
+ return await failWith(error, false);
9826
+ }
9827
+ logger.warn("模型输出被 max-tokens 截断且无工具调用,丢弃该轮输出并追加提醒后继续");
9828
+ omitted.add(assistantMessage);
9829
+ messages.push(makePluginUserMessage(TRUNCATION_NUDGE_TEXT));
9830
+ continue;
9831
+ }
9832
+ nudges += 1;
9833
+ if (nudges >= MAX_CONSECUTIVE_FAILURES) {
9834
+ const error = `模型连续 ${MAX_CONSECUTIVE_FAILURES} 轮未调用压缩工具,放弃本次压缩`;
9835
+ logger.warn(error);
9836
+ return await failWith(error, false);
9837
+ }
9838
+ logger.warn("模型未调用压缩工具(输出纯文本),追加提醒后继续");
9839
+ messages.push(makePluginUserMessage(COMPRESSION_NUDGE_TEXT));
9840
+ continue;
9841
+ }
9842
+ nudges = 0;
9843
+ truncations = 0;
9844
+ /** 本轮失败且未被同轮后续成功提交解决的写入目标。 */
9845
+ const unresolved = /* @__PURE__ */ new Set();
9846
+ for (const call of calls) {
9847
+ const result = call.name === "completeCompression" && unresolved.size > 0 ? {
9848
+ text: COMPLETION_BLOCKED_TEXT,
9849
+ isError: true
9850
+ } : state.executeCall(call.name, call.arguments);
9851
+ const target = writeTargetOf(call.name, call.arguments);
9852
+ if (target !== void 0) {
9853
+ if (result.isError) unresolved.add(target);
9854
+ else unresolved.delete(target);
9855
+ }
9856
+ messages.push(toolResultOf(call, result));
9857
+ if (state.completed) break;
9858
+ }
9859
+ if (state.completed) {
9860
+ if (options.signal?.aborted) return await failWith(COMPACTION_ABORTED_ERROR, true);
9861
+ const text = state.buildFinalBlock();
9862
+ if (state.replacementCount === 0 && state.rewriteCount === 0) logger.warn("压缩完成但未执行任何压缩替换(空提交)");
9863
+ logger.info(`压缩循环完成(${rounds} 轮,${state.replacementCount} 次压缩替换,${state.rewriteCount} 条提问重写,输出 ${text.length} 字符)`);
9864
+ const stats = buildStats();
9865
+ const id = await recordSessionId(true, stats, text.length);
9866
+ return {
9867
+ ok: true,
9868
+ text,
9869
+ rounds,
9870
+ stats,
9871
+ ...usage === void 0 ? {} : { usage },
9872
+ ...id === void 0 ? {} : { recordSessionId: id }
9873
+ };
9874
+ }
9682
9875
  }
9683
9876
  }
9684
9877
  //#endregion
9685
9878
  //#region src/precompress.ts
9686
9879
  /** 进程内注册表:session.id → 任务(重启即清空,由对账阶段恢复)。 */
9687
- const jobs = /* @__PURE__ */ new Map();
9880
+ const jobs$1 = /* @__PURE__ */ new Map();
9688
9881
  /**
9689
9882
  * 查询与活跃待定标记匹配的任务:pendingSeq 或会话对象不一致视为过期,
9690
9883
  * 中止并移除后返回 undefined(过期任务的信封写入落在已脱钩对象上,无保留价值)。
9691
9884
  */
9692
9885
  function findPrecompressionJob(session, pendingSeq) {
9693
- const job = jobs.get(session.id);
9886
+ const job = jobs$1.get(session.id);
9694
9887
  if (job === void 0) return void 0;
9695
9888
  if (job.session === session && job.pendingSeq === pendingSeq) return job;
9696
9889
  disposePrecompression(session.id);
@@ -9702,7 +9895,7 @@ function findPrecompressionJob(session, pendingSeq) {
9702
9895
  function startPrecompression(options) {
9703
9896
  const { ctx, session, config, pendingSeq, triggerMessageIndex } = options;
9704
9897
  const logger = makeLogger(ctx, config.debug);
9705
- const existing = jobs.get(session.id);
9898
+ const existing = jobs$1.get(session.id);
9706
9899
  if (existing !== void 0) {
9707
9900
  if (existing.session === session && existing.pendingSeq === pendingSeq) return {
9708
9901
  ok: true,
@@ -9738,7 +9931,7 @@ function startPrecompression(options) {
9738
9931
  promise,
9739
9932
  state: "running"
9740
9933
  };
9741
- jobs.set(session.id, job);
9934
+ jobs$1.set(session.id, job);
9742
9935
  runJobBody(ctx, job, options, logger).then(settle, settle);
9743
9936
  logger.step(`预压缩:任务启动(pendingSeq ${pendingSeq},区间 [${prepare.prepared.range.start}..${prepare.prepared.range.end}],遮蔽 ${prepare.prepared.replaceSeqs.length} 个表层节点)`);
9744
9937
  return {
@@ -9840,30 +10033,159 @@ function adoptPersistedSummary(data) {
9840
10033
  }
9841
10034
  /** 中止并移除会话的后台任务(session/disposed 或过期清理)。 */
9842
10035
  function disposePrecompression(sessionId) {
9843
- const job = jobs.get(sessionId);
10036
+ const job = jobs$1.get(sessionId);
9844
10037
  if (job === void 0) return;
9845
- jobs.delete(sessionId);
10038
+ jobs$1.delete(sessionId);
9846
10039
  job.controller.abort();
9847
10040
  }
9848
10041
  /** 中止并移除全部后台任务(插件卸载)。 */
9849
10042
  function disposeAllPrecompressions() {
9850
- for (const sessionId of [...jobs.keys()]) disposePrecompression(sessionId);
10043
+ for (const sessionId of [...jobs$1.keys()]) disposePrecompression(sessionId);
10044
+ }
10045
+ //#endregion
10046
+ //#region src/reflect.ts
10047
+ /** session.id → 任务。 */
10048
+ const jobs = /* @__PURE__ */ new Map();
10049
+ /** session.id → 最近一次非中止失败时的 history 块集合键。 */
10050
+ const failedKeys = /* @__PURE__ */ new Map();
10051
+ /** history 块集合键:按 seq 拼接。 */
10052
+ function historyBlocksKey(blocks) {
10053
+ return blocks.map((block) => block.seq).join(",");
10054
+ }
10055
+ /**
10056
+ * 选择归档块:从最后一个块往前累加 token,合计不超过 keepBudget 的尾部块保留,
10057
+ * 至少保留 1 个;其余全部归档。tokensOf 返回单块 token。
10058
+ */
10059
+ function selectArchiveBlocks(blocks, tokensOf, keepBudget) {
10060
+ let keepFrom = blocks.length;
10061
+ let total = 0;
10062
+ for (let i = blocks.length - 1; i >= 0; i -= 1) {
10063
+ const block = blocks[i];
10064
+ const next = total + tokensOf(block);
10065
+ if (keepFrom < blocks.length && next > keepBudget) break;
10066
+ total = next;
10067
+ keepFrom = i;
10068
+ }
10069
+ return {
10070
+ archived: blocks.slice(0, keepFrom),
10071
+ kept: blocks.slice(keepFrom)
10072
+ };
10073
+ }
10074
+ /** 查询会话当前任务。 */
10075
+ function peekReflectJob(sessionId) {
10076
+ return jobs.get(sessionId);
10077
+ }
10078
+ /** 取出会话当前任务并从注册表移除(提交或丢弃前调用)。 */
10079
+ function takeReflectJob(sessionId) {
10080
+ const job = jobs.get(sessionId);
10081
+ jobs.delete(sessionId);
10082
+ return job;
10083
+ }
10084
+ /** 最近一次非中止失败时的 history 块集合键。 */
10085
+ function reflectFailedKey(sessionId) {
10086
+ return failedKeys.get(sessionId);
10087
+ }
10088
+ /** 启动后台反思;调用方保证同会话无运行中任务。 */
10089
+ function startReflection(options) {
10090
+ const { ctx, session, config, target, reasoningEffort } = options;
10091
+ const logger = makeLogger(ctx, config.debug);
10092
+ const controller = new AbortController();
10093
+ let settle;
10094
+ const promise = new Promise((resolve) => {
10095
+ settle = resolve;
10096
+ });
10097
+ const job = {
10098
+ session,
10099
+ key: options.key,
10100
+ archived: options.archived,
10101
+ view: options.view,
10102
+ skills: options.skills,
10103
+ estimatedTokens: options.estimatedTokens,
10104
+ shadowedCharCount: options.shadowedCharCount,
10105
+ target,
10106
+ ...reasoningEffort === void 0 ? {} : { reasoningEffort },
10107
+ controller,
10108
+ promise,
10109
+ state: "running"
10110
+ };
10111
+ jobs.set(session.id, job);
10112
+ failedKeys.delete(session.id);
10113
+ runJobBody(ctx, job, config).then(settle, settle);
10114
+ return job;
10115
+ async function runJobBody(context, current, cfg) {
10116
+ const { view } = current;
10117
+ try {
10118
+ const outcome = await runCompressionLoop(context, current.session, {
10119
+ view,
10120
+ originalChars: current.shadowedCharCount,
10121
+ phase: "reflect",
10122
+ taskText: buildCompressionTaskText("reflect", view.minIndex ?? 0, view.maxIndex ?? 0, view.segments),
10123
+ target: current.target,
10124
+ maxTokens: cfg.compressMaxTokens,
10125
+ rateLimitWaitMs: cfg.rateLimitWaitMs,
10126
+ skipReasoning: cfg.compressSkipReasoning,
10127
+ debug: cfg.debug,
10128
+ ...current.reasoningEffort === void 0 ? {} : { reasoningEffort: current.reasoningEffort },
10129
+ signal: current.controller.signal
10130
+ });
10131
+ if (outcome.ok) {
10132
+ current.state = "done";
10133
+ current.result = outcome;
10134
+ logger.info(`反思完成(${outcome.stats.durationMs}ms),等待下一个 pre-step 提交`);
10135
+ return;
10136
+ }
10137
+ fail(current, {
10138
+ error: outcome.error,
10139
+ aborted: outcome.aborted,
10140
+ ...outcome.recordSessionId === void 0 ? {} : { diagnosticSessionId: outcome.recordSessionId }
10141
+ });
10142
+ logger.info(`反思失败: ${outcome.error}`);
10143
+ } catch (error) {
10144
+ const message = error instanceof Error ? error.message : String(error);
10145
+ fail(current, {
10146
+ error: message,
10147
+ aborted: current.controller.signal.aborted
10148
+ });
10149
+ logger.warn(`反思任务异常: ${message}`);
10150
+ }
10151
+ }
10152
+ }
10153
+ /** 登记失败;非中止失败记录集合键,阻止同一块集合重试。 */
10154
+ function fail(job, failure) {
10155
+ job.state = "failed";
10156
+ job.failure = failure;
10157
+ if (!failure.aborted && jobs.get(job.session.id) === job) failedKeys.set(job.session.id, job.key);
10158
+ }
10159
+ /** 中止并移除会话的反思任务,清除失败记录。 */
10160
+ function disposeReflection(sessionId) {
10161
+ failedKeys.delete(sessionId);
10162
+ const job = jobs.get(sessionId);
10163
+ if (job === void 0) return;
10164
+ jobs.delete(sessionId);
10165
+ job.controller.abort();
10166
+ }
10167
+ /** 中止并移除全部反思任务(插件卸载)。 */
10168
+ function disposeAllReflections() {
10169
+ for (const sessionId of [...jobs.keys()]) disposeReflection(sessionId);
10170
+ failedKeys.clear();
9851
10171
  }
9852
10172
  //#endregion
9853
10173
  //#region src/compress.ts
9854
10174
  /**
9855
10175
  * 两级自动压缩(观察/反思)与 compaction 生命周期提交。
9856
10176
  * 导出 estimateTextTokens / isPairBalancedAfter / computeCompressRange / historySection /
9857
- * historyTextOf / findObservePending / prepareObserveCompression / commitObserveCompression /
9858
- * reflectPass / observePass / maybeCompress。
10177
+ * historyTextOf / archivedHistoryTextOf / findObservePending / prepareObserveCompression / commitObserveCompression /
10178
+ * reflectPass / commitReflection / observePass / maybeCompress。
9859
10179
  *
9860
10180
  * - 摘要生成走工具驱动的压缩循环(compress-loop.ts runCompressionLoop):首条 user
9861
10181
  * 消息仅含压缩指令与 start/end 区间,模型经 getHistory / compressHistory /
9862
10182
  * completeCompression 工具完成压缩;最终 <history> 块由插件从视图与替换记录构建,
9863
10183
  * 全程无需整块校验
9864
- * - 反思:全部 <history> 块 token 合计(估算 × 换算系数)≥ reflectThresholdTokens 时,
9865
- * 把全部块条目作为压缩视图重新压缩合并(视图无条目时跳过,如全部为不可解析的历史
9866
- * 遗留块)
10184
+ * - 反思(异步归档):<history> 块 token 合计(估算 × 换算系数,不计 archived-history)
10185
+ * ≥ reflectThresholdTokens 时,保留合计不超过阈值 1/3 的尾部块(至少 1 个),其余块在
10186
+ * 后台归档为一个 <archived-history> 块(reflect.ts);完成后的首个有输入的 pre-step 提交
10187
+ * 替换,并把被归档块中的 skill 以 skill-invocation 消息注入本 step;失败只记
10188
+ * compaction/end(error),块集合变化后重试
9867
10189
  * - 观察(打标记 → 对账 → 到期注入):净压力(换算系数 × 未压缩表层估算,未压缩 =
9868
10190
  * 表层 − 已压缩块 − 系统提示词估算)首次 ≥ observeThresholdTokens 时记录待定标记
9869
10191
  * (触发点 = 当时的最后一条完整消息 index),并立即开始后台预压缩(precompress.ts,
@@ -9875,24 +10197,24 @@ function disposeAllPrecompressions() {
9875
10197
  * tailMessageCount=0 时触发当轮即到期,阻塞等待注入
9876
10198
  * - 两个阈值都按主模型真实 token 计;换算系数 = 上次请求真实用量基线 ÷ 锚点估算
9877
10199
  * (工具定义估算 + 锚点表层),无真实用量基线或计量失败按 1 计
9878
- * - 待定标记与压缩结果以 log-only om 信封事件(借用 feedback/record,kind 为
10200
+ * - 待定标记与压缩结果以 ignorable 的 plugin record(kind 为
9879
10201
  * om/observe-pending / om/observe-invalidate / om/observe-summary,见 om-event.ts)
9880
10202
  * 持久化在会话日志中(重启后从日志恢复);压缩失败保留待定,下个 pre-step 重启任务重试
9881
- * - 两级在 pre-step 串行执行(先反思后观察;观察的压缩主体在后台运行,pre-step 仅在
9882
- * 到期结果未就绪时阻塞等待);仅主会话生效;omEnabled=false 关闭
10203
+ * - pre-step 先做反思检查(只启动或跳过,不阻塞),再执行观察(压缩主体在后台运行,
10204
+ * pre-step 仅在到期结果未就绪时阻塞等待);仅主会话生效;omEnabled=false 关闭
9883
10205
  * - 压缩目标默认跟随会话路由;compressProvider + compressModel 成对配置时覆盖路由
9884
10206
  * (成对配置下未路由会话也执行压缩);compressReasoningEffort 配置时压缩前经
9885
10207
  * ctx.llm.resolveModelInfo 校验目标模型 reasoning.efforts(按 provider+model 缓存),
9886
10208
  * 未命中 / 无元数据 / 查询失败降级为模型默认并报告 reasoning-effort-unavailable 降级
9887
- * - 压缩边界:最后一个合法 <history> 块之后的消息视为未压缩,其前不重复压缩
9888
- * - 压缩循环最终失败(连续无工具调用 / 请求级错误)时 pass 返回失败结果(携带最后一次
10209
+ * - 压缩边界:最后一个合法 <history> 或 <archived-history> 块之后的消息视为未压缩,其前不重复压缩
10210
+ * - 观察压缩循环最终失败(连续无工具调用 / 请求级错误)时 pass 返回失败结果(携带最后一次
9889
10211
  * 错误),压缩流程向上传播,pre-step 据此拒绝本 step 中断当前 turn;signal 中止标记
9890
10212
  * aborted(不中断);成功与失败均落盘压缩会话记录子会话(失败时其 id 随结果传播为
9891
10213
  * 诊断子会话 id)
9892
10214
  * - 提交走宿主 compaction/* 生命周期事件(start 带 phase → summary → 替换消息 → end),
9893
10215
  * 失败补 end(error,实际报错 + 诊断子会话 sessionId);替换消息 source 标记插件标识供 UI 认领
9894
10216
  * - 挂载失败类问题(systemPrompt/tokenMeter 服务异常)始终 console 到外部进程,并追加
9895
- * log-only om 警告事件(借用 feedback/record,客户端渲染功能降级警告行,每会话同一
10217
+ * ignorable 的 om 警告 plugin record(客户端渲染功能降级警告行,每会话同一
9896
10218
  * 问题至多一次);
9897
10219
  * 辅助估算的普通运行时报错仅记日志。降级与报错都不阻塞压缩(tokenMeter 计量失败时
9898
10220
  * 本轮跳过观察,反思换算系数按 1 计)
@@ -9945,31 +10267,33 @@ async function resolveCompressionEffort(ctx, session, config, target, logger) {
9945
10267
  compressionEffortCache.set(cacheKey, resolved);
9946
10268
  return resolved;
9947
10269
  }
10270
+ /** 插件自产 user/message 的文本;其余事件返回 undefined。 */
10271
+ function pluginOwnedText(event) {
10272
+ if (event?.type !== "user/message") return void 0;
10273
+ if (!isPluginOwnedSource(event.data.source)) return void 0;
10274
+ return blocksToText(event.data.content);
10275
+ }
9948
10276
  /**
9949
- * 运行压缩循环并归一化结果:失败统一追加 compaction/end(error)(携带诊断子会话 id),
9950
- * 成功记会话记录日志;返回循环结果(成功时由调用方提交)。
10277
+ * 判定消息是否为本插件的归档块消息并返回整段文本:插件自产且文本以
10278
+ * <archived-history> 开标签起始;其余返回 undefined。
9951
10279
  */
9952
- async function runPassLoop(ctx, session, lifecycle, options, logger, phase) {
9953
- const outcome = await runCompressionLoop(ctx, session, options);
9954
- if (!outcome.ok) {
9955
- logger.warn(`${phase === "reflect" ? "反思" : "观察"}:压缩循环失败(${outcome.error}),诊断子会话 ${outcome.recordSessionId ?? "未落盘"},追加 compaction/end(error)`);
9956
- try {
9957
- appendCompactionEnd(session, lifecycle, outcome.error, outcome.recordSessionId, outcome.stats.durationMs);
9958
- } catch {}
9959
- return outcome;
9960
- }
9961
- if (outcome.recordSessionId !== void 0) logger.step(`压缩会话记录子会话 ${outcome.recordSessionId}`);
9962
- return outcome;
10280
+ function archivedHistoryTextOf(event) {
10281
+ const text = pluginOwnedText(event);
10282
+ if (text === void 0) return void 0;
10283
+ const head = text.trimStart();
10284
+ const open = `<${ARCHIVED_HISTORY_TAG}`;
10285
+ if (!head.startsWith(open)) return void 0;
10286
+ const next = head.charAt(open.length);
10287
+ return next === ">" || next === " " ? text : void 0;
9963
10288
  }
9964
10289
  /**
9965
10290
  * 判定消息是否为本插件的压缩日志消息并提取日志文本(按 source 标记判断,兼容旧宿主
9966
- * checkpoint 标记 'compact')。仅当消息文本含 <history> 开标签时视为压缩日志,返回整段
9967
- * 文本;其余返回 undefined。
10291
+ * checkpoint 标记 'compact')。仅当消息文本含 <history> 开标签且不是归档块时视为压缩
10292
+ * 日志,返回整段文本;其余返回 undefined。
9968
10293
  */
9969
10294
  function historyTextOf(event) {
9970
- if (event?.type !== "user/message") return void 0;
9971
- if (!isPluginOwnedSource(event.data.source)) return void 0;
9972
- const text = blocksToText(event.data.content);
10295
+ const text = pluginOwnedText(event);
10296
+ if (text === void 0 || archivedHistoryTextOf(event) !== void 0) return void 0;
9973
10297
  const idx = text.indexOf(`<${HISTORY_TAG}`);
9974
10298
  if (idx === -1) return void 0;
9975
10299
  const rest = text.slice(idx + 7 + 1);
@@ -10042,16 +10366,28 @@ function computeCompressRange(session, endMessageIndex) {
10042
10366
  };
10043
10367
  }
10044
10368
  /**
10045
- * 压缩边界(historySection):扫描表层全部节点,收集所有合法 <history> 压缩日志块
10046
- * (内文 + seq,按表层顺序),并以最后一个块的 seq 作为压缩边界——边界之后的消息视为
10047
- * 未压缩,其前(含边界自身)视为已压缩。无压缩日志时 blocks 为空、boundarySeq 为
10048
- * undefined。
10369
+ * 压缩边界(historySection):扫描表层全部节点,分别收集合法 <history> 块与
10370
+ * <archived-history> 归档块(内文 + seq,按表层顺序),并以两类块中表层位置最后的
10371
+ * 一个作为压缩边界——边界之后的消息视为未压缩,其前(含边界自身)视为已压缩。
10372
+ * 无压缩块时 blocks / archived 为空、boundarySeq 为 undefined。
10049
10373
  */
10050
10374
  function historySection(session) {
10051
10375
  const blocks = [];
10376
+ const archived = [];
10052
10377
  let boundarySeq;
10378
+ const events = session.snapshotEvents();
10053
10379
  for (const seq of session.surface.nodes) {
10054
- const text = historyTextOf(session.snapshotEvents()[seq]);
10380
+ const event = events[seq];
10381
+ const archivedText = archivedHistoryTextOf(event);
10382
+ if (archivedText !== void 0) {
10383
+ archived.push({
10384
+ text: archivedText,
10385
+ seq
10386
+ });
10387
+ boundarySeq = seq;
10388
+ continue;
10389
+ }
10390
+ const text = historyTextOf(event);
10055
10391
  if (text === void 0) continue;
10056
10392
  blocks.push({
10057
10393
  text,
@@ -10061,6 +10397,7 @@ function historySection(session) {
10061
10397
  }
10062
10398
  return {
10063
10399
  blocks,
10400
+ archived,
10064
10401
  boundarySeq
10065
10402
  };
10066
10403
  }
@@ -10179,113 +10516,221 @@ function appendHistoryMessage(session, content, sourceEventSeqs, surfaceOp, comp
10179
10516
  });
10180
10517
  }
10181
10518
  /**
10182
- * 反思:全部 <history> 块 token 合计 ≥ reflectThresholdTokens 时,把全部块内条目作为
10183
- * 压缩视图送入工具压缩循环,整个块区段合并替换为一条更紧凑的摘要。视图无条目(全部
10184
- * 为不可解析的历史遗留块)时跳过。失败不产生部分替换;最终失败返回失败结果
10185
- * (error = 最后一次错误)。
10519
+ * 反思(异步归档)检查:每个 pre-step 在观察前调用,不阻塞、不失败。
10520
+ * - 有运行中或待提交任务:跳过(待提交任务由 commitReflection 提交)
10521
+ * - 有失败任务:写 compaction/start + end(error) 后移除
10522
+ * - 无任务:history 块 token 合计(估算 × 换算系数)≥ reflectThresholdTokens 时,
10523
+ * 保留合计不超过阈值 1/3 的尾部块(至少 1 个),其余归档,启动后台反思;
10524
+ * 同一块集合上次失败则不重试
10186
10525
  */
10187
- async function reflectPass(ctx, agent, config, target, signal, reasoningEffort) {
10526
+ function reflectPass(ctx, agent, config, target, reasoningEffort) {
10188
10527
  const session = agent.session;
10189
10528
  const logger = makeLogger(ctx, config.debug);
10190
- logger.step(`反思检查(反思阈值 ${config.reflectThresholdTokens} tokens)`);
10191
- const { blocks } = historySection(session);
10192
- if (blocks.length === 0) {
10193
- logger.step("反思:无 <history> 压缩日志,跳过");
10194
- return { failed: false };
10529
+ const job = peekReflectJob(session.id);
10530
+ if (job !== void 0 && job.session !== session) disposeReflection(session.id);
10531
+ else if (job?.state === "failed") {
10532
+ takeReflectJob(session.id);
10533
+ recordReflectFailure(session, job, logger);
10534
+ return;
10535
+ } else if (job !== void 0) {
10536
+ logger.step(job.state === "running" ? "反思:后台任务运行中,跳过" : "反思:结果待提交,跳过");
10537
+ return;
10195
10538
  }
10539
+ startReflectionIfNeeded(ctx, session, config, target, reasoningEffort, logger);
10540
+ }
10541
+ /**
10542
+ * 提交已完成的反思(pre-step 在 next() 之后、本 step 有待输入消息时调用):
10543
+ * 校验被归档块仍在表层且相邻后写 compaction/start → summary → 替换为 archived-history → end,
10544
+ * 返回需追加到本 step 的 skill 注入消息。无待提交任务、校验或提交失败返回空数组。
10545
+ */
10546
+ function commitReflection(ctx, agent, config) {
10547
+ const session = agent.session;
10548
+ const job = peekReflectJob(session.id);
10549
+ if (job === void 0 || job.state !== "done") return [];
10550
+ takeReflectJob(session.id);
10551
+ if (job.session !== session) return [];
10552
+ return commitReflectJob(session, job, config, makeLogger(ctx, config.debug));
10553
+ }
10554
+ /** 触发检查:达到阈值且有可归档块时启动后台反思。 */
10555
+ function startReflectionIfNeeded(ctx, session, config, target, reasoningEffort, logger) {
10196
10556
  const threshold = config.reflectThresholdTokens;
10197
- const estimatedTokens = blocks.reduce((total, block) => total + estimateTextTokens(block.text), 0);
10557
+ logger.step(`反思检查(反思阈值 ${threshold} tokens)`);
10558
+ const { blocks } = historySection(session);
10559
+ if (blocks.length < 2) {
10560
+ logger.step(`反思:<history> 块 ${blocks.length} 个,无可归档块,跳过`);
10561
+ return;
10562
+ }
10563
+ const key = historyBlocksKey(blocks);
10564
+ if (reflectFailedKey(session.id) === key) {
10565
+ logger.step("反思:上次失败后 <history> 块未变化,跳过");
10566
+ return;
10567
+ }
10568
+ const estimatedTotal = blocks.reduce((total, block) => total + estimateTextTokens(block.text), 0);
10198
10569
  const measurement = measurePressure(ctx, session, logger);
10199
10570
  const ratio = measurement === void 0 ? 1 : conversionRatio(measurement, estimateToolsTokens(session, logger));
10200
- const tokens = Math.round(ratio * estimatedTokens);
10201
- const shadowedCharCount = blocks.reduce((total, block) => total + historyInnerText(block.text).length, 0);
10571
+ const tokens = Math.round(ratio * estimatedTotal);
10572
+ const detail = `${tokens} tokens(估算 ${estimatedTotal} × 换算系数 ${ratio.toFixed(2)})`;
10202
10573
  if (tokens < threshold) {
10203
- logger.step(`反思:摘要 ${tokens} tokens(估算 ${estimatedTokens} × 换算系数 ${ratio.toFixed(2)})< 阈值 ${threshold},跳过`);
10204
- return { failed: false };
10574
+ logger.step(`反思:<history> 块 ${detail} < 阈值 ${threshold},跳过`);
10575
+ return;
10205
10576
  }
10206
- logger.step(`反思:摘要 ${tokens} tokens(估算 ${estimatedTokens} × 换算系数 ${ratio.toFixed(2)})≥ 阈值 ${threshold},触发精简合并(${blocks.length} 个块)`);
10207
- const first = blocks[0];
10208
- const last = blocks[blocks.length - 1];
10209
- if (first === void 0 || last === void 0) {
10210
- logger.step("反思:块区段缺失,跳过");
10211
- return { failed: false };
10577
+ const { archived, kept } = selectArchiveBlocks(blocks, (block) => ratio * estimateTextTokens(block.text), threshold / 3);
10578
+ if (archived.length === 0) {
10579
+ logger.step("反思:尾部保留预算覆盖全部块,无可归档块,跳过");
10580
+ return;
10212
10581
  }
10213
- const view = buildReflectView(blocks, { skipReasoning: config.compressSkipReasoning });
10582
+ const { view, skills } = buildArchiveView(archived);
10214
10583
  if (view.minIndex === void 0 || view.maxIndex === void 0) {
10215
- logger.step("反思:块内无可定位条目(历史遗留块),跳过");
10216
- return { failed: false };
10584
+ logger.step("反思:被归档块内无可定位条目(历史遗留块),跳过");
10585
+ return;
10217
10586
  }
10218
- const blockSeqs = blocks.map((block) => block.seq);
10587
+ startReflection({
10588
+ ctx,
10589
+ session,
10590
+ config,
10591
+ target,
10592
+ ...reasoningEffort === void 0 ? {} : { reasoningEffort },
10593
+ key,
10594
+ archived,
10595
+ view,
10596
+ skills,
10597
+ estimatedTokens: archived.reduce((total, block) => total + estimateTextTokens(block.text), 0),
10598
+ shadowedCharCount: archived.reduce((total, block) => total + historyInnerText(block.text).length, 0)
10599
+ });
10600
+ logger.info(`反思:<history> 块 ${detail} ≥ 阈值 ${threshold},后台归档 ${archived.length} 个块,保留 ${kept.length} 个`);
10601
+ }
10602
+ /** 失败任务:在当前开放 turn 内写 compaction/start + end(error);中止的任务不记录。 */
10603
+ function recordReflectFailure(session, job, logger) {
10604
+ const failure = job.failure;
10605
+ if (failure === void 0 || failure.aborted) return;
10219
10606
  const lifecycle = {
10220
10607
  compactionId: newCompactionId(),
10221
10608
  turn: openTurnOf(session)
10222
10609
  };
10223
10610
  try {
10224
- logger.step("反思:追加 compaction/start(压缩循环前开启压缩中提示)");
10225
10611
  appendCompactionStart(session, lifecycle, "reflect");
10612
+ appendCompactionEnd(session, lifecycle, failure.error, failure.diagnosticSessionId);
10226
10613
  } catch (error) {
10227
10614
  const message = error instanceof Error ? error.message : String(error);
10228
- logger.warn(`反思压缩启动失败: ${message}`);
10229
- return { failed: false };
10615
+ logger.warn(`反思失败记录追加失败: ${message}`);
10230
10616
  }
10231
- const summaryResult = await runPassLoop(ctx, session, lifecycle, {
10232
- view,
10233
- originalChars: shadowedCharCount,
10234
- phase: "reflect",
10235
- taskText: buildCompressionTaskText("reflect", view.minIndex, view.maxIndex),
10236
- target,
10237
- maxTokens: config.compressMaxTokens,
10238
- rateLimitWaitMs: config.rateLimitWaitMs,
10239
- skipReasoning: config.compressSkipReasoning,
10240
- debug: config.debug,
10241
- ...reasoningEffort === void 0 ? {} : { reasoningEffort },
10242
- ...signal === void 0 ? {} : { signal }
10243
- }, logger, "reflect");
10244
- if (!summaryResult.ok) return {
10245
- failed: true,
10246
- error: summaryResult.error,
10247
- aborted: summaryResult.aborted,
10248
- ...summaryResult.recordSessionId === void 0 ? {} : { diagnosticSessionId: summaryResult.recordSessionId }
10617
+ }
10618
+ /** 被归档块仍在表层且在表层顺序中相邻。 */
10619
+ function archivedBlocksIntact(session, job) {
10620
+ const nodes = session.surface.nodes;
10621
+ const first = job.archived[0];
10622
+ if (first === void 0) return false;
10623
+ const start = nodes.indexOf(SessionSeq(first.seq));
10624
+ if (start < 0) return false;
10625
+ return job.archived.every((block, i) => nodes[start + i] === block.seq);
10626
+ }
10627
+ /** 提交成功任务;返回需注入的 skill 消息(表层已有同名 skill 的不注入)。 */
10628
+ function commitReflectJob(session, job, config, logger) {
10629
+ const result = job.result;
10630
+ const first = job.archived[0];
10631
+ const last = job.archived[job.archived.length - 1];
10632
+ if (result === void 0 || first === void 0 || last === void 0) return [];
10633
+ if (!archivedBlocksIntact(session, job)) {
10634
+ logger.info("反思:被归档块已不在表层或不再相邻,丢弃本次结果");
10635
+ return [];
10636
+ }
10637
+ const blockSeqs = job.archived.map((block) => block.seq);
10638
+ const lifecycle = {
10639
+ compactionId: newCompactionId(),
10640
+ turn: openTurnOf(session)
10249
10641
  };
10250
- const report = summaryResult.text;
10251
10642
  try {
10252
- logger.step("反思提交:追加 compaction/summary(影子价格认领)");
10643
+ appendCompactionStart(session, lifecycle, "reflect");
10644
+ } catch (error) {
10645
+ const message = error instanceof Error ? error.message : String(error);
10646
+ logger.warn(`反思提交启动失败: ${message}`);
10647
+ return [];
10648
+ }
10649
+ try {
10253
10650
  const summarySeq = appendCompactionSummary(session, {
10254
10651
  lifecycle,
10255
- summary: report,
10652
+ summary: result.text,
10256
10653
  shadowedRange: {
10257
10654
  start: first.seq,
10258
10655
  end: last.seq
10259
10656
  },
10260
10657
  shadowedSeqs: blockSeqs,
10261
- shadowedTokenCount: estimatedTokens,
10262
- shadowedCharCount,
10263
- provider: target.provider,
10264
- model: target.model,
10658
+ shadowedTokenCount: job.estimatedTokens,
10659
+ shadowedCharCount: job.shadowedCharCount,
10660
+ provider: job.target.provider,
10661
+ model: job.target.model,
10265
10662
  maxTokens: config.compressMaxTokens,
10266
- stats: summaryResult.stats,
10267
- ...summaryResult.usage === void 0 ? {} : { usage: summaryResult.usage },
10268
- ...reasoningEffort === void 0 ? {} : { reasoningEffort }
10663
+ stats: result.stats,
10664
+ ...result.usage === void 0 ? {} : { usage: result.usage },
10665
+ ...job.reasoningEffort === void 0 ? {} : { reasoningEffort: job.reasoningEffort }
10269
10666
  });
10270
- logger.step("反思提交:替换整个 <history> 块区段为合并摘要");
10271
- appendHistoryMessage(session, report, [summarySeq, ...blockSeqs], {
10667
+ appendHistoryMessage(session, result.text, [summarySeq, ...blockSeqs], {
10272
10668
  op: "replace",
10273
10669
  startSeq: first.seq,
10274
10670
  endSeq: last.seq
10275
10671
  }, lifecycle.compactionId);
10276
- logger.step("反思提交:追加 compaction/end");
10277
- appendCompactionEnd(session, lifecycle, void 0, summaryResult.recordSessionId);
10278
- logger.info(`反思完成(摘要 ${tokens} tokens ≥ 阈值 ${threshold},合并 ${blocks.length} 个块为一条)`);
10279
- return { failed: false };
10672
+ appendCompactionEnd(session, lifecycle, void 0, result.recordSessionId);
10280
10673
  } catch (error) {
10281
10674
  const message = error instanceof Error ? error.message : String(error);
10282
10675
  logger.warn(`反思提交失败: ${message}`);
10283
10676
  try {
10284
- appendCompactionEnd(session, lifecycle, message, void 0, summaryResult.stats.durationMs);
10677
+ appendCompactionEnd(session, lifecycle, message, void 0, result.stats.durationMs);
10285
10678
  } catch {}
10286
- return { failed: false };
10679
+ return [];
10680
+ }
10681
+ const live = liveSkillNames(session);
10682
+ const messages = job.skills.filter((skill) => !live.has(skill.name)).map((skill) => createUserMessage({
10683
+ content: [{
10684
+ type: "text",
10685
+ text: skill.content
10686
+ }],
10687
+ source: {
10688
+ kind: SKILL_INVOCATION_KIND,
10689
+ name: skill.name,
10690
+ form: "instructions"
10691
+ }
10692
+ }));
10693
+ logger.info(`反思提交:${job.archived.length} 个 <history> 块归档为 archived-history,注入 ${messages.length} 个 skill`);
10694
+ return messages;
10695
+ }
10696
+ /** 表层中仍以 skill 形态存在的名称:history 块内 skill_content、手动加载消息、skill 工具调用。 */
10697
+ function liveSkillNames(session) {
10698
+ const names = /* @__PURE__ */ new Set();
10699
+ const events = session.snapshotEvents();
10700
+ for (const seq of session.surface.nodes) {
10701
+ const event = events[seq];
10702
+ if (event === void 0) continue;
10703
+ const history = historyTextOf(event);
10704
+ if (history !== void 0) {
10705
+ for (const match of history.matchAll(/<skill_content name="([^"]*)"/g)) names.add(unescapeAttr(match[1] ?? ""));
10706
+ continue;
10707
+ }
10708
+ if (event.type === "user/message") {
10709
+ const source = event.data.source;
10710
+ if (source.kind === "skill-invocation" && typeof source.name === "string") names.add(source.name);
10711
+ continue;
10712
+ }
10713
+ if (event.type === "assistant/message") for (const block of event.data.message.content) {
10714
+ if (block.type !== "tool-call" || block.name !== "skill") continue;
10715
+ const name = skillArgName(block.arguments);
10716
+ if (name !== void 0) names.add(name);
10717
+ }
10718
+ }
10719
+ return names;
10720
+ }
10721
+ /** skill 工具调用参数中的 name;参数非法时 undefined。 */
10722
+ function skillArgName(args) {
10723
+ try {
10724
+ const parsed = JSON.parse(args);
10725
+ return typeof parsed?.name === "string" ? parsed.name : void 0;
10726
+ } catch {
10727
+ return;
10287
10728
  }
10288
10729
  }
10730
+ /** XML 属性值反转义。 */
10731
+ function unescapeAttr(value) {
10732
+ return value.replaceAll("&quot;", "\"").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&apos;", "'").replaceAll("&amp;", "&");
10733
+ }
10289
10734
  /**
10290
10735
  * 估算系统提示词 tokens:按 agent 作用域组装并渲染系统提示词,按长度/4 启发式计。
10291
10736
  * systemPrompt 服务经 ctx.get 容错读取(ctx 属性访问在服务未挂载时抛错);服务缺失
@@ -10501,8 +10946,8 @@ async function observePass(ctx, agent, config, waitCount, target, signal, reason
10501
10946
  const threshold = config.observeThresholdTokens;
10502
10947
  const measurement = measurePressure(ctx, session, logger);
10503
10948
  if (measurement === void 0) return { failed: false };
10504
- const { blocks } = historySection(session);
10505
- const historyTokens = blocks.reduce((total, block) => total + estimateTextTokens(block.text), 0);
10949
+ const { blocks, archived } = historySection(session);
10950
+ const historyTokens = [...blocks, ...archived].reduce((total, block) => total + estimateTextTokens(block.text), 0);
10506
10951
  const systemTokens = await estimateSystemPromptTokens(ctx, agent, logger, signal);
10507
10952
  const ratio = conversionRatio(measurement, estimateToolsTokens(session, logger));
10508
10953
  const uncompressedTokens = Math.max(0, measurement.surfaceTokens - historyTokens - systemTokens);
@@ -10643,9 +11088,9 @@ async function observePass(ctx, agent, config, waitCount, target, signal, reason
10643
11088
  });
10644
11089
  }
10645
11090
  /**
10646
- * 压力检查 + 两级压缩入口:先反思后观察,pre-step 阻塞串行执行;仅主会话生效。
10647
- * 反思摘要耗尽失败时直接返回失败结果(观察无需继续,本轮将被拒绝);观察失败同样
10648
- * 传播失败结果,由 pre-step 拒绝本 step 中断当前 turn。
11091
+ * 压力检查 + 两级压缩入口(pre-step 调用,仅主会话生效):
11092
+ * 先反思(异步:只启动或提交后台任务,不阻塞、不失败),后观察(阻塞注入)。
11093
+ * 观察失败传播失败结果,由 pre-step 拒绝本 step 中断当前 turn。
10649
11094
  */
10650
11095
  async function maybeCompress(ctx, agent, config, signal) {
10651
11096
  const session = agent.session;
@@ -10663,11 +11108,7 @@ async function maybeCompress(ctx, agent, config, signal) {
10663
11108
  const reasoningEffort = await resolveCompressionEffort(ctx, session, config, target, logger);
10664
11109
  const waitCount = config.tailMessageCount;
10665
11110
  logger.step("反思 pass 开始");
10666
- const reflect = await reflectPass(ctx, agent, config, target, signal, reasoningEffort);
10667
- if (reflect.failed) {
10668
- logger.step("反思 pass 失败(本轮将被拒绝),跳过观察 pass");
10669
- return reflect;
10670
- }
11111
+ reflectPass(ctx, agent, config, target, reasoningEffort);
10671
11112
  logger.step("反思 pass 结束,观察 pass 开始");
10672
11113
  const observe = await observePass(ctx, agent, config, waitCount, target, signal, reasoningEffort);
10673
11114
  logger.step("观察 pass 结束,压缩流程完成");
@@ -10889,7 +11330,7 @@ function cosineSimilarity(a, b) {
10889
11330
  /** 默认配置(冻结对象,resolveConfig 合并的基底;debug 缺省值在解析时按 NODE_ENV 判定)。 */
10890
11331
  const DEFAULT_CONFIG = Object.freeze({
10891
11332
  observeThresholdTokens: 35e3,
10892
- reflectThresholdTokens: 4e4,
11333
+ reflectThresholdTokens: 8e4,
10893
11334
  compressMaxTokens: void 0,
10894
11335
  rateLimitWaitMs: 6e4,
10895
11336
  recompressConcurrency: 2,
@@ -10901,7 +11342,6 @@ const DEFAULT_CONFIG = Object.freeze({
10901
11342
  progressReminderIdleSteps: 4,
10902
11343
  progressReminderIdleToolCalls: 10,
10903
11344
  debug: false,
10904
- recallEnabled: true,
10905
11345
  semanticRecallEnabled: true,
10906
11346
  modelDir: sharedModelDir(),
10907
11347
  compressProvider: void 0,
@@ -10923,7 +11363,6 @@ const Config = Schema.object({
10923
11363
  progressReminderIdleSteps: Schema.number().step(1).min(1).default(DEFAULT_CONFIG.progressReminderIdleSteps).volatile(),
10924
11364
  progressReminderIdleToolCalls: Schema.number().step(1).min(0).default(DEFAULT_CONFIG.progressReminderIdleToolCalls).volatile(),
10925
11365
  debug: Schema.boolean().default(process.env.NODE_ENV !== "production").volatile(),
10926
- recallEnabled: Schema.boolean().default(DEFAULT_CONFIG.recallEnabled).volatile(),
10927
11366
  semanticRecallEnabled: Schema.boolean().default(DEFAULT_CONFIG.semanticRecallEnabled).volatile(),
10928
11367
  modelDir: Schema.string().default(DEFAULT_CONFIG.modelDir).volatile(),
10929
11368
  compressProvider: Schema.string().volatile(),
@@ -10999,8 +11438,7 @@ function resolveConfig(raw) {
10999
11438
  config.progressReminderEnabled = resolveBoolean(input.progressReminderEnabled, true);
11000
11439
  config.progressReminderIdleEnabled = resolveBoolean(input.progressReminderIdleEnabled, DEFAULT_CONFIG.progressReminderIdleEnabled);
11001
11440
  config.debug = resolveBoolean(input.debug, process.env.NODE_ENV !== "production");
11002
- config.recallEnabled = resolveBoolean(input.recallEnabled, true);
11003
- config.semanticRecallEnabled = config.recallEnabled && resolveBoolean(input.semanticRecallEnabled, true);
11441
+ config.semanticRecallEnabled = resolveBoolean(input.semanticRecallEnabled, true);
11004
11442
  const modelDir = input.modelDir;
11005
11443
  if (typeof modelDir === "string" && modelDir.trim() !== "") config.modelDir = modelDir;
11006
11444
  config.compressProvider = resolveOptionalString(input.compressProvider);
@@ -11211,11 +11649,14 @@ function renderCompleteMessageXml(session, cm, options = {}) {
11211
11649
  //#endregion
11212
11650
  //#region src/semantic-recall.ts
11213
11651
  /**
11214
- * recall 语义增强的检索实现:按自然语言 query 对会话全部完整消息(含被压缩/遮蔽的)做
11215
- * 语义检索,返回最匹配的完整消息与匹配说明。
11652
+ * recall 的 query 检索实现:对会话全部完整消息(含被压缩/遮蔽的)检索,返回最匹配的
11653
+ * 完整消息与匹配说明。
11216
11654
  * 导出 SemanticOptions / RangeArgs / resolveSemanticRange / tokenize / matchExplanation /
11217
- * SEMANTIC_MODEL_NOT_READY_MESSAGE / semanticSearch。
11218
- * 向量为本地 ONNX 嵌入(cosine 相似度);只匹配文本,纯图片消息不进候选池;
11655
+ * keywordTerms / SEMANTIC_MODEL_NOT_READY_MESSAGE / semanticSearch / keywordSearch。
11656
+ * - 语义检索:本地 ONNX 嵌入(cosine 相似度)
11657
+ * - 字符串匹配(语义增强关闭时):query 按空白拆词,不区分大小写计命中词数,同分时
11658
+ * index 大的优先,零命中不返回
11659
+ * 只匹配文本,纯图片消息不进候选池;
11219
11660
  * 区间缺省检索全部、区间不合法回退全量并在输出中告知;输出契约同 recall
11220
11661
  * ({ text, images },条目为 XML 形态见 recall-xml.ts,超大结果由 tool-result-pruner
11221
11662
  * 裁剪);候选池排除本次调用自身的 toolcall 完整消息(其渲染文本含 query 原文,
@@ -11287,13 +11728,11 @@ function matchExplanation(query, text, score) {
11287
11728
  }
11288
11729
  /** 模型未就绪时返回给模型的文案(下载完成后直接再次调用即可)。 */
11289
11730
  const SEMANTIC_MODEL_NOT_READY_MESSAGE = "语义检索暂不可用,本地向量模型尚未就绪。";
11290
- /** 在会话完整消息中做语义检索,返回 TOP-K 命中条目。 */
11291
- async function semanticSearch(input) {
11292
- const { session, query, topK, start, end, offset, selfCallId, getPruner, options } = input;
11293
- const embed = options?.embedder ?? ((texts) => getEmbedder().then((fn) => fn(texts)));
11294
- if ((await options?.modelStatus?.() ?? "ready") !== "ready") return textOnly(SEMANTIC_MODEL_NOT_READY_MESSAGE);
11731
+ /** 收集区间内可检索的候选;会话为空或区间内无候选时返回提示文案。 */
11732
+ function collectCandidates(input) {
11733
+ const { session, start, end, offset, selfCallId } = input;
11295
11734
  const cms = indexCompleteMessages(session);
11296
- if (cms.length === 0) return textOnly("会话中没有可检索的消息");
11735
+ if (cms.length === 0) return "会话中没有可检索的消息";
11297
11736
  const range = resolveSemanticRange(cms.length, {
11298
11737
  start,
11299
11738
  end,
@@ -11313,7 +11752,20 @@ async function semanticSearch(input) {
11313
11752
  text
11314
11753
  });
11315
11754
  }
11316
- if (candidates.length === 0) return textOnly("指定范围内没有可检索的消息");
11755
+ if (candidates.length === 0) return "指定范围内没有可检索的消息";
11756
+ return {
11757
+ candidates,
11758
+ range
11759
+ };
11760
+ }
11761
+ /** 在会话完整消息中做语义检索,返回 TOP-K 命中条目。 */
11762
+ async function semanticSearch(input) {
11763
+ const { query, topK, options } = input;
11764
+ const embed = options?.embedder ?? ((texts) => getEmbedder().then((fn) => fn(texts)));
11765
+ if ((await options?.modelStatus?.() ?? "ready") !== "ready") return textOnly(SEMANTIC_MODEL_NOT_READY_MESSAGE);
11766
+ const collected = collectCandidates(input);
11767
+ if (typeof collected === "string") return textOnly(collected);
11768
+ const { candidates, range } = collected;
11317
11769
  const [queryVec] = await embed([query]);
11318
11770
  if (!queryVec) return textOnly("语义检索失败:无法生成查询向量");
11319
11771
  const vectors = await embed(candidates.map((c) => c.text));
@@ -11323,18 +11775,53 @@ async function semanticSearch(input) {
11323
11775
  score: cosineSimilarity(queryVec, vectors[i] ?? /* @__PURE__ */ new Float32Array(0))
11324
11776
  }));
11325
11777
  scored.sort((a, b) => b.score - a.score);
11326
- const limit = topK ?? 3;
11327
- const hits = scored.slice(0, limit);
11778
+ const hits = scored.slice(0, topK ?? 3).map((hit) => ({
11779
+ ...hit,
11780
+ explanation: matchExplanation(query, hit.text, hit.score)
11781
+ }));
11782
+ return renderHits(input, range, `${candidates.length} 条可嵌入`, scored.length, hits);
11783
+ }
11784
+ /** 字符串匹配的检索词:query 按空白拆分、转小写、去重。 */
11785
+ function keywordTerms(query) {
11786
+ return [...new Set(query.toLowerCase().split(/\s+/u).filter((term) => term.length > 0))];
11787
+ }
11788
+ /** 在会话完整消息中按字符串匹配检索(语义增强关闭时),返回 TOP-K 命中条目。 */
11789
+ function keywordSearch(input) {
11790
+ const terms = keywordTerms(input.query);
11791
+ if (terms.length === 0) return textOnly("query 不能为空");
11792
+ const collected = collectCandidates(input);
11793
+ if (typeof collected === "string") return textOnly(collected);
11794
+ const { candidates, range } = collected;
11795
+ const scored = candidates.map((c) => {
11796
+ const lower = c.text.toLowerCase();
11797
+ const matched = terms.filter((term) => lower.includes(term));
11798
+ return {
11799
+ ...c,
11800
+ score: matched.length,
11801
+ matched
11802
+ };
11803
+ }).filter((c) => c.score > 0);
11804
+ if (scored.length === 0) return textOnly(`未找到包含 ${terms.join(" ")} 中任一词的消息(字符串匹配,不区分大小写)`);
11805
+ scored.sort((a, b) => b.score - a.score || b.cm.index - a.cm.index);
11806
+ const hits = scored.slice(0, input.topK ?? 3).map((hit) => ({
11807
+ ...hit,
11808
+ explanation: `命中 ${hit.score}/${terms.length} 个词: ${hit.matched.join(" ")}`
11809
+ }));
11810
+ return renderHits(input, range, `${candidates.length} 条,字符串匹配`, scored.length, hits);
11811
+ }
11812
+ /** 渲染命中条目:查询与检索说明以 XML 注释置于条目之前,每条命中前附匹配说明。 */
11813
+ function renderHits(input, range, poolNote, total, hits) {
11814
+ const { session, query, start, getPruner } = input;
11328
11815
  const parts = [];
11329
11816
  const images = [];
11330
- const rangeNote = range.fallback ? "指定区间不合法(start/end 越界等),已回退检索全部消息" : start === void 0 ? `检索全部消息(${candidates.length} 条可嵌入)` : `检索区间 [${range.lo}..${range.hi}](${candidates.length} 条可嵌入)`;
11817
+ const rangeNote = range.fallback ? "指定区间不合法(start/end 越界等),已回退检索全部消息" : start === void 0 ? `检索全部消息(${poolNote})` : `检索区间 [${range.lo}..${range.hi}](${poolNote})`;
11331
11818
  parts.push(`<!-- ${xmlCommentText(`查询: ${query}`)} -->`);
11332
11819
  parts.push(`<!-- ${xmlCommentText(rangeNote)} -->`);
11333
- parts.push(`<!-- ${xmlCommentText(`匹配 TOP-${hits.length}(共 ${scored.length} 条候选)`)} -->`);
11820
+ parts.push(`<!-- ${xmlCommentText(`匹配 TOP-${hits.length}(共 ${total} 条候选)`)} -->`);
11334
11821
  for (let i = 0; i < hits.length; i += 1) {
11335
11822
  const hit = hits[i];
11336
11823
  if (!hit) continue;
11337
- const note = `<!-- ${xmlCommentText(`${i + 1}. ${matchExplanation(query, hit.text, hit.score)}`)} -->`;
11824
+ const note = `<!-- ${xmlCommentText(`${i + 1}. ${hit.explanation}`)} -->`;
11338
11825
  let xml;
11339
11826
  let hitImages = [];
11340
11827
  try {
@@ -11360,28 +11847,20 @@ async function semanticSearch(input) {
11360
11847
  //#endregion
11361
11848
  //#region src/recall.ts
11362
11849
  /**
11363
- * recall 工具:回看原始会话(含被压缩内容),语义增强启用时额外支持按含义检索。
11364
- * 导出 recallArgsSchema / enhancedRecallArgsSchema / RecallArgs / parseRecallArgs / buildRecallTool。
11850
+ * recall 工具:回看原始会话(含被压缩内容)。
11851
+ * 导出 recallArgsSchema / RecallArgs / parseRecallArgs / buildRecallTool。
11365
11852
  * - 区间模式:按完整消息 index 的 start/end/offset 精确返回区间内全部完整消息。
11366
- * - 语义模式(仅增强启用且带 query):语义检索见 semantic-recall.ts。
11853
+ * - 检索模式(带 query):语义增强启用时按含义检索,否则按字符串匹配,见 semantic-recall.ts。
11367
11854
  * 输出值为 { text, images }(契约见 recall-output.ts),text 为 XML 条目序列
11368
11855
  * (形态见 recall-xml.ts);recall 自身不设输出上限,超大工具结果由 tool-result-pruner 裁剪。
11369
11856
  */
11370
11857
  /**
11371
- * 基础 recall 参数 schema:start 必填;end 与 offset 至少提供一个(同时给出时 end 优先)。
11858
+ * recall 参数 schema:带 query 走检索模式(区间可选,用于限定检索范围);
11859
+ * 不带 query 时 start 必填,end 与 offset 至少提供一个(同时给出时 end 优先)。
11372
11860
  * 各字段描述经 .describe() 透传到 wire JSON Schema。
11373
11861
  */
11374
11862
  const recallArgsSchema = z.object({
11375
- start: z.number().describe("完整消息 index,基准边界,与 end 或 offset 配合指定区间;end 与 offset 至少提供一个(同时给出时 end 优先)。"),
11376
- end: z.number().optional().describe("与 offset 互斥,指定区间另一边界。"),
11377
- offset: z.number().optional().describe("与 end 互斥,相对 start 的步数(正向后、负向前)。")
11378
- }).refine((args) => args.end !== void 0 || args.offset !== void 0, { message: "end 与 offset 至少提供一个" });
11379
- /**
11380
- * 语义增强 recall 参数 schema:带 query 走语义模式(区间可选,用于限定检索范围),
11381
- * 不带 query 时与基础 schema 的校验一致。
11382
- */
11383
- const enhancedRecallArgsSchema = z.object({
11384
- query: z.string().optional().describe("按含义检索的自然语言 query(中英文与代码术语皆可,如 \"修复 retry backoff 的逻辑\");提供时 start/end/offset 仅用于限定搜索区间,缺省检索全部。"),
11863
+ query: z.string().optional().describe("检索 query(中英文与代码术语皆可);提供时 start/end/offset 仅用于限定搜索区间,缺省检索全部。"),
11385
11864
  top_k: z.number().int().min(1).max(10).optional().describe("仅 query 模式:返回最匹配条数(1-10,默认 3)。"),
11386
11865
  start: z.number().optional().describe("完整消息 index,基准边界,与 end 或 offset 配合指定区间;未提供 query 时必填,且 end 与 offset 至少提供一个(同时给出时 end 优先)。"),
11387
11866
  end: z.number().optional().describe("与 offset 互斥,指定区间另一边界。"),
@@ -11406,47 +11885,50 @@ const enhancedRecallArgsSchema = z.object({
11406
11885
  message: "end 与 offset 至少提供一个"
11407
11886
  });
11408
11887
  });
11409
- /** 解析并校验 recall 调用参数(semantic 为语义增强是否启用):失败时抛出首个校验问题的可读消息。 */
11410
- function parseRecallArgs(raw, semantic = false) {
11411
- const result = (semantic ? enhancedRecallArgsSchema : recallArgsSchema).safeParse(raw);
11888
+ /** 解析并校验 recall 调用参数:失败时抛出首个校验问题的可读消息。 */
11889
+ function parseRecallArgs(raw) {
11890
+ const result = recallArgsSchema.safeParse(raw);
11412
11891
  if (!result.success) throw new Error(result.error.issues.map((issue) => `${issue.path.join(".") || "args"}: ${issue.message}`).join("; "));
11413
11892
  return result.data;
11414
11893
  }
11415
- /** 基础工具描述。 */
11416
- const RECALL_DESCRIPTION = `在你需要查看历史消息时调用。${COMPLETE_MESSAGE_DEFINITION}此工具按 index 区间精确返回区间内全部完整消息的内容。`;
11417
- /** 语义增强启用时的工具描述。 */
11418
- const ENHANCED_RECALL_DESCRIPTION = `在你需要查看历史消息时调用。${COMPLETE_MESSAGE_DEFINITION}两种用法:1) 给出 start 与 end 或 offset,按 index 区间精确返回区间内全部完整消息的内容;2) 给出 query,按自然语言含义检索最符合的完整消息,默认全量搜索,可用 start/end/offset 限定区间。注意:query 只匹配文本。`;
11894
+ /** 工具描述:两种用法;query 的匹配方式随语义增强开关变化。 */
11895
+ function recallDescription(semantic) {
11896
+ return `在你需要查看历史消息时调用。${COMPLETE_MESSAGE_DEFINITION}两种用法:1) 给出 start 与 end 或 offset,按 index 区间精确返回区间内全部完整消息的内容;2) 给出 query,${semantic ? "按自然语言含义检索最符合的完整消息" : "按字符串匹配检索完整消息(query 按空白拆词、不区分大小写,按命中词数排序,宜用原文中出现的文件名、函数名、错误码或 key-word 关键词)"},默认全量搜索,可用 start/end/offset 限定区间。注意:query 只匹配文本。`;
11897
+ }
11419
11898
  /**
11420
- * 构建 recall 工具定义:按 start/end/offset 定位完整消息区间并渲染原始内容(标 index);
11421
- * 传入 semantic 选项时额外支持 query 语义检索。
11899
+ * 构建 recall 工具定义:按 start/end/offset 定位完整消息区间并渲染原始内容(标 index),
11900
+ * 或按 query 检索(传入 semantic 选项时语义检索,否则字符串匹配)。
11422
11901
  */
11423
11902
  function buildRecallTool(options) {
11424
11903
  const getPruner = options?.getPruner;
11425
11904
  const semantic = options?.semantic;
11426
11905
  return {
11427
11906
  name: "recall",
11428
- description: semantic ? ENHANCED_RECALL_DESCRIPTION : RECALL_DESCRIPTION,
11429
- parameters: parametersFromZod(semantic ? enhancedRecallArgsSchema : recallArgsSchema),
11907
+ description: recallDescription(semantic !== void 0),
11908
+ parameters: parametersFromZod(recallArgsSchema),
11430
11909
  output: {
11431
11910
  schema: RECALL_OUTPUT_SCHEMA,
11432
11911
  render: (_args, value) => renderRecallOutput(value)
11433
11912
  },
11434
11913
  async execute(args, exec) {
11435
- const { query, top_k, start, end, offset } = parseRecallArgs(args, semantic !== void 0);
11914
+ const { query, top_k, start, end, offset } = parseRecallArgs(args);
11436
11915
  const session = exec.agent?.session;
11437
11916
  if (!session) return textOnly("会话异常");
11438
11917
  if (!isMainSession(session)) return textOnly("recall 仅主会话可用");
11439
- if (query !== void 0) return semanticSearch({
11440
- session,
11441
- query,
11442
- topK: top_k,
11443
- start,
11444
- end,
11445
- offset,
11446
- selfCallId: String(exec.callId ?? ""),
11447
- getPruner: () => getPruner?.(),
11448
- options: semantic
11449
- });
11918
+ if (query !== void 0) {
11919
+ const input = {
11920
+ session,
11921
+ query,
11922
+ topK: top_k,
11923
+ start,
11924
+ end,
11925
+ offset,
11926
+ selfCallId: String(exec.callId ?? ""),
11927
+ getPruner: () => getPruner?.(),
11928
+ options: semantic
11929
+ };
11930
+ return semantic ? semanticSearch(input) : keywordSearch(input);
11931
+ }
11450
11932
  if (start === void 0) return textOnly("start 必填");
11451
11933
  const cms = indexCompleteMessages(session);
11452
11934
  const startIndex = Number.isFinite(start) ? Math.floor(start) : 0;
@@ -11570,15 +12052,15 @@ function findLifecycle(session, compactionId) {
11570
12052
  }
11571
12053
  return lifecycle;
11572
12054
  }
11573
- /** 重建被压缩内容的视图;不可重建时返回错误。 */
12055
+ /** 重建被压缩内容的视图:反思用被归档块的归档视图,观察用原消息;不可重建时返回错误。 */
11574
12056
  function rebuildView(session, phase, shadowedSeqs, skipReasoning) {
11575
- if (phase === "reflect") return buildReflectView(shadowedSeqs.flatMap((seq) => {
12057
+ if (phase === "reflect") return buildArchiveView(shadowedSeqs.flatMap((seq) => {
11576
12058
  const text = historyTextOf(session.snapshotEvents()[seq]);
11577
12059
  return text === void 0 ? [] : [{
11578
12060
  text,
11579
12061
  seq
11580
12062
  }];
11581
- }), { skipReasoning });
12063
+ })).view;
11582
12064
  return buildObserveView(session, shadowedSeqs, { skipReasoning });
11583
12065
  }
11584
12066
  /** 按 compactionId 重建一次已成功压缩的输入视图;不可重放时返回错误文本。 */
@@ -11635,7 +12117,7 @@ async function recompress(ctx, agent, config, request, signal) {
11635
12117
  view,
11636
12118
  originalChars,
11637
12119
  phase,
11638
- taskText: buildCompressionTaskText(phase, view.minIndex, view.maxIndex),
12120
+ taskText: buildCompressionTaskText(phase, view.minIndex, view.maxIndex, view.segments),
11639
12121
  target,
11640
12122
  maxTokens: config.compressMaxTokens,
11641
12123
  rateLimitWaitMs: config.rateLimitWaitMs,
@@ -11957,7 +12439,7 @@ function apply(ctx, config) {
11957
12439
  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 ?? "模型默认"}`);
11958
12440
  const warnModel = (message) => ctx.logger.warn(`dsh-plugin-om: ${message}`);
11959
12441
  const logModel = (message) => logger.info(message);
11960
- if (resolved.recallEnabled && ctx.get("tools") === void 0) logger.warn("tools 服务未挂载,recall 暂不可用");
12442
+ if (ctx.get("tools") === void 0) logger.warn("tools 服务未挂载,recall 暂不可用");
11961
12443
  if (ctx.get("commands") === void 0) logger.warn("commands 服务未挂载,重压缩与 OM 结果评估命令暂不可用");
11962
12444
  ctx.inject(["tools"], (inner) => {
11963
12445
  let disposeRecall;
@@ -11966,13 +12448,13 @@ function apply(ctx, config) {
11966
12448
  /** 保持注册的 recall 与当前配置一致;仅语义增强首次生效或更换目录时启动后台预热。 */
11967
12449
  const syncTools = () => {
11968
12450
  const next = currentConfig(config);
11969
- const semantic = next.recallEnabled && next.semanticRecallEnabled;
11970
- if (disposeRecall && (!next.recallEnabled || registered?.semantic !== semantic || semantic && registered.modelDir !== next.modelDir)) {
12451
+ const semantic = next.semanticRecallEnabled;
12452
+ if (disposeRecall && (registered?.semantic !== semantic || semantic && registered.modelDir !== next.modelDir)) {
11971
12453
  disposeRecall();
11972
12454
  disposeRecall = void 0;
11973
12455
  registered = void 0;
11974
12456
  }
11975
- if (next.recallEnabled && !disposeRecall) {
12457
+ if (!disposeRecall) {
11976
12458
  const directory = next.modelDir;
11977
12459
  disposeRecall = inner.tools.register(buildRecallTool({
11978
12460
  getPruner: () => inner.get("toolResultPruner"),
@@ -12002,6 +12484,8 @@ function apply(ctx, config) {
12002
12484
  ctx.inject(["sessions"], (inner) => registerThinkingBinding(inner, logger));
12003
12485
  ctx.on("session/disposed", (session) => disposePrecompression(session.id));
12004
12486
  ctx.effect(() => () => disposeAllPrecompressions(), "dsh-plugin-om: precompression registry");
12487
+ ctx.on("session/disposed", (session) => disposeReflection(session.id));
12488
+ ctx.effect(() => () => disposeAllReflections(), "dsh-plugin-om: reflection registry");
12005
12489
  ctx.on("agent/pre-step", async ({ agent, signal }, next) => {
12006
12490
  let outcome = { failed: false };
12007
12491
  try {
@@ -12019,7 +12503,16 @@ function apply(ctx, config) {
12019
12503
  logger.warn(`上下文压缩失败,拒绝本 step 中断当前 turn:${outcome.error}${diagnostic}`);
12020
12504
  return { kind: "reject" };
12021
12505
  }
12022
- const decision = await next();
12506
+ let decision = await next();
12507
+ if (decision.kind === "enter" && decision.messages.length > 0 && !signal.aborted && isMainSession(agent.session)) try {
12508
+ const skills = commitReflection(ctx, agent, currentConfig(config));
12509
+ if (skills.length > 0) decision = {
12510
+ ...decision,
12511
+ messages: [...decision.messages, ...skills]
12512
+ };
12513
+ } catch (error) {
12514
+ logger.warn(`反思提交失败: ${error instanceof Error ? error.message : String(error)}`);
12515
+ }
12023
12516
  const latest = currentConfig(config);
12024
12517
  const reminders = activeSystemReminders(latest);
12025
12518
  if (decision.kind === "enter" && !signal.aborted && reminders.length > 0 && isMainSession(agent.session)) return {