dsh-retrace 0.4.148 → 0.4.151
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.
- package/README.md +15 -14
- package/README.zh.md +18 -10
- package/bin/retrace.mjs +0 -0
- package/lib/adapter/dsh-writer.js +2 -2
- package/lib/adapter/dsh.js +8 -508
- package/lib/archaeology-cli.js +3 -3
- package/lib/boot-pin.js +1 -1
- package/lib/client-i18n.js +22 -13
- package/lib/client.bundle.js +3 -3
- package/lib/client.js +136 -205
- package/lib/close-guard-client.js +2 -2
- package/lib/dynamic-client.js +3 -3
- package/lib/dynamic-host.js +8 -257
- package/lib/host-core.js +2 -193
- package/lib/http.js +3 -132
- package/lib/index.js +365 -862
- package/lib/marker-carrier.js +4 -4
- package/lib/platform/session-paths.js +11 -43
- package/lib/prewrite-guard.js +0 -28
- package/lib/span-semantics.js +1 -1
- package/lib/versioning.js +34 -2
- package/package.json +20 -16
- package/lib/adapter/compaction-backend.js +0 -92
- package/lib/adapter/register-compaction-backend.js +0 -93
- package/lib/auto-fold-scheduler.js +0 -519
- package/lib/badge.js +0 -65
- package/lib/cache-metrics.js +0 -358
- package/lib/context-level.js +0 -139
- package/lib/core-contract.js +0 -77
- package/lib/fold-auto.js +0 -621
- package/lib/fold-boundary.js +0 -1051
- package/lib/fold-core-text.js +0 -52
- package/lib/fold-core.js +0 -191
- package/lib/fold-summary.js +0 -168
- package/lib/hw3-fallback.js +0 -262
- package/lib/identity/code-assign.js +0 -228
- package/lib/identity/dedupe.js +0 -168
- package/lib/identity/shortcode.js +0 -782
- package/lib/identity/sidebar-badge.js +0 -270
- package/lib/identity-check-cli.js +0 -379
- package/lib/ledger-guard.js +0 -491
- package/lib/token-estimate.js +0 -91
package/lib/adapter/dsh.js
CHANGED
|
@@ -75,7 +75,7 @@ export function foldSurfaceWithProjections(fold, events, projections) {
|
|
|
75
75
|
// span 语义(状态枚举 + 轮首回退/切片规则)收敛到单一真相模块——
|
|
76
76
|
// 适配层与业务层(host-core/message-list)调用同一实现,不再各写一份。
|
|
77
77
|
import {
|
|
78
|
-
SPAN_STATUS
|
|
78
|
+
SPAN_STATUS, spanAt, spanOk, spanMiss,
|
|
79
79
|
isRoundBoundaryEvent,
|
|
80
80
|
} from '../span-semantics.js'
|
|
81
81
|
// 跨层契约运行时校验(形状违规 → 指名道姓的错误,不静默/不奇怪地炸)
|
|
@@ -168,17 +168,6 @@ export async function hostPriceNode(opts = {}) {
|
|
|
168
168
|
}
|
|
169
169
|
}
|
|
170
170
|
|
|
171
|
-
/* @public-strip:start */
|
|
172
|
-
/** 官方 nodes 里 [start..end] 位置段的节点 seq(折叠候选 shadowedSeqs)。 */
|
|
173
|
-
function rangeSeqs(nodes, start, end) {
|
|
174
|
-
const si = nodes.indexOf(start)
|
|
175
|
-
const ei = nodes.indexOf(end)
|
|
176
|
-
if (si === -1 || ei === -1 || si > ei) return []
|
|
177
|
-
return nodes.slice(si, ei + 1)
|
|
178
|
-
}
|
|
179
|
-
|
|
180
|
-
/* @public-strip:end */
|
|
181
|
-
|
|
182
171
|
/**
|
|
183
172
|
* seq → 事件查找:优先按数组下标(真实会话 seq 自 0 连续、index==seq),下标与 seq
|
|
184
173
|
* 不符(异构测试数据/截断重排)时才惰性建值索引兜底——正确性优先,热路径零额外分配。
|
|
@@ -219,9 +208,6 @@ async function readEvents(sessionId) {
|
|
|
219
208
|
|
|
220
209
|
/** 从指定文件路径读全量事件(测试可注入路径;生产走 readEvents 按基座候选找)。
|
|
221
210
|
* 单次编辑/查询操作会连读多次(span+文件快照事实),每次全量
|
|
222
|
-
* @public-strip:start
|
|
223
|
-
* fold 单次操作连读 3-4 次(边界/span/摘要),同样吃这层缓存。
|
|
224
|
-
* @public-strip:end
|
|
225
211
|
* zstd 解压+JSON+foldSurface(1.37M 事件秒级)→ 加**进程级短缓存**(同一次命令
|
|
226
212
|
* 内共享一次读取;以 mtime+size 校验文件未变,变了即失效,防与写入撕裂)。
|
|
227
213
|
* TTL 很短(300ms)只覆盖单次命令的连续读取,不缓存跨命令的陈旧数据。 */
|
|
@@ -302,22 +288,11 @@ export async function readEventsFromFile(filePath) {
|
|
|
302
288
|
* (与业务层 host-core 同一实现)——本函数只负责「读事件 + 判状态 + 给规则喂料」。
|
|
303
289
|
*
|
|
304
290
|
* @param {Array} events - 全量事件(通用格式)。
|
|
305
|
-
* @public-strip:start
|
|
306
|
-
* @param {number|string} target - seq 或 messageId(round/tail 用);range 模式下为区间起点。
|
|
307
|
-
* @param {'round'|'tail'|'range'} [mode] - round=遮蔽目标轮;tail=从目标轮首遮蔽到面尾;
|
|
308
|
-
* range=遮蔽 [target..opts.endSeq] 区间(折叠完成块)。
|
|
309
|
-
* @param {object} [opts] - range 模式:opts.endSeq = 区间终点(必须为 surface 节点)。
|
|
310
|
-
* @public-strip:else
|
|
311
291
|
* @param {number|string} target - seq 或 messageId。
|
|
312
292
|
* @param {'round'|'tail'} [mode] - round=遮蔽目标轮;tail=从目标轮首遮蔽到面尾。
|
|
313
|
-
* @public-strip:end
|
|
314
293
|
* @returns {{status:string, span:object|null, facts:object}} 显式状态结果(见上)。
|
|
315
294
|
*/
|
|
316
|
-
/* @public-strip:start */
|
|
317
|
-
export function computeSpan(events, target, mode = 'round', opts = {}) {
|
|
318
|
-
/* @public-strip:else
|
|
319
295
|
export function computeSpan(events, target, mode = 'round') {
|
|
320
|
-
@public-strip:end */
|
|
321
296
|
const numericTarget = typeof target === 'number' && Number.isSafeInteger(target) && target >= 0
|
|
322
297
|
// ① 事件列表不可读/为空:没有任何快照证据 → not-found,且 facts.fileMaxSeq = -1。
|
|
323
298
|
// (调用方 spanMissArgsOf 不把无证据的结果下传 → 业务层按内存视图判定,0.4.24 行为不变)
|
|
@@ -388,33 +363,10 @@ export function computeSpan(events, target, mode = 'round') {
|
|
|
388
363
|
const index = nodes.indexOf(seq)
|
|
389
364
|
// ⑤ 目标在日志里但不在当前面 → 已被更早的 replace(fold/recall/compact)遮蔽
|
|
390
365
|
if (index === -1) return spanMiss(SPAN_STATUS.ALREADY_SHADOWED, facts)
|
|
391
|
-
/* @public-strip:start */
|
|
392
|
-
let endSeq
|
|
393
|
-
if (mode === SPAN_MODE.RANGE) {
|
|
394
|
-
// range:折叠完成块区间 [seq..endSeq]——位置连续段(marker 折叠承载)。
|
|
395
|
-
// 端点必须是 surface 节点;区间可含 marker(先前折叠节点,折叠链收敛语义)。
|
|
396
|
-
endSeq = typeof opts?.endSeq === 'number' ? opts.endSeq : seq
|
|
397
|
-
const endIndex = nodes.indexOf(endSeq)
|
|
398
|
-
if (endIndex === -1) return spanMiss(SPAN_STATUS.ALREADY_SHADOWED, facts) // 终点不在当前面
|
|
399
|
-
if (index > endIndex) return spanMiss(SPAN_STATUS.NOT_FOUND, facts) // 位置序上区间倒置(非连续段)
|
|
400
|
-
}
|
|
401
|
-
/* @public-strip:end */
|
|
402
366
|
// ⑥ 规则单一真相:轮首回退/尾部切片/区间段全部由 spanAt 给(业务层同一实现)
|
|
403
367
|
const span = spanAt(nodes, index, {
|
|
404
368
|
mode,
|
|
405
369
|
isBoundary: (nodeSeq) => isRoundBoundaryEvent(at(nodeSeq)),
|
|
406
|
-
/* @public-strip:start */
|
|
407
|
-
endSeq,
|
|
408
|
-
// ⑥b 区间不拆工具对(接线 lib/span-semantics.js expandRangeForToolPairs):
|
|
409
|
-
// - eventOf = 本函数自己的 seq→事件(与 isBoundary 同一份全量事件);
|
|
410
|
-
// - pairAssistantTools 必须 **true**:`tool/call` 不是面节点(内核
|
|
411
|
-
// lib/index.js SURFACE_EVENT_TYPES 只含 system/developer/user/
|
|
412
|
-
// assistant/tool-result),真实面上要配对的是 assistant/message 的
|
|
413
|
-
// tool-call 块 ↔ tool/result(守卫 W1 的 wire 口径,实测 seq 43843/43845)。
|
|
414
|
-
// 只在 range 模式生效(spanAt 内 round/tail 路径不读这两项)。
|
|
415
|
-
eventOf: at,
|
|
416
|
-
pairAssistantTools: true,
|
|
417
|
-
/* @public-strip:end */
|
|
418
370
|
})
|
|
419
371
|
if (!span) return spanMiss(SPAN_STATUS.NOT_FOUND, facts)
|
|
420
372
|
// 契约运行时化:适配器产出的 span 结构在出口自检
|
|
@@ -479,18 +431,10 @@ export function computeSpanProbe(events, target, mode = 'round', opts = {}) {
|
|
|
479
431
|
export const dshAdapter = {
|
|
480
432
|
reader: { readEvents },
|
|
481
433
|
/** 便捷:读事件 + 算遮蔽一步到位(供 index.js/http.js 注入 args.span)。 */
|
|
482
|
-
/* @public-strip:start */
|
|
483
|
-
async spanFromFile(sessionId, target, mode = 'round', opts = {}) {
|
|
484
|
-
const events = await readEvents(sessionId)
|
|
485
|
-
// 契约运行时化:跨层返回前自检结果形状
|
|
486
|
-
return assertSpanResult(computeSpan(events, target, mode, opts), 'dshAdapter.spanFromFile')
|
|
487
|
-
},
|
|
488
|
-
/* @public-strip:else
|
|
489
434
|
async spanFromFile(sessionId, target, mode = 'round') {
|
|
490
435
|
const events = await readEvents(sessionId)
|
|
491
436
|
return assertSpanResult(computeSpan(events, target, mode), 'dshAdapter.spanFromFile')
|
|
492
437
|
},
|
|
493
|
-
@public-strip:end */
|
|
494
438
|
/**
|
|
495
439
|
* 便捷:读事件一次,同时给出 span 与文件快照事实。status ≠ ok 时
|
|
496
440
|
* 调用方(withFileSpan/http.js)按状态注入 args.spanStatus/spanFacts → host-core
|
|
@@ -503,430 +447,6 @@ export const dshAdapter = {
|
|
|
503
447
|
const events = await readEvents(sessionId)
|
|
504
448
|
return assertSpanResult(computeSpanProbe(events, target, mode, opts), 'dshAdapter.spanProbeFromFile')
|
|
505
449
|
},
|
|
506
|
-
/* @public-strip:start */
|
|
507
|
-
/**
|
|
508
|
-
* 上下文用量体检 + 折叠建议:读文件 → 测量上下文用量(中文校正)+ 候选折叠块
|
|
509
|
-
* (头部之后最老完成块)+ 收益估算。全中文建议给正解。
|
|
510
|
-
* (体检命令 A):返回带 cacheMetrics = 缓存前缀读数 +
|
|
511
|
-
* 官方压缩史(cacheReadTokens = 官方 API usage 实测;缓存度量留痕,上下文用量报告可见)。
|
|
512
|
-
* @param {string} [filePath] 可选:直接指定会话文件路径(测试注入;生产走基座候选)。
|
|
513
|
-
*/
|
|
514
|
-
async contextLevelFromFile(sessionId, opts = {}, filePath) {
|
|
515
|
-
// OOM 修:超大件不做整读(measure 整读+物化曾把宿主堆抬到 2.5GB+ ⇒ V8 OOM ⇒ exit 5)
|
|
516
|
-
try {
|
|
517
|
-
const { statSync } = await import('node:fs')
|
|
518
|
-
const p = filePath ?? sessionFilePath(sessionId)
|
|
519
|
-
const size = statSync(p).size
|
|
520
|
-
const cap = Number(opts?.maxSessionBytes ?? (Number(process.env.DSH_RETRACE_MAX_SESSION_MB ?? 64) * 1048576))
|
|
521
|
-
// B:大会话早折 —— 超大件不再一律跳过(跳过=把它让给官方引擎 ⇒ 官方超窗 ⇒ OOM)
|
|
522
|
-
// 标记 large + 早触发线(0.5×窗);仍超硬上限(默认 512MB)才跳过,避免不可控物化
|
|
523
|
-
const largeBytes = Number(opts?.largeSessionBytes ?? 32 * 1048576)
|
|
524
|
-
const hardCap = Number(opts?.hardMaxSessionBytes ?? 512 * 1048576)
|
|
525
|
-
const large = size > largeBytes
|
|
526
|
-
if (size > hardCap) return { skipped: true, reason: 'session-too-large', sizeBytes: size, hostTokens: null, pct: null, band: 'unknown' }
|
|
527
|
-
globalThis.__retraceSizeHint = { sessionId, size, large, cap }
|
|
528
|
-
} catch { /* stat 失败按原路径走 */ }
|
|
529
|
-
const events = filePath ? await readEventsFromFile(filePath) : await readEvents(sessionId)
|
|
530
|
-
if (!Array.isArray(events) || events.length === 0) return null
|
|
531
|
-
const { measureContextLevel, estimateRangeTokens, YELLOW_RATIO } = await import('../context-level.js')
|
|
532
|
-
// surface 口径:面节点 = 官方 foldSurface(宿主同版,显式带已注册消息投影)/ 镜像折
|
|
533
|
-
// 容错回退(见 surfaceFoldOf / surfaceNodeSeqs)。nodes 同时用于候选定位(compaction 后
|
|
534
|
-
// events seq 序失真);folded.projectedMessages 供逐节点估价(投影后的消息参与估价)。
|
|
535
|
-
const folded = surfaceFoldOf(events)
|
|
536
|
-
const nodes = folded ? folded.nodes : mirrorSurfaceNodeSeqs(events)
|
|
537
|
-
// 真宿主口径:官方逐节点估价(注入优先 → 官方包;都无 → null,回落校正估算)
|
|
538
|
-
const priceNode = await hostPriceNode({ ...opts, projectedMessages: folded?.projectedMessages ?? null })
|
|
539
|
-
const level = measureContextLevel(events, {
|
|
540
|
-
...opts,
|
|
541
|
-
surface: opts.surface !== false && nodes.length ? nodes : null,
|
|
542
|
-
priceNode,
|
|
543
|
-
})
|
|
544
|
-
// 折叠候选(唯一实现 lib/fold-boundary.js nextFoldCandidate):
|
|
545
|
-
// surface 节点序上**跳过** marker 型事件(我方 retrace-* marker / fix-line marker 与
|
|
546
|
-
// v0 checkpoint)与官方 compact checkpoint,从第一个真实用户输入起,向前合并相邻小块
|
|
547
|
-
// 直到块质量达标(内容节点 ≥ N=8 且预估释放 ≥ M=30000,env 可配)→ 候选即"一个块一个
|
|
548
|
-
// marker 一个 turn"。不再沿用旧规则"nodes 上第一个非 compact 的 user/message"
|
|
549
|
-
// (旧规则会把 fix-line v0 checkpoint 当用户输入折成 1 节点碎片块)。
|
|
550
|
-
// (官方失效/不再抢先):suggestion 生成线按 pct 阈值——默认 0.6;接线处传
|
|
551
|
-
// suggestPct=自动层触发线(0.55)→ 55-60% 灰区也有候选。
|
|
552
|
-
// 折叠链深度(临时上限,见 fold-boundary.js 头注):达到上限 → 不给 suggestion
|
|
553
|
-
// (该会话不再产生新折叠块,转归档),并在报告里显式说明。
|
|
554
|
-
let suggestion = null
|
|
555
|
-
let candidateRejection = null
|
|
556
|
-
const {
|
|
557
|
-
nextFoldCandidate, foldChainOfEvents, resolveFoldDepthLimit, depthLimitNotice, FOLD_REJECT: REJECT, FOLD_DEPTH_ACTION,
|
|
558
|
-
} = await import('../fold-boundary.js')
|
|
559
|
-
const chain = foldChainOfEvents(events)
|
|
560
|
-
const maxChainDepth = resolveFoldDepthLimit(opts?.env, opts?.foldQuality ?? {})
|
|
561
|
-
const atDepthLimit = chain.broken || chain.depth >= maxChainDepth
|
|
562
|
-
const foldDepth = {
|
|
563
|
-
depth: chain.depth,
|
|
564
|
-
maxChainDepth,
|
|
565
|
-
deepestMarkerSeq: chain.deepestMarkerSeq,
|
|
566
|
-
atLimit: atDepthLimit,
|
|
567
|
-
// chain.broken = 日志里已有 replace 目标不在面内(链结构不可信)→ 同样停折(fail-closed)
|
|
568
|
-
broken: chain.broken,
|
|
569
|
-
action: atDepthLimit ? FOLD_DEPTH_ACTION : null,
|
|
570
|
-
notice: atDepthLimit ? depthLimitNotice({ depth: chain.depth, maxChainDepth, deepestMarkerSeq: chain.deepestMarkerSeq }) : null,
|
|
571
|
-
}
|
|
572
|
-
const suggestPct = Number.isFinite(opts?.suggestPct) && opts.suggestPct > 0 && opts.suggestPct < 1 ? opts.suggestPct : YELLOW_RATIO
|
|
573
|
-
// 阈值按**会话当前路由模型窗口**算 —— 窗口由接线处经
|
|
574
|
-
// ctx.llm.resolveModelInfo(provider,model).context.contextWindow 解析后注入
|
|
575
|
-
// (number 或 async (sessionId)=>number|null);不再用固定 786,432/838,860。
|
|
576
|
-
const modelWindow = await (async () => {
|
|
577
|
-
const w = opts?.modelWindow
|
|
578
|
-
try { const v = typeof w === 'function' ? await w(sessionId) : w; return Number.isFinite(v) && v > 0 ? v : null } catch { return null }
|
|
579
|
-
})()
|
|
580
|
-
const triggerRatio = Number.isFinite(opts?.triggerRatio) && opts.triggerRatio > 0 && opts.triggerRatio < 1 ? opts.triggerRatio : 0.8
|
|
581
|
-
const targetRatio = Number.isFinite(opts?.targetRatio) && opts.targetRatio > 0 && opts.targetRatio < triggerRatio ? opts.targetRatio : 0.6
|
|
582
|
-
// 修(真落点): 本行才是**决策**阈值(下方 overSuggest 用它;levelBrief 也打印它)。
|
|
583
|
-
// 窗口未知时原逻辑回落 `opts.suggestTokens`(= wiring 786,432) ⇒ 小窗口模型下官方 0.8×窗永远先到、我方零保护。
|
|
584
|
-
// 修: 窗口未知 ⇒ **套保守上限** `min(base, FALLBACK_TRIGGER_TOKENS=500k)`(env `DSH_RETRACE_FALLBACK_TRIGGER_TOKENS` 可覆写)。
|
|
585
|
-
const baseTriggerTokens = modelWindow !== null ? Math.floor(modelWindow * triggerRatio) : (Number.isFinite(opts?.suggestTokens) && opts.suggestTokens > 0 ? opts.suggestTokens : null)
|
|
586
|
-
// 修(根因B:**阈值分裂 ⇒ 死区**):
|
|
587
|
-
// 调度器判定线 300,000(auto-fold-scheduler.FALLBACK_TRIGGER_TOKENS)与此处 cap 500,000 **不一致**
|
|
588
|
-
// ⇒ hostTokens 落在 [300k,500k) 时调度器说"已越线"、适配器却 overSuggest=false ⇒ **候选构造从未执行**
|
|
589
|
-
// ⇒ 日志把"没构造"渲染成"无候选"(现场会话 482,063 正落死区)。
|
|
590
|
-
// ⇒ **单源**: 默认与调度器一致取 300,000(env 仍可覆盖,两侧取同一 env)。
|
|
591
|
-
const capTokens = Number(process.env.DSH_RETRACE_FALLBACK_TRIGGER_TOKENS ?? 300000)
|
|
592
|
-
// 修(真因): measureOpts 未传 `suggestTokens` ⇒ `baseTriggerTokens` 为 **null** ⇒ 原 `min(...)` 不成立
|
|
593
|
-
// ⇒ `level.triggerTokens=null` ⇒ levelBrief 回落打印 wiring 的 786,432,且决策退化成"仅按 pct" ⇒ **保守阈值形同虚设**。
|
|
594
|
-
// 现在: **窗口未知 ⇒ 阈值直接取保守上限**(有 suggestTokens 时取二者较小),让"按 token 的抢先折"在小窗口模型上也成立。
|
|
595
|
-
const triggerTokens = modelWindow === null
|
|
596
|
-
? (Number.isFinite(baseTriggerTokens) && Number.isFinite(capTokens) ? Math.min(baseTriggerTokens, capTokens) : capTokens)
|
|
597
|
-
: baseTriggerTokens
|
|
598
|
-
const targetTokens = modelWindow !== null ? Math.floor(modelWindow * targetRatio) : null
|
|
599
|
-
// B: 大会话早触发线(0.5×窗) —— 供调度器在官方 0.8 线之前先折
|
|
600
|
-
const earlyTriggerTokens = modelWindow !== null ? Math.floor(modelWindow * 0.5) : null
|
|
601
|
-
const sizeHint = globalThis.__retraceSizeHint && globalThis.__retraceSizeHint.sessionId === sessionId ? globalThis.__retraceSizeHint : null
|
|
602
|
-
const large = sizeHint?.large === true
|
|
603
|
-
// floor 闸:折后不得低于 floorTokens = floor(0.45×该会话路由模型 contextWindow)。
|
|
604
|
-
// 常量与算法与上游参考补丁逐字一致:
|
|
605
|
-
// FLOOR_RATIO=0.45 / TARGET_RATIO=0.50,同用宿主口径 tokenMeter 值判定。
|
|
606
|
-
const floorRatio = Number.isFinite(opts?.floorRatio) && opts.floorRatio > 0 && opts.floorRatio < targetRatio ? opts.floorRatio : 0.45
|
|
607
|
-
const floorTokens = modelWindow !== null ? Math.floor(modelWindow * floorRatio) : null
|
|
608
|
-
Object.assign(level, { modelWindow, windowUnknown: modelWindow === null, triggerTokens, targetTokens, floorTokens, earlyTriggerTokens, large, sizeBytes: sizeHint?.size ?? null, triggerRatio, targetRatio, floorRatio })
|
|
609
|
-
// 触发规则:官方估价可用 → hostTokens ≥ triggerTokens(按模型窗口);否则回落 pct
|
|
610
|
-
const overSuggest = Number.isFinite(level.hostTokens) && triggerTokens !== null
|
|
611
|
-
? level.hostTokens >= triggerTokens
|
|
612
|
-
: level.pct >= suggestPct
|
|
613
|
-
if (atDepthLimit) {
|
|
614
|
-
// 已达深度上限 → 明确"为什么没有建议"(上下文用量/日志都说"转归档"),不走到候选判定
|
|
615
|
-
candidateRejection = { reason: REJECT.DEPTH_LIMIT_REACHED, depth: chain.depth, maxChainDepth, deepestMarkerSeq: chain.deepestMarkerSeq, action: FOLD_DEPTH_ACTION }
|
|
616
|
-
} else if (overSuggest && nodes.length > 0) {
|
|
617
|
-
const cand = nextFoldCandidate(events, nodes, { env: opts?.env, config: opts?.foldQuality, maxRounds: opts?.maxRounds })
|
|
618
|
-
if (cand.ok) {
|
|
619
|
-
// computeSpan 显式状态复核(range 端点要求为当前 surface 连续段)
|
|
620
|
-
const result = computeSpan(events, cand.start, 'range', { endSeq: cand.end })
|
|
621
|
-
const span = result.status === SPAN_STATUS.OK ? result.span : null
|
|
622
|
-
if (span) {
|
|
623
|
-
const gain = estimateRangeTokens(events, span.shadowedSeqs)
|
|
624
|
-
suggestion = {
|
|
625
|
-
foldRange: { start: span.start, end: span.end, rounds: cand.rounds, reason: cand.reason },
|
|
626
|
-
gainTokens: gain,
|
|
627
|
-
shadowed: span.shadowedSeqs.length,
|
|
628
|
-
// 块质量证据:内容节点数 / 合并轮数 / 内容时间窗(取内容时间)
|
|
629
|
-
contentNodes: cand.contentNodes,
|
|
630
|
-
mergedBlocks: cand.merged,
|
|
631
|
-
contentTimeLo: cand.contentTimeLo,
|
|
632
|
-
contentTimeHi: cand.contentTimeHi,
|
|
633
|
-
afterPct: level.window > 0 ? Math.max(0, (level.cjkTokens - gain) / level.window) : 0,
|
|
634
|
-
}
|
|
635
|
-
} else {
|
|
636
|
-
candidateRejection = { reason: `span-${String(result?.status ?? 'unknown')}`, contentNodes: cand.contentNodes, estTokens: cand.estTokens }
|
|
637
|
-
}
|
|
638
|
-
} else {
|
|
639
|
-
candidateRejection = {
|
|
640
|
-
reason: cand.reason,
|
|
641
|
-
contentNodes: cand.contentNodes ?? 0,
|
|
642
|
-
estTokens: cand.estTokens ?? 0,
|
|
643
|
-
minContentNodes: cand.minContentNodes,
|
|
644
|
-
minFoldTokens: cand.minFoldTokens,
|
|
645
|
-
}
|
|
646
|
-
}
|
|
647
|
-
}
|
|
648
|
-
// 度量(体检命令 A):缓存前缀读数 +
|
|
649
|
-
// 官方压缩史。cacheReadTokens = 官方 API usage 实测(事件现成);compactionHistory
|
|
650
|
-
// = 缓存度量留痕(该会话被官方压缩 N 次/共打掉 X token,含每次明细)。纯读,
|
|
651
|
-
// 度量失败只缺 cacheMetrics 字段,不阻断上下文用量报告。
|
|
652
|
-
let cacheMetrics = null
|
|
653
|
-
try {
|
|
654
|
-
const { latestCacheReadTokens: latestRead, compactionHistory: historyOf } = await import('../cache-metrics.js')
|
|
655
|
-
cacheMetrics = {
|
|
656
|
-
latestCacheReadTokens: latestRead(events),
|
|
657
|
-
compactionHistory: historyOf(events),
|
|
658
|
-
}
|
|
659
|
-
} catch { /* 度量失败 → 不带 cacheMetrics */ }
|
|
660
|
-
// 后续修正: **不再合成 rejection** —— 合成的真值会让 index.js 的用户可见建议
|
|
661
|
-
// 首次触发并打出 `内容节点 undefined`(建议回归)。日志侧的"无候选原因"改由**调度器的日志兜底**给。
|
|
662
|
-
return { ...level, suggestion, candidateRejection, foldDepth, cacheMetrics }
|
|
663
|
-
},
|
|
664
|
-
/**
|
|
665
|
-
* fold 自动边界(50 轮上限接线)——fold 命令未显式给 endSeq 时,按
|
|
666
|
-
* foldBoundaryFrom 从 start 起自动兜底切块。默认 = 单轮语义完成块;
|
|
667
|
-
* 显式 rounds 多轮编组时由 foldBoundary 内部 ≤FOLD_MAX_ROUNDS=50 上限兜底。
|
|
668
|
-
*
|
|
669
|
-
* **保留原语义** = 纯边界(不裁质量)——手动显式区间的调用方仍用它做
|
|
670
|
-
* 端点合法性判断;自动层/自动边界走 foldBlockFromFile(候选过滤+门槛+合并)。
|
|
671
|
-
* @param {string} [filePath] 可选:直接指定会话文件路径(测试注入)。
|
|
672
|
-
*/
|
|
673
|
-
async foldBoundaryFromFile(sessionId, start, opts = {}, filePath) {
|
|
674
|
-
const events = filePath ? await readEventsFromFile(filePath) : await readEvents(sessionId)
|
|
675
|
-
if (!Array.isArray(events) || events.length === 0) return null
|
|
676
|
-
const { foldBoundaryFrom } = await import('../fold-boundary.js')
|
|
677
|
-
return foldBoundaryFrom(events, Number(start), opts)
|
|
678
|
-
},
|
|
679
|
-
/**
|
|
680
|
-
* 自动边界**加质量门槛**的块判定(surface 口径)——resolveFoldAuto /
|
|
681
|
-
* 上下文用量建议同一规则(lib/fold-boundary.js nextFoldCandidate:候选过滤 a + 最小门槛 b +
|
|
682
|
-
* 相邻小块合并 c)。返回:
|
|
683
|
-
* {ok:true, start,end,rounds,reason,contentNodes,estTokens,merged,shadowedSeqs,
|
|
684
|
-
* contentTimeLo,contentTimeHi}
|
|
685
|
-
* |{ok:false, reason, contentNodes, estTokens, minContentNodes, minFoldTokens}
|
|
686
|
-
* 端点一律取当前 surface 节点 → 调用方直接可用作 range span 端点。
|
|
687
|
-
* @param {string} [filePath] 可选:测试注入。
|
|
688
|
-
*/
|
|
689
|
-
async foldBlockFromFile(sessionId, start, opts = {}, filePath) {
|
|
690
|
-
const events = filePath ? await readEventsFromFile(filePath) : await readEvents(sessionId)
|
|
691
|
-
if (!Array.isArray(events) || events.length === 0) return { ok: false, reason: 'no-events', contentNodes: 0, estTokens: 0 }
|
|
692
|
-
const nodes = surfaceNodeSeqs(events)
|
|
693
|
-
if (!Array.isArray(nodes) || nodes.length === 0) return { ok: false, reason: 'no-surface', contentNodes: 0, estTokens: 0 }
|
|
694
|
-
const { nextFoldCandidate } = await import('../fold-boundary.js')
|
|
695
|
-
return nextFoldCandidate(events, nodes, {
|
|
696
|
-
from: Number.isInteger(Number(start)) ? Number(start) : undefined,
|
|
697
|
-
rounds: opts?.rounds,
|
|
698
|
-
maxRounds: opts?.maxRounds,
|
|
699
|
-
env: opts?.env,
|
|
700
|
-
config: opts?.foldQuality,
|
|
701
|
-
})
|
|
702
|
-
},
|
|
703
|
-
/**
|
|
704
|
-
* unfold 展开数据(视图层回填):读文件 → 找 marker 的被遮蔽 seq
|
|
705
|
-
* → 提取被遮蔽 seq 的消息内容(按序,供客户端渲染整块供人回看)。模型上下文不变(仍=摘要)。
|
|
706
|
-
* 逆序链式定位 = 按 markerSeq 找(展开指定折叠块)。
|
|
707
|
-
*
|
|
708
|
-
* **识别全部 marker 形态**:规则收敛到 `lib/fold-boundary.js`
|
|
709
|
-
* 的 `isUnfoldableMarkerEvent`(= 既有 marker 判定 `isRetraceMarkerEvent` /
|
|
710
|
-
* `isCompactCheckpointEvent` 且带遮蔽内容),不再只看 `assistant/message` 的
|
|
711
|
-
* `retrace-fold-*`:混合链上不识别 `fix-line-fold-*` / `fix-line/unfolded-checkpoint`
|
|
712
|
-
* (user/message 形态)或官方 compact checkpoint 时,展开顺序失控 → 触发展开死结
|
|
713
|
-
* (下层被上层折了 → 上层 replace 目标消失 → 会话不可构造)。recall/edit marker 等既有
|
|
714
|
-
* 形态同样识别(**不另起一套判定**)。
|
|
715
|
-
*
|
|
716
|
-
* **展开前链完整性检查(逆链序)**:先算折叠链,若本 marker 已被**上层折叠块**覆盖
|
|
717
|
-
* (其遮蔽范围含本 marker)→ **拒绝展开**并返回中文可操作提示(指明"请先展开上层块
|
|
718
|
-
* #N"),不返回 rows。理由:被覆盖的 marker 已不在 surface,任何"把它换回内容"的动作
|
|
719
|
-
* 都会写出 replace 目标缺失的日志(`invalid seed event … start seq <X> not found in
|
|
720
|
-
* surface` → Session 构造失败)。上层块未被展开前,只能先展开上层块(逆链序:自最上层
|
|
721
|
-
* 往外),展开上层块会穿透到本块的原文 → 内容等价可见。
|
|
722
|
-
*
|
|
723
|
-
* **穿透 marker 直达原文(幂等)**——块内若含 marker 节点(fold 折
|
|
724
|
-
* fold 链 / 召回编辑 marker / 外部 checkpoint),递归穿透其 shadowedSeqs 到最终原文,
|
|
725
|
-
* 不再只展开一层(旧行为:展开只见另一层 marker 行,文本为空,用户需多次展开)。穿透行
|
|
726
|
-
* 标注 `depth`/`viaMarkerSeq`(审计;直连原文行仍是 {seq,type,text} 兼容旧客户端);
|
|
727
|
-
* 带文本的遮蔽卡(如 fix-line v0 摘要卡)其卡文本作为首行保留,再穿透到原文
|
|
728
|
-
* (卡 = 该块在上下文里的样子,+ 原文供人回看)。
|
|
729
|
-
* 幂等:纯读同一文件 → 同一结果(重复展开一致);嵌套链一次到底(深度上限
|
|
730
|
-
* UNFOLD_MAX_DEPTH 防病态自引,已访问 marker 不重复展开)。
|
|
731
|
-
* 另返回 contentTimeRange(被折内容节点时间窗,marker 执行时刻不作语义)。
|
|
732
|
-
* @returns {Promise<object|null>} null = 该 seq 不是可展开的遮蔽载体 / 不存在;
|
|
733
|
-
* `{refused:true, …}` = 链完整性检查拒绝展开(调用方按 refused 转错误文案)。
|
|
734
|
-
*/
|
|
735
|
-
async unfoldContentFromFile(sessionId, markerSeq, filePath) {
|
|
736
|
-
const events = filePath ? await readEventsFromFile(filePath) : await readEvents(sessionId)
|
|
737
|
-
if (!Array.isArray(events) || events.length === 0) return null
|
|
738
|
-
// 注意:不要假设 events 数组 index == seq(实际 seq 起点随文件格式变——实测真会话
|
|
739
|
-
// seq 自 0 连续、index==seq;测试测试数据 header 后 seq 自 1、index=seq-1)——统一按值找
|
|
740
|
-
const marker = events.find((e) => e?.seq === Number(markerSeq))
|
|
741
|
-
const {
|
|
742
|
-
UNFOLD_MAX_DEPTH, UNFOLD_MAX_ROWS, isFoldContentNode,
|
|
743
|
-
isUnfoldableMarkerEvent, markerShadowedSeqs, foldChainOfEvents, unfoldChainRefusal,
|
|
744
|
-
} = await import('../fold-boundary.js')
|
|
745
|
-
if (!marker || !isUnfoldableMarkerEvent(marker)) return null
|
|
746
|
-
const shadowed = markerShadowedSeqs(marker)
|
|
747
|
-
if (shadowed.length === 0) return null
|
|
748
|
-
const markerNum = Number(markerSeq)
|
|
749
|
-
// ⚠️ 改动的实质:展开**前**先做链完整性检查(逆链序)——被上层块覆盖的 marker
|
|
750
|
-
// 直接拒绝(带中文可操作提示),不产出 rows;否则调用方(把展开落成 re-replace)
|
|
751
|
-
// 会写出不可构造的会话日志。
|
|
752
|
-
const chain = foldChainOfEvents(events)
|
|
753
|
-
const refusal = unfoldChainRefusal({ markerSeq: markerNum, chain })
|
|
754
|
-
if (refusal) return refusal
|
|
755
|
-
// 读侧"先看里程碑卡"层:**旧形态** marker 的 editor.trio(结构化摘要)存在则附上
|
|
756
|
-
// ——客户端展开前先显示卡(块标题/一句话结论/时间),决定是否展开 rows。
|
|
757
|
-
// **新形态**(两段结构的第 2 段)把结构化摘要序列化进了 content(官方封闭词表里
|
|
758
|
-
// 没有结构化落点),故结构化卡只在旧数据上有;新数据的卡文本随 content 呈现给
|
|
759
|
-
// 模型即为人读部分(留痕 + 可解释),unfold 只负责逐字回填原文 rows。
|
|
760
|
-
const trio = marker.data?.editor?.trio ?? null
|
|
761
|
-
// 修订链读侧——若后续 fold marker 的 supersededBy 指向本卡,
|
|
762
|
-
// 提示"后有修订"(本结论已被取代,别误信旧结论)。旧卡仍在可审计。
|
|
763
|
-
// 两种形态都认:旧形态读 roadmap-card.supersededBy;新形态从序列化文本里的
|
|
764
|
-
// 「取代旧结论(seq N…)」行取 N(serializeTrio 写出的那一行)。
|
|
765
|
-
let supersededByNewer = null
|
|
766
|
-
for (const ev of events) {
|
|
767
|
-
if (!ev || ev.seq <= markerNum) continue
|
|
768
|
-
if (!isFoldMarkerLike(ev)) continue
|
|
769
|
-
const newerCard = ev.data?.editor?.trio?.['roadmap-card']
|
|
770
|
-
if (newerCard && Number(newerCard.supersededBy) === markerNum) {
|
|
771
|
-
supersededByNewer = ev.seq
|
|
772
|
-
break
|
|
773
|
-
}
|
|
774
|
-
if (supersededSeqOfText(carrierContentText(ev)) === markerNum) {
|
|
775
|
-
supersededByNewer = ev.seq
|
|
776
|
-
break
|
|
777
|
-
}
|
|
778
|
-
}
|
|
779
|
-
const bySeq = new Map(events.map((e) => [e?.seq, e]))
|
|
780
|
-
const rows = []
|
|
781
|
-
let truncated = false
|
|
782
|
-
const expanded = new Set() // 已穿透的 marker seq(防自引/环)
|
|
783
|
-
const seqsOf = (ev) => markerShadowedSeqs(ev)
|
|
784
|
-
const rowOf = (ev, seq, depth, via) => {
|
|
785
|
-
const type = ev.type
|
|
786
|
-
let text = ''
|
|
787
|
-
if (type === 'user/message') {
|
|
788
|
-
text = Array.isArray(ev.data?.content) ? ev.data.content.filter((b) => b?.type === 'text' && typeof b.text === 'string').map((b) => b.text).join('\n') : ''
|
|
789
|
-
} else if (type === 'assistant/message') {
|
|
790
|
-
text = Array.isArray(ev.data?.message?.content) ? ev.data.message.content.filter((b) => b?.type === 'text' && typeof b.text === 'string').map((b) => b.text).join('\n') : ''
|
|
791
|
-
}
|
|
792
|
-
const row = { seq, type: type === 'user/message' ? 'user' : type === 'assistant/message' ? 'assistant' : 'tool', text }
|
|
793
|
-
// 穿透行才带审计字段(直连原文行保持旧形状,向后兼容)
|
|
794
|
-
if (depth > 0) { row.depth = depth; row.viaMarkerSeq = via }
|
|
795
|
-
return row
|
|
796
|
-
}
|
|
797
|
-
const walk = (seq, depth, via) => {
|
|
798
|
-
if (rows.length >= UNFOLD_MAX_ROWS) { truncated = true; return }
|
|
799
|
-
const ev = bySeq.get(seq)
|
|
800
|
-
if (!ev) return
|
|
801
|
-
const inner = seqsOf(ev)
|
|
802
|
-
// 穿透条件(两道;规则全部来自共享 marker 判定,不另起一套):
|
|
803
|
-
// ① **全部 marker 形态**(isUnfoldableMarkerEvent:我方 retrace-fold-* / 外部
|
|
804
|
-
// fix-line-fold-* 与 fix-line/unfolded-checkpoint / 官方 compact checkpoint /
|
|
805
|
-
// recall·edit marker)——marker 折 marker 链的"直达原文";
|
|
806
|
-
// ② 自身**无可见文本**的遮蔽载体(行渲染为空文本,毫无信息)→ 穿透到被遮蔽原文。
|
|
807
|
-
// 带文本的遮蔽卡(如 fix-line v0 摘要卡)两者都满足:先把**卡文本本身**作为一行
|
|
808
|
-
// 呈现(它就是该节点在块里的样子),再穿透到被遮蔽原文(展开的意图 = 看原文)。
|
|
809
|
-
const isMarkerCarrier = isUnfoldableMarkerEvent(ev)
|
|
810
|
-
const hasOwnText = rowOf(ev, seq, 0, null).text.length > 0
|
|
811
|
-
const shouldPenetrate = inner.length > 0 && depth < UNFOLD_MAX_DEPTH && !expanded.has(ev.seq) && (isMarkerCarrier || !hasOwnText)
|
|
812
|
-
if (shouldPenetrate) {
|
|
813
|
-
expanded.add(ev.seq)
|
|
814
|
-
if (hasOwnText && rows.length < UNFOLD_MAX_ROWS) rows.push(rowOf(ev, seq, depth, via))
|
|
815
|
-
for (const s of inner) walk(s, depth + 1, ev.seq)
|
|
816
|
-
return
|
|
817
|
-
}
|
|
818
|
-
rows.push(rowOf(ev, seq, depth, via))
|
|
819
|
-
}
|
|
820
|
-
for (const seq of shadowed) walk(seq, 0, null)
|
|
821
|
-
// 内容时间窗(权威口径;marker 执行时刻 = event.time,只作审计)。
|
|
822
|
-
// 口径 = **展开后可见的原文行**(含穿透层;块的原文时间跨穿透链)里的真内容节点时间:
|
|
823
|
-
// marker 行(空文本)/checkpoint 行不计入。
|
|
824
|
-
const contentTimes = []
|
|
825
|
-
for (const row of rows) {
|
|
826
|
-
const ev = bySeq.get(row.seq)
|
|
827
|
-
if (!ev || !isFoldContentNode(ev)) continue
|
|
828
|
-
if (Number.isFinite(ev.time) && ev.time > 0) contentTimes.push(ev.time)
|
|
829
|
-
}
|
|
830
|
-
// 内容时间窗权威口径 = 展开后可见原文行的时间(上方 contentTimes);旧形态
|
|
831
|
-
// marker 另有落盘的 contentTimeRange(editor 成员)作兜底——新形态没有该成员
|
|
832
|
-
// (官方词表无位置),兜底链退化为 trio 卡的 contentTimeRange(仅旧数据)。
|
|
833
|
-
const contentTimeRange = contentTimes.length > 0
|
|
834
|
-
? { lo: Math.min(...contentTimes), hi: Math.max(...contentTimes) }
|
|
835
|
-
: (marker.data?.editor?.contentTimeRange ?? trio?.['roadmap-card']?.contentTimeRange ?? null)
|
|
836
|
-
return {
|
|
837
|
-
markerSeq: markerNum,
|
|
838
|
-
trio,
|
|
839
|
-
supersededByNewer,
|
|
840
|
-
rows,
|
|
841
|
-
// 审计:marker 自身时间(执行时刻)——展示/检索语义取 contentTimeRange
|
|
842
|
-
markerTime: Number.isFinite(marker.time) ? marker.time : null,
|
|
843
|
-
contentTimeRange,
|
|
844
|
-
...(truncated ? { truncated: true, maxRows: UNFOLD_MAX_ROWS } : {}),
|
|
845
|
-
}
|
|
846
|
-
},
|
|
847
|
-
/**
|
|
848
|
-
* 折叠摘要:读文件 → 折叠块事件 → 确定摘要。
|
|
849
|
-
* 输入 = **surface 节点序**(折叠块本体 = span.shadowedSeqs,
|
|
850
|
-
* 官方 nodes 位置连续段),而非 LOG 切片——日志 append-only 含先前被遮蔽轮的原事件
|
|
851
|
-
* (幽灵),LOG 切片会把幽灵轮二次汇总(轮次/工具结果虚增、尾输入指向已不在 surface
|
|
852
|
-
* 的旧输入)。端点 [start..end] 必为 surface 节点(range mode 保证);若端点不在
|
|
853
|
-
* 官方 nodes(被遮蔽/非节点)→ 兜底 LOG 切片(保持旧行为兼容)。
|
|
854
|
-
*/
|
|
855
|
-
async summaryFromFile(sessionId, start, end, filePath) {
|
|
856
|
-
const events = filePath ? await readEventsFromFile(filePath) : await readEvents(sessionId)
|
|
857
|
-
if (!Array.isArray(events) || events.length === 0) return null
|
|
858
|
-
const lo = Number(start)
|
|
859
|
-
const hi = Number(end)
|
|
860
|
-
if (!Number.isInteger(lo) || !Number.isInteger(hi) || lo < 0 || hi < lo) return null
|
|
861
|
-
const { buildFoldSummary } = await import('../fold-summary.js')
|
|
862
|
-
// 以官方 surface nodes 位置段为输入(消幽灵轮)
|
|
863
|
-
const bySeq = new Map(events.map((e, i) => [e?.seq, i]))
|
|
864
|
-
let slice = null
|
|
865
|
-
try {
|
|
866
|
-
const folded = foldSurfaceWithProjections(foldSurface, events, sessionMessageProjections())
|
|
867
|
-
const nodes = folded?.nodes
|
|
868
|
-
if (Array.isArray(nodes) && nodes.length > 0) {
|
|
869
|
-
const si = nodes.indexOf(lo)
|
|
870
|
-
const ei = nodes.indexOf(hi)
|
|
871
|
-
if (si !== -1 && ei !== -1 && si <= ei) {
|
|
872
|
-
const shadowed = nodes.slice(si, ei + 1)
|
|
873
|
-
const picked = []
|
|
874
|
-
for (const seq of shadowed) {
|
|
875
|
-
const idx = bySeq.get(seq)
|
|
876
|
-
if (idx !== undefined && events[idx]) picked.push(events[idx])
|
|
877
|
-
}
|
|
878
|
-
if (picked.length > 0) slice = picked
|
|
879
|
-
}
|
|
880
|
-
}
|
|
881
|
-
} catch { /* foldSurface 失败 → 兜底 LOG 切片 */ }
|
|
882
|
-
if (!slice) {
|
|
883
|
-
if (hi >= events.length) return null
|
|
884
|
-
slice = events.slice(lo, hi + 1)
|
|
885
|
-
}
|
|
886
|
-
return buildFoldSummary(slice, { start: lo, end: hi })
|
|
887
|
-
},
|
|
888
|
-
/**
|
|
889
|
-
* 折叠摘要组:读文件 → surface 位置段事件 → 摘要组对象
|
|
890
|
-
* ({'roadmap-card':{blockTitle,summary,keySeqs,timeRange}, process, archive})。
|
|
891
|
-
* 与 summaryFromFile 同源(消幽灵轮:输入 = surface nodes 位置段非 LOG 切片);
|
|
892
|
-
* summaryFromFile 给单文本(content 人读),本方法给结构化(editor.trio,读侧用)。
|
|
893
|
-
* @param {string} [filePath] 可选:测试注入。
|
|
894
|
-
*/
|
|
895
|
-
async trioFromFile(sessionId, start, end, filePath) {
|
|
896
|
-
const events = filePath ? await readEventsFromFile(filePath) : await readEvents(sessionId)
|
|
897
|
-
if (!Array.isArray(events) || events.length === 0) return null
|
|
898
|
-
const lo = Number(start)
|
|
899
|
-
const hi = Number(end)
|
|
900
|
-
if (!Number.isInteger(lo) || !Number.isInteger(hi) || lo < 0 || hi < lo) return null
|
|
901
|
-
const { buildFoldTrio } = await import('../fold-core.js')
|
|
902
|
-
const bySeq = new Map(events.map((e, i) => [e?.seq, i]))
|
|
903
|
-
let picked = null
|
|
904
|
-
let shadowedSeqs = null
|
|
905
|
-
try {
|
|
906
|
-
const folded = foldSurfaceWithProjections(foldSurface, events, sessionMessageProjections())
|
|
907
|
-
const nodes = folded?.nodes
|
|
908
|
-
if (Array.isArray(nodes) && nodes.length > 0) {
|
|
909
|
-
const si = nodes.indexOf(lo)
|
|
910
|
-
const ei = nodes.indexOf(hi)
|
|
911
|
-
if (si !== -1 && ei !== -1 && si <= ei) {
|
|
912
|
-
shadowedSeqs = nodes.slice(si, ei + 1)
|
|
913
|
-
const arr = []
|
|
914
|
-
for (const seq of shadowedSeqs) {
|
|
915
|
-
const idx = bySeq.get(seq)
|
|
916
|
-
if (idx !== undefined && events[idx]) arr.push(events[idx])
|
|
917
|
-
}
|
|
918
|
-
if (arr.length > 0) picked = arr
|
|
919
|
-
}
|
|
920
|
-
}
|
|
921
|
-
} catch { /* foldSurface 失败 → 兜底 LOG 切片 */ }
|
|
922
|
-
if (!picked) {
|
|
923
|
-
if (hi >= events.length) return null
|
|
924
|
-
picked = events.slice(lo, hi + 1)
|
|
925
|
-
shadowedSeqs = null
|
|
926
|
-
}
|
|
927
|
-
return buildFoldTrio(picked, { start: lo, end: hi, shadowedSeqs: shadowedSeqs ?? [lo, hi], foldedAt: Date.now() })
|
|
928
|
-
},
|
|
929
|
-
/* @public-strip:end */
|
|
930
450
|
/**
|
|
931
451
|
* 从文件全量事件算某 turn 内的最大 step 号(情形② marker step 分配用)。
|
|
932
452
|
* 绕开 host 窗口化事件视图(稀疏内存视图可能看不到 turn 内全部 step,
|
|
@@ -937,18 +457,18 @@ export const dshAdapter = {
|
|
|
937
457
|
}
|
|
938
458
|
|
|
939
459
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
940
|
-
//
|
|
941
|
-
//
|
|
942
|
-
//
|
|
460
|
+
// 语义会话标识推导——工作区 createdAt 序号 + 父链,与外部工具
|
|
461
|
+
// 会话标识表生成器同规则(表的新鲜版,不冲突)。
|
|
462
|
+
// 会话标识 = 工作区2 + 序号3 + 父工作区2 + 父序号3;根父 = FF000。
|
|
943
463
|
// 只读会话文件帧1(header),全量 ~110 会话 ≈ 30ms,懒加载缓存。
|
|
944
464
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
945
465
|
|
|
946
466
|
/**
|
|
947
467
|
* 工作区目录名 → 2 位缩写:实现见 `lib/platform/session-paths.js`(单一真相;
|
|
948
|
-
*
|
|
468
|
+
* 会话标识侧实现与本文件的推导器共用同一份,避免换机器分叉)。
|
|
949
469
|
*/
|
|
950
470
|
|
|
951
|
-
/**
|
|
471
|
+
/** 派生会话标识表:扫活动基座各工作区会话 header,按 createdAt 排序编号,含父链。 */
|
|
952
472
|
export async function deriveBadgeTable(opts = {}) {
|
|
953
473
|
const { readSessionHeader } = await import('dsh-log-contract')
|
|
954
474
|
const root = opts.root ?? activeSessionsRoot()
|
|
@@ -963,7 +483,7 @@ export async function deriveBadgeTable(opts = {}) {
|
|
|
963
483
|
parent: typeof header.parentSession === 'string' ? header.parentSession : null,
|
|
964
484
|
})
|
|
965
485
|
}
|
|
966
|
-
// 工作区内按 createdAt 排序 → 序号(
|
|
486
|
+
// 工作区内按 createdAt 排序 → 序号(与会话标识表生成器一致)
|
|
967
487
|
const byWs = {}
|
|
968
488
|
for (const r of rows) (byWs[r.ws] ??= []).push(r)
|
|
969
489
|
const seqOf = new Map() // sessionId → { ws, seq }
|
|
@@ -990,7 +510,7 @@ export async function deriveBadgeTable(opts = {}) {
|
|
|
990
510
|
let deriveCache = null
|
|
991
511
|
let derivePromise = null
|
|
992
512
|
|
|
993
|
-
/**
|
|
513
|
+
/** 语义会话标识(推导):懒加载缓存;会话不在表(如已删/新加入但未扫)返回 null。 */
|
|
994
514
|
export async function semanticBadgeOf(sessionId) {
|
|
995
515
|
const id = String(sessionId ?? '')
|
|
996
516
|
if (deriveCache !== null) return deriveCache[id] ?? null
|
|
@@ -1010,23 +530,3 @@ export function invalidateBadgeDerive() {
|
|
|
1010
530
|
deriveCache = null
|
|
1011
531
|
derivePromise = null
|
|
1012
532
|
}
|
|
1013
|
-
|
|
1014
|
-
/* @public-strip:start */
|
|
1015
|
-
// 折叠专属读侧 helper(判定 + 修订链文本解析):只被上面展开路径使用,而展开路径
|
|
1016
|
-
// 本身属折叠能力 ⇒ 两者一同进出公开面(留在公开面就是"没有折叠功能却带着折叠词表")。
|
|
1017
|
-
/** 折叠 marker 型(旧形态 assistant/message + retrace-fold-*;新形态两段结构第 2 段)。 */
|
|
1018
|
-
function isFoldMarkerLike(event) {
|
|
1019
|
-
const id = String(event?.data?.message?.id ?? event?.data?.id ?? '')
|
|
1020
|
-
if (event?.type === 'assistant/message' && id.startsWith('retrace-fold-')) return true
|
|
1021
|
-
return isCarrierMarkerEvent(event) && id.startsWith('retrace-fold-')
|
|
1022
|
-
}
|
|
1023
|
-
|
|
1024
|
-
/** 序列化结构化摘要文本里的「取代旧结论(seq N…)」→ N(取不到 -1)。 */
|
|
1025
|
-
function supersededSeqOfText(text) {
|
|
1026
|
-
if (typeof text !== 'string' || text.length === 0) return -1
|
|
1027
|
-
const matched = /取代旧结论\(seq\s+(\d+)/.exec(text) ?? /取代\s*seq\s+(\d+)/.exec(text)
|
|
1028
|
-
if (!matched) return -1
|
|
1029
|
-
const num = Number(matched[1])
|
|
1030
|
-
return Number.isSafeInteger(num) ? num : -1
|
|
1031
|
-
}
|
|
1032
|
-
/* @public-strip:end */
|
package/lib/archaeology-cli.js
CHANGED
|
@@ -1,9 +1,9 @@
|
|
|
1
1
|
/**
|
|
2
2
|
* dsh-retrace · lib/archaeology-cli.js
|
|
3
3
|
*
|
|
4
|
-
* 会话日志考古 CLI 的核心逻辑(只读索引 / 查询 / 抽取 / 文件历史 /
|
|
4
|
+
* 会话日志考古 CLI 的核心逻辑(只读索引 / 查询 / 抽取 / 文件历史 / 标识)。
|
|
5
5
|
* 与 dsh-log-contract 的 archaeology.js 分工:B 侧提供 extract/audit 纯函数,
|
|
6
|
-
* 本模块提供 A 侧的文件版本考古(write/edit
|
|
6
|
+
* 本模块提供 A 侧的文件版本考古(write/edit 重放)与标识(parent 链)。
|
|
7
7
|
* **只读不写**(纪律 )。
|
|
8
8
|
*/
|
|
9
9
|
import { loadSessionLog, extractToolOutputs, auditToolCalls } from 'dsh-log-contract';
|
|
@@ -124,7 +124,7 @@ export function resolveSessionFile(ref) {
|
|
|
124
124
|
}
|
|
125
125
|
|
|
126
126
|
/**
|
|
127
|
-
*
|
|
127
|
+
* 标识(A4):从当前会话沿 header.parentSession 追溯父链。
|
|
128
128
|
* @param log - loadSessionLog 结果。
|
|
129
129
|
* @returns {{ id, parentId, ancestors: Array<{id, parentId}> }}
|
|
130
130
|
*/
|
package/lib/boot-pin.js
CHANGED
|
@@ -12,7 +12,7 @@
|
|
|
12
12
|
* 与 lib/watchdog.js 同款:定时器创建/销毁可注入(`schedule` / `unschedule`),
|
|
13
13
|
* 于是"句柄有没有 unref""dispose 有没有撤销"能被用例直接捕获,不靠 review。
|
|
14
14
|
* 职责边界:本模块只决定"何时重试";"重试做什么"由 `run()` 注入(装配点传
|
|
15
|
-
*
|
|
15
|
+
* 标题清理一轮),"现在有没有可处理的会话"由 `hasResidentSessions()` 注入。
|
|
16
16
|
* 本模块零 import、零宿主服务引用(可单测,也进得了动态件 realm)。
|
|
17
17
|
*/
|
|
18
18
|
|