dsh-plugin-om 0.0.59 → 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 (44) hide show
  1. package/README.md +34 -19
  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 +1 -4
  9. package/dist/client/om-config-controller.d.ts.map +1 -1
  10. package/dist/client.js +26 -35
  11. package/dist/client.js.map +1 -1
  12. package/dist/compress-loop.d.ts +5 -5
  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 +13 -1
  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 +1290 -842
  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 +104 -16
  41. package/dist/skill/compaction-eval/scripts/view.mjs +317 -104
  42. package/dist/types.d.ts +13 -12
  43. package/dist/types.d.ts.map +1 -1
  44. 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,390 +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
- /** 压缩会话首条消息中预注入区间条目的标题行,评估脚本据此提取原文视图。 */
339
- const INITIAL_HISTORY_HEADER = "区间当前条目(等同 getHistory 全区间返回):";
340
- const COMPLETE_MESSAGE_DEFINITION = "`完整消息`指一条`用户消息`、`模型输出文本`、`具有result的toolcall`或`手动加载的skill`;首条 index 为 0,按会话顺序递增。";
341
- /**
342
- * 最终 <history> 块内文块首的格式说明注释(XML 注释)。通用部分(条目标签语义 +
343
- * CDATA 约定 + toolcall 结构)始终保留;<user_message> /
344
- * <skill_content> / <ask-user-question> 的条目说明仅在块内存在对应条目时追加。
345
- */
346
- function historyFormatNote(sections = {}) {
347
- const parts = [
348
- COMPLETE_MESSAGE_DEFINITION,
349
- "<TAG index=\"N\">表示单条完整消息,<TAG start=\"A\" end=\"B\"> 表示多条连续消息,start/end 是首尾完整消息的 index;消息块的内容是用CDATA包裹的纯文本",
350
- "<assistant type=\"toolcall\" tool-name=\"T\" index=\"N\"> 表示工具调用,内含 <tool-args> 与 <tool-result> 两个CDATA子元素(调用参数与工具返回内容)"
351
- ];
352
- if (sections.user) parts.push("<user_message index=\"N\"> 表示用户消息原文");
353
- if (sections.skill) parts.push("<skill_content name=\"S\" index=\"N\"> 表示未压缩的原始 skill");
354
- if (sections.askUserQuestion) parts.push("<ask-user-question index=\"N\"> 表示向用户提问,CDATA 内为逐题成对的 q:(提问)与 a:(用户回答)行,未作答的题记为 a:(未回答)");
355
- return `<!-- ${parts.join(";")} -->`;
356
- }
357
- /** skill 工具名:toolcall 条目的工具名为该值时视为 skill 加载,<history> 块中以 <skill_content> 元素呈现。 */
358
- const SKILL_TOOL_NAME = "skill";
359
- /**
360
- * 提问工具名:成功且问题与答案完整配对时视为合法 ask,失败调用按普通 toolcall 处理。
361
- * 合法 ask 直接压缩需二次确认;未直接压缩的原始 ask 重写后以 q/a 形式保留。
362
- */
363
- const ASK_USER_QUESTION_TOOL_NAME = "ask_user_question";
364
- /**
365
- * 压缩因 signal 中止而放弃时 compaction/end 的 error 标识(服务端写入、客户端过滤):
366
- * 中止不是失败,客户端据此隐藏失败行(宿主不变量要求无 summary 的 end 必须带 error)。
367
- */
368
- const COMPACTION_ABORTED_ERROR = "压缩已中止(signal aborted)";
369
- /**
370
- * 判定 user/message 的 source 是否为本插件自产或宿主压缩 checkpoint(压缩日志消息与
371
- * 宿主压缩替换消息)。这类消息不占完整消息 index。宿主迁移前的 v3 信封形态
372
- * (kind 'plugin' + plugin 字段)仅作读取防御保留。
373
- */
374
- function isPluginOwnedSource(source) {
375
- if (source?.kind === "compact-checkpoint") return true;
376
- if (source?.kind === "plugin:dsh-plugin-om") return true;
377
- if (source?.kind !== "plugin") return false;
378
- return source.plugin === "dsh-plugin-om" || source.plugin === "compact";
379
- }
380
- //#endregion
381
- //#region src/logger.ts
382
- /**
383
- * 插件日志门面:step 为步骤级(debug)日志,按配置开关过滤;info/warn 始终输出。
384
- * 导出 PluginLogger / makeLogger。
385
- */
386
- /** 构建插件日志门面:统一加 PLUGIN_LABEL 前缀,step 按 debug 开关过滤。 */
387
- function makeLogger(ctx, debug) {
388
- return {
389
- step(message) {
390
- if (typeof debug === "function" ? debug() : debug) ctx.logger.debug(`${PLUGIN_LABEL}: ${message}`);
391
- },
392
- info(message) {
393
- ctx.logger.info(`${PLUGIN_LABEL}: ${message}`);
394
- },
395
- warn(message) {
396
- ctx.logger.warn(`${PLUGIN_LABEL}: ${message}`);
397
- }
398
- };
399
- }
400
- //#endregion
401
- //#region src/compaction-log.ts
402
- /** 诊断子会话的 descriptor provider(宿主子代理列表识别用)。 */
403
- const COMPACTION_LOG_PROVIDER = "om-compaction-log";
404
- /** 压缩 pass 的中文标签(会话记录 label 用;未知阶段回落「压缩」)。 */
405
- function phaseLabel(phase) {
406
- if (phase === "observe") return "观察";
407
- if (phase === "reflect") return "反思";
408
- return "压缩";
409
- }
410
- /**
411
- * 压缩会话记录 label:`OM会话(起点-终点)-观察/反思`,区间缺失省略括号段;
412
- * 重压缩追加 `-重压缩`,失败追加 `-失败`。
413
- */
414
- function compressionRecordLabel(phase, range, success, retry) {
415
- return `OM会话${range.min === void 0 || range.max === void 0 ? "" : `(${range.min}-${range.max})`}-${phaseLabel(phase)}${retry ? "-重压缩" : ""}${success ? "" : "-失败"}`;
416
- }
417
- /** 失败产物文本:`无(压缩失败[:原因[;最后一轮 finish=…[,输出 N tokens]]])`。 */
418
- function failureText(failure) {
419
- if (failure === void 0) return "无(压缩失败)";
420
- const last = failure.finish === void 0 ? "" : `;最后一轮 finish=${failure.finish}${failure.outputTokens === void 0 ? "" : `,输出 ${failure.outputTokens} tokens`}`;
421
- return `无(压缩失败:${failure.reason}${last})`;
422
- }
423
- /** 生成模型信息:压缩模型、思考等级、原始消息与压缩产物的字符数(k 单位)。 */
424
- function compressionInfo(info) {
425
- const effort = info.reasoningEffort ?? "默认思考等级";
426
- const result = info.resultChars === void 0 ? failureText(info.failure) : `${formatCompactCount(info.resultChars)} 字符`;
427
- return {
428
- text: `压缩使用模型 ${info.target.provider}/${info.target.model}(${effort}),原始消息 ${formatCompactCount(info.originalChars)} 字符,压缩产物 ${result}`,
429
- provider: info.target.provider,
430
- model: info.target.model
431
- };
432
- }
433
- /**
434
- * 构造一个 seed 事件信封:seq 由调用方按顺序传入,surface 事件附 surfaceOp:'append'。
435
- * 宿主 seed 边界校验信封字段(type/seq/time/data/surfaceOp)与消息形状,并原样保留
436
- * time(append 路径会强制改写为 Date.now()),故诊断记录经 seed 重建时间线。信封为
437
- * 判别联合,泛型构造需一次断言(与 tests/helpers.ts 同法)。
438
- */
439
- function seedEvent(type, seq, time, data, surfaceOp) {
440
- return {
441
- type,
442
- seq,
443
- time,
444
- data,
445
- ...surfaceOp === void 0 ? {} : { surfaceOp }
446
- };
447
- }
448
- /**
449
- * 重建压缩循环的 seed 事件时间线:descriptor + turn/step 生命周期 + 逐消息事件。每个
450
- * 事件携带从循环统计推导的 time——turn 边界取循环起止、第 k 个 assistant 取第 k 轮
451
- * 起止(step/start = startedAt、assistant/message = startedAt + durationMs)、工具调用
452
- * 与结果与其 assistant 同刻(内存工具瞬时)——并把逐轮 usage 附加到 assistant/message。
453
- * 时间全程单调不减;轮次数组短于 assistant 数时(流错误注入的部分 assistant)回落上一
454
- * 轮结束时刻与循环结束时刻。
455
- */
456
- function buildCompressionSeed(messages, stats, label, info, system) {
457
- const seed = [];
458
- const push = (type, time, data, surfaceOp) => {
459
- seed.push(seedEvent(type, seed.length, time, data, surfaceOp));
460
- };
461
- let cursor = stats.startedAt;
462
- const at = (time) => {
463
- cursor = Math.max(cursor, time);
464
- return cursor;
465
- };
466
- const executed = new Set(messages.filter((message) => message.role === "tool").map((message) => message.toolCallId));
467
- push("subagent/descriptor", at(stats.startedAt), {
468
- version: SUBAGENT_DESCRIPTOR_VERSION,
469
- mode: "one-shot",
470
- provider: COMPACTION_LOG_PROVIDER,
471
- label
472
- });
473
- push("turn/start", at(stats.startedAt), { turn: 1 });
474
- let step = 1;
475
- let assistantIndex = 0;
476
- let stepTime = stats.startedAt;
477
- let stepOpen = false;
478
- let pending = [];
479
- const closeStep = () => {
480
- if (!stepOpen) return;
481
- for (const call of pending) {
482
- if (executed.has(call.id)) continue;
483
- const repair = createToolResultMessage({
484
- callId: call.id,
485
- content: [{
486
- type: "text",
487
- text: "压缩循环未执行此工具调用"
488
- }],
489
- isError: true
490
- });
491
- push("tool/result", at(stepTime), {
492
- turn: 1,
493
- step,
494
- message: {
495
- ...repair,
496
- id: `forked-tool-result-${call.id}-${uuid()}`
497
- },
498
- error: {
499
- name: "ToolNotStartedError",
500
- code: "TOOL_NOT_STARTED"
501
- }
502
- }, "append");
503
- }
504
- push("step/end", at(stepTime), {
505
- turn: 1,
506
- step
507
- });
508
- pending = [];
509
- stepOpen = false;
510
- };
511
- for (const message of messages) if (message.role === "assistant") {
512
- closeStep();
513
- step += 1;
514
- const round = stats.rounds[assistantIndex];
515
- assistantIndex += 1;
516
- const startAt = round?.startedAt ?? stepTime;
517
- const completedAt = round === void 0 ? stats.completedAt : round.startedAt + round.durationMs;
518
- push("step/start", at(startAt), {
519
- turn: 1,
520
- step
521
- });
522
- stepOpen = true;
523
- const assistant = message;
524
- const assistantTime = at(completedAt);
525
- push("assistant/message", assistantTime, {
526
- turn: 1,
527
- step,
528
- message: assistant,
529
- stream: [],
530
- ...round?.usage === void 0 ? {} : { usage: round.usage }
531
- }, "append");
532
- stepTime = assistantTime;
533
- pending = assistant.content.filter((block) => block.type === "tool-call");
534
- for (const call of pending) {
535
- if (!executed.has(call.id)) continue;
536
- push("tool/call", at(stepTime), {
537
- turn: 1,
538
- step,
539
- callId: call.id,
540
- name: call.name,
541
- arguments: call.arguments
542
- });
543
- }
544
- } else if (message.role === "tool") push("tool/result", at(stepTime), {
545
- turn: 1,
546
- step,
547
- message
548
- }, "append");
549
- else if (!stepOpen) {
550
- const user = message;
551
- push("step/start", at(stats.startedAt), {
552
- turn: 1,
553
- step
554
- });
555
- stepOpen = true;
556
- if (system !== void 0 && system !== "") push("system/message", at(stats.startedAt), {
557
- turn: 1,
558
- step,
559
- message: createSystemMessage(system)
560
- }, "append");
561
- push("user/message", at(stats.startedAt), {
562
- ...user,
563
- source: { kind: "user" }
564
- }, "append");
565
- } else {
566
- const user = message;
567
- push("user/message", at(stepTime), user, "append");
568
- }
569
- closeStep();
570
- if (info !== void 0) {
571
- step += 1;
572
- push("step/start", at(stats.completedAt), {
573
- turn: 1,
574
- step
575
- });
576
- push("assistant/message", at(stats.completedAt), {
577
- turn: 1,
578
- step,
579
- message: createAssistantMessage({
580
- content: [{
581
- type: "text",
582
- text: info.text
583
- }],
584
- source: {
585
- provider: info.provider,
586
- model: info.model
587
- }
588
- }),
589
- stream: []
590
- }, "append");
591
- push("step/end", at(stats.completedAt), {
592
- turn: 1,
593
- step
594
- });
595
- }
596
- push("turn/end", at(stats.completedAt), {
597
- turn: 1,
598
- reason: { kind: "completed" }
599
- });
600
- return seed;
601
- }
602
- /**
603
- * 把一次压缩工具循环的完整会话消息组落盘为子会话:以重建时间线的 seed 事件经
604
- * ctx.sessions.create 构造子会话(header origin 'subagent'、parentSession 指向主会话、
605
- * delegationDepth = 父 + 1、cwd 继承主会话;首事件 one-shot descriptor,provider
606
- * om-compaction-log,label 含完整消息区间与阶段;info 存在时尾部追加一条模型文本),flush 持久化,在父会话登记
607
- * subagent/catalog,返回子会话 id。成功与失败均调用;落盘自身绝不抛错,任何失败仅
608
- * logger.warn 并返回 undefined。
609
- */
610
- async function recordCompressionSession(ctx, parentSession, options) {
611
- const logger = makeLogger(ctx, options.debug);
612
- try {
613
- const header = parentSession.header;
614
- const label = compressionRecordLabel(options.phase, options.range ?? {}, options.success, options.retry === true);
615
- const seed = buildCompressionSeed(options.messages, options.stats, label, options.info, options.system);
616
- const sessions = ctx.get("sessions");
617
- if (sessions === void 0) {
618
- logger.warn("sessions 服务未挂载,跳过压缩会话记录落盘");
619
- return;
620
- }
621
- const child = sessions.create(SessionId(`om-compaction-log-${uuid()}`), {
622
- seed,
623
- meta: {
624
- ...header.cwd === void 0 ? {} : { cwd: header.cwd },
625
- parentSession: parentSession.id,
626
- origin: "subagent",
627
- delegationDepth: (header.delegationDepth ?? 0) + 1
628
- }
629
- });
630
- const persistence = ctx.get("sessionPersistence");
631
- if (persistence === void 0) throw new Error("宿主未提供 sessionPersistence 服务");
632
- const write = await persistence.create(child.header);
633
- try {
634
- await write.append(child.snapshotEvents());
635
- await write.flush();
636
- } finally {
637
- await write.close();
638
- }
639
- parentSession.append("subagent/catalog", {
640
- version: 0,
641
- childId: child.id,
642
- childCreatedAt: child.header.createdAt,
643
- mode: "one-shot",
644
- label
645
- });
646
- await sessions.flush(parentSession);
647
- return child.id;
648
- } catch (error) {
649
- const message = error instanceof Error ? error.message : String(error);
650
- logger.warn(`压缩会话记录子会话落盘失败: ${message}`);
651
- return;
652
- }
653
- }
654
- //#endregion
655
- //#region node_modules/.pnpm/@xmldom+xmldom@0.9.11/node_modules/@xmldom/xmldom/lib/conventions.js
656
- var require_conventions = /* @__PURE__ */ __commonJSMin(((exports) => {
657
- /**
658
- * Ponyfill for `Array.prototype.find` which is only available in ES6 runtimes.
659
- *
660
- * Works with anything that has a `length` property and index access properties,
661
- * including NodeList.
662
- *
663
- * @param {T[] | { length: number; [number]: T }} list
664
- * @param {function (item: T, index: number, list:T[]):boolean} predicate
665
- * @param {Partial<Pick<ArrayConstructor['prototype'], 'find'>>?} ac
666
- * Allows injecting a custom implementation in tests (`Array.prototype` by default).
667
- * @returns {T | undefined}
668
- * @template {unknown} T
669
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find
670
- * @see https://tc39.es/ecma262/multipage/indexed-collections.html#sec-array.prototype.find
671
- */
672
- function find(list, predicate, ac) {
673
- if (ac === void 0) ac = Array.prototype;
674
- if (list && typeof ac.find === "function") return ac.find.call(list, predicate);
675
- for (var i = 0; i < list.length; i++) if (hasOwn(list, i)) {
676
- var item = list[i];
677
- 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;
678
317
  }
679
318
  }
680
319
  /**
@@ -7742,7 +7381,7 @@ var require_dom_parser = /* @__PURE__ */ __commonJSMin(((exports) => {
7742
7381
  exports.onWarningStopParsing = onWarningStopParsing;
7743
7382
  }));
7744
7383
  //#endregion
7745
- //#region src/log-index.ts
7384
+ //#region src/constants.ts
7746
7385
  var import_lib = (/* @__PURE__ */ __commonJSMin(((exports) => {
7747
7386
  var conventions = require_conventions();
7748
7387
  exports.assign = conventions.assign;
@@ -7782,6 +7421,80 @@ var import_lib = (/* @__PURE__ */ __commonJSMin(((exports) => {
7782
7421
  exports.onErrorStopParsing = domParser.onErrorStopParsing;
7783
7422
  exports.onWarningStopParsing = domParser.onWarningStopParsing;
7784
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
7785
7498
  /**
7786
7499
  * 会话日志索引:完整消息索引与渲染。
7787
7500
  * 导出 indexCompleteMessages(完整消息三类折叠索引,recall 与摘要共用同一套编号)、
@@ -8377,13 +8090,17 @@ function parseBlockEntries(blockText, blockSeq) {
8377
8090
  }
8378
8091
  const start = intAttr(el, "start");
8379
8092
  const end = intAttr(el, "end");
8380
- if (start !== void 0 && end !== void 0) entries.push({
8381
- kind: "assistant",
8382
- lo: start,
8383
- hi: end,
8384
- text,
8385
- blockSeq
8386
- });
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
+ }
8387
8104
  } else if (el.nodeName === "skill_content") {
8388
8105
  const index = intAttr(el, "index");
8389
8106
  if (index !== void 0) {
@@ -8435,18 +8152,67 @@ function parseBlockEntries(blockText, blockSeq) {
8435
8152
  if (entries.length === 0) return opaque();
8436
8153
  return entries;
8437
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
+ }
8438
8171
  /**
8439
- * 反思视图:全部 <history> 块(historySection 收集,按表层顺序)的内条目投影为条目。
8440
- * 要求区间为全部块内条目引用的最小 / 最大 index;块解析失败降级为不可定位遗留条目;
8441
- * skipReasoning 时不含 <reasoning> 参考条目。
8172
+ * 归档视图:被归档 <history> 块的条目去掉 reasoning 与具名 skill。用户条目与已处理
8173
+ * ask 原样保留并作为分隔,其间连续的可定位 assistant 条目构成一个归档段;不可定位的
8174
+ * 遗留条目同样作为分隔原样保留。具名 skill 按名称去重保留最新一份,随结果返回。
8442
8175
  */
8443
- function buildReflectView(blocks, options = {}) {
8176
+ function buildArchiveView(blocks) {
8177
+ const skills = /* @__PURE__ */ new Map();
8444
8178
  const entries = [];
8445
- for (const block of blocks) entries.push(...parseBlockEntries(block.text, block.seq));
8446
- 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();
8447
8209
  return {
8448
- entries: filtered,
8449
- ...viewBounds(filtered)
8210
+ view: {
8211
+ entries,
8212
+ ...viewBounds(entries),
8213
+ segments
8214
+ },
8215
+ skills: [...skills.values()].sort((a, b) => a.index - b.index)
8450
8216
  };
8451
8217
  }
8452
8218
  /**
@@ -8539,6 +8305,7 @@ function entryToElement(doc, entry) {
8539
8305
  el.setAttribute("start", String(entry.lo));
8540
8306
  el.setAttribute("end", String(entry.hi));
8541
8307
  }
8308
+ if (entry.keyWord !== void 0) el.setAttribute("key-word", entry.keyWord);
8542
8309
  appendCdataText(doc, el, entry.text);
8543
8310
  return el;
8544
8311
  }
@@ -8552,6 +8319,474 @@ function renderEntriesXml(entries) {
8552
8319
  return entries.map((entry) => serializer.serializeToString(entryToElement(doc, entry))).join("\n");
8553
8320
  }
8554
8321
  //#endregion
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
8555
8790
  //#region src/compress-tools.ts
8556
8791
  /** 判定 JSON 对象,不接受数组或 null。 */
8557
8792
  function isJsonRecord(value) {
@@ -8763,6 +8998,11 @@ var CompressionState = class CompressionState {
8763
8998
  text: `${CompressionState.spanLabel(lo, hi)} 超出要求的压缩区间 [${minIndex}..${maxIndex}]`,
8764
8999
  isError: true
8765
9000
  };
9001
+ const archive = this.archiveCheck(lo, hi, content, args.keywords);
9002
+ if (typeof archive === "string") return {
9003
+ text: archive,
9004
+ isError: true
9005
+ };
8766
9006
  let insideCount = 0;
8767
9007
  for (const entry of this.view.entries) {
8768
9008
  if (entry.lo === void 0 || entry.hi === void 0) continue;
@@ -8818,13 +9058,32 @@ var CompressionState = class CompressionState {
8818
9058
  this.replacements.push({
8819
9059
  lo,
8820
9060
  hi,
8821
- content
9061
+ content,
9062
+ ...archive === void 0 ? {} : { keywords: archive }
8822
9063
  });
8823
9064
  return {
8824
9065
  text: `已压缩${CompressionState.spanLabel(lo, hi)}(${insideCount} 条 assistant 条目)`,
8825
9066
  isError: false
8826
9067
  };
8827
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
+ }
8828
9087
  /** 完全包含该条目的替换记录;替换区间两两不相交,至多一条。 */
8829
9088
  replacementFor(entry) {
8830
9089
  const { lo, hi } = entry;
@@ -8868,7 +9127,8 @@ var CompressionState = class CompressionState {
8868
9127
  kind: "assistant",
8869
9128
  lo: rep.lo,
8870
9129
  hi: rep.hi,
8871
- text: rep.content
9130
+ text: rep.content,
9131
+ ...rep.keywords === void 0 ? {} : { keyWord: rep.keywords.join(", ") }
8872
9132
  },
8873
9133
  blocks: [],
8874
9134
  replacement: rep
@@ -8961,6 +9221,11 @@ var CompressionState = class CompressionState {
8961
9221
  text: `尚未处理原始 ask(index ${pending.join("、")}):请直接压缩,或先查看再调用 rewriteAskUserQuestion 重写后保留`,
8962
9222
  isError: true
8963
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
+ };
8964
9229
  this._completed = true;
8965
9230
  return {
8966
9231
  text: this.buildFinalBlock(),
@@ -8990,8 +9255,10 @@ var CompressionState = class CompressionState {
8990
9255
  const note = historyFormatNote({
8991
9256
  user: entries.some((e) => e.kind === "user"),
8992
9257
  skill: entries.some((e) => e.kind === "assistant" && e.toolName === "skill"),
8993
- askUserQuestion: entries.some(isAskEntry)
9258
+ askUserQuestion: entries.some(isAskEntry),
9259
+ keyWord: entries.some((e) => e.keyWord !== void 0)
8994
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}>`;
8995
9262
  return `<${HISTORY_TAG} tip="${HISTORY_TIP}">\n${note}\n${renderEntriesXml(entries)}\n</${HISTORY_TAG}>`;
8996
9263
  }
8997
9264
  };
@@ -9103,6 +9370,48 @@ const COMPRESSION_TOOL_SCHEMAS = [
9103
9370
  }
9104
9371
  }
9105
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
+ });
9106
9415
  //#endregion
9107
9416
  //#region src/rate-limit.ts
9108
9417
  /**
@@ -9166,8 +9475,8 @@ async function gateRateLimit(waitMs, signal) {
9166
9475
  * REFLECT_COMPRESSION_PROMPT / ASK_COMPRESSION_PROMPT / CompressionLoopOptions / CompressionOutcome / CompressionStats / COMPRESSION_NUDGE_TEXT / TRUNCATION_NUDGE_TEXT / COMPLETION_BLOCKED_TEXT。
9167
9476
  *
9168
9477
  * - 首条 user 消息为压缩指令与 start/end 区间(buildCompressionTaskText),循环附上
9169
- * 全区间 getHistory 结果,原始提问随之视为已查看;共享压缩提示词作为 system,反思
9170
- * pass 追加反思合并约束
9478
+ * 全区间 getHistory 结果,原始提问随之视为已查看;共享压缩提示词作为 system,归档
9479
+ * 视图追加归档深度压缩约束并改用归档工具定义
9171
9480
  * - 每轮请求携带压缩工具 schemas(purpose='compaction',maxTokens 沿用配置);流经
9172
9481
  * BlockAssembler 组装为 assistant 消息,工具执行结果以 tool-result 消息回填
9173
9482
  * - completeCompression 校验通过后立即停止(同轮后续工具调用不再执行),最终 <history>
@@ -9221,12 +9530,22 @@ function buildCompressionPrompt(skipReasoning) {
9221
9530
  /**
9222
9531
  * 构建压缩会话首条 user 消息的指令部分(压缩指令 + start/end 区间);区间条目由循环附加。
9223
9532
  */
9224
- function buildCompressionTaskText(phase, start, end) {
9225
- if (phase === "reflect") return `合并压缩全部 <history> 块,完整消息区间 [${start}..${end}]:区间条目附在下方,用 compressHistory 重新压缩合并 assistant 条目,完成后调用 completeCompression。`;
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
+ }
9226
9538
  return `压缩完整消息区间 [${start}..${end}]:区间条目附在下方,用 compressHistory 压缩 assistant 条目,完成后调用 completeCompression。`;
9227
9539
  }
9228
- /** 反思合并的额外约束,只在反思 pass 注入。 */
9229
- const REFLECT_COMPRESSION_PROMPT = ["【反思合并】", "- 重新压缩已有摘要条目时,保留其中的不可再生信息,不要逐轮缩减。"].join("\n");
9540
+ /** 归档深度压缩的额外约束,只在归档视图注入。 */
9541
+ const REFLECT_COMPRESSION_PROMPT = [
9542
+ "【归档深度压缩】",
9543
+ "- 本次产物是归档块,原文可由主模型通过 recall 按 index 找回;此规则优先于上方的粒度要求。",
9544
+ "- 用户消息与已处理的提问原样保留,无需处理。",
9545
+ "- 相邻两条用户消息之间的全部 assistant 条目构成一个归档段,每段压成一句话:写清结论、决策与涉及的文件,不写过程。",
9546
+ "- 一句话不超过 300 字符、不换行;已被段内后续进展取代的信息直接舍弃。",
9547
+ "- keywords 选原文中出现、便于检索的词:文件名、函数名、命令、错误码、主题词。"
9548
+ ].join("\n");
9230
9549
  /** 原始合法 ask 的处理约束,只在视图含待处理原始提问时注入。 */
9231
9550
  const ASK_COMPRESSION_PROMPT = [
9232
9551
  "【原始提问处理】",
@@ -9351,10 +9670,11 @@ async function runCompressionLoop(ctx, session, options) {
9351
9670
  const logger = makeLogger(ctx, options.debug);
9352
9671
  const view = withoutReasoning(options.view, options.skipReasoning);
9353
9672
  const state = new CompressionState(view);
9354
- 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;
9355
9675
  const system = [
9356
9676
  buildCompressionPrompt(options.skipReasoning),
9357
- ...options.phase === "reflect" ? [REFLECT_COMPRESSION_PROMPT] : [],
9677
+ ...view.segments === void 0 ? [] : [REFLECT_COMPRESSION_PROMPT],
9358
9678
  ...state.hasPendingAsks ? [ASK_COMPRESSION_PROMPT] : []
9359
9679
  ].join("\n\n");
9360
9680
  const messages = [makePluginUserMessage(withInitialHistory(options.taskText, state))];
@@ -9476,266 +9796,94 @@ async function runCompressionLoop(ctx, session, options) {
9476
9796
  logger.warn(`压缩循环触发限流(429),等待 ${options.rateLimitWaitMs}ms 后重试`);
9477
9797
  continue;
9478
9798
  }
9479
- if (retryTransient(failureMessage, failureStatus)) continue;
9480
- logger.warn(`压缩循环请求失败: ${failureMessage}`);
9481
- pushPartialAssistant(assembler, messages, options.target);
9482
- return await failWith(failureMessage, false);
9483
- }
9484
- transientRetries = 0;
9485
- rounds += 1;
9486
- if (assembler.usage !== void 0) usage = addUsage(usage, assembler.usage);
9487
- roundStats.push({
9488
- round: rounds,
9489
- startedAt: roundStartedAt,
9490
- durationMs: Date.now() - roundStartedAt,
9491
- ...assembler.usage === void 0 ? {} : { usage: assembler.usage }
9492
- });
9493
- const assistantMessage = assembler.message({
9494
- provider: options.target.provider,
9495
- model: options.target.model
9496
- });
9497
- messages.push(assistantMessage);
9498
- const calls = assembler.blocks().filter((block) => block.type === "tool-call");
9499
- if (calls.length === 0) {
9500
- if (finish.kind === "max-tokens") {
9501
- truncations += 1;
9502
- if (truncations >= MAX_CONSECUTIVE_FAILURES) {
9503
- const error = `模型连续 ${MAX_CONSECUTIVE_FAILURES} 轮输出被 max-tokens 截断,放弃本次压缩`;
9504
- logger.warn(error);
9505
- return await failWith(error, false);
9506
- }
9507
- logger.warn("模型输出被 max-tokens 截断且无工具调用,丢弃该轮输出并追加提醒后继续");
9508
- omitted.add(assistantMessage);
9509
- messages.push(makePluginUserMessage(TRUNCATION_NUDGE_TEXT));
9510
- continue;
9511
- }
9512
- nudges += 1;
9513
- if (nudges >= MAX_CONSECUTIVE_FAILURES) {
9514
- const error = `模型连续 ${MAX_CONSECUTIVE_FAILURES} 轮未调用压缩工具,放弃本次压缩`;
9515
- logger.warn(error);
9516
- return await failWith(error, false);
9517
- }
9518
- logger.warn("模型未调用压缩工具(输出纯文本),追加提醒后继续");
9519
- messages.push(makePluginUserMessage(COMPRESSION_NUDGE_TEXT));
9520
- continue;
9521
- }
9522
- nudges = 0;
9523
- truncations = 0;
9524
- /** 本轮失败且未被同轮后续成功提交解决的写入目标。 */
9525
- const unresolved = /* @__PURE__ */ new Set();
9526
- for (const call of calls) {
9527
- const result = call.name === "completeCompression" && unresolved.size > 0 ? {
9528
- text: COMPLETION_BLOCKED_TEXT,
9529
- isError: true
9530
- } : state.executeCall(call.name, call.arguments);
9531
- const target = writeTargetOf(call.name, call.arguments);
9532
- if (target !== void 0) {
9533
- if (result.isError) unresolved.add(target);
9534
- else unresolved.delete(target);
9535
- }
9536
- messages.push(toolResultOf(call, result));
9537
- if (state.completed) break;
9538
- }
9539
- if (state.completed) {
9540
- if (options.signal?.aborted) return await failWith(COMPACTION_ABORTED_ERROR, true);
9541
- const text = state.buildFinalBlock();
9542
- if (state.replacementCount === 0 && state.rewriteCount === 0) logger.warn("压缩完成但未执行任何压缩替换(空提交)");
9543
- logger.info(`压缩循环完成(${rounds} 轮,${state.replacementCount} 次压缩替换,${state.rewriteCount} 条提问重写,输出 ${text.length} 字符)`);
9544
- const stats = buildStats();
9545
- const id = await recordSessionId(true, stats, text.length);
9546
- return {
9547
- ok: true,
9548
- text,
9549
- rounds,
9550
- stats,
9551
- ...usage === void 0 ? {} : { usage },
9552
- ...id === void 0 ? {} : { recordSessionId: id }
9553
- };
9554
- }
9555
- }
9556
- }
9557
- //#endregion
9558
- //#region src/om-event.ts
9559
- /** om 信封 text 前缀:标识该 feedback/record 记录由本插件写入。 */
9560
- const OM_EVENT_PREFIX = "om:1:";
9561
- /**
9562
- * 解码一条会话事件为 om 私有事件:仅识别 feedback/record 中带 om 信封前缀的
9563
- * text;前缀缺失、JSON 非法、kind 未知或载荷字段缺失时返回 undefined。
9564
- */
9565
- function readOmEvent(event) {
9566
- if (event === void 0 || event === null || event.type !== "feedback/record") return void 0;
9567
- const text = event.data.text;
9568
- if (typeof text !== "string" || !text.startsWith("om:1:")) return void 0;
9569
- let envelope;
9570
- try {
9571
- envelope = JSON.parse(text.slice(5));
9572
- } catch {
9573
- return;
9574
- }
9575
- if (envelope === null || typeof envelope !== "object" || Array.isArray(envelope)) return void 0;
9576
- const { kind, ...rest } = envelope;
9577
- switch (kind) {
9578
- case "om/warning": {
9579
- const { problem, message } = rest;
9580
- if (typeof problem !== "string" || typeof message !== "string") return void 0;
9581
- return {
9582
- kind,
9583
- data: {
9584
- problem,
9585
- message
9586
- },
9587
- seq: event.seq
9588
- };
9589
- }
9590
- case "om/observe-pending": {
9591
- const { triggerMessageIndex } = rest;
9592
- if (typeof triggerMessageIndex !== "number" || !Number.isSafeInteger(triggerMessageIndex)) return void 0;
9593
- return {
9594
- kind,
9595
- data: { triggerMessageIndex },
9596
- seq: event.seq
9597
- };
9598
- }
9599
- case "om/observe-invalidate": {
9600
- const { pendingSeq } = rest;
9601
- if (typeof pendingSeq !== "number" || !Number.isSafeInteger(pendingSeq)) return void 0;
9602
- return {
9603
- kind,
9604
- data: { pendingSeq },
9605
- seq: event.seq
9606
- };
9607
- }
9608
- case "om/observe-summary": {
9609
- const { pendingSeq, report, provider, model, startedAt, completedAt, durationMs, recordSessionId, usage, reasoningEffort } = rest;
9610
- if (typeof pendingSeq !== "number" || !Number.isSafeInteger(pendingSeq)) return void 0;
9611
- if (typeof report !== "string") return void 0;
9612
- if (typeof provider !== "string" || typeof model !== "string") return void 0;
9613
- if (!isFiniteNumber(startedAt) || !isFiniteNumber(completedAt) || !isFiniteNumber(durationMs)) return void 0;
9614
- if (recordSessionId !== void 0 && typeof recordSessionId !== "string") return void 0;
9615
- if (reasoningEffort !== void 0 && typeof reasoningEffort !== "string") return void 0;
9616
- const parsedUsage = readTokenUsage(usage);
9617
- if (parsedUsage === null) return void 0;
9618
- return {
9619
- kind,
9620
- data: {
9621
- pendingSeq,
9622
- report,
9623
- provider,
9624
- model,
9625
- startedAt,
9626
- completedAt,
9627
- durationMs,
9628
- ...recordSessionId === void 0 ? {} : { recordSessionId },
9629
- ...parsedUsage === void 0 ? {} : { usage: parsedUsage },
9630
- ...reasoningEffort === void 0 ? {} : { reasoningEffort }
9631
- },
9632
- seq: event.seq
9633
- };
9634
- }
9635
- default: return;
9636
- }
9637
- }
9638
- /** 校验有限数值字段(时间戳/耗时)。 */
9639
- function isFiniteNumber(value) {
9640
- return typeof value === "number" && Number.isFinite(value);
9641
- }
9642
- /** 校验可选 token usage 字段:缺省返回 undefined,非法返回 null,合法返回仅含已知数值字段的对象。 */
9643
- function readTokenUsage(value) {
9644
- if (value === void 0) return void 0;
9645
- if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
9646
- const usage = value;
9647
- const { inputTokens, outputTokens } = usage;
9648
- if (!isFiniteNumber(inputTokens) || !isFiniteNumber(outputTokens)) return null;
9649
- const result = {
9650
- inputTokens,
9651
- outputTokens
9652
- };
9653
- for (const key of [
9654
- "totalTokens",
9655
- "cacheReadTokens",
9656
- "cacheWriteTokens",
9657
- "reasoningTokens"
9658
- ]) {
9659
- const field = usage[key];
9660
- if (field === void 0) continue;
9661
- if (!isFiniteNumber(field)) return null;
9662
- result[key] = field;
9663
- }
9664
- return result;
9665
- }
9666
- /** 编码一条 om 私有事件为 feedback/record 的 text 信封。 */
9667
- function encodeOmEvent(kind, data) {
9668
- return `${OM_EVENT_PREFIX}${JSON.stringify({
9669
- kind,
9670
- ...data
9671
- })}`;
9672
- }
9673
- /** 追加一条 om 私有事件(借用 feedback/record,log-only,不进 surface),返回事件 seq。 */
9674
- function appendOmEvent(session, kind, data) {
9675
- return session.append("feedback/record", { text: encodeOmEvent(kind, data) }).seq;
9676
- }
9677
- function findOmEvents(session, kind) {
9678
- const result = [];
9679
- for (const event of session.snapshotEvents()) {
9680
- const om = readOmEvent(event);
9681
- if (om !== void 0 && (kind === void 0 || om.kind === kind)) result.push(om);
9682
- }
9683
- return result;
9684
- }
9685
- //#endregion
9686
- //#region src/degrade.ts
9687
- /**
9688
- * 降级报告:压缩流程中的挂载失败统一出口。
9689
- * 导出 reportDegrade / DEGRADE_PROBLEMS / DegradedProblem。
9690
- *
9691
- * - 挂载失败类问题(服务缺失、服务调用异常)始终 console.warn 到宿主进程外部输出,
9692
- * 并向会话日志追加 log-only 的 om 警告事件(借用 feedback/record 的 om 信封,
9693
- * 见 om-event.ts;客户端渲染为「功能降级」警告行);
9694
- * 同一会话同一问题只报告一次(按日志扫描去重,重启不重复)
9695
- * - 报告动作自身绝不抛错:追加失败只记日志,不阻塞压缩
9696
- * - 辅助函数的普通运行时报错(组装失败、请求头读取失败)不走本模块,仅记日志
9697
- */
9698
- /** 各降级问题面向用户的简短说明(om/warning 信封载荷 message;客户端警告行直接展示)。 */
9699
- const DEGRADE_PROBLEMS = {
9700
- "systemPrompt-missing": "系统提示词服务未挂载,上下文压力估算不扣除系统提示词 tokens(压缩触发会偏早)",
9701
- "tokenMeter-unavailable": "token 计量服务异常,上下文压力估算降级(可能跳过压缩或按 0 计)",
9702
- "reasoning-effort-unavailable": "配置的压缩思考等级不被压缩目标模型支持,压缩降级为模型默认思考等级"
9703
- };
9704
- /**
9705
- * 报告一次挂载失败类降级:console.warn 始终输出到宿主进程外部;同会话同问题首次
9706
- * 出现时,向会话日志追加 log-only om 警告事件(客户端渲染警告行,每会话最多
9707
- * 一次)并输出 logger.warn(避免每个 pre-step 重复刷日志)。
9708
- * 日志扫描/事件追加失败只记日志,绝不抛错、不阻塞压缩。
9709
- */
9710
- function reportDegrade(session, logger, problem) {
9711
- const message = DEGRADE_PROBLEMS[problem];
9712
- let first = true;
9713
- try {
9714
- first = !findOmEvents(session, "om/warning").some((om) => om.data.problem === problem);
9715
- } catch {}
9716
- if (!first) return;
9717
- console.warn(`${PLUGIN_LABEL}: ${message}`);
9718
- logger.warn(message);
9719
- try {
9720
- appendOmEvent(session, "om/warning", {
9721
- problem,
9722
- message
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 }
9723
9812
  });
9724
- } catch (error) {
9725
- const text = error instanceof Error ? error.message : String(error);
9726
- 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
+ }
9727
9875
  }
9728
9876
  }
9729
9877
  //#endregion
9730
9878
  //#region src/precompress.ts
9731
9879
  /** 进程内注册表:session.id → 任务(重启即清空,由对账阶段恢复)。 */
9732
- const jobs = /* @__PURE__ */ new Map();
9880
+ const jobs$1 = /* @__PURE__ */ new Map();
9733
9881
  /**
9734
9882
  * 查询与活跃待定标记匹配的任务:pendingSeq 或会话对象不一致视为过期,
9735
9883
  * 中止并移除后返回 undefined(过期任务的信封写入落在已脱钩对象上,无保留价值)。
9736
9884
  */
9737
9885
  function findPrecompressionJob(session, pendingSeq) {
9738
- const job = jobs.get(session.id);
9886
+ const job = jobs$1.get(session.id);
9739
9887
  if (job === void 0) return void 0;
9740
9888
  if (job.session === session && job.pendingSeq === pendingSeq) return job;
9741
9889
  disposePrecompression(session.id);
@@ -9747,7 +9895,7 @@ function findPrecompressionJob(session, pendingSeq) {
9747
9895
  function startPrecompression(options) {
9748
9896
  const { ctx, session, config, pendingSeq, triggerMessageIndex } = options;
9749
9897
  const logger = makeLogger(ctx, config.debug);
9750
- const existing = jobs.get(session.id);
9898
+ const existing = jobs$1.get(session.id);
9751
9899
  if (existing !== void 0) {
9752
9900
  if (existing.session === session && existing.pendingSeq === pendingSeq) return {
9753
9901
  ok: true,
@@ -9783,7 +9931,7 @@ function startPrecompression(options) {
9783
9931
  promise,
9784
9932
  state: "running"
9785
9933
  };
9786
- jobs.set(session.id, job);
9934
+ jobs$1.set(session.id, job);
9787
9935
  runJobBody(ctx, job, options, logger).then(settle, settle);
9788
9936
  logger.step(`预压缩:任务启动(pendingSeq ${pendingSeq},区间 [${prepare.prepared.range.start}..${prepare.prepared.range.end}],遮蔽 ${prepare.prepared.replaceSeqs.length} 个表层节点)`);
9789
9937
  return {
@@ -9885,30 +10033,159 @@ function adoptPersistedSummary(data) {
9885
10033
  }
9886
10034
  /** 中止并移除会话的后台任务(session/disposed 或过期清理)。 */
9887
10035
  function disposePrecompression(sessionId) {
9888
- const job = jobs.get(sessionId);
10036
+ const job = jobs$1.get(sessionId);
9889
10037
  if (job === void 0) return;
9890
- jobs.delete(sessionId);
10038
+ jobs$1.delete(sessionId);
9891
10039
  job.controller.abort();
9892
10040
  }
9893
10041
  /** 中止并移除全部后台任务(插件卸载)。 */
9894
10042
  function disposeAllPrecompressions() {
9895
- 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();
9896
10171
  }
9897
10172
  //#endregion
9898
10173
  //#region src/compress.ts
9899
10174
  /**
9900
10175
  * 两级自动压缩(观察/反思)与 compaction 生命周期提交。
9901
10176
  * 导出 estimateTextTokens / isPairBalancedAfter / computeCompressRange / historySection /
9902
- * historyTextOf / findObservePending / prepareObserveCompression / commitObserveCompression /
9903
- * reflectPass / observePass / maybeCompress。
10177
+ * historyTextOf / archivedHistoryTextOf / findObservePending / prepareObserveCompression / commitObserveCompression /
10178
+ * reflectPass / commitReflection / observePass / maybeCompress。
9904
10179
  *
9905
10180
  * - 摘要生成走工具驱动的压缩循环(compress-loop.ts runCompressionLoop):首条 user
9906
10181
  * 消息仅含压缩指令与 start/end 区间,模型经 getHistory / compressHistory /
9907
10182
  * completeCompression 工具完成压缩;最终 <history> 块由插件从视图与替换记录构建,
9908
10183
  * 全程无需整块校验
9909
- * - 反思:全部 <history> 块 token 合计(估算 × 换算系数)≥ reflectThresholdTokens 时,
9910
- * 把全部块条目作为压缩视图重新压缩合并(视图无条目时跳过,如全部为不可解析的历史
9911
- * 遗留块)
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),块集合变化后重试
9912
10189
  * - 观察(打标记 → 对账 → 到期注入):净压力(换算系数 × 未压缩表层估算,未压缩 =
9913
10190
  * 表层 − 已压缩块 − 系统提示词估算)首次 ≥ observeThresholdTokens 时记录待定标记
9914
10191
  * (触发点 = 当时的最后一条完整消息 index),并立即开始后台预压缩(precompress.ts,
@@ -9920,24 +10197,24 @@ function disposeAllPrecompressions() {
9920
10197
  * tailMessageCount=0 时触发当轮即到期,阻塞等待注入
9921
10198
  * - 两个阈值都按主模型真实 token 计;换算系数 = 上次请求真实用量基线 ÷ 锚点估算
9922
10199
  * (工具定义估算 + 锚点表层),无真实用量基线或计量失败按 1 计
9923
- * - 待定标记与压缩结果以 log-only om 信封事件(借用 feedback/record,kind 为
10200
+ * - 待定标记与压缩结果以 ignorable 的 plugin record(kind 为
9924
10201
  * om/observe-pending / om/observe-invalidate / om/observe-summary,见 om-event.ts)
9925
10202
  * 持久化在会话日志中(重启后从日志恢复);压缩失败保留待定,下个 pre-step 重启任务重试
9926
- * - 两级在 pre-step 串行执行(先反思后观察;观察的压缩主体在后台运行,pre-step 仅在
9927
- * 到期结果未就绪时阻塞等待);仅主会话生效;omEnabled=false 关闭
10203
+ * - pre-step 先做反思检查(只启动或跳过,不阻塞),再执行观察(压缩主体在后台运行,
10204
+ * pre-step 仅在到期结果未就绪时阻塞等待);仅主会话生效;omEnabled=false 关闭
9928
10205
  * - 压缩目标默认跟随会话路由;compressProvider + compressModel 成对配置时覆盖路由
9929
10206
  * (成对配置下未路由会话也执行压缩);compressReasoningEffort 配置时压缩前经
9930
10207
  * ctx.llm.resolveModelInfo 校验目标模型 reasoning.efforts(按 provider+model 缓存),
9931
10208
  * 未命中 / 无元数据 / 查询失败降级为模型默认并报告 reasoning-effort-unavailable 降级
9932
- * - 压缩边界:最后一个合法 <history> 块之后的消息视为未压缩,其前不重复压缩
9933
- * - 压缩循环最终失败(连续无工具调用 / 请求级错误)时 pass 返回失败结果(携带最后一次
10209
+ * - 压缩边界:最后一个合法 <history> 或 <archived-history> 块之后的消息视为未压缩,其前不重复压缩
10210
+ * - 观察压缩循环最终失败(连续无工具调用 / 请求级错误)时 pass 返回失败结果(携带最后一次
9934
10211
  * 错误),压缩流程向上传播,pre-step 据此拒绝本 step 中断当前 turn;signal 中止标记
9935
10212
  * aborted(不中断);成功与失败均落盘压缩会话记录子会话(失败时其 id 随结果传播为
9936
10213
  * 诊断子会话 id)
9937
10214
  * - 提交走宿主 compaction/* 生命周期事件(start 带 phase → summary → 替换消息 → end),
9938
10215
  * 失败补 end(error,实际报错 + 诊断子会话 sessionId);替换消息 source 标记插件标识供 UI 认领
9939
10216
  * - 挂载失败类问题(systemPrompt/tokenMeter 服务异常)始终 console 到外部进程,并追加
9940
- * log-only om 警告事件(借用 feedback/record,客户端渲染功能降级警告行,每会话同一
10217
+ * ignorable 的 om 警告 plugin record(客户端渲染功能降级警告行,每会话同一
9941
10218
  * 问题至多一次);
9942
10219
  * 辅助估算的普通运行时报错仅记日志。降级与报错都不阻塞压缩(tokenMeter 计量失败时
9943
10220
  * 本轮跳过观察,反思换算系数按 1 计)
@@ -9990,31 +10267,33 @@ async function resolveCompressionEffort(ctx, session, config, target, logger) {
9990
10267
  compressionEffortCache.set(cacheKey, resolved);
9991
10268
  return resolved;
9992
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
+ }
9993
10276
  /**
9994
- * 运行压缩循环并归一化结果:失败统一追加 compaction/end(error)(携带诊断子会话 id),
9995
- * 成功记会话记录日志;返回循环结果(成功时由调用方提交)。
10277
+ * 判定消息是否为本插件的归档块消息并返回整段文本:插件自产且文本以
10278
+ * <archived-history> 开标签起始;其余返回 undefined。
9996
10279
  */
9997
- async function runPassLoop(ctx, session, lifecycle, options, logger, phase) {
9998
- const outcome = await runCompressionLoop(ctx, session, options);
9999
- if (!outcome.ok) {
10000
- logger.warn(`${phase === "reflect" ? "反思" : "观察"}:压缩循环失败(${outcome.error}),诊断子会话 ${outcome.recordSessionId ?? "未落盘"},追加 compaction/end(error)`);
10001
- try {
10002
- appendCompactionEnd(session, lifecycle, outcome.error, outcome.recordSessionId, outcome.stats.durationMs);
10003
- } catch {}
10004
- return outcome;
10005
- }
10006
- if (outcome.recordSessionId !== void 0) logger.step(`压缩会话记录子会话 ${outcome.recordSessionId}`);
10007
- 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;
10008
10288
  }
10009
10289
  /**
10010
10290
  * 判定消息是否为本插件的压缩日志消息并提取日志文本(按 source 标记判断,兼容旧宿主
10011
- * checkpoint 标记 'compact')。仅当消息文本含 <history> 开标签时视为压缩日志,返回整段
10012
- * 文本;其余返回 undefined。
10291
+ * checkpoint 标记 'compact')。仅当消息文本含 <history> 开标签且不是归档块时视为压缩
10292
+ * 日志,返回整段文本;其余返回 undefined。
10013
10293
  */
10014
10294
  function historyTextOf(event) {
10015
- if (event?.type !== "user/message") return void 0;
10016
- if (!isPluginOwnedSource(event.data.source)) return void 0;
10017
- const text = blocksToText(event.data.content);
10295
+ const text = pluginOwnedText(event);
10296
+ if (text === void 0 || archivedHistoryTextOf(event) !== void 0) return void 0;
10018
10297
  const idx = text.indexOf(`<${HISTORY_TAG}`);
10019
10298
  if (idx === -1) return void 0;
10020
10299
  const rest = text.slice(idx + 7 + 1);
@@ -10087,16 +10366,28 @@ function computeCompressRange(session, endMessageIndex) {
10087
10366
  };
10088
10367
  }
10089
10368
  /**
10090
- * 压缩边界(historySection):扫描表层全部节点,收集所有合法 <history> 压缩日志块
10091
- * (内文 + seq,按表层顺序),并以最后一个块的 seq 作为压缩边界——边界之后的消息视为
10092
- * 未压缩,其前(含边界自身)视为已压缩。无压缩日志时 blocks 为空、boundarySeq 为
10093
- * undefined。
10369
+ * 压缩边界(historySection):扫描表层全部节点,分别收集合法 <history> 块与
10370
+ * <archived-history> 归档块(内文 + seq,按表层顺序),并以两类块中表层位置最后的
10371
+ * 一个作为压缩边界——边界之后的消息视为未压缩,其前(含边界自身)视为已压缩。
10372
+ * 无压缩块时 blocks / archived 为空、boundarySeq 为 undefined。
10094
10373
  */
10095
10374
  function historySection(session) {
10096
10375
  const blocks = [];
10376
+ const archived = [];
10097
10377
  let boundarySeq;
10378
+ const events = session.snapshotEvents();
10098
10379
  for (const seq of session.surface.nodes) {
10099
- 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);
10100
10391
  if (text === void 0) continue;
10101
10392
  blocks.push({
10102
10393
  text,
@@ -10106,6 +10397,7 @@ function historySection(session) {
10106
10397
  }
10107
10398
  return {
10108
10399
  blocks,
10400
+ archived,
10109
10401
  boundarySeq
10110
10402
  };
10111
10403
  }
@@ -10224,113 +10516,221 @@ function appendHistoryMessage(session, content, sourceEventSeqs, surfaceOp, comp
10224
10516
  });
10225
10517
  }
10226
10518
  /**
10227
- * 反思:全部 <history> 块 token 合计 ≥ reflectThresholdTokens 时,把全部块内条目作为
10228
- * 压缩视图送入工具压缩循环,整个块区段合并替换为一条更紧凑的摘要。视图无条目(全部
10229
- * 为不可解析的历史遗留块)时跳过。失败不产生部分替换;最终失败返回失败结果
10230
- * (error = 最后一次错误)。
10519
+ * 反思(异步归档)检查:每个 pre-step 在观察前调用,不阻塞、不失败。
10520
+ * - 有运行中或待提交任务:跳过(待提交任务由 commitReflection 提交)
10521
+ * - 有失败任务:写 compaction/start + end(error) 后移除
10522
+ * - 无任务:history 块 token 合计(估算 × 换算系数)≥ reflectThresholdTokens 时,
10523
+ * 保留合计不超过阈值 1/3 的尾部块(至少 1 个),其余归档,启动后台反思;
10524
+ * 同一块集合上次失败则不重试
10231
10525
  */
10232
- async function reflectPass(ctx, agent, config, target, signal, reasoningEffort) {
10526
+ function reflectPass(ctx, agent, config, target, reasoningEffort) {
10233
10527
  const session = agent.session;
10234
10528
  const logger = makeLogger(ctx, config.debug);
10235
- logger.step(`反思检查(反思阈值 ${config.reflectThresholdTokens} tokens)`);
10236
- const { blocks } = historySection(session);
10237
- if (blocks.length === 0) {
10238
- logger.step("反思:无 <history> 压缩日志,跳过");
10239
- 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;
10240
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) {
10241
10556
  const threshold = config.reflectThresholdTokens;
10242
- 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);
10243
10569
  const measurement = measurePressure(ctx, session, logger);
10244
10570
  const ratio = measurement === void 0 ? 1 : conversionRatio(measurement, estimateToolsTokens(session, logger));
10245
- const tokens = Math.round(ratio * estimatedTokens);
10246
- 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)})`;
10247
10573
  if (tokens < threshold) {
10248
- logger.step(`反思:摘要 ${tokens} tokens(估算 ${estimatedTokens} × 换算系数 ${ratio.toFixed(2)})< 阈值 ${threshold},跳过`);
10249
- return { failed: false };
10574
+ logger.step(`反思:<history> 块 ${detail} < 阈值 ${threshold},跳过`);
10575
+ return;
10250
10576
  }
10251
- logger.step(`反思:摘要 ${tokens} tokens(估算 ${estimatedTokens} × 换算系数 ${ratio.toFixed(2)})≥ 阈值 ${threshold},触发精简合并(${blocks.length} 个块)`);
10252
- const first = blocks[0];
10253
- const last = blocks[blocks.length - 1];
10254
- if (first === void 0 || last === void 0) {
10255
- logger.step("反思:块区段缺失,跳过");
10256
- 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;
10257
10581
  }
10258
- const view = buildReflectView(blocks, { skipReasoning: config.compressSkipReasoning });
10582
+ const { view, skills } = buildArchiveView(archived);
10259
10583
  if (view.minIndex === void 0 || view.maxIndex === void 0) {
10260
- logger.step("反思:块内无可定位条目(历史遗留块),跳过");
10261
- return { failed: false };
10584
+ logger.step("反思:被归档块内无可定位条目(历史遗留块),跳过");
10585
+ return;
10262
10586
  }
10263
- 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;
10264
10606
  const lifecycle = {
10265
10607
  compactionId: newCompactionId(),
10266
10608
  turn: openTurnOf(session)
10267
10609
  };
10268
10610
  try {
10269
- logger.step("反思:追加 compaction/start(压缩循环前开启压缩中提示)");
10270
10611
  appendCompactionStart(session, lifecycle, "reflect");
10612
+ appendCompactionEnd(session, lifecycle, failure.error, failure.diagnosticSessionId);
10271
10613
  } catch (error) {
10272
10614
  const message = error instanceof Error ? error.message : String(error);
10273
- logger.warn(`反思压缩启动失败: ${message}`);
10274
- return { failed: false };
10615
+ logger.warn(`反思失败记录追加失败: ${message}`);
10275
10616
  }
10276
- const summaryResult = await runPassLoop(ctx, session, lifecycle, {
10277
- view,
10278
- originalChars: shadowedCharCount,
10279
- phase: "reflect",
10280
- taskText: buildCompressionTaskText("reflect", view.minIndex, view.maxIndex),
10281
- target,
10282
- maxTokens: config.compressMaxTokens,
10283
- rateLimitWaitMs: config.rateLimitWaitMs,
10284
- skipReasoning: config.compressSkipReasoning,
10285
- debug: config.debug,
10286
- ...reasoningEffort === void 0 ? {} : { reasoningEffort },
10287
- ...signal === void 0 ? {} : { signal }
10288
- }, logger, "reflect");
10289
- if (!summaryResult.ok) return {
10290
- failed: true,
10291
- error: summaryResult.error,
10292
- aborted: summaryResult.aborted,
10293
- ...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)
10294
10641
  };
10295
- const report = summaryResult.text;
10296
10642
  try {
10297
- 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 {
10298
10650
  const summarySeq = appendCompactionSummary(session, {
10299
10651
  lifecycle,
10300
- summary: report,
10652
+ summary: result.text,
10301
10653
  shadowedRange: {
10302
10654
  start: first.seq,
10303
10655
  end: last.seq
10304
10656
  },
10305
10657
  shadowedSeqs: blockSeqs,
10306
- shadowedTokenCount: estimatedTokens,
10307
- shadowedCharCount,
10308
- provider: target.provider,
10309
- model: target.model,
10658
+ shadowedTokenCount: job.estimatedTokens,
10659
+ shadowedCharCount: job.shadowedCharCount,
10660
+ provider: job.target.provider,
10661
+ model: job.target.model,
10310
10662
  maxTokens: config.compressMaxTokens,
10311
- stats: summaryResult.stats,
10312
- ...summaryResult.usage === void 0 ? {} : { usage: summaryResult.usage },
10313
- ...reasoningEffort === void 0 ? {} : { reasoningEffort }
10663
+ stats: result.stats,
10664
+ ...result.usage === void 0 ? {} : { usage: result.usage },
10665
+ ...job.reasoningEffort === void 0 ? {} : { reasoningEffort: job.reasoningEffort }
10314
10666
  });
10315
- logger.step("反思提交:替换整个 <history> 块区段为合并摘要");
10316
- appendHistoryMessage(session, report, [summarySeq, ...blockSeqs], {
10667
+ appendHistoryMessage(session, result.text, [summarySeq, ...blockSeqs], {
10317
10668
  op: "replace",
10318
10669
  startSeq: first.seq,
10319
10670
  endSeq: last.seq
10320
10671
  }, lifecycle.compactionId);
10321
- logger.step("反思提交:追加 compaction/end");
10322
- appendCompactionEnd(session, lifecycle, void 0, summaryResult.recordSessionId);
10323
- logger.info(`反思完成(摘要 ${tokens} tokens ≥ 阈值 ${threshold},合并 ${blocks.length} 个块为一条)`);
10324
- return { failed: false };
10672
+ appendCompactionEnd(session, lifecycle, void 0, result.recordSessionId);
10325
10673
  } catch (error) {
10326
10674
  const message = error instanceof Error ? error.message : String(error);
10327
10675
  logger.warn(`反思提交失败: ${message}`);
10328
10676
  try {
10329
- appendCompactionEnd(session, lifecycle, message, void 0, summaryResult.stats.durationMs);
10677
+ appendCompactionEnd(session, lifecycle, message, void 0, result.stats.durationMs);
10330
10678
  } catch {}
10331
- 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;
10332
10728
  }
10333
10729
  }
10730
+ /** XML 属性值反转义。 */
10731
+ function unescapeAttr(value) {
10732
+ return value.replaceAll("&quot;", "\"").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&apos;", "'").replaceAll("&amp;", "&");
10733
+ }
10334
10734
  /**
10335
10735
  * 估算系统提示词 tokens:按 agent 作用域组装并渲染系统提示词,按长度/4 启发式计。
10336
10736
  * systemPrompt 服务经 ctx.get 容错读取(ctx 属性访问在服务未挂载时抛错);服务缺失
@@ -10546,8 +10946,8 @@ async function observePass(ctx, agent, config, waitCount, target, signal, reason
10546
10946
  const threshold = config.observeThresholdTokens;
10547
10947
  const measurement = measurePressure(ctx, session, logger);
10548
10948
  if (measurement === void 0) return { failed: false };
10549
- const { blocks } = historySection(session);
10550
- 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);
10551
10951
  const systemTokens = await estimateSystemPromptTokens(ctx, agent, logger, signal);
10552
10952
  const ratio = conversionRatio(measurement, estimateToolsTokens(session, logger));
10553
10953
  const uncompressedTokens = Math.max(0, measurement.surfaceTokens - historyTokens - systemTokens);
@@ -10688,9 +11088,9 @@ async function observePass(ctx, agent, config, waitCount, target, signal, reason
10688
11088
  });
10689
11089
  }
10690
11090
  /**
10691
- * 压力检查 + 两级压缩入口:先反思后观察,pre-step 阻塞串行执行;仅主会话生效。
10692
- * 反思摘要耗尽失败时直接返回失败结果(观察无需继续,本轮将被拒绝);观察失败同样
10693
- * 传播失败结果,由 pre-step 拒绝本 step 中断当前 turn。
11091
+ * 压力检查 + 两级压缩入口(pre-step 调用,仅主会话生效):
11092
+ * 先反思(异步:只启动或提交后台任务,不阻塞、不失败),后观察(阻塞注入)。
11093
+ * 观察失败传播失败结果,由 pre-step 拒绝本 step 中断当前 turn。
10694
11094
  */
10695
11095
  async function maybeCompress(ctx, agent, config, signal) {
10696
11096
  const session = agent.session;
@@ -10708,11 +11108,7 @@ async function maybeCompress(ctx, agent, config, signal) {
10708
11108
  const reasoningEffort = await resolveCompressionEffort(ctx, session, config, target, logger);
10709
11109
  const waitCount = config.tailMessageCount;
10710
11110
  logger.step("反思 pass 开始");
10711
- const reflect = await reflectPass(ctx, agent, config, target, signal, reasoningEffort);
10712
- if (reflect.failed) {
10713
- logger.step("反思 pass 失败(本轮将被拒绝),跳过观察 pass");
10714
- return reflect;
10715
- }
11111
+ reflectPass(ctx, agent, config, target, reasoningEffort);
10716
11112
  logger.step("反思 pass 结束,观察 pass 开始");
10717
11113
  const observe = await observePass(ctx, agent, config, waitCount, target, signal, reasoningEffort);
10718
11114
  logger.step("观察 pass 结束,压缩流程完成");
@@ -10934,7 +11330,7 @@ function cosineSimilarity(a, b) {
10934
11330
  /** 默认配置(冻结对象,resolveConfig 合并的基底;debug 缺省值在解析时按 NODE_ENV 判定)。 */
10935
11331
  const DEFAULT_CONFIG = Object.freeze({
10936
11332
  observeThresholdTokens: 35e3,
10937
- reflectThresholdTokens: 4e4,
11333
+ reflectThresholdTokens: 8e4,
10938
11334
  compressMaxTokens: void 0,
10939
11335
  rateLimitWaitMs: 6e4,
10940
11336
  recompressConcurrency: 2,
@@ -10946,7 +11342,6 @@ const DEFAULT_CONFIG = Object.freeze({
10946
11342
  progressReminderIdleSteps: 4,
10947
11343
  progressReminderIdleToolCalls: 10,
10948
11344
  debug: false,
10949
- recallEnabled: true,
10950
11345
  semanticRecallEnabled: true,
10951
11346
  modelDir: sharedModelDir(),
10952
11347
  compressProvider: void 0,
@@ -10968,7 +11363,6 @@ const Config = Schema.object({
10968
11363
  progressReminderIdleSteps: Schema.number().step(1).min(1).default(DEFAULT_CONFIG.progressReminderIdleSteps).volatile(),
10969
11364
  progressReminderIdleToolCalls: Schema.number().step(1).min(0).default(DEFAULT_CONFIG.progressReminderIdleToolCalls).volatile(),
10970
11365
  debug: Schema.boolean().default(process.env.NODE_ENV !== "production").volatile(),
10971
- recallEnabled: Schema.boolean().default(DEFAULT_CONFIG.recallEnabled).volatile(),
10972
11366
  semanticRecallEnabled: Schema.boolean().default(DEFAULT_CONFIG.semanticRecallEnabled).volatile(),
10973
11367
  modelDir: Schema.string().default(DEFAULT_CONFIG.modelDir).volatile(),
10974
11368
  compressProvider: Schema.string().volatile(),
@@ -11044,8 +11438,7 @@ function resolveConfig(raw) {
11044
11438
  config.progressReminderEnabled = resolveBoolean(input.progressReminderEnabled, true);
11045
11439
  config.progressReminderIdleEnabled = resolveBoolean(input.progressReminderIdleEnabled, DEFAULT_CONFIG.progressReminderIdleEnabled);
11046
11440
  config.debug = resolveBoolean(input.debug, process.env.NODE_ENV !== "production");
11047
- config.recallEnabled = resolveBoolean(input.recallEnabled, true);
11048
- config.semanticRecallEnabled = config.recallEnabled && resolveBoolean(input.semanticRecallEnabled, true);
11441
+ config.semanticRecallEnabled = resolveBoolean(input.semanticRecallEnabled, true);
11049
11442
  const modelDir = input.modelDir;
11050
11443
  if (typeof modelDir === "string" && modelDir.trim() !== "") config.modelDir = modelDir;
11051
11444
  config.compressProvider = resolveOptionalString(input.compressProvider);
@@ -11256,11 +11649,14 @@ function renderCompleteMessageXml(session, cm, options = {}) {
11256
11649
  //#endregion
11257
11650
  //#region src/semantic-recall.ts
11258
11651
  /**
11259
- * recall 语义增强的检索实现:按自然语言 query 对会话全部完整消息(含被压缩/遮蔽的)做
11260
- * 语义检索,返回最匹配的完整消息与匹配说明。
11652
+ * recall 的 query 检索实现:对会话全部完整消息(含被压缩/遮蔽的)检索,返回最匹配的
11653
+ * 完整消息与匹配说明。
11261
11654
  * 导出 SemanticOptions / RangeArgs / resolveSemanticRange / tokenize / matchExplanation /
11262
- * SEMANTIC_MODEL_NOT_READY_MESSAGE / semanticSearch。
11263
- * 向量为本地 ONNX 嵌入(cosine 相似度);只匹配文本,纯图片消息不进候选池;
11655
+ * keywordTerms / SEMANTIC_MODEL_NOT_READY_MESSAGE / semanticSearch / keywordSearch。
11656
+ * - 语义检索:本地 ONNX 嵌入(cosine 相似度)
11657
+ * - 字符串匹配(语义增强关闭时):query 按空白拆词,不区分大小写计命中词数,同分时
11658
+ * index 大的优先,零命中不返回
11659
+ * 只匹配文本,纯图片消息不进候选池;
11264
11660
  * 区间缺省检索全部、区间不合法回退全量并在输出中告知;输出契约同 recall
11265
11661
  * ({ text, images },条目为 XML 形态见 recall-xml.ts,超大结果由 tool-result-pruner
11266
11662
  * 裁剪);候选池排除本次调用自身的 toolcall 完整消息(其渲染文本含 query 原文,
@@ -11332,13 +11728,11 @@ function matchExplanation(query, text, score) {
11332
11728
  }
11333
11729
  /** 模型未就绪时返回给模型的文案(下载完成后直接再次调用即可)。 */
11334
11730
  const SEMANTIC_MODEL_NOT_READY_MESSAGE = "语义检索暂不可用,本地向量模型尚未就绪。";
11335
- /** 在会话完整消息中做语义检索,返回 TOP-K 命中条目。 */
11336
- async function semanticSearch(input) {
11337
- const { session, query, topK, start, end, offset, selfCallId, getPruner, options } = input;
11338
- const embed = options?.embedder ?? ((texts) => getEmbedder().then((fn) => fn(texts)));
11339
- 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;
11340
11734
  const cms = indexCompleteMessages(session);
11341
- if (cms.length === 0) return textOnly("会话中没有可检索的消息");
11735
+ if (cms.length === 0) return "会话中没有可检索的消息";
11342
11736
  const range = resolveSemanticRange(cms.length, {
11343
11737
  start,
11344
11738
  end,
@@ -11358,7 +11752,20 @@ async function semanticSearch(input) {
11358
11752
  text
11359
11753
  });
11360
11754
  }
11361
- 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;
11362
11769
  const [queryVec] = await embed([query]);
11363
11770
  if (!queryVec) return textOnly("语义检索失败:无法生成查询向量");
11364
11771
  const vectors = await embed(candidates.map((c) => c.text));
@@ -11368,18 +11775,53 @@ async function semanticSearch(input) {
11368
11775
  score: cosineSimilarity(queryVec, vectors[i] ?? /* @__PURE__ */ new Float32Array(0))
11369
11776
  }));
11370
11777
  scored.sort((a, b) => b.score - a.score);
11371
- const limit = topK ?? 3;
11372
- 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;
11373
11815
  const parts = [];
11374
11816
  const images = [];
11375
- 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})`;
11376
11818
  parts.push(`<!-- ${xmlCommentText(`查询: ${query}`)} -->`);
11377
11819
  parts.push(`<!-- ${xmlCommentText(rangeNote)} -->`);
11378
- parts.push(`<!-- ${xmlCommentText(`匹配 TOP-${hits.length}(共 ${scored.length} 条候选)`)} -->`);
11820
+ parts.push(`<!-- ${xmlCommentText(`匹配 TOP-${hits.length}(共 ${total} 条候选)`)} -->`);
11379
11821
  for (let i = 0; i < hits.length; i += 1) {
11380
11822
  const hit = hits[i];
11381
11823
  if (!hit) continue;
11382
- const note = `<!-- ${xmlCommentText(`${i + 1}. ${matchExplanation(query, hit.text, hit.score)}`)} -->`;
11824
+ const note = `<!-- ${xmlCommentText(`${i + 1}. ${hit.explanation}`)} -->`;
11383
11825
  let xml;
11384
11826
  let hitImages = [];
11385
11827
  try {
@@ -11405,28 +11847,20 @@ async function semanticSearch(input) {
11405
11847
  //#endregion
11406
11848
  //#region src/recall.ts
11407
11849
  /**
11408
- * recall 工具:回看原始会话(含被压缩内容),语义增强启用时额外支持按含义检索。
11409
- * 导出 recallArgsSchema / enhancedRecallArgsSchema / RecallArgs / parseRecallArgs / buildRecallTool。
11850
+ * recall 工具:回看原始会话(含被压缩内容)。
11851
+ * 导出 recallArgsSchema / RecallArgs / parseRecallArgs / buildRecallTool。
11410
11852
  * - 区间模式:按完整消息 index 的 start/end/offset 精确返回区间内全部完整消息。
11411
- * - 语义模式(仅增强启用且带 query):语义检索见 semantic-recall.ts。
11853
+ * - 检索模式(带 query):语义增强启用时按含义检索,否则按字符串匹配,见 semantic-recall.ts。
11412
11854
  * 输出值为 { text, images }(契约见 recall-output.ts),text 为 XML 条目序列
11413
11855
  * (形态见 recall-xml.ts);recall 自身不设输出上限,超大工具结果由 tool-result-pruner 裁剪。
11414
11856
  */
11415
11857
  /**
11416
- * 基础 recall 参数 schema:start 必填;end 与 offset 至少提供一个(同时给出时 end 优先)。
11858
+ * recall 参数 schema:带 query 走检索模式(区间可选,用于限定检索范围);
11859
+ * 不带 query 时 start 必填,end 与 offset 至少提供一个(同时给出时 end 优先)。
11417
11860
  * 各字段描述经 .describe() 透传到 wire JSON Schema。
11418
11861
  */
11419
11862
  const recallArgsSchema = z.object({
11420
- start: z.number().describe("完整消息 index,基准边界,与 end 或 offset 配合指定区间;end 与 offset 至少提供一个(同时给出时 end 优先)。"),
11421
- end: z.number().optional().describe("与 offset 互斥,指定区间另一边界。"),
11422
- offset: z.number().optional().describe("与 end 互斥,相对 start 的步数(正向后、负向前)。")
11423
- }).refine((args) => args.end !== void 0 || args.offset !== void 0, { message: "end 与 offset 至少提供一个" });
11424
- /**
11425
- * 语义增强 recall 参数 schema:带 query 走语义模式(区间可选,用于限定检索范围),
11426
- * 不带 query 时与基础 schema 的校验一致。
11427
- */
11428
- const enhancedRecallArgsSchema = z.object({
11429
- query: z.string().optional().describe("按含义检索的自然语言 query(中英文与代码术语皆可,如 \"修复 retry backoff 的逻辑\");提供时 start/end/offset 仅用于限定搜索区间,缺省检索全部。"),
11863
+ query: z.string().optional().describe("检索 query(中英文与代码术语皆可);提供时 start/end/offset 仅用于限定搜索区间,缺省检索全部。"),
11430
11864
  top_k: z.number().int().min(1).max(10).optional().describe("仅 query 模式:返回最匹配条数(1-10,默认 3)。"),
11431
11865
  start: z.number().optional().describe("完整消息 index,基准边界,与 end 或 offset 配合指定区间;未提供 query 时必填,且 end 与 offset 至少提供一个(同时给出时 end 优先)。"),
11432
11866
  end: z.number().optional().describe("与 offset 互斥,指定区间另一边界。"),
@@ -11451,47 +11885,50 @@ const enhancedRecallArgsSchema = z.object({
11451
11885
  message: "end 与 offset 至少提供一个"
11452
11886
  });
11453
11887
  });
11454
- /** 解析并校验 recall 调用参数(semantic 为语义增强是否启用):失败时抛出首个校验问题的可读消息。 */
11455
- function parseRecallArgs(raw, semantic = false) {
11456
- const result = (semantic ? enhancedRecallArgsSchema : recallArgsSchema).safeParse(raw);
11888
+ /** 解析并校验 recall 调用参数:失败时抛出首个校验问题的可读消息。 */
11889
+ function parseRecallArgs(raw) {
11890
+ const result = recallArgsSchema.safeParse(raw);
11457
11891
  if (!result.success) throw new Error(result.error.issues.map((issue) => `${issue.path.join(".") || "args"}: ${issue.message}`).join("; "));
11458
11892
  return result.data;
11459
11893
  }
11460
- /** 基础工具描述。 */
11461
- const RECALL_DESCRIPTION = `在你需要查看历史消息时调用。${COMPLETE_MESSAGE_DEFINITION}此工具按 index 区间精确返回区间内全部完整消息的内容。`;
11462
- /** 语义增强启用时的工具描述。 */
11463
- 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
+ }
11464
11898
  /**
11465
- * 构建 recall 工具定义:按 start/end/offset 定位完整消息区间并渲染原始内容(标 index);
11466
- * 传入 semantic 选项时额外支持 query 语义检索。
11899
+ * 构建 recall 工具定义:按 start/end/offset 定位完整消息区间并渲染原始内容(标 index),
11900
+ * 或按 query 检索(传入 semantic 选项时语义检索,否则字符串匹配)。
11467
11901
  */
11468
11902
  function buildRecallTool(options) {
11469
11903
  const getPruner = options?.getPruner;
11470
11904
  const semantic = options?.semantic;
11471
11905
  return {
11472
11906
  name: "recall",
11473
- description: semantic ? ENHANCED_RECALL_DESCRIPTION : RECALL_DESCRIPTION,
11474
- parameters: parametersFromZod(semantic ? enhancedRecallArgsSchema : recallArgsSchema),
11907
+ description: recallDescription(semantic !== void 0),
11908
+ parameters: parametersFromZod(recallArgsSchema),
11475
11909
  output: {
11476
11910
  schema: RECALL_OUTPUT_SCHEMA,
11477
11911
  render: (_args, value) => renderRecallOutput(value)
11478
11912
  },
11479
11913
  async execute(args, exec) {
11480
- const { query, top_k, start, end, offset } = parseRecallArgs(args, semantic !== void 0);
11914
+ const { query, top_k, start, end, offset } = parseRecallArgs(args);
11481
11915
  const session = exec.agent?.session;
11482
11916
  if (!session) return textOnly("会话异常");
11483
11917
  if (!isMainSession(session)) return textOnly("recall 仅主会话可用");
11484
- if (query !== void 0) return semanticSearch({
11485
- session,
11486
- query,
11487
- topK: top_k,
11488
- start,
11489
- end,
11490
- offset,
11491
- selfCallId: String(exec.callId ?? ""),
11492
- getPruner: () => getPruner?.(),
11493
- options: semantic
11494
- });
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
+ }
11495
11932
  if (start === void 0) return textOnly("start 必填");
11496
11933
  const cms = indexCompleteMessages(session);
11497
11934
  const startIndex = Number.isFinite(start) ? Math.floor(start) : 0;
@@ -11615,15 +12052,15 @@ function findLifecycle(session, compactionId) {
11615
12052
  }
11616
12053
  return lifecycle;
11617
12054
  }
11618
- /** 重建被压缩内容的视图;不可重建时返回错误。 */
12055
+ /** 重建被压缩内容的视图:反思用被归档块的归档视图,观察用原消息;不可重建时返回错误。 */
11619
12056
  function rebuildView(session, phase, shadowedSeqs, skipReasoning) {
11620
- if (phase === "reflect") return buildReflectView(shadowedSeqs.flatMap((seq) => {
12057
+ if (phase === "reflect") return buildArchiveView(shadowedSeqs.flatMap((seq) => {
11621
12058
  const text = historyTextOf(session.snapshotEvents()[seq]);
11622
12059
  return text === void 0 ? [] : [{
11623
12060
  text,
11624
12061
  seq
11625
12062
  }];
11626
- }), { skipReasoning });
12063
+ })).view;
11627
12064
  return buildObserveView(session, shadowedSeqs, { skipReasoning });
11628
12065
  }
11629
12066
  /** 按 compactionId 重建一次已成功压缩的输入视图;不可重放时返回错误文本。 */
@@ -11680,7 +12117,7 @@ async function recompress(ctx, agent, config, request, signal) {
11680
12117
  view,
11681
12118
  originalChars,
11682
12119
  phase,
11683
- taskText: buildCompressionTaskText(phase, view.minIndex, view.maxIndex),
12120
+ taskText: buildCompressionTaskText(phase, view.minIndex, view.maxIndex, view.segments),
11684
12121
  target,
11685
12122
  maxTokens: config.compressMaxTokens,
11686
12123
  rateLimitWaitMs: config.rateLimitWaitMs,
@@ -12002,7 +12439,7 @@ function apply(ctx, config) {
12002
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 ?? "模型默认"}`);
12003
12440
  const warnModel = (message) => ctx.logger.warn(`dsh-plugin-om: ${message}`);
12004
12441
  const logModel = (message) => logger.info(message);
12005
- if (resolved.recallEnabled && ctx.get("tools") === void 0) logger.warn("tools 服务未挂载,recall 暂不可用");
12442
+ if (ctx.get("tools") === void 0) logger.warn("tools 服务未挂载,recall 暂不可用");
12006
12443
  if (ctx.get("commands") === void 0) logger.warn("commands 服务未挂载,重压缩与 OM 结果评估命令暂不可用");
12007
12444
  ctx.inject(["tools"], (inner) => {
12008
12445
  let disposeRecall;
@@ -12011,13 +12448,13 @@ function apply(ctx, config) {
12011
12448
  /** 保持注册的 recall 与当前配置一致;仅语义增强首次生效或更换目录时启动后台预热。 */
12012
12449
  const syncTools = () => {
12013
12450
  const next = currentConfig(config);
12014
- const semantic = next.recallEnabled && next.semanticRecallEnabled;
12015
- 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)) {
12016
12453
  disposeRecall();
12017
12454
  disposeRecall = void 0;
12018
12455
  registered = void 0;
12019
12456
  }
12020
- if (next.recallEnabled && !disposeRecall) {
12457
+ if (!disposeRecall) {
12021
12458
  const directory = next.modelDir;
12022
12459
  disposeRecall = inner.tools.register(buildRecallTool({
12023
12460
  getPruner: () => inner.get("toolResultPruner"),
@@ -12047,6 +12484,8 @@ function apply(ctx, config) {
12047
12484
  ctx.inject(["sessions"], (inner) => registerThinkingBinding(inner, logger));
12048
12485
  ctx.on("session/disposed", (session) => disposePrecompression(session.id));
12049
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");
12050
12489
  ctx.on("agent/pre-step", async ({ agent, signal }, next) => {
12051
12490
  let outcome = { failed: false };
12052
12491
  try {
@@ -12064,7 +12503,16 @@ function apply(ctx, config) {
12064
12503
  logger.warn(`上下文压缩失败,拒绝本 step 中断当前 turn:${outcome.error}${diagnostic}`);
12065
12504
  return { kind: "reject" };
12066
12505
  }
12067
- 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
+ }
12068
12516
  const latest = currentConfig(config);
12069
12517
  const reminders = activeSystemReminders(latest);
12070
12518
  if (decision.kind === "enter" && !signal.aborted && reminders.length > 0 && isMainSession(agent.session)) return {