oh-my-knowledge 0.48.0 → 0.49.0

package/dist/observability/inbox.js

@@ -1,14 +1,23 @@
 import { createHash } from 'node:crypto';
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { OMK_HOME } from '../eval-core/default-dirs.js';
-import { isReportFileName, reportFilePath } from '../eval-core/artifact-file-names.js';
+import { isReportFileName, randomRunToken, reportFilePath } from '../eval-core/artifact-file-names.js';
 import { migrateLegacyReportFiles } from '../eval-core/report-file-migration.js';
 import { extractGapSignalsFromTrace } from '../analysis/gap-analyzer.js';
-import { ccTracesToResultEntries } from './trace-adapter.js';
+import { loadTraceSessions, tracesToResultEntries, skillSegmentTimestampObserved, } from './trace-adapter.js';
+import { normalizeTraceTimestamp } from './trace-ir.js';
 import { isSearchToolCall, toolCallQuery } from '../shared/tool-search.js';
+import { isToolCallFailure, isToolCallSuccess } from '../shared/tool-call-status.js';
+import { isTraceSourceKind as isObservationSourceKind } from '../shared/trace-source-kind.js';
+import { incrementRecordCount, ownRecordValue, setOwnRecordValue, sumRecordCounts, } from '../shared/record-count.js';
 import { durationMsBetween } from '../shared/time.js';
-import { buildObservationExperienceReport, normalizeObservationExperienceReport, } from './experience.js';
+import { buildObservationExperienceReport, compactObservationExperienceReport, normalizeObservationExperienceReport, } from './experience.js';
+import { parseDiagnosisBundle } from '../shared/diagnosis-schema.js';
+import { parseTraceIngestionSummary } from './trace-ingestion.js';
+import { createTraceSessionIndex, traceSessionRefIdentity } from './trace-session-index.js';
+import { isInstalledSkillAssetPath } from './trace-attribution.js';
+import { writeJsonFileAtomic } from '../shared/atomic-json.js';
 // observe inbox（观测收件箱）产物根目录。导出名沿用 *_OBSERVATIONS_DIR 以少动 importer,
 // 但落盘目录已统一到 observe-inbox 词根(命令 omk observe inbox / kind observe-inbox)。
 // 项目级 .omk/observe-inbox 优先、全局兜底 —— 这套 project/global 归属是既有正常行为,本次只改名不改归属。
@@ -16,6 +25,7 @@ export const DEFAULT_PROJECT_OBSERVATIONS_DIR = join(process.cwd(), '.omk', 'obs
 export const DEFAULT_GLOBAL_OBSERVATIONS_DIR = join(OMK_HOME, 'observe-inbox');
 export const DEFAULT_OBSERVATIONS_DIR = DEFAULT_PROJECT_OBSERVATIONS_DIR;
 const OBSERVATION_INBOX_SCHEMA_VERSION = 2;
+const UNOBSERVED_TIMESTAMP = '1970-01-01T00:00:00.000Z';
 function hashString(input) {
     return createHash('sha256').update(input).digest('hex').slice(0, 16);
 }
@@ -39,12 +49,16 @@ export function normalizeObservationKeyInput(value) {
         .replace(/\/+/g, '/')
         .replace(/\/$/, ''));
 }
+/** Legacy migration only. New reports take sourceKind from Trace IR. */
 export function inferObservationSourceKind(sourceTrace) {
-    if (sourceTrace.includes('/openclaw') || sourceTrace.includes('/.openclaw/'))
+    const normalized = sourceTrace.replaceAll('\\', '/').toLowerCase();
+    if (/(?:^|\/)\.?openclaw(?:\/|$)/.test(normalized))
         return 'openclaw';
-    if (sourceTrace.endsWith('.jsonl'))
+    if (/(?:^|\/)\.?codex\/sessions(?:\/|$)/.test(normalized))
+        return 'codex';
+    if (/(?:^|\/)\.?claude(?:\/|$)/.test(normalized))
         return 'claude';
-    if (sourceTrace.endsWith('.log'))
+    if (normalized.endsWith('.log'))
         return 'markdown_log';
     return 'unknown';
 }
@@ -75,7 +89,7 @@ function snippet(value, max = 240) {
     return normalized ? normalized.slice(0, max) : undefined;
 }
 function isSuccessfulSearch(tc) {
-    if (!isSearchToolCall(tc) || tc.success === false)
+    if (!isSearchToolCall(tc) || !isToolCallSuccess(tc))
         return false;
     const out = snippet(tc.output, 1000) ?? '';
     return out !== '' && !/No matches found/i.test(out);
@@ -108,7 +122,7 @@ function failedSearchSubtype(tc, allCalls, index, skillName) {
         return 'not_found';
     if (/exceeds maximum allowed tokens|maximum allowed tokens|token limit|timed out|timeout/i.test(out))
         return 'tool_limit';
-    if (tc.success === false)
+    if (isToolCallFailure(tc))
         return 'tool_failure';
     const laterSuccess = allCalls.slice(index + 1).some((later) => isSuccessfulSearch(later) && isSameTopicSearch(tc, later));
     return laterSuccess ? 'exploratory_miss' : 'hard_miss';
@@ -117,12 +131,7 @@ function isTransientPath(value) {
     return /(?:^|\s)(?:\/private)?\/tmp\/|(?:^|\s)\/var\/folders\/|figma_[\w.-]+\.(?:png|jpg|jpeg|webp)\b/i.test(value);
 }
 function isSkillAssetPath(value, skillName) {
-    if (!value || !skillName)
-        return false;
-    return value.includes(`/.claude/skills/${skillName}/`)
-        || value.includes(`.claude/skills/${skillName}/`)
-        || value.includes(`/.openclaw/workspace/skills/${skillName}/`)
-        || value.includes(`.openclaw/workspace/skills/${skillName}/`);
+    return isInstalledSkillAssetPath(value, skillName);
 }
 function topicTokens(value) {
     return new Set(normalizeObservationKeyInput(value)
@@ -205,12 +214,13 @@ function severityFor(signalType, subtype, confidence) {
 }
 function buildSessionTimeRanges(sessions) {
     return sessions.map((session) => ({
-        sessionId: session.sessionId,
-        sessionGroupId: session.sessionGroupId,
+        sessionId: session.runId,
+        traceId: session.traceId,
+        sessionGroupId: session.rootRunId,
         sourceTrace: session.sourcePath,
-        sourceKind: session.sourceKind ?? inferObservationSourceKind(session.sourcePath),
-        traceRole: session.traceRole,
-        traceLabel: session.traceLabel,
+        sourceKind: session.sourceKind,
+        traceRole: session.role,
+        traceLabel: session.label,
         cwd: session.cwd,
         startTimestamp: session.startTimestamp,
         endTimestamp: session.endTimestamp,
@@ -302,7 +312,8 @@ function itemsFromSegment(segment) {
     // attributionConfidence 仅 0.3，没有 skill 改进价值，直接过滤。
     if (segment.skillName === 'general')
         return [];
-    const sampleId = `${segment.sessionId}:${segment.segmentIndex}`;
+    const evidenceStreamId = traceSessionRefIdentity(segment);
+    const sampleId = `${evidenceStreamId}:${segment.segmentIndex}`;
     const signals = extractGapSignalsFromTrace({
         sampleId,
         turns: segment.turns,
@@ -339,6 +350,7 @@ function itemsFromSegment(segment) {
                 outputSnippet: snippet(tc?.output),
                 messageIndex: tc?.messageIndex,
                 messageUuid: tc?.messageUuid,
+                callInstanceId: tc?.callInstanceId,
                 toolUseId: tc?.toolUseId,
                 segmentTimestamp: tc?.timestamp ?? segment.startTimestamp,
             };
@@ -359,11 +371,12 @@ function itemsFromSegment(segment) {
         const confidence = confidenceForSubtype(subtype, signal);
         const severity = severityFor(signalType, subtype, confidence);
         const item = {
-            id: hashString([segment.sessionId, segment.sourceTrace ?? '', segment.segmentIndex, signal.type, subtype, JSON.stringify(evidence)].join('\u0000')),
+            id: hashString([evidenceStreamId, segment.segmentIndex, signal.type, subtype, JSON.stringify(evidence)].join('\u0000')),
             skillName: segment.skillName,
             artifactVersion: 'unknown',
             cwd: segment.cwd,
             sessionId: segment.sessionId,
+            traceId: evidenceStreamId,
             sourceTrace: '',
             sourceKind: 'unknown',
             signalType,
@@ -376,7 +389,9 @@ function itemsFromSegment(segment) {
             firstSeen: segment.startTimestamp,
             lastSeen: segment.endTimestamp,
             occurrences: 1,
+            timestampedOccurrences: skillSegmentTimestampObserved(segment) ? 1 : 0,
             recentSessionIds: [segment.sessionId],
+            recentTraceIds: [evidenceStreamId],
             representativeEvidence: [evidence],
         };
         items.push(item);
@@ -386,7 +401,7 @@ function itemsFromSegment(segment) {
 function skillSessionCountKey(segment) {
     if (segment.traceRole && segment.traceRole !== 'standalone')
         return segment.sessionId;
-    return segment.sourceTrace ? `${segment.sessionId}\u0000${segment.sourceTrace}` : segment.sessionId;
+    return traceSessionRefIdentity(segment);
 }
 /**
  * 不再附带 diagnostics 字段 —— observability 不再反向驱动 diagnosis。
@@ -394,7 +409,8 @@ function skillSessionCountKey(segment) {
  * `buildObserveDiagnosticsFromReport(report)` 写入 `report.diagnostics`。
  */
 export function buildObservationInboxReport(tracePath, options = {}) {
-    const { sessions, segments } = ccTracesToResultEntries(tracePath);
+    const { sessions, segments, ingestion } = tracesToResultEntries(tracePath);
+    const skillSegments = segments.filter((segment) => segment.skillName !== 'general');
     const generatedAt = new Date().toISOString();
     const sessionTimeRanges = buildSessionTimeRanges(sessions);
     const sessionTimeRange = buildOverallSessionTimeRange(sessionTimeRanges);
@@ -402,41 +418,89 @@ export function buildObservationInboxReport(tracePath, options = {}) {
     const skillInvocationLastSeen = {};
     const skillToolCallCounts = {};
     const sessionsBySkill = new Map();
-    for (const segment of segments) {
-        if (segment.skillName === 'general')
-            continue;
-        skillInvocationCounts[segment.skillName] = (skillInvocationCounts[segment.skillName] ?? 0) + 1;
-        if (!skillInvocationLastSeen[segment.skillName] || segment.endTimestamp > skillInvocationLastSeen[segment.skillName]) {
-            skillInvocationLastSeen[segment.skillName] = segment.endTimestamp;
+    let timestampedSegmentCount = 0;
+    for (const segment of skillSegments) {
+        incrementRecordCount(skillInvocationCounts, segment.skillName);
+        if (skillSegmentTimestampObserved(segment)) {
+            timestampedSegmentCount += 1;
+            const previousLastSeen = ownRecordValue(skillInvocationLastSeen, segment.skillName);
+            if (!previousLastSeen || segment.endTimestamp > previousLastSeen) {
+                setOwnRecordValue(skillInvocationLastSeen, segment.skillName, segment.endTimestamp);
+            }
         }
-        const toolCounts = skillToolCallCounts[segment.skillName] ?? {};
+        const toolCounts = ownRecordValue(skillToolCallCounts, segment.skillName) ?? {};
         for (const toolCall of segment.toolCalls) {
-            toolCounts[toolCall.tool] = (toolCounts[toolCall.tool] ?? 0) + 1;
+            incrementRecordCount(toolCounts, toolCall.tool);
         }
-        skillToolCallCounts[segment.skillName] = toolCounts;
+        setOwnRecordValue(skillToolCallCounts, segment.skillName, toolCounts);
         const set = sessionsBySkill.get(segment.skillName) ?? new Set();
         set.add(skillSessionCountKey(segment));
         sessionsBySkill.set(segment.skillName, set);
     }
     const skillSessionCounts = Object.fromEntries(Array.from(sessionsBySkill.entries()).map(([skill, sessionIds]) => [skill, sessionIds.size]));
+    const sessionIndex = createTraceSessionIndex(sessions);
+    const messageRefsByTraceId = new Map();
+    const messageRefsForSegment = (segment) => {
+        const session = sessionIndex.resolve(segment);
+        if (!session)
+            return undefined;
+        if (messageRefsByTraceId.has(session.traceId)) {
+            return messageRefsByTraceId.get(session.traceId);
+        }
+        const messages = messageRefsFromEvents(session.events);
+        messageRefsByTraceId.set(session.traceId, messages);
+        return messages;
+    };
     const aggregationState = createInboxAggregationState();
-    for (const segment of segments) {
+    const occurrenceItems = [];
+    for (const segment of skillSegments) {
         const sourceTrace = segment.sourceTrace ?? tracePath;
+        const resolvedSession = sessionIndex.resolve(segment);
+        const traceId = segment.traceId
+            ?? resolvedSession?.traceId
+            ?? traceSessionRefIdentity(segment);
+        const sourceKind = segment.sourceKind ?? resolvedSession?.sourceKind ?? 'unknown';
         const segmentItems = itemsFromSegment(segment).map((item) => {
+            const evidence = {
+                ...item.evidence,
+                traceId,
+                sessionId: segment.sessionId,
+                sourceTrace,
+                sourceKind,
+            };
             const withSource = {
                 ...item,
+                traceId,
                 sourceTrace,
-                sourceKind: segment.sourceKind ?? inferObservationSourceKind(sourceTrace),
+                sourceKind,
+                evidence,
+                recentTraceIds: [traceId],
+                representativeEvidence: [evidence],
             };
             return {
                 ...withSource,
-                messageWindow: buildObservationMessageWindow(withSource),
+                messageWindow: buildObservationMessageWindow(withSource, 3, messageRefsForSegment(segment)),
             };
         });
+        occurrenceItems.push(...segmentItems);
         addInboxItemsToState(aggregationState, segmentItems);
     }
     const items = finishInboxAggregation(aggregationState);
-    const experience = buildObservationExperienceReport({ sessions, segments, items, generatedAt, reviewState: options.reviewState });
+    // Experience 归因必须基于每次实际发生的 signal。收件箱聚合会跨 session
+    // 合并同类项，firstSeen/lastSeen 和 sourceTrace 已不足以反推原 invocation。
+    // occurrence 仍引用聚合 item 的稳定 ID，保证 experience 引用可在 report.items
+    // 中解析，同时保留本次发生的 trace/session/timestamp 作为归因事实。
+    const experienceItems = occurrenceItems.map((item) => ({
+        ...item,
+        id: aggregationState.byKey.get(keyFor(item))?.id ?? item.id,
+    }));
+    const experience = buildObservationExperienceReport({
+        sessions,
+        segments: skillSegments,
+        items: experienceItems,
+        generatedAt,
+        reviewState: options.reviewState,
+    });
     const report = {
         kind: 'observe-inbox',
         schemaVersion: OBSERVATION_INBOX_SCHEMA_VERSION,
@@ -446,12 +510,17 @@ export function buildObservationInboxReport(tracePath, options = {}) {
             sessionCount: sessions.length,
             sessionTimeRange,
             sessionTimeRanges,
-            segmentCount: segments.length,
+            ingestion,
+            segmentCount: skillSegments.length,
             itemCount: items.length,
             skillInvocationCounts,
             skillSessionCounts,
             skillInvocationLastSeen,
             skillToolCallCounts,
+            timestampedSegmentCount,
+            timestampCoverage: skillSegments.length > 0
+                ? timestampedSegmentCount / skillSegments.length
+                : 0,
         },
         items,
         experience,
@@ -462,44 +531,132 @@ function createInboxAggregationState() {
     return {
         byKey: new Map(),
         sessionLastSeenByKey: new Map(),
+        traceLastSeenByKey: new Map(),
+        primaryOccurrenceIdByKey: new Map(),
     };
 }
 function addInboxItemsToState(state, items) {
     for (const item of items) {
         const key = keyFor(item);
         const sessionLastSeen = state.sessionLastSeenByKey.get(key) ?? new Map();
+        const traceLastSeen = state.traceLastSeenByKey.get(key) ?? new Map();
+        const traceIdentity = item.traceId
+            ?? item.evidence.traceId
+            ?? `${item.sourceTrace}\u0000${item.sessionId}`;
         const previousSessionLastSeen = sessionLastSeen.get(item.sessionId);
         if (!previousSessionLastSeen || item.lastSeen > previousSessionLastSeen) {
             sessionLastSeen.set(item.sessionId, item.lastSeen);
         }
         state.sessionLastSeenByKey.set(key, sessionLastSeen);
+        const previousTraceLastSeen = traceLastSeen.get(traceIdentity);
+        if (!previousTraceLastSeen || item.lastSeen > previousTraceLastSeen) {
+            traceLastSeen.set(traceIdentity, item.lastSeen);
+        }
+        state.traceLastSeenByKey.set(key, traceLastSeen);
         const existing = state.byKey.get(key);
         if (!existing) {
-            state.byKey.set(key, { ...item, representativeEvidence: [item.evidence], recentSessionIds: [item.sessionId] });
+            state.primaryOccurrenceIdByKey.set(key, item.id);
+            state.byKey.set(key, {
+                ...item,
+                id: hashString(`aggregate\u0000${key}`),
+                timestampedOccurrences: timestampedOccurrencesOf(item),
+                representativeEvidence: [item.evidence],
+                recentSessionIds: [item.sessionId],
+                recentTraceIds: [traceIdentity],
+            });
             continue;
         }
-        existing.occurrences += item.occurrences;
-        if (item.firstSeen < existing.firstSeen)
-            existing.firstSeen = item.firstSeen;
-        if (item.lastSeen > existing.lastSeen)
-            existing.lastSeen = item.lastSeen;
-        existing.confidence = Math.max(existing.confidence, item.confidence);
-        existing.attributionConfidence = Math.max(existing.attributionConfidence, item.attributionConfidence);
-        if (severityRank(item.severity) > severityRank(existing.severity)
-            || (item.severity === existing.severity && item.confidence > existing.confidence)) {
+        const existingTimestampedOccurrences = timestampedOccurrencesOf(existing);
+        const itemTimestampedOccurrences = timestampedOccurrencesOf(item);
+        existing.occurrences = sumRecordCounts(existing.occurrences, item.occurrences);
+        if (itemTimestampedOccurrences > 0) {
+            if (existingTimestampedOccurrences === 0 || item.firstSeen < existing.firstSeen) {
+                existing.firstSeen = item.firstSeen;
+            }
+            if (existingTimestampedOccurrences === 0 || item.lastSeen > existing.lastSeen) {
+                existing.lastSeen = item.lastSeen;
+            }
+        }
+        existing.timestampedOccurrences = sumRecordCounts(existingTimestampedOccurrences, itemTimestampedOccurrences);
+        const shouldReplaceEvidence = severityRank(item.severity) > severityRank(existing.severity)
+            || (item.severity === existing.severity
+                && (item.confidence > existing.confidence
+                    || (item.confidence === existing.confidence && item.lastSeen > existing.lastSeen)
+                    || (item.confidence === existing.confidence
+                        && item.lastSeen === existing.lastSeen
+                        && item.id.localeCompare(state.primaryOccurrenceIdByKey.get(key) ?? '') < 0)));
+        if (shouldReplaceEvidence) {
+            state.primaryOccurrenceIdByKey.set(key, item.id);
             existing.severity = item.severity;
-            existing.severityReasonCode = item.severityReasonCode;
             existing.evidence = item.evidence;
-            existing.messageWindow = item.messageWindow;
+            existing.sessionId = item.sessionId;
+            existing.sourceTrace = item.sourceTrace;
+            existing.sourceKind = item.sourceKind;
+            replaceOptionalProperty(existing, 'severityReasonCode', item.severityReasonCode);
+            replaceOptionalProperty(existing, 'messageWindow', item.messageWindow);
+            replaceOptionalProperty(existing, 'traceId', item.traceId);
+            replaceOptionalProperty(existing, 'cwd', item.cwd);
         }
+        existing.confidence = Math.max(existing.confidence, item.confidence);
+        existing.attributionConfidence = Math.max(existing.attributionConfidence, item.attributionConfidence);
         existing.recentSessionIds = Array.from(sessionLastSeen.entries())
-            .sort((a, b) => b[1].localeCompare(a[1]))
+            .sort((a, b) => b[1].localeCompare(a[1]) || a[0].localeCompare(b[0]))
             .map(([sessionId]) => sessionId)
             .slice(0, 3);
-        existing.representativeEvidence.push(item.evidence);
-        existing.representativeEvidence = existing.representativeEvidence.slice(0, 50);
+        existing.recentTraceIds = Array.from(traceLastSeen.entries())
+            .sort((a, b) => b[1].localeCompare(a[1]) || a[0].localeCompare(b[0]))
+            .map(([identity]) => identity)
+            .slice(0, 3);
+        existing.representativeEvidence = stableRepresentativeEvidence(existing.evidence, [...existing.representativeEvidence, item.evidence]);
+    }
+}
+function timestampedOccurrencesOf(item) {
+    return item.timestampedOccurrences
+        ?? (item.firstSeen === UNOBSERVED_TIMESTAMP && item.lastSeen === UNOBSERVED_TIMESTAMP
+            ? 0
+            : item.occurrences);
+}
+function replaceOptionalProperty(target, key, value) {
+    if (value === undefined) {
+        delete target[key];
+    }
+    else {
+        target[key] = value;
     }
 }
+function stableRepresentativeEvidence(primary, values) {
+    const primaryKey = observationEvidenceIdentity(primary);
+    const uniqueEvidence = new Map();
+    for (const value of values) {
+        uniqueEvidence.set(observationEvidenceIdentity(value), value);
+    }
+    uniqueEvidence.set(primaryKey, primary);
+    const others = Array.from(uniqueEvidence.entries())
+        .filter(([key]) => key !== primaryKey)
+        .sort((a, b) => (b[1].segmentTimestamp ?? '').localeCompare(a[1].segmentTimestamp ?? '')
+        || a[0].localeCompare(b[0]))
+        .map(([, value]) => value);
+    return [primary, ...others].slice(0, 50);
+}
+function observationEvidenceIdentity(value) {
+    return JSON.stringify([
+        value.traceId ?? '',
+        value.sessionId ?? '',
+        value.sourceTrace ?? '',
+        value.sourceKind ?? '',
+        value.tool ?? '',
+        value.query ?? '',
+        value.path ?? '',
+        value.outputSnippet ?? '',
+        value.assistantSnippet ?? '',
+        value.markerToken ?? '',
+        value.messageIndex ?? null,
+        value.messageUuid ?? '',
+        value.callInstanceId ?? '',
+        value.toolUseId ?? '',
+        value.segmentTimestamp ?? '',
+    ]);
+}
 function finishInboxAggregation(state) {
     return Array.from(state.byKey.values()).sort(compareInboxItems);
 }
@@ -524,21 +681,37 @@ function compareInboxItems(a, b) {
     const confidence = b.confidence - a.confidence;
     if (confidence !== 0)
         return confidence;
+    const timestampEvidence = Number(timestampedOccurrencesOf(b) > 0) - Number(timestampedOccurrencesOf(a) > 0);
+    if (timestampEvidence !== 0)
+        return timestampEvidence;
     const lastSeen = b.lastSeen.localeCompare(a.lastSeen);
     if (lastSeen !== 0)
         return lastSeen;
     return b.occurrences - a.occurrences;
 }
 export function saveObservationInboxReport(report, outDir = DEFAULT_OBSERVATIONS_DIR) {
+    const compact = compactObservationInboxReport(report);
+    if (!normalizeObservationInboxReport(compact)) {
+        throw new Error('拒绝写入无法回读的 observe inbox 报告。');
+    }
     mkdirSync(outDir, { recursive: true });
     migrateLegacyReportFiles(outDir, 'observe-inbox');
-    // 保留毫秒;同秒不同毫秒生成的两份 report 不应静默互相覆盖。
+    // 保留毫秒并追加随机段；即使同一毫秒生成两份 report，也不能静默互相覆盖。
     // 例: '2026-05-07T12:00:00.999Z' → '2026-05-07T12-00-00-999'
     const stamp = report.meta.generatedAt.replace(/[:.]/g, '-').replace(/Z$/, '');
-    const path = reportFilePath(outDir, stamp);
-    writeFileSync(path, JSON.stringify(report, null, 2));
+    const path = reportFilePath(outDir, `${stamp}-${randomRunToken()}`);
+    writeJsonFileAtomic(path, compact);
     return path;
 }
+export function compactObservationInboxReport(report) {
+    const { experience, ...persisted } = report;
+    return experience
+        ? {
+            ...persisted,
+            experience: compactObservationExperienceReport(experience),
+        }
+        : persisted;
+}
 export function loadObservationInboxReports(dir = DEFAULT_OBSERVATIONS_DIR) {
     if (!existsSync(dir)) {
         if (dir === DEFAULT_PROJECT_OBSERVATIONS_DIR && existsSync(DEFAULT_GLOBAL_OBSERVATIONS_DIR)) {
@@ -555,12 +728,9 @@ export function loadObservationInboxReports(dir = DEFAULT_OBSERVATIONS_DIR) {
             if (!report)
                 return null;
             report.items = report.items.map((item) => {
-                const sourceKind = item.sourceKind;
                 return {
                     ...item,
-                    sourceKind: sourceKind === 'openclaw'
-                        ? 'openclaw'
-                        : (item.sourceKind ?? inferObservationSourceKind(item.sourceTrace)),
+                    sourceKind: item.sourceKind ?? inferObservationSourceKind(item.sourceTrace),
                     severityReasonCode: item.severityReasonCode ?? severityReasonCodeFor(item),
                     severityReason: undefined,
                 };
@@ -588,20 +758,358 @@ function normalizeObservationInboxReport(value) {
         return null;
     if (report.schemaVersion !== OBSERVATION_INBOX_SCHEMA_VERSION)
         return null;
-    if (!report.meta || typeof report.meta !== 'object' || !Array.isArray(report.items))
+    if (!isObservationInboxMeta(report.meta) || !Array.isArray(report.items))
         return null;
+    if (!report.items.every(isObservationInboxItem))
+        return null;
+    if (report.meta.itemCount !== report.items.length)
+        return null;
+    const items = report.items.map((item) => ({
+        ...item,
+        timestampedOccurrences: timestampedOccurrencesOf(item),
+    }));
     const experience = report.experience === undefined
         ? undefined
-        : normalizeObservationExperienceReport(report.experience) ?? undefined;
+        : normalizeObservationExperienceReport(report.experience);
+    if (report.experience !== undefined && !experience)
+        return null;
+    const diagnostics = report.diagnostics === undefined
+        ? undefined
+        : parseDiagnosisBundle(report.diagnostics);
+    if (report.diagnostics !== undefined && !diagnostics)
+        return null;
+    if (!observationInboxReferencesAreConsistent(report.meta, items, experience ?? undefined))
+        return null;
     return {
         kind: 'observe-inbox',
         schemaVersion: OBSERVATION_INBOX_SCHEMA_VERSION,
         meta: report.meta,
-        items: report.items,
+        items,
         ...(experience ? { experience } : {}),
-        ...(report.diagnostics !== undefined ? { diagnostics: report.diagnostics } : {}),
+        ...(diagnostics ? { diagnostics } : {}),
     };
 }
+function observationInboxReferencesAreConsistent(meta, items, experience) {
+    const itemIds = new Set(items.map((item) => item.id));
+    if (itemIds.size !== items.length)
+        return false;
+    if (items.some((item) => new Set(item.recentSessionIds).size !== item.recentSessionIds.length
+        || (item.recentTraceIds !== undefined
+            && new Set(item.recentTraceIds).size !== item.recentTraceIds.length)
+        || item.occurrences < item.recentSessionIds.length
+        || item.occurrences < (item.recentTraceIds?.length ?? 0)
+        || timestampedOccurrencesOf(item) > item.occurrences
+        || (item.traceId !== undefined
+            && (item.evidence.traceId !== item.traceId
+                || !item.recentTraceIds?.includes(item.traceId)))
+        || (item.evidence.sourceTrace !== undefined
+            && item.evidence.sourceTrace !== item.sourceTrace)
+        || (item.evidence.sessionId !== undefined
+            && item.evidence.sessionId !== item.sessionId)
+        || (item.evidence.sourceKind !== undefined
+            && item.evidence.sourceKind !== item.sourceKind)
+        || item.representativeEvidence.length === 0
+        || observationEvidenceIdentity(item.representativeEvidence[0])
+            !== observationEvidenceIdentity(item.evidence)
+        || new Set(item.representativeEvidence.map(observationEvidenceIdentity)).size
+            !== item.representativeEvidence.length))
+        return false;
+    if (meta.sessionCount !== undefined
+        && meta.sessionTimeRanges !== undefined
+        && meta.sessionCount !== meta.sessionTimeRanges.length)
+        return false;
+    if (meta.sessionTimeRanges !== undefined
+        && (new Set(meta.sessionTimeRanges.map((range) => range.traceId ?? `${range.sourceTrace}\u0000${range.sessionId}`)).size
+            !== meta.sessionTimeRanges.length
+            || !overallSessionTimeRangeMatches(meta.sessionTimeRange, meta.sessionTimeRanges)))
+        return false;
+    if (!experience)
+        return true;
+    if (meta.generatedAt !== experience.generatedAt
+        || meta.segmentCount !== experience.invocations.length
+        ||
+            experience.invocations.some((invocation) => invocation.relatedObservationIds.some((id) => !itemIds.has(id))))
+        return false;
+    const invocationCounts = Object.fromEntries(experience.skills.map((skill) => [skill.skillName, skill.invocationCount]));
+    const sessionCounts = Object.fromEntries(experience.skills.map((skill) => [skill.skillName, skill.sessionCount]));
+    const lastSeen = Object.fromEntries(experience.skills
+        .filter((skill) => (skill.timestampedInvocationCount
+        ?? (skill.firstSeen === UNOBSERVED_TIMESTAMP ? 0 : skill.invocationCount)) > 0)
+        .map((skill) => [skill.skillName, skill.lastSeen]));
+    const toolCounts = Object.fromEntries(experience.skills.map((skill) => [skill.skillName, skill.toolCounts]));
+    return (meta.skillInvocationCounts === undefined
+        || inboxRecordsEqual(meta.skillInvocationCounts, invocationCounts)) && (meta.skillSessionCounts === undefined
+        || inboxRecordsEqual(meta.skillSessionCounts, sessionCounts)) && (meta.skillInvocationLastSeen === undefined
+        || inboxRecordsEqual(meta.skillInvocationLastSeen, lastSeen)) && (meta.skillToolCallCounts === undefined
+        || (inboxRecordKeysEqual(meta.skillToolCallCounts, toolCounts)
+            && Object.keys(toolCounts).every((skillName) => inboxRecordsEqual(meta.skillToolCallCounts?.[skillName] ?? {}, toolCounts[skillName]))));
+}
+function overallSessionTimeRangeMatches(actual, ranges) {
+    if (!actual)
+        return true;
+    const expected = buildOverallSessionTimeRange(ranges);
+    if (!expected)
+        return false;
+    return actual.from === expected.from
+        && actual.to === expected.to
+        && actual.durationMs === expected.durationMs;
+}
+function inboxRecordsEqual(left, right) {
+    return inboxRecordKeysEqual(left, right)
+        && Object.keys(left).every((key) => left[key] === right[key]);
+}
+function inboxRecordKeysEqual(left, right) {
+    const leftKeys = Object.keys(left).sort();
+    const rightKeys = Object.keys(right).sort();
+    return leftKeys.length === rightKeys.length
+        && leftKeys.every((key, index) => key === rightKeys[index]);
+}
+function isObservationInboxMeta(value) {
+    if (!isInboxRecord(value)
+        || typeof value.tracePath !== 'string'
+        || !isInboxTimestamp(value.generatedAt)
+        || (value.sessionCount !== undefined && !isInboxCount(value.sessionCount))
+        || !isInboxCount(value.segmentCount)
+        || !isInboxCount(value.itemCount)
+        || (value.ingestion !== undefined
+            && parseTraceIngestionSummary(value.ingestion) === null)
+        || (value.skillInvocationCounts !== undefined && !isInboxCountRecord(value.skillInvocationCounts))
+        || (value.skillSessionCounts !== undefined && !isInboxCountRecord(value.skillSessionCounts))
+        || (value.timestampedSegmentCount !== undefined
+            && (!isInboxCount(value.timestampedSegmentCount)
+                || value.timestampedSegmentCount > value.segmentCount))
+        || (value.timestampCoverage !== undefined
+            && (!isInboxRate(value.timestampCoverage)
+                || value.timestampedSegmentCount === undefined
+                || !inboxRatesEqual(value.timestampCoverage, (value.segmentCount > 0
+                    ? value.timestampedSegmentCount / value.segmentCount
+                    : 0))))
+        || (value.skillInvocationLastSeen !== undefined
+            && !isInboxTimestampRecord(value.skillInvocationLastSeen))
+        || (value.skillToolCallCounts !== undefined
+            && (!isInboxRecord(value.skillToolCallCounts)
+                || !Object.values(value.skillToolCallCounts).every(isInboxCountRecord))))
+        return false;
+    if (value.sessionTimeRange !== undefined
+        && (!isInboxRecord(value.sessionTimeRange)
+            || !isInboxTimestampRangeOrEmpty(value.sessionTimeRange.from, value.sessionTimeRange.to)
+            || !isInboxDurationConsistent(value.sessionTimeRange.from, value.sessionTimeRange.to, value.sessionTimeRange.durationMs)))
+        return false;
+    if (value.skillInvocationCounts !== undefined) {
+        const invocationCounts = value.skillInvocationCounts;
+        const invocationTotal = safeInboxCountSum(Object.values(invocationCounts));
+        if (invocationTotal !== value.segmentCount)
+            return false;
+        if (value.skillSessionCounts !== undefined
+            && Object.entries(value.skillSessionCounts).some(([skillName, count]) => count > (invocationCounts[skillName] ?? 0)))
+            return false;
+        if (value.skillInvocationLastSeen !== undefined
+            && Object.keys(value.skillInvocationLastSeen).some((skillName) => !Object.hasOwn(invocationCounts, skillName)))
+            return false;
+        if (value.skillToolCallCounts !== undefined
+            && Object.keys(value.skillToolCallCounts).some((skillName) => !Object.hasOwn(invocationCounts, skillName)))
+            return false;
+    }
+    return value.sessionTimeRanges === undefined
+        || (Array.isArray(value.sessionTimeRanges)
+            && value.sessionTimeRanges.every(isObservationSessionTimeRange));
+}
+function isObservationSessionTimeRange(value) {
+    return isInboxRecord(value)
+        && typeof value.sessionId === 'string'
+        && (value.traceId === undefined || typeof value.traceId === 'string')
+        && (value.sessionGroupId === undefined || typeof value.sessionGroupId === 'string')
+        && typeof value.sourceTrace === 'string'
+        && isObservationSourceKind(value.sourceKind)
+        && (value.traceRole === undefined
+            || value.traceRole === 'standalone'
+            || value.traceRole === 'main'
+            || value.traceRole === 'subagent')
+        && (value.traceLabel === undefined || typeof value.traceLabel === 'string')
+        && (value.cwd === undefined || typeof value.cwd === 'string')
+        && isInboxOptionalTimestamp(value.startTimestamp)
+        && isInboxOptionalTimestamp(value.endTimestamp)
+        && isInboxDurationConsistent(value.startTimestamp, value.endTimestamp, value.durationMs);
+}
+function isObservationInboxItem(value) {
+    if (!isInboxRecord(value)
+        || typeof value.id !== 'string'
+        || typeof value.skillName !== 'string'
+        || typeof value.artifactVersion !== 'string'
+        || (value.artifactHash !== undefined && typeof value.artifactHash !== 'string')
+        || (value.cwd !== undefined && typeof value.cwd !== 'string')
+        || typeof value.sessionId !== 'string'
+        || (value.traceId !== undefined && typeof value.traceId !== 'string')
+        || typeof value.sourceTrace !== 'string'
+        || (value.sourceKind !== undefined
+            && !isObservationSourceKind(value.sourceKind))
+        || !isObservationSignalType(value.signalType)
+        || !isObservationSignalSubtype(value.signalSubtype)
+        || !isInboxRate(value.confidence)
+        || !isInboxRate(value.attributionConfidence)
+        || !isObservationSeverity(value.severity)
+        || (value.severityReasonCode !== undefined
+            && !isObservationSeverityReasonCode(value.severityReasonCode))
+        || (value.severityReason !== undefined && typeof value.severityReason !== 'string')
+        || !isObservationEvidence(value.evidence)
+        || !isInboxTimestampRange(value.firstSeen, value.lastSeen)
+        || !isInboxCount(value.occurrences)
+        || value.occurrences === 0
+        || (value.timestampedOccurrences !== undefined
+            && (!isInboxCount(value.timestampedOccurrences)
+                || value.timestampedOccurrences > value.occurrences))
+        || !isInboxStringArray(value.recentSessionIds)
+        || (value.recentTraceIds !== undefined
+            && !isInboxStringArray(value.recentTraceIds))
+        || !Array.isArray(value.representativeEvidence)
+        || !value.representativeEvidence.every(isObservationEvidence))
+        return false;
+    const timestampedOccurrences = value.timestampedOccurrences === undefined
+        ? (value.firstSeen === UNOBSERVED_TIMESTAMP && value.lastSeen === UNOBSERVED_TIMESTAMP
+            ? 0
+            : value.occurrences)
+        : value.timestampedOccurrences;
+    if (timestampedOccurrences === 0
+        ? value.firstSeen !== UNOBSERVED_TIMESTAMP || value.lastSeen !== UNOBSERVED_TIMESTAMP
+        : value.firstSeen === UNOBSERVED_TIMESTAMP || value.lastSeen === UNOBSERVED_TIMESTAMP)
+        return false;
+    return value.messageWindow === undefined || isObservationMessageWindow(value.messageWindow);
+}
+function isObservationEvidence(value) {
+    if (!isInboxRecord(value))
+        return false;
+    const strings = [
+        value.traceId,
+        value.sessionId,
+        value.sourceTrace,
+        value.tool,
+        value.query,
+        value.path,
+        value.outputSnippet,
+        value.assistantSnippet,
+        value.markerToken,
+        value.messageUuid,
+        value.callInstanceId,
+        value.toolUseId,
+        value.segmentTimestamp,
+    ];
+    return strings.slice(0, -1).every((field) => field === undefined || typeof field === 'string')
+        && (value.sourceKind === undefined || isObservationSourceKind(value.sourceKind))
+        && isInboxOptionalTimestamp(value.segmentTimestamp)
+        && (value.messageIndex === undefined
+            || isInboxCount(value.messageIndex));
+}
+function isObservationMessageWindow(value) {
+    return isInboxRecord(value)
+        && Array.isArray(value.before)
+        && value.before.every(isObservationMessageRef)
+        && Array.isArray(value.event)
+        && value.event.every(isObservationMessageRef)
+        && Array.isArray(value.after)
+        && value.after.every(isObservationMessageRef)
+        && (value.resolutionAfter === 'resolved'
+            || value.resolutionAfter === 'unresolved'
+            || value.resolutionAfter === 'unknown');
+}
+function isObservationMessageRef(value) {
+    return isInboxRecord(value)
+        && (value.role === 'user'
+            || value.role === 'assistant'
+            || value.role === 'other')
+        && typeof value.snippet === 'string'
+        && isInboxCount(value.messageIndex)
+        && (value.uuid === undefined || typeof value.uuid === 'string')
+        && isInboxOptionalTimestamp(value.timestamp);
+}
+function isObservationSignalType(value) {
+    return value === 'failed_search'
+        || value === 'repeated_failure'
+        || value === 'hedging'
+        || value === 'explicit_marker';
+}
+function isObservationSignalSubtype(value) {
+    return value === 'hard_miss'
+        || value === 'repeated_failure'
+        || value === 'exploratory_miss'
+        || value === 'tool_error'
+        || value === 'permission_error'
+        || value === 'bash_probe'
+        || value === 'not_found'
+        || value === 'transient_file_missing'
+        || value === 'skill_asset_read_failed'
+        || value === 'permission_denied'
+        || value === 'tool_limit'
+        || value === 'tool_failure'
+        || value === 'regex_only'
+        || value === 'llm_classified'
+        || value === 'marker';
+}
+function isObservationSeverity(value) {
+    return value === 'high' || value === 'medium' || value === 'low' || value === 'noise';
+}
+function isObservationSeverityReasonCode(value) {
+    return value === 'knowledge_gap_suspected'
+        || value === 'repeated_failure_suspected'
+        || value === 'explicit_gap_marker'
+        || value === 'exploratory_probe'
+        || value === 'skill_asset_unavailable'
+        || value === 'soft_hedging_signal'
+        || value === 'tool_or_runtime_noise';
+}
+function isInboxRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function isInboxCount(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
+function isInboxRate(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 1;
+}
+function inboxRatesEqual(left, right) {
+    return Math.abs(left - right) <= 1e-6;
+}
+function safeInboxCountSum(values) {
+    try {
+        return sumRecordCounts(...values);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isInboxTimestamp(value) {
+    return typeof value === 'string' && normalizeTraceTimestamp(value) !== undefined;
+}
+function isInboxOptionalTimestamp(value) {
+    return value === undefined || isInboxTimestamp(value);
+}
+function isInboxTimestampRange(start, end) {
+    return isInboxTimestamp(start)
+        && isInboxTimestamp(end)
+        && Date.parse(start) <= Date.parse(end);
+}
+function isInboxTimestampRangeOrEmpty(start, end) {
+    return start === '' && end === '' || isInboxTimestampRange(start, end);
+}
+function isInboxDurationConsistent(start, end, duration) {
+    if (duration !== undefined && !isInboxCount(duration))
+        return false;
+    if (start === undefined || end === undefined || start === '' || end === '') {
+        return duration === undefined;
+    }
+    return typeof start === 'string'
+        && typeof end === 'string'
+        && isInboxTimestampRange(start, end)
+        && duration === durationMsBetween(start, end);
+}
+function isInboxStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+function isInboxCountRecord(value) {
+    return isInboxRecord(value) && Object.values(value).every(isInboxCount);
+}
+function isInboxTimestampRecord(value) {
+    return isInboxRecord(value) && Object.values(value).every(isInboxTimestamp);
+}
 export function loadLatestObservationInboxReport(dir = DEFAULT_OBSERVATIONS_DIR) {
     const reports = loadObservationInboxReports(dir);
     if (reports.length === 0)
@@ -619,13 +1127,13 @@ export function queryObservationInbox(dir = DEFAULT_OBSERVATIONS_DIR) {
 export function summarizeObservationInboxBySkill(items, reports = []) {
     const invocationCounts = reports.reduce((acc, report) => {
         for (const [skill, count] of Object.entries(report.meta.skillInvocationCounts ?? {})) {
-            acc[skill] = (acc[skill] ?? 0) + count;
+            incrementRecordCount(acc, skill, count);
         }
         return acc;
     }, {});
     const sessionCounts = reports.reduce((acc, report) => {
         for (const [skill, count] of Object.entries(report.meta.skillSessionCounts ?? {})) {
-            acc[skill] = (acc[skill] ?? 0) + count;
+            incrementRecordCount(acc, skill, count);
         }
         return acc;
     }, {});
@@ -640,14 +1148,17 @@ export function summarizeObservationInboxBySkill(items, reports = []) {
         const group = bySkill.get(skillName) ?? [];
         return {
             skillName,
-            invocationCount: invocationCounts[skillName] ?? group.reduce((sum, item) => sum + item.occurrences, 0),
+            invocationCount: invocationCounts[skillName]
+                ?? sumRecordCounts(...group.map((item) => item.occurrences)),
             sessionCount: sessionCounts[skillName] ?? new Set(group.flatMap((item) => item.recentSessionIds)).size,
             observationCount: group.length,
             highCount: group.filter((item) => item.severity === 'high').length,
             mediumCount: group.filter((item) => item.severity === 'medium').length,
             lowCount: group.filter((item) => item.severity === 'low').length,
             noiseCount: group.filter((item) => item.severity === 'noise').length,
-            latestSeen: group.reduce((latest, item) => item.lastSeen > latest ? item.lastSeen : latest, ''),
+            latestSeen: group
+                .filter((item) => timestampedOccurrencesOf(item) > 0)
+                .reduce((latest, item) => item.lastSeen > latest ? item.lastSeen : latest, ''),
         };
     }).sort((a, b) => {
         const riskA = a.highCount * 100 + a.mediumCount * 10 + a.lowCount;
@@ -665,33 +1176,45 @@ export function findObservationInboxItem(id, dir = DEFAULT_OBSERVATIONS_DIR) {
     }
     return aggregateInboxItems(reports.flatMap((report) => report.items)).find((item) => item.id === id) ?? null;
 }
-export function buildObservationMessageWindow(item, radius = 3) {
+export function buildObservationMessageWindow(item, radius = 3, preloadedMessages) {
     if (!item.sourceTrace.endsWith('.jsonl'))
         return undefined;
     const index = item.evidence.messageIndex;
-    if (typeof index !== 'number' || index < 0 || !existsSync(item.sourceTrace))
+    if (typeof index !== 'number'
+        || index < 0
+        || (preloadedMessages === undefined && !existsSync(item.sourceTrace)))
         return undefined;
-    const messages = readJsonlMessageRefs(item.sourceTrace);
+    const messages = preloadedMessages ?? readJsonlMessageRefs(item.sourceTrace);
     if (messages.length === 0)
         return undefined;
-    const position = messages.findIndex((message) => message.messageIndex === index);
+    const position = messages.findIndex((message) => {
+        if (message.messageIndex !== index)
+            return false;
+        if (item.evidence.toolUseId)
+            return message.snippet.includes(item.evidence.toolUseId);
+        if (item.evidence.messageUuid)
+            return message.uuid === item.evidence.messageUuid;
+        return true;
+    });
     if (position < 0)
         return undefined;
     const before = messages.slice(Math.max(0, position - radius), position);
     const event = messages.slice(position, position + 1);
     let after = messages.slice(position + 1, Math.min(messages.length, position + radius + 1));
     if (item.evidence.toolUseId) {
-        const result = messages.find((message) => message.messageIndex > index && message.snippet.includes(item.evidence.toolUseId));
-        if (result && !event.some((message) => message.messageIndex === result.messageIndex)) {
+        const result = messages.find((message, messagePosition) => messagePosition !== position
+            && message.messageIndex >= index
+            && message.snippet.includes(item.evidence.toolUseId));
+        if (result && !event.includes(result)) {
             event.push(result);
-            after = after.filter((message) => message.messageIndex !== result.messageIndex);
+            after = after.filter((message) => message !== result);
         }
     }
     return {
         before,
         event,
         after,
-        resolutionAfter: inferResolutionAfter(messages.slice(index + 1), item.signalType),
+        resolutionAfter: inferResolutionAfter(messages.slice(position + 1), item.signalType),
     };
 }
 export function formatObservationShow(item) {
@@ -717,55 +1240,39 @@ export function formatObservationShow(item) {
     return lines.join('\n');
 }
 function readJsonlMessageRefs(path) {
-    return readFileSync(path, 'utf-8')
-        .split('\n')
-        .map((line, index) => {
-        const trimmed = line.trim();
-        if (!trimmed)
-            return null;
-        try {
-            const record = JSON.parse(trimmed);
-            const type = String(record.type ?? 'other');
-            if (type !== 'user' && type !== 'assistant')
-                return null;
-            const message = record.message;
-            const role = message?.role === 'assistant' ? 'assistant' : message?.role === 'user' ? 'user' : type === 'assistant' ? 'assistant' : type === 'user' ? 'user' : 'other';
-            return {
-                role,
-                snippet: snippet(extractRecordText(record), 500) ?? '',
-                messageIndex: index,
-                uuid: typeof record.uuid === 'string' ? record.uuid : undefined,
-                timestamp: typeof record.timestamp === 'string' ? record.timestamp : undefined,
-            };
+    let events;
+    try {
+        events = loadTraceSessions(path)[0]?.events ?? [];
+    }
+    catch {
+        return [];
+    }
+    return messageRefsFromEvents(events);
+}
+function messageRefsFromEvents(events) {
+    return events.flatMap((event) => {
+        const common = {
+            messageIndex: event.sourceIndex,
+            uuid: event.sourceEventId ?? event.eventId,
+            timestamp: event.timestamp,
+        };
+        if (event.eventKind === 'message') {
+            const text = snippet(event.text, 500);
+            const role = event.role === 'assistant'
+                ? 'assistant'
+                : event.role === 'user' ? 'user' : 'other';
+            return text ? [{ ...common, role, snippet: text }] : [];
         }
-        catch {
-            return null;
+        if (event.eventKind === 'tool_call') {
+            const text = snippet(`tool_use ${event.tool.displayName ?? event.tool.name} ${event.callId} ${JSON.stringify(event.input)}`, 500);
+            return text ? [{ ...common, role: 'assistant', snippet: text }] : [];
         }
-    })
-        .filter((message) => message !== null && message.snippet !== '');
-}
-function extractRecordText(record) {
-    const message = record.message;
-    const content = message?.content;
-    if (typeof content === 'string')
-        return content;
-    if (Array.isArray(content)) {
-        return content.map((part) => {
-            if (!part || typeof part !== 'object')
-                return '';
-            const obj = part;
-            if (obj.type === 'text')
-                return String(obj.text ?? '');
-            if (obj.type === 'tool_use')
-                return `tool_use ${String(obj.name ?? '')} ${String(obj.id ?? '')} ${JSON.stringify(obj.input ?? {})}`;
-            if (obj.type === 'tool_result')
-                return `tool_result ${String(obj.tool_use_id ?? '')} ${String(obj.content ?? '')}`;
-            if (obj.type === 'thinking')
-                return '';
-            return JSON.stringify(obj);
-        }).filter(Boolean).join('\n');
-    }
-    return JSON.stringify(record);
+        if (event.eventKind === 'tool_result') {
+            const text = snippet(`tool_result ${event.callId} ${event.output}`, 500);
+            return text ? [{ ...common, role: 'other', snippet: text }] : [];
+        }
+        return [];
+    });
 }
 function inferResolutionAfter(messages, signalType) {
     if (signalType !== 'failed_search' && signalType !== 'repeated_failure')
@@ -786,7 +1293,8 @@ function formatMessageRefs(messages) {
 export function selectExploreInboxItems(items, limit, includeNoise = false, random = Math.random) {
     const candidates = items
         .filter((item) => item.severity === 'medium' || item.severity === 'low' || (includeNoise && item.severity === 'noise'))
-        .sort((a, b) => b.lastSeen.localeCompare(a.lastSeen))
+        .sort((a, b) => Number(timestampedOccurrencesOf(b) > 0) - Number(timestampedOccurrencesOf(a) > 0)
+        || b.lastSeen.localeCompare(a.lastSeen))
         .slice(0, 50);
     const shuffled = [...candidates];
     for (let i = shuffled.length - 1; i > 0; i--) {