oh-my-knowledge 0.48.0 → 0.49.0

package/dist/observability/trace-segmenter.js

@@ -1,27 +1,44 @@
 /** Skill segmentation and ResultEntry projection for loaded traces. */
-import { isToolResultFailureText } from './text-signals.js';
-import { extractAttributionSkillRef, extractBusinessActionSkillRef, extractCommandSkillRef, extractSkillReadFileRef, extractSkillScriptCommandRef, extractSkillToolUseRef, stripCommandEnvelopeText, } from './trace-attribution.js';
+import { createHash } from 'node:crypto';
+import { incrementRecordCount } from '../shared/record-count.js';
+import { truncateToolCallsForPersistence, truncateTurnsForPersistence, } from '../shared/trace-projection.js';
+import { sumTokenCounts, tokenCount } from '../shared/token-usage.js';
+import { legacyCcSessionToTraceSession } from './trace-source.js';
+import { normalizeTraceTimestamp } from './trace-ir.js';
+import { extractAttributionSkillRefFromEvent, extractBusinessActionSkillRefFromEvent, extractCommandSkillRefFromEvent, extractSkillReadFileRefFromEvent, extractSkillScriptCommandRefFromEvent, extractSkillToolUseRefFromEvent, stripCommandEnvelopeText, } from './trace-attribution.js';
+export const UNOBSERVED_TRACE_TIMESTAMP = '1970-01-01T00:00:00.000Z';
+export function skillSegmentTimestampObserved(segment) {
+    return segment.timestampObserved
+        ?? segment.startTimestamp !== UNOBSERVED_TRACE_TIMESTAMP;
+}
 // ---------- Segment by skill ----------
 /**
- * 扫描 session records, 按 skill 信号把 tool calls 切成多段。
+ * 扫描 Trace IR events, 按 skill 信号把 tool calls 切成多段。
  * 一个 session 可能产生 1-N 个 SkillSegment。
  */
-export function segmentBySkill(session) {
+export function segmentTraceBySkill(session) {
     const segments = [];
+    const orderedEvents = session.events
+        .map((event, order) => ({ event, order }))
+        .sort((a, b) => a.event.sourceIndex - b.event.sourceIndex || a.order - b.order)
+        .map(({ event }) => event);
     let currentSkill = 'general';
     let currentSkillSource;
     let currentSegment = createEmptySegment(session, currentSkill, 0, 0);
     let segmentIndex = 0;
-    // 用 tool_use_id → ToolCallInfo 的映射, 收到 tool_result 时回填 output / success
+    const lastSourceIndex = orderedEvents.reduce((max, event) => Math.max(max, event.sourceIndex), 0);
     const pendingToolUses = new Map();
-    const markCurrentRecord = (recordIndex) => {
-        currentSegment.endRecordIndex = Math.max(currentSegment.endRecordIndex ?? currentSegment.startRecordIndex ?? recordIndex, recordIndex);
+    const assistantTurnsBySourceIndex = new Map();
+    const humanTurnsBySourceIndex = new Map();
+    const invalidTokenUsage = new WeakSet();
+    const markSegmentRecord = (segment, recordIndex) => {
+        segment.endRecordIndex = Math.max(segment.endRecordIndex ?? segment.startRecordIndex ?? recordIndex, recordIndex);
     };
     const flushCurrent = (endRecordIndex) => {
         if (currentSegment.turns.length > 0 || currentSegment.toolCalls.length > 0) {
             if (typeof endRecordIndex === 'number') {
                 const start = currentSegment.startRecordIndex ?? 0;
-                currentSegment.endRecordIndex = Math.max(start, Math.min(session.records.length - 1, endRecordIndex));
+                currentSegment.endRecordIndex = Math.max(start, Math.min(lastSourceIndex, endRecordIndex));
             }
             segments.push(currentSegment);
             return true;
@@ -38,196 +55,331 @@ export function segmentBySkill(session) {
         currentSkill = ref.skillName;
         currentSkillSource = ref.pluginName;
     };
-    for (const [recordIndex, raw] of session.records.entries()) {
-        // records 是 unknown[], 按 type 字段做 structural type guard
-        if (!raw || typeof raw !== 'object' || !('type' in raw))
-            continue;
-        const rec = raw;
-        if (rec.type === 'user') {
-            const u = rec;
-            // 检测 skill 信号 2 (slash command)
-            const cmdSkill = extractCommandSkillRef(u);
-            if (cmdSkill && !isCurrentSkillRef(cmdSkill)) {
-                startNewSegment(cmdSkill, recordIndex, u.timestamp, {
-                    source: 'command-name',
-                    confidence: 0.85,
-                    rawSkillRef: cmdSkill.rawSkillRef,
-                    pluginName: cmdSkill.pluginName,
-                    commandName: `/${cmdSkill.rawSkillRef}`,
-                });
-            }
-            else if (!cmdSkill) {
-                const businessActionSkill = extractBusinessActionSkillRef(u);
-                if (businessActionSkill && !isCurrentSkillRef(businessActionSkill)) {
-                    startNewSegment(businessActionSkill, recordIndex, u.timestamp, {
-                        source: 'business-action',
-                        confidence: 0.85,
-                        rawSkillRef: businessActionSkill.rawSkillRef,
-                        pluginName: businessActionSkill.pluginName,
-                        commandName: businessActionSkill.rawSkillRef,
-                    });
-                }
-                else {
-                    const scriptSkill = extractSkillScriptCommandRef(u);
-                    if (scriptSkill && !isCurrentSkillRef(scriptSkill)) {
-                        startNewSegment(scriptSkill, recordIndex, u.timestamp, {
-                            source: 'skill-script',
-                            confidence: 0.75,
-                            rawSkillRef: scriptSkill.rawSkillRef,
-                            pluginName: scriptSkill.pluginName,
-                            commandName: scriptSkill.rawSkillRef,
-                        });
+    const eventGroups = groupEventsBySourceIndex(orderedEvents);
+    for (const eventGroup of eventGroups) {
+        const boundary = skillBoundaryForEventGroup(eventGroup, session, currentSegment);
+        if (boundary && !isCurrentSkillRef(boundary.ref)) {
+            startNewSegment(boundary.ref, eventGroup[0].sourceIndex, eventGroup.find((event) => event.timestamp)?.timestamp, boundary.attribution);
+        }
+        for (const event of eventsInCorrelationOrder(eventGroup)) {
+            const recordIndex = event.sourceIndex;
+            updateSegmentTimestamp(currentSegment, event.timestamp);
+            if (event.eventKind === 'message' && event.role === 'user') {
+                if (event.origin === 'human') {
+                    const textContent = stripCommandEnvelopeText(event.text);
+                    if (textContent) {
+                        const existing = humanTurnsBySourceIndex.get(recordIndex);
+                        if (existing && currentSegment.turns.includes(existing)) {
+                            existing.content = existing.content
+                                ? `${existing.content}\n${textContent}`
+                                : textContent;
+                        }
+                        else {
+                            const turn = { role: 'user', content: textContent };
+                            currentSegment.turns.push(turn);
+                            humanTurnsBySourceIndex.set(recordIndex, turn);
+                        }
                     }
                 }
+                updateSegmentTimestamp(currentSegment, event.timestamp);
+                markSegmentRecord(currentSegment, recordIndex);
+                continue;
             }
-            // 处理 tool_result(回填之前的 tool_use)
-            if (typeof u.message.content !== 'string') {
-                for (const part of u.message.content) {
-                    if (part.type === 'tool_result') {
-                        const pending = pendingToolUses.get(part.tool_use_id);
-                        if (pending) {
-                            const failed = part.is_error === true || isToolResultFailureText(part.content);
-                            pending.toolCall.output = part.content;
-                            pending.toolCall.success = !failed;
-                            if (failed) {
-                                pending.segmentRef.metrics.numToolFailures += 1;
-                            }
-                            pendingToolUses.delete(part.tool_use_id);
-                        }
+            if (event.eventKind === 'message' && event.role === 'assistant') {
+                updateSegmentSourceModel(currentSegment, session.sourceMetadata, event.model);
+                if (event.text) {
+                    const existing = assistantTurnsBySourceIndex.get(recordIndex);
+                    if (existing && currentSegment.turns.includes(existing)) {
+                        existing.content = existing.content
+                            ? `${existing.content}\n${event.text}`
+                            : event.text;
+                    }
+                    else {
+                        const turn = { role: 'assistant', content: event.text };
+                        currentSegment.turns.push(turn);
+                        assistantTurnsBySourceIndex.set(recordIndex, turn);
+                        currentSegment.metrics.numTurns += 1;
                     }
                 }
+                updateSegmentTimestamp(currentSegment, event.timestamp);
+                markSegmentRecord(currentSegment, recordIndex);
+                continue;
             }
-            // user text 合并到 tool turn(简化处理, 不强区分角色)
-            const textContent = extractUserText(u);
-            if (textContent) {
-                currentSegment.turns.push({ role: 'tool', content: textContent });
-                currentSegment.metrics.numTurns += 1;
-            }
-            updateSegmentTimestamp(currentSegment, u.timestamp);
-            markCurrentRecord(recordIndex);
-            continue;
-        }
-        if (rec.type === 'assistant') {
-            const a = rec;
-            // 检测 skill 信号 1 (Skill tool_use); 信号 3 (Read SKILL.md) 作 fallback。
-            // OpenClaw 场景里一条用户消息可能包含多个业务动作,
-            // 后续读取不同 SKILL.md 才是实际运行到哪个 skill 的稳定边界。
-            const skillTool = extractSkillToolUseRef(a);
-            if (skillTool && !isCurrentSkillRef(skillTool)) {
-                startNewSegment(skillTool, recordIndex, a.timestamp, {
-                    source: 'skill-tool',
-                    confidence: 0.95,
-                    rawSkillRef: skillTool.rawSkillRef,
-                    pluginName: skillTool.pluginName,
-                });
-            }
-            else if (!skillTool) {
-                const attrSkill = extractAttributionSkillRef(a);
-                if (attrSkill && !isCurrentSkillRef(attrSkill)) {
-                    startNewSegment(attrSkill, recordIndex, a.timestamp, {
-                        source: 'command-name',
-                        confidence: 0.85,
-                        rawSkillRef: attrSkill.rawSkillRef,
-                        pluginName: attrSkill.pluginName,
-                        commandName: `/${attrSkill.rawSkillRef}`,
-                    });
+            if (event.eventKind === 'tool_call') {
+                updateSegmentSourceModel(currentSegment, session.sourceMetadata, event.model);
+                const toolCall = {
+                    tool: event.tool.name,
+                    ...(event.tool.sourceName ? { sourceTool: event.tool.sourceName } : {}),
+                    ...(event.tool.namespace ? { toolNamespace: event.tool.namespace } : {}),
+                    ...(event.tool.provider ? { toolProvider: event.tool.provider } : {}),
+                    input: event.input,
+                    output: '',
+                    status: 'unknown',
+                    statusSource: 'unknown',
+                    success: false,
+                    messageIndex: recordIndex,
+                    messageUuid: event.sourceEventId ?? event.eventId,
+                    callInstanceId: event.callInstanceId ?? event.eventId,
+                    toolUseId: event.callId,
+                    timestamp: event.timestamp,
+                    sourceTrace: session.sourcePath,
+                    sourceKind: session.sourceKind,
+                    traceRole: session.role,
+                    traceLabel: session.label,
+                };
+                currentSegment.toolCalls.push(toolCall);
+                currentSegment.metrics.numToolCalls += 1;
+                const pending = pendingToolUses.get(event.callId) ?? [];
+                pending.push({ toolCall, segmentRef: currentSegment });
+                pendingToolUses.set(event.callId, pending);
+                let turn = assistantTurnsBySourceIndex.get(recordIndex);
+                if (!turn || !currentSegment.turns.includes(turn)) {
+                    turn = { role: 'assistant', content: '' };
+                    currentSegment.turns.push(turn);
+                    assistantTurnsBySourceIndex.set(recordIndex, turn);
+                    currentSegment.metrics.numTurns += 1;
                 }
-                else {
-                    const scriptSkill = extractSkillScriptCommandRef(a);
-                    if (scriptSkill && !isCurrentSkillRef(scriptSkill)) {
-                        startNewSegment(scriptSkill, recordIndex, a.timestamp, {
-                            source: 'skill-script',
-                            confidence: 0.7,
-                            rawSkillRef: scriptSkill.rawSkillRef,
-                            pluginName: scriptSkill.pluginName,
-                            commandName: scriptSkill.rawSkillRef,
-                        });
+                turn.toolCalls = [...(turn.toolCalls ?? []), toolCall];
+                updateSegmentTimestamp(currentSegment, event.timestamp);
+                markSegmentRecord(currentSegment, recordIndex);
+                continue;
+            }
+            if (event.eventKind === 'tool_result') {
+                const queue = pendingToolUses.get(event.callId);
+                const matchingIndex = event.callInstanceId
+                    ? queue?.findIndex((candidate) => candidate.toolCall.callInstanceId === event.callInstanceId)
+                    : undefined;
+                const pending = matchingIndex !== undefined && matchingIndex >= 0
+                    ? queue?.splice(matchingIndex, 1)[0]
+                    : event.callInstanceId
+                        ? undefined
+                        : queue?.shift();
+                if (pending) {
+                    pending.toolCall.output = event.output;
+                    pending.toolCall.status = event.status;
+                    pending.toolCall.statusSource = event.statusSource;
+                    pending.toolCall.success = event.status === 'success';
+                    if (event.status === 'failure')
+                        pending.segmentRef.metrics.numToolFailures += 1;
+                    if (event.status === 'cancelled') {
+                        pending.segmentRef.metrics.numToolCancelled =
+                            (pending.segmentRef.metrics.numToolCancelled ?? 0) + 1;
+                    }
+                    if (event.status === 'unknown')
+                        pending.segmentRef.metrics.numToolUnknown += 1;
+                    updateSegmentTimestamp(pending.segmentRef, event.timestamp);
+                    if (pending.segmentRef === currentSegment) {
+                        markSegmentRecord(pending.segmentRef, recordIndex);
                     }
                     else {
-                        const readSkill = extractSkillReadFileRef(a);
-                        if (readSkill && !isCurrentSkillRef(readSkill) && shouldCutOnReadSkill(session, currentSegment)) {
-                            startNewSegment(readSkill, recordIndex, a.timestamp, {
-                                source: 'read-skill-md',
-                                confidence: 0.5,
-                                rawSkillRef: readSkill.rawSkillRef,
-                                pluginName: readSkill.pluginName,
-                            });
-                        }
+                        // The result completes the originating call, but its source record
+                        // belongs to the segment active after the explicit boundary.
+                        markSegmentRecord(currentSegment, recordIndex);
                     }
+                    if (queue?.length === 0)
+                        pendingToolUses.delete(event.callId);
                 }
-            }
-            // 提取 tool_use → ToolCallInfo(success 先标 true, 等 tool_result 回填)
-            const toolCalls = [];
-            let assistantText = '';
-            const assistantContent = Array.isArray(a.message.content) ? a.message.content : [];
-            for (const part of assistantContent) {
-                if (part.type === 'text' && part.text)
-                    assistantText += part.text;
-                if (part.type === 'tool_use' && part.id && part.name) {
-                    const tc = {
-                        tool: part.name,
-                        input: part.input ?? {},
-                        output: '',
-                        success: true,
-                        messageIndex: recordIndex,
-                        messageUuid: a.uuid,
-                        toolUseId: part.id,
-                        timestamp: a.timestamp,
-                        sourceTrace: session.sourcePath,
-                        sourceKind: session.sourceKind,
-                        traceRole: session.traceRole,
-                        traceLabel: session.traceLabel,
-                    };
-                    toolCalls.push(tc);
-                    pendingToolUses.set(part.id, { toolCall: tc, segmentRef: currentSegment });
+                else {
+                    updateSegmentTimestamp(currentSegment, event.timestamp);
+                    markSegmentRecord(currentSegment, recordIndex);
                 }
+                continue;
             }
-            if (toolCalls.length > 0 || assistantText) {
-                currentSegment.turns.push({
-                    role: 'assistant',
-                    content: assistantText,
-                    toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-                });
-                currentSegment.metrics.numTurns += 1;
-                currentSegment.toolCalls.push(...toolCalls);
-                currentSegment.metrics.numToolCalls += toolCalls.length;
-            }
-            // 累加 token usage
-            const usage = a.message.usage;
-            if (usage) {
-                currentSegment.metrics.inputTokens += usage.input_tokens ?? 0;
-                currentSegment.metrics.outputTokens += usage.output_tokens ?? 0;
-                currentSegment.metrics.cacheReadTokens += usage.cache_read_input_tokens ?? 0;
-                currentSegment.metrics.cacheCreationTokens += usage.cache_creation_input_tokens ?? 0;
+            if (event.eventKind === 'usage') {
+                if (!invalidTokenUsage.has(currentSegment)) {
+                    const nextUsage = [
+                        safeTokenCountAddition(currentSegment.metrics.inputTokens, event.inputTokens),
+                        safeTokenCountAddition(currentSegment.metrics.outputTokens, event.outputTokens),
+                        safeTokenCountAddition(currentSegment.metrics.cacheReadTokens, event.cacheReadTokens),
+                        safeTokenCountAddition(currentSegment.metrics.cacheCreationTokens, event.cacheCreationTokens),
+                    ];
+                    if (nextUsage.some((value) => value === undefined)
+                        || safeTokenCountSum(nextUsage) === undefined) {
+                        currentSegment.metrics.inputTokens = 0;
+                        currentSegment.metrics.outputTokens = 0;
+                        currentSegment.metrics.cacheReadTokens = 0;
+                        currentSegment.metrics.cacheCreationTokens = 0;
+                        currentSegment.metrics.tokenUsageObserved = false;
+                        invalidTokenUsage.add(currentSegment);
+                    }
+                    else {
+                        [
+                            currentSegment.metrics.inputTokens,
+                            currentSegment.metrics.outputTokens,
+                            currentSegment.metrics.cacheReadTokens,
+                            currentSegment.metrics.cacheCreationTokens,
+                        ] = nextUsage;
+                        currentSegment.metrics.tokenUsageObserved = true;
+                    }
+                }
+                updateSegmentSourceModel(currentSegment, session.sourceMetadata, event.model);
+                updateSegmentTimestamp(currentSegment, event.timestamp);
             }
-            updateSegmentTimestamp(currentSegment, a.timestamp);
-            markCurrentRecord(recordIndex);
-            continue;
+            markSegmentRecord(currentSegment, recordIndex);
+        }
+    }
+    for (const queue of pendingToolUses.values()) {
+        for (const pending of queue) {
+            pending.segmentRef.metrics.numToolUnknown += 1;
         }
-        // 其他 type(permission-mode / file-history-snapshot) 不产出事件,但仍属于当前
-        // skill 生命周期窗口,用于保持下一次 skill 边界前的连续上下文。
-        markCurrentRecord(recordIndex);
     }
-    flushCurrent(session.records.length - 1);
-    // 孤儿 tool_use(没对应 tool_result 的)保持 success=true, 但标记为未闭合
+    flushCurrent(lastSourceIndex);
     return segments;
 }
+function eventsInCorrelationOrder(events) {
+    return events
+        .map((event, order) => ({ event, order }))
+        .sort((left, right) => correlationRank(left.event) - correlationRank(right.event) || left.order - right.order)
+        .map(({ event }) => event);
+}
+function correlationRank(event) {
+    if (event.eventKind === 'tool_call')
+        return 0;
+    if (event.eventKind === 'tool_result')
+        return 2;
+    return 1;
+}
+function groupEventsBySourceIndex(events) {
+    const groups = [];
+    for (const event of events) {
+        const current = groups.at(-1);
+        if (current?.[0]?.sourceIndex === event.sourceIndex)
+            current.push(event);
+        else
+            groups.push([event]);
+    }
+    return groups;
+}
+function skillBoundaryForEventGroup(events, session, currentSegment) {
+    const humanMessages = events.filter((event) => event.eventKind === 'message' && event.role === 'user' && event.origin === 'human');
+    const assistantMessages = events.filter((event) => event.eventKind === 'message' && event.role === 'assistant');
+    const toolCalls = events.filter((event) => event.eventKind === 'tool_call');
+    for (const event of toolCalls) {
+        const ref = extractSkillToolUseRefFromEvent(event);
+        if (ref) {
+            return {
+                ref,
+                attribution: {
+                    source: 'skill-tool',
+                    confidence: 0.95,
+                    rawSkillRef: ref.rawSkillRef,
+                    pluginName: ref.pluginName,
+                },
+            };
+        }
+    }
+    for (const event of humanMessages) {
+        const ref = extractCommandSkillRefFromEvent(event);
+        if (ref) {
+            return {
+                ref,
+                attribution: {
+                    source: 'command-name',
+                    confidence: 0.85,
+                    rawSkillRef: ref.rawSkillRef,
+                    pluginName: ref.pluginName,
+                    commandName: `/${ref.rawSkillRef}`,
+                },
+            };
+        }
+    }
+    for (const event of humanMessages) {
+        const ref = extractBusinessActionSkillRefFromEvent(event);
+        if (ref) {
+            return {
+                ref,
+                attribution: {
+                    source: 'business-action',
+                    confidence: 0.85,
+                    rawSkillRef: ref.rawSkillRef,
+                    pluginName: ref.pluginName,
+                    commandName: ref.rawSkillRef,
+                },
+            };
+        }
+    }
+    for (const event of assistantMessages) {
+        const ref = extractAttributionSkillRefFromEvent(event);
+        if (ref) {
+            return {
+                ref,
+                attribution: {
+                    source: 'command-name',
+                    confidence: 0.85,
+                    rawSkillRef: ref.rawSkillRef,
+                    pluginName: ref.pluginName,
+                    commandName: `/${ref.rawSkillRef}`,
+                },
+            };
+        }
+    }
+    for (const event of [...humanMessages, ...assistantMessages, ...toolCalls]) {
+        const ref = extractSkillScriptCommandRefFromEvent(event);
+        if (ref) {
+            return {
+                ref,
+                attribution: {
+                    source: 'skill-script',
+                    confidence: event.eventKind === 'message' && event.role === 'user' ? 0.75 : 0.7,
+                    rawSkillRef: ref.rawSkillRef,
+                    pluginName: ref.pluginName,
+                    commandName: ref.rawSkillRef,
+                },
+            };
+        }
+    }
+    for (const event of toolCalls) {
+        const ref = extractSkillReadFileRefFromEvent(event);
+        if (ref && shouldCutOnReadSkill(currentSegment)) {
+            return {
+                ref,
+                attribution: {
+                    source: 'read-skill-md',
+                    confidence: 0.5,
+                    rawSkillRef: ref.rawSkillRef,
+                    pluginName: ref.pluginName,
+                },
+            };
+        }
+    }
+    return null;
+}
+/** @deprecated Compatibility entry point for Claude-shaped fixtures. */
+export function segmentBySkill(session) {
+    return segmentTraceBySkill('events' in session ? session : legacyCcSessionToTraceSession(session));
+}
+function updateSegmentSourceModel(segment, sessionMetadata, model) {
+    if (!model)
+        return;
+    const baseMetadata = { ...sessionMetadata };
+    delete baseMetadata.model;
+    const models = new Set(segment.sourceMetadata?.model?.split(', ').filter(Boolean) ?? []);
+    models.add(model);
+    segment.sourceMetadata = {
+        ...baseMetadata,
+        ...segment.sourceMetadata,
+        model: Array.from(models).join(', '),
+    };
+}
 function createEmptySegment(session, skillName, index, recordIndex, timestamp, attribution) {
-    const ts = timestamp ?? session.startTimestamp ?? new Date().toISOString();
+    const observedTimestamp = normalizeTraceTimestamp(timestamp);
+    const ts = observedTimestamp ?? UNOBSERVED_TRACE_TIMESTAMP;
     return {
         skillName,
         attribution: attribution ?? { source: 'general', confidence: 0.3 },
-        sessionId: session.sessionGroupId ?? session.sessionId,
-        traceSessionId: session.sessionId,
+        sessionId: session.rootRunId,
+        traceSessionId: session.runId,
+        traceId: session.traceId,
         sourceTrace: session.sourcePath,
         sourceKind: session.sourceKind,
-        traceRole: session.traceRole,
-        traceLabel: session.traceLabel,
+        traceRole: session.role,
+        traceLabel: session.label,
         segmentIndex: index,
         startRecordIndex: recordIndex,
         endRecordIndex: recordIndex,
         startTimestamp: ts,
         endTimestamp: ts,
+        timestampObserved: observedTimestamp !== undefined,
         cwd: session.cwd,
         turns: [],
         toolCalls: [],
@@ -237,17 +389,30 @@ function createEmptySegment(session, skillName, index, recordIndex, timestamp, a
             outputTokens: 0,
             cacheReadTokens: 0,
             cacheCreationTokens: 0,
+            tokenUsageObserved: false,
             numTurns: 0,
             numToolCalls: 0,
             numToolFailures: 0,
+            numToolCancelled: 0,
+            numToolUnknown: 0,
         },
     };
 }
 function updateSegmentTimestamp(seg, timestamp) {
-    if (!timestamp)
+    const normalized = normalizeTraceTimestamp(timestamp);
+    if (!normalized)
         return;
-    if (!seg.endTimestamp || timestamp > seg.endTimestamp)
-        seg.endTimestamp = timestamp;
+    seg.timestampObserved = true;
+    if (seg.startTimestamp === UNOBSERVED_TRACE_TIMESTAMP) {
+        seg.startTimestamp = normalized;
+        seg.endTimestamp = normalized;
+    }
+    else {
+        if (normalized < seg.startTimestamp)
+            seg.startTimestamp = normalized;
+        if (!seg.endTimestamp || normalized > seg.endTimestamp)
+            seg.endTimestamp = normalized;
+    }
     // 重算 durationMs
     try {
         const start = new Date(seg.startTimestamp).getTime();
@@ -257,23 +422,22 @@ function updateSegmentTimestamp(seg, timestamp) {
     }
     catch { /* skip */ }
 }
-function shouldCutOnReadSkill(session, currentSegment) {
+function shouldCutOnReadSkill(currentSegment) {
     return currentSegment.skillName === 'general'
-        || currentSegment.attribution?.source === 'read-skill-md'
-        || session.sourceKind === 'openclaw';
+        || currentSegment.attribution?.source === 'read-skill-md';
 }
-function extractUserText(record) {
-    const content = record.message.content;
-    if (typeof content === 'string')
-        return stripCommandEnvelopeText(content);
-    const parts = [];
-    for (const p of content) {
-        if (p.type === 'text')
-            parts.push(stripCommandEnvelopeText(p.text));
-        if (p.type === 'tool_result' && typeof p.content === 'string')
-            parts.push(p.content);
+function safeTokenCountAddition(current, value) {
+    const addition = tokenCount(value);
+    return current <= Number.MAX_SAFE_INTEGER - addition ? current + addition : undefined;
+}
+function safeTokenCountSum(values) {
+    let total = 0;
+    for (const value of values) {
+        if (total > Number.MAX_SAFE_INTEGER - value)
+            return undefined;
+        total += value;
     }
-    return parts.join('\n');
+    return total;
 }
 // ---------- Segment → ResultEntry ----------
 /**
@@ -281,41 +445,58 @@ function extractUserText(record) {
  *
  * 映射规则(详见 docs/skill-health-spec.md):
  *   - 每 segment 一个 ResultEntry
- *   - sample_id = `${sessionId}:${segmentIndex}`
+ *   - sample_id 锚定 traceId + skillName + startRecordIndex
  *   - variant key = skill 名(复用 omk 的 variant 维度作为 skill 分组维度)
  */
 export function segmentsToResultEntries(segments) {
     return segments.map((seg) => ({
-        sample_id: `${seg.sessionId}:${seg.segmentIndex}`,
+        sample_id: `trace:${createHash('sha256')
+            .update([
+            seg.traceId ?? seg.traceSessionId ?? seg.sessionId,
+            seg.skillName,
+            String(seg.startRecordIndex ?? 0),
+        ].join('\u0000'))
+            .digest('hex')
+            .slice(0, 32)}`,
         variants: {
             [seg.skillName]: buildVariantResult(seg),
         },
     }));
 }
 function buildVariantResult(seg) {
-    const totalTokens = seg.metrics.inputTokens + seg.metrics.outputTokens;
-    const toolSuccessRate = seg.metrics.numToolCalls > 0
-        ? (seg.metrics.numToolCalls - seg.metrics.numToolFailures) / seg.metrics.numToolCalls
-        : 1;
+    const totalTokens = sumTokenCounts(seg.metrics.inputTokens, seg.metrics.outputTokens, seg.metrics.cacheReadTokens, seg.metrics.cacheCreationTokens);
+    const cancelledToolCalls = seg.metrics.numToolCancelled ?? 0;
+    const comparableToolCalls = Math.max(0, seg.metrics.numToolCalls - seg.metrics.numToolUnknown - cancelledToolCalls);
+    const toolDistribution = {};
+    for (const toolCall of seg.toolCalls) {
+        incrementRecordCount(toolDistribution, toolCall.tool);
+    }
     return {
         ok: true,
         durationMs: seg.metrics.durationMs,
-        durationApiMs: seg.metrics.durationMs,
+        durationApiMs: 0,
         inputTokens: seg.metrics.inputTokens,
         outputTokens: seg.metrics.outputTokens,
         totalTokens,
         cacheReadTokens: seg.metrics.cacheReadTokens,
         cacheCreationTokens: seg.metrics.cacheCreationTokens,
+        ...(!seg.metrics.tokenUsageObserved && { tokenUsageReportedByExecutor: false }),
         execCostUSD: 0,
         judgeCostUSD: 0,
         costUSD: 0,
+        costReportedByExecutor: false,
         numTurns: seg.metrics.numTurns,
         numToolCalls: seg.metrics.numToolCalls,
         numToolFailures: seg.metrics.numToolFailures,
-        toolSuccessRate,
+        numToolCancelled: cancelledToolCalls,
+        numToolUnknown: seg.metrics.numToolUnknown,
+        ...(comparableToolCalls > 0 && {
+            toolSuccessRate: Number(((comparableToolCalls - seg.metrics.numToolFailures) / comparableToolCalls).toFixed(2)),
+        }),
         toolNames: Array.from(new Set(seg.toolCalls.map((tc) => tc.tool))),
+        toolDistribution,
         outputPreview: null,
-        turns: seg.turns,
-        toolCalls: seg.toolCalls,
+        turns: truncateTurnsForPersistence(seg.turns),
+        toolCalls: truncateToolCallsForPersistence(seg.toolCalls),
     };
 }