oh-my-knowledge 0.47.0 → 0.49.0

package/dist/observability/trace-source.js

@@ -1,25 +1,68 @@
-/** Trace source loading and parsing for Claude JSONL / OpenClaw JSONL / generic markdown logs. */
-import { readFileSync, readdirSync, statSync } from 'node:fs';
-import { basename, dirname, join, relative } from 'node:path';
-import { extractMarkdownLogSkill } from './trace-attribution.js';
-import { isToolResultFailureText } from './text-signals.js';
+/** Trace source loading and parsing for Claude / Codex / OpenClaw JSONL and generic markdown logs. */
+import { createHash } from 'node:crypto';
+import { closeSync, openSync, readFileSync, readSync, readdirSync, realpathSync, statSync, } from 'node:fs';
+import { basename, dirname, isAbsolute, join, relative, sep } from 'node:path';
+import { StringDecoder } from 'node:string_decoder';
+import { isCodexGuardianRollout, isCodexJsonl, parseCodexSessionFile, } from './codex-trace-adapter.js';
+import { extractMarkdownLogSkill, isClaudeBuiltinCommand, stripCommandEnvelopeText, } from './trace-attribution.js';
+import { isRuntimeProtocolPromptText, isSyntheticUserMessageText, isToolResultFailureText, } from './text-signals.js';
+import { normalizeToolIdentity } from '../shared/tool-identity.js';
+import { correlateTraceToolEvents, createTraceId, normalizeTraceTimestamp, traceTimestampBounds, } from './trace-ir.js';
+import { nonNegativeMetric, tokenCount } from '../shared/token-usage.js';
+import { emptyTraceIngestionSummary, mergeTraceIngestionSummaries, } from './trace-ingestion.js';
+const TRACE_READ_CHUNK_BYTES = 64 * 1024;
+const MAX_JSONL_RECORD_CHARS = 32 * 1024 * 1024;
+const MAX_MARKDOWN_LOG_BYTES = 64 * 1024 * 1024;
 // ---------- Load ----------
 /**
  * 加载一个目录(或单个 JSONL/agent markdown log 文件)下的所有 session。
  * 递归扫描目录,覆盖 Claude Code 主 session 旁边的 subagents/*.jsonl,
  * 也支持 agent workspace/logs/*.log 里的 Markdown 对话记录。
  */
-export function loadCcSessions(path) {
+export function loadTraceSessions(path) {
+    return loadTraceCorpus(path).sessions;
+}
+export function loadTraceCorpus(path) {
     const stat = statSync(path);
     if (stat.isFile()) {
-        return parseTraceFile(path).map((session) => withStandaloneTraceMetadata(session));
+        const parsed = parseTraceFile(path);
+        return {
+            sessions: resolveParentLinkedSessionGroups(parsed.sessions.map((session) => withStandaloneTraceMetadata(session))),
+            ingestion: parsed.ingestion,
+        };
     }
     const entries = collectTraceFiles(path);
-    return annotateSessionGroups(path, entries.flatMap(parseTraceFile));
+    const parsed = entries.map(parseTraceFile);
+    return {
+        sessions: resolveParentLinkedSessionGroups(annotateSessionGroups(path, parsed.flatMap((entry) => entry.sessions))),
+        ingestion: mergeTraceIngestionSummaries(parsed.map((entry) => entry.ingestion)),
+    };
 }
-function collectTraceFiles(dir) {
+/** @deprecated Use `loadTraceSessions`. */
+export const loadCcSessions = loadTraceSessions;
+function collectTraceFiles(dir, visitedDirs = new Set(), visitedFiles = new Set(), rootRealPath) {
+    let realDir;
+    try {
+        realDir = realpathSync(dir);
+    }
+    catch (cause) {
+        throw new Error(`无法读取 trace 输入目录：${dir}`, { cause });
+    }
+    const scanRoot = rootRealPath ?? realDir;
+    if (!isWithinTraceRoot(scanRoot, realDir))
+        return [];
+    if (visitedDirs.has(realDir))
+        return [];
+    visitedDirs.add(realDir);
     const files = [];
-    for (const entry of readdirSync(dir)) {
+    let entries;
+    try {
+        entries = readdirSync(dir).sort();
+    }
+    catch (cause) {
+        throw new Error(`无法扫描 trace 输入目录：${dir}`, { cause });
+    }
+    for (const entry of entries) {
         if (entry === 'node_modules' || entry === '.git')
             continue;
         const entryPath = join(dir, entry);
@@ -27,33 +70,71 @@ function collectTraceFiles(dir) {
         try {
             stat = statSync(entryPath);
         }
-        catch {
-            continue;
+        catch (cause) {
+            throw new Error(`无法读取 trace 输入项：${entryPath}`, { cause });
         }
         if (stat.isDirectory()) {
-            files.push(...collectTraceFiles(entryPath));
+            files.push(...collectTraceFiles(entryPath, visitedDirs, visitedFiles, scanRoot));
         }
         else if (entry.endsWith('.jsonl') || entry.endsWith('.log')) {
+            let realFile;
+            try {
+                realFile = realpathSync(entryPath);
+            }
+            catch (cause) {
+                throw new Error(`无法解析 trace 输入文件：${entryPath}`, { cause });
+            }
+            if (!isWithinTraceRoot(scanRoot, realFile))
+                continue;
+            if (visitedFiles.has(realFile))
+                continue;
+            visitedFiles.add(realFile);
             files.push(entryPath);
         }
     }
     return files.sort();
 }
+function isWithinTraceRoot(rootRealPath, candidateRealPath) {
+    const rel = relative(rootRealPath, candidateRealPath);
+    return rel === '' || (!isAbsolute(rel) && rel !== '..' && !rel.startsWith(`..${sep}`));
+}
+const JSONL_TRACE_ADAPTERS = [
+    {
+        sourceKind: 'codex',
+        matches: isCodexJsonl,
+        parse: parseCodexSessionFile,
+        shouldFilter: isCodexGuardianRollout,
+    },
+    {
+        sourceKind: 'openclaw',
+        matches: isOpenClawJsonl,
+        parse: parseOpenClawSessionFile,
+    },
+    {
+        sourceKind: 'claude',
+        matches: isClaudeJsonl,
+        parse: parseClaudeSessionFile,
+    },
+];
 function parseTraceFile(filePath) {
-    if (filePath.endsWith('.jsonl'))
-        return [parseJsonlSessionFile(filePath)];
+    if (filePath.endsWith('.jsonl')) {
+        return parseJsonlSessionFile(filePath);
+    }
     if (filePath.endsWith('.log'))
         return parseMarkdownLogFile(filePath);
-    return [];
+    return {
+        sessions: [],
+        ingestion: emptyTraceIngestionSummary(),
+    };
 }
 function withStandaloneTraceMetadata(session) {
     return {
         ...session,
-        sessionGroupId: session.sessionId,
-        sessionGroupPath: dirname(session.sourcePath),
-        traceId: traceIdFor(session),
-        traceRole: session.traceRole ?? 'standalone',
-        traceLabel: session.traceLabel ?? basename(session.sourcePath),
+        rootRunId: session.rootRunId || session.runId,
+        groupPath: session.groupPath || dirname(session.sourcePath),
+        traceId: session.traceId || traceIdFor(session),
+        role: session.role ?? 'standalone',
+        label: session.label || basename(session.sourcePath),
     };
 }
 function annotateSessionGroups(rootPath, sessions) {
@@ -71,7 +152,7 @@ function annotateSessionGroups(rootPath, sessions) {
         const mainSession = sessions
             .filter((session) => groupRootForPath(session.sourcePath, groupRoots) === root && !isSubagentTrace(session.sourcePath))
             .sort((a, b) => a.sourcePath.localeCompare(b.sourcePath))[0];
-        groupIdByRoot.set(root, mainSession?.sessionId || basename(root) || relative(dirname(rootPath), root) || root);
+        groupIdByRoot.set(root, mainSession?.runId || basename(root) || relative(dirname(rootPath), root) || root);
     }
     return sessions.map((session) => {
         const groupRoot = groupRootForPath(session.sourcePath, groupRoots);
@@ -80,27 +161,105 @@ function annotateSessionGroups(rootPath, sessions) {
         const role = isSubagentTrace(session.sourcePath) ? 'subagent' : 'main';
         return {
             ...session,
-            sessionGroupId: groupIdByRoot.get(groupRoot) ?? session.sessionId,
-            sessionGroupPath: groupRoot,
-            traceId: traceIdFor(session),
-            traceRole: role,
-            traceLabel: traceLabelFor(session.sourcePath, groupRoot, role),
+            rootRunId: groupIdByRoot.get(groupRoot) ?? session.runId,
+            groupPath: groupRoot,
+            traceId: session.traceId || traceIdFor(session),
+            role,
+            label: traceLabelFor(session.sourcePath, groupRoot, role),
         };
     });
 }
+function resolveParentLinkedSessionGroups(sessions) {
+    const sessionBySourceAndId = new Map();
+    const ambiguousSessionKeys = new Set();
+    for (const session of sessions) {
+        const key = traceRunKey(session.sourceKind, session.runId);
+        if (ambiguousSessionKeys.has(key))
+            continue;
+        if (sessionBySourceAndId.has(key)) {
+            sessionBySourceAndId.delete(key);
+            ambiguousSessionKeys.add(key);
+            continue;
+        }
+        sessionBySourceAndId.set(key, session);
+    }
+    const linkedSessionKeys = new Set();
+    for (const session of sessions) {
+        if (!session.rootRunId || session.rootRunId === session.runId)
+            continue;
+        linkedSessionKeys.add(traceRunKey(session.sourceKind, session.runId));
+        linkedSessionKeys.add(traceRunKey(session.sourceKind, session.rootRunId));
+    }
+    return sessions.map((session) => {
+        const sessionKey = traceRunKey(session.sourceKind, session.runId);
+        if (ambiguousSessionKeys.has(sessionKey))
+            return isolateAmbiguousSession(session);
+        if (!linkedSessionKeys.has(sessionKey))
+            return session;
+        if (!session.rootRunId || session.rootRunId === session.runId) {
+            return {
+                ...session,
+                rootRunId: session.runId,
+                groupPath: `${session.sourceKind}:${session.runId}`,
+            };
+        }
+        const seen = new Set([session.runId]);
+        let groupId = session.rootRunId || session.runId;
+        while (true) {
+            if (seen.has(groupId)) {
+                return isolateAmbiguousSession(session);
+            }
+            seen.add(groupId);
+            const parentKey = traceRunKey(session.sourceKind, groupId);
+            if (ambiguousSessionKeys.has(parentKey))
+                return isolateAmbiguousSession(session);
+            const parent = sessionBySourceAndId.get(parentKey);
+            if (!parent)
+                break;
+            const parentGroupId = parent.rootRunId || parent.runId;
+            if (parentGroupId === parent.runId) {
+                groupId = parent.runId;
+                break;
+            }
+            groupId = parentGroupId;
+        }
+        return {
+            ...session,
+            rootRunId: groupId,
+            groupPath: `${session.sourceKind}:${groupId}`,
+        };
+    });
+}
+function traceRunKey(sourceKind, runId) {
+    return `${sourceKind}\u0000${runId}`;
+}
+function isolateAmbiguousSession(session) {
+    return {
+        ...session,
+        rootRunId: session.runId,
+        groupPath: `${session.sourceKind}:trace:${session.traceId}`,
+    };
+}
 function traceIdFor(session) {
-    return `${session.sessionId}\u0000${session.sourcePath}`;
+    return createTraceId({
+        sourceKind: session.sourceKind,
+        runId: session.runId,
+        sourcePath: session.sourcePath,
+    });
 }
 function isSubagentTrace(filePath) {
-    return filePath.split('/').includes('subagents');
+    return normalizedTracePath(filePath).split('/').includes('subagents');
 }
 function subagentGroupRoot(filePath) {
     const marker = '/subagents/';
-    const index = filePath.indexOf(marker);
+    const index = normalizedTracePath(filePath).indexOf(marker);
     if (index < 0)
         return undefined;
     return filePath.slice(0, index);
 }
+function normalizedTracePath(filePath) {
+    return filePath.replaceAll('\\', '/');
+}
 function groupRootForPath(filePath, groupRoots) {
     const subagentRoot = subagentGroupRoot(filePath);
     if (subagentRoot && groupRoots.has(subagentRoot))
@@ -115,75 +274,525 @@ function traceLabelFor(filePath, groupRoot, role) {
     return role === 'subagent' ? rel : `main/${basename(filePath)}`;
 }
 function parseJsonlSessionFile(filePath) {
-    const content = readFileSync(filePath, 'utf-8');
     const records = [];
-    for (const line of content.split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
+    const indexedRecords = [];
+    let sourceRecordCount = 0;
+    let malformedRecordCount = 0;
+    let ignoredValueCount = 0;
+    forEachNonEmptyUtf8Line(filePath, (trimmed) => {
+        sourceRecordCount += 1;
         try {
-            records.push(JSON.parse(trimmed));
+            const parsed = JSON.parse(trimmed);
+            if (isRecordObject(parsed)) {
+                const record = parsed;
+                records.push(record);
+                indexedRecords.push(record);
+            }
+            else {
+                ignoredValueCount += 1;
+                indexedRecords.push(undefined);
+            }
         }
         catch {
+            malformedRecordCount += 1;
+            indexedRecords.push(undefined);
             // malformed line → skip. cc 有罕见的截断 record, 不让单行 fail 整个 session
         }
+    });
+    const ingestion = {
+        fileCount: 1,
+        sourceRecordCount,
+        parsedRecordCount: records.length,
+        malformedRecordCount,
+        ignoredValueCount,
+        unknownEventCount: 0,
+        filteredSessionCount: 0,
+    };
+    if (records.length === 0)
+        return { sessions: [], ingestion };
+    const matchingAdapters = JSONL_TRACE_ADAPTERS.filter((adapter) => adapter.matches(records));
+    let session;
+    if (matchingAdapters.length === 1) {
+        const adapter = matchingAdapters[0];
+        if (adapter.shouldFilter?.(records)) {
+            return {
+                sessions: [],
+                ingestion: { ...ingestion, filteredSessionCount: 1 },
+            };
+        }
+        session = adapter.parse(filePath, indexedRecords);
+    }
+    else {
+        session = parseUnknownJsonlSession(filePath, indexedRecords);
+    }
+    return {
+        sessions: [session],
+        ingestion: {
+            ...ingestion,
+            unknownEventCount: session.events.filter((event) => event.eventKind === 'unknown').length,
+        },
+    };
+}
+function forEachNonEmptyUtf8Line(filePath, visit) {
+    let fd;
+    try {
+        fd = openSync(filePath, 'r');
+    }
+    catch (cause) {
+        throw new Error(`无法读取 trace 输入文件：${filePath}`, { cause });
+    }
+    const decoder = new StringDecoder('utf8');
+    const buffer = Buffer.allocUnsafe(TRACE_READ_CHUNK_BYTES);
+    let pending = '';
+    const consumeCompleteLines = () => {
+        let newline = pending.indexOf('\n');
+        while (newline >= 0) {
+            if (newline > MAX_JSONL_RECORD_CHARS) {
+                throw new Error(`trace JSONL 单条记录超过 ${MAX_JSONL_RECORD_CHARS} 字符上限：${filePath}`);
+            }
+            const trimmed = pending.slice(0, newline).trim();
+            pending = pending.slice(newline + 1);
+            if (trimmed)
+                visit(trimmed);
+            newline = pending.indexOf('\n');
+        }
+        if (pending.length > MAX_JSONL_RECORD_CHARS) {
+            throw new Error(`trace JSONL 单条记录超过 ${MAX_JSONL_RECORD_CHARS} 字符上限：${filePath}`);
+        }
+    };
+    try {
+        while (true) {
+            const bytesRead = readSync(fd, buffer, 0, buffer.length, null);
+            if (bytesRead === 0)
+                break;
+            pending += decoder.write(buffer.subarray(0, bytesRead));
+            consumeCompleteLines();
+        }
+        pending += decoder.end();
+        consumeCompleteLines();
+        const trimmed = pending.trim();
+        if (trimmed.length > MAX_JSONL_RECORD_CHARS) {
+            throw new Error(`trace JSONL 单条记录超过 ${MAX_JSONL_RECORD_CHARS} 字符上限：${filePath}`);
+        }
+        if (trimmed)
+            visit(trimmed);
+    }
+    catch (cause) {
+        if (cause instanceof Error
+            && cause.message.startsWith('trace JSONL 单条记录超过'))
+            throw cause;
+        throw new Error(`无法解析 trace 输入文件：${filePath}`, { cause });
     }
-    return isOpenClawJsonl(records) ? parseOpenClawSessionFile(filePath, records) : parseCcSessionFile(filePath, records);
+    finally {
+        closeSync(fd);
+    }
+}
+function isClaudeJsonl(records) {
+    return records.some((record) => (record.type === 'assistant' || record.type === 'user')
+        && typeof record.sessionId === 'string'
+        && isRecordObject(record.message)) || records.some((record) => isKnownClaudeRecordType(record.type)
+        && typeof record.sessionId === 'string');
+}
+function parseUnknownJsonlSession(filePath, records) {
+    const first = records.find((record) => Boolean(record));
+    const firstRecord = first;
+    const runId = firstRecord && typeof firstRecord.sessionId === 'string'
+        ? firstRecord.sessionId
+        : firstRecord && typeof firstRecord.runId === 'string'
+            ? firstRecord.runId
+            : basename(filePath, '.jsonl');
+    const events = records.flatMap((record, sourceIndex) => {
+        if (!record)
+            return [];
+        const rawRecord = record;
+        const sourceType = typeof record.type === 'string' ? record.type : 'unknown';
+        const sourceEventId = typeof record.uuid === 'string'
+            ? record.uuid
+            : typeof rawRecord.id === 'string'
+                ? rawRecord.id
+                : undefined;
+        return [{
+                eventKind: 'unknown',
+                eventId: `${runId}:${sourceIndex}:unknown`,
+                sourceEventId,
+                sourceIndex,
+                sourceType,
+                timestamp: normalizeTraceTimestamp(record.timestamp),
+                raw: record,
+            }];
+    });
+    const bounds = traceTimestampBounds(events.map((event) => event.timestamp));
+    return {
+        runId,
+        rootRunId: runId,
+        traceId: createTraceId({ sourceKind: 'unknown', runId, sourcePath: filePath }),
+        groupPath: dirname(filePath),
+        role: 'standalone',
+        label: basename(filePath),
+        sourcePath: filePath,
+        sourceKind: 'unknown',
+        events,
+        ...bounds,
+    };
 }
-function parseCcSessionFile(filePath, records) {
-    const first = records.find((r) => 'sessionId' in r && typeof r.sessionId === 'string');
-    const last = [...records].reverse().find((r) => 'timestamp' in r && typeof r.timestamp === 'string');
+function parseClaudeSessionFile(filePath, records) {
+    const first = records.find((r) => r && 'sessionId' in r && typeof r.sessionId === 'string');
+    const runId = first?.sessionId ?? basename(filePath, '.jsonl');
+    const events = correlateTraceToolEvents(records.flatMap((record, sourceIndex) => record ? legacyRecordToTraceEvents(record, runId, sourceIndex, 'claude') : []));
+    const bounds = traceTimestampBounds([
+        ...events.map((event) => event.timestamp),
+        first?.timestamp,
+    ]);
     return {
-        sessionId: first?.sessionId ?? filePath.split('/').pop().replace('.jsonl', ''),
+        runId,
+        rootRunId: runId,
+        traceId: createTraceId({ sourceKind: 'claude', runId, sourcePath: filePath }),
+        groupPath: dirname(filePath),
+        role: 'standalone',
+        label: basename(filePath),
         sourcePath: filePath,
         sourceKind: 'claude',
-        records,
+        events,
         cwd: first?.cwd,
         gitBranch: first?.gitBranch,
         entrypoint: first?.entrypoint,
-        startTimestamp: first?.timestamp,
-        endTimestamp: last?.timestamp,
+        ...bounds,
     };
 }
+export function legacyCcSessionToTraceSession(session) {
+    const runId = session.sessionId;
+    const rootRunId = session.sessionGroupId ?? runId;
+    const sourceKind = session.sourceKind ?? 'claude';
+    const traceId = session.traceId ?? createTraceId({
+        sourceKind,
+        runId,
+        sourcePath: session.sourcePath,
+    });
+    const events = correlateTraceToolEvents(session.records.flatMap((record, sourceIndex) => legacyRecordToTraceEvents(record, runId, sourceIndex, sourceKind)));
+    const bounds = traceTimestampBounds([
+        ...events.map((event) => event.timestamp),
+        session.startTimestamp,
+        session.endTimestamp,
+    ]);
+    return {
+        runId,
+        rootRunId,
+        traceId,
+        groupPath: session.sessionGroupPath ?? dirname(session.sourcePath),
+        role: session.traceRole ?? 'standalone',
+        label: session.traceLabel ?? basename(session.sourcePath),
+        sourcePath: session.sourcePath,
+        sourceKind,
+        events,
+        cwd: session.cwd,
+        gitBranch: session.gitBranch,
+        entrypoint: session.entrypoint,
+        sourceMetadata: session.sourceMetadata,
+        ...bounds,
+    };
+}
+function legacyRecordToTraceEvents(raw, runId, sourceIndex, sourceKind) {
+    if (!isRecordObject(raw))
+        return [];
+    const sourceType = typeof raw.type === 'string' ? raw.type : 'unknown';
+    const timestamp = normalizeTraceTimestamp(raw.timestamp);
+    const sourceEventId = typeof raw.uuid === 'string'
+        ? raw.uuid
+        : typeof raw.id === 'string'
+            ? raw.id
+            : undefined;
+    const eventId = (suffix) => `${runId}:${sourceIndex}:${suffix}`;
+    if (sourceType === 'user' && isRecordObject(raw.message)) {
+        const content = raw.message.content;
+        const events = [];
+        const parts = typeof content === 'string' ? [{ type: 'text', text: content }] : Array.isArray(content) ? content : [];
+        let partIndex = 0;
+        for (const part of parts) {
+            if (!isRecordObject(part))
+                continue;
+            if (part.type === 'text' && typeof part.text === 'string' && part.text.trim()) {
+                const text = sourceKind === 'claude'
+                    ? stripClaudeBuiltinCommandEnvelope(part.text)
+                    : part.text;
+                if (!text) {
+                    partIndex += 1;
+                    continue;
+                }
+                events.push({
+                    eventKind: 'message',
+                    eventId: eventId(`message-${partIndex}`),
+                    sourceEventId,
+                    sourceIndex,
+                    sourceType,
+                    timestamp,
+                    role: 'user',
+                    origin: classifyUserMessageOrigin(raw, text),
+                    text,
+                });
+            }
+            else if (part.type === 'tool_result'
+                && typeof part.tool_use_id === 'string') {
+                const output = typeof part.content === 'string' ? part.content : JSON.stringify(part.content ?? '');
+                const explicit = typeof part.is_error === 'boolean';
+                const inferredFailure = !explicit && isToolResultFailureText(output);
+                events.push({
+                    eventKind: 'tool_result',
+                    eventId: eventId(`tool-result-${partIndex}`),
+                    sourceEventId,
+                    sourceIndex,
+                    sourceType,
+                    timestamp,
+                    callId: part.tool_use_id,
+                    output,
+                    status: explicit
+                        ? part.is_error === true ? 'failure' : 'success'
+                        : inferredFailure ? 'failure' : 'unknown',
+                    statusSource: explicit ? 'runtime' : inferredFailure ? 'inferred' : 'unknown',
+                });
+            }
+            partIndex += 1;
+        }
+        return events;
+    }
+    if (sourceType === 'assistant' && isRecordObject(raw.message)) {
+        const events = [];
+        const content = Array.isArray(raw.message.content) ? raw.message.content : [];
+        const model = typeof raw.message.model === 'string' ? raw.message.model : undefined;
+        const text = content.flatMap((part) => isRecordObject(part) && part.type === 'text' && typeof part.text === 'string' ? [part.text] : []).join('\n');
+        if (text) {
+            events.push({
+                eventKind: 'message',
+                eventId: eventId('message'),
+                sourceEventId,
+                sourceIndex,
+                sourceType,
+                timestamp,
+                role: 'assistant',
+                origin: 'synthetic',
+                text,
+                model,
+                attributionSkill: typeof raw.attributionSkill === 'string' ? raw.attributionSkill : undefined,
+            });
+        }
+        content.forEach((part, partIndex) => {
+            if (isRecordObject(part)
+                && part.type === 'tool_use'
+                && typeof part.id === 'string'
+                && typeof part.name === 'string') {
+                events.push({
+                    eventKind: 'tool_call',
+                    eventId: eventId(`tool-call-${partIndex}`),
+                    sourceEventId,
+                    sourceIndex,
+                    sourceType,
+                    timestamp,
+                    callId: part.id,
+                    tool: normalizeToolIdentity({ sourceName: part.name }),
+                    input: isRecordObject(part.input) ? part.input : {},
+                    model,
+                });
+            }
+        });
+        if (isRecordObject(raw.message.usage)) {
+            const usageEvent = usageEventFromLegacy(raw.message.usage, eventId('usage'), sourceIndex, sourceType, timestamp, model);
+            events.push(usageEvent ?? {
+                eventKind: 'unknown',
+                eventId: eventId('invalid-usage'),
+                sourceEventId,
+                sourceIndex,
+                sourceType,
+                timestamp,
+                raw,
+            });
+        }
+        return events;
+    }
+    if (sourceType === 'system') {
+        if (raw.subtype === 'turn_duration') {
+            return [{
+                    eventKind: 'lifecycle',
+                    eventId: eventId('turn-completed'),
+                    sourceEventId,
+                    sourceIndex,
+                    sourceType,
+                    timestamp,
+                    phase: 'turn_completed',
+                    durationMs: nonNegativeMetric(raw.durationMs),
+                }];
+        }
+        const text = claudeSystemRecordText(raw);
+        if (text) {
+            return [{
+                    eventKind: 'message',
+                    eventId: eventId('system-message'),
+                    sourceEventId,
+                    sourceIndex,
+                    sourceType,
+                    timestamp,
+                    role: 'system',
+                    origin: 'runtime',
+                    text,
+                }];
+        }
+        return [];
+    }
+    const lifecycle = lifecycleEventFromLegacy(raw, runId, sourceIndex, sourceType, timestamp);
+    if (lifecycle)
+        return [lifecycle];
+    if (isKnownClaudeRecordType(sourceType))
+        return [];
+    return [{
+            eventKind: 'unknown',
+            eventId: eventId('unknown'),
+            sourceEventId,
+            sourceIndex,
+            sourceType,
+            timestamp,
+            raw,
+        }];
+}
+function stripClaudeBuiltinCommandEnvelope(text) {
+    const match = /<command-name>\/([^<]+)<\/command-name>/.exec(text);
+    return match?.[1] && isClaudeBuiltinCommand(match[1])
+        ? stripCommandEnvelopeText(text)
+        : text;
+}
+function isKnownClaudeRecordType(value) {
+    return value === 'assistant'
+        || value === 'user'
+        || value === 'attachment'
+        || value === 'pr-link'
+        || value === 'mode'
+        || value === 'permission-mode'
+        || value === 'last-prompt'
+        || value === 'ai-title'
+        || value === 'agent-name'
+        || value === 'system'
+        || value === 'file-history-snapshot'
+        || value === 'queue-operation';
+}
+function claudeSystemRecordText(record) {
+    if (typeof record.content === 'string' && record.content.trim())
+        return record.content;
+    if (typeof record.message === 'string' && record.message.trim())
+        return record.message;
+    if (record.subtype !== 'api_error' || !isRecordObject(record.error))
+        return '';
+    if (typeof record.error.formatted === 'string' && record.error.formatted.trim()) {
+        return record.error.formatted;
+    }
+    return typeof record.error.message === 'string' ? record.error.message : '';
+}
+function usageEventFromLegacy(usage, eventId, sourceIndex, sourceType, timestamp, model) {
+    if (!isValidUsageCounters(usage.input_tokens, usage.output_tokens, usage.cache_read_input_tokens, usage.cache_creation_input_tokens))
+        return null;
+    return {
+        eventKind: 'usage',
+        eventId,
+        sourceIndex,
+        sourceType,
+        timestamp,
+        model,
+        inputTokens: tokenCount(usage.input_tokens),
+        outputTokens: tokenCount(usage.output_tokens),
+        cacheReadTokens: tokenCount(usage.cache_read_input_tokens),
+        cacheCreationTokens: tokenCount(usage.cache_creation_input_tokens),
+    };
+}
+function lifecycleEventFromLegacy(raw, runId, sourceIndex, sourceType, timestamp) {
+    const phase = /^session[._-]started$/i.test(sourceType)
+        ? 'session_started'
+        : /^session[._-]ended$/i.test(sourceType)
+            ? 'session_ended'
+            : /^turn[._-]started$/i.test(sourceType)
+                ? 'turn_started'
+                : /^turn[._-](?:ended|completed)$/i.test(sourceType)
+                    ? 'turn_completed'
+                    : /^turn[._-]aborted$/i.test(sourceType)
+                        ? 'turn_aborted'
+                        : /^turn[._-]interrupted$/i.test(sourceType)
+                            ? 'turn_interrupted'
+                            : null;
+    if (!phase)
+        return null;
+    return {
+        eventKind: 'lifecycle',
+        eventId: `${runId}:${sourceIndex}:lifecycle`,
+        sourceIndex,
+        sourceType,
+        timestamp,
+        turnId: typeof raw.turnId === 'string' ? raw.turnId : undefined,
+        phase,
+        reason: typeof raw.reason === 'string' ? raw.reason : undefined,
+        durationMs: nonNegativeMetric(raw.durationMs),
+    };
+}
+function classifyUserMessageOrigin(record, text) {
+    if (record.isMeta === true && typeof record.sourceToolUseID === 'string')
+        return 'skill-context';
+    if (/^Base directory for this skill:\s+.+(?:\n| )#\s+[a-z0-9][\w.-]*/i.test(text))
+        return 'skill-context';
+    if (isRuntimeInjectedMessage(text))
+        return 'runtime';
+    if (record.entrypoint === 'sdk-ts'
+        && typeof record.promptId === 'string'
+        && (/^进入.+流程。当前页面已经完成本地工作区恢复/.test(text)
+            || /gui-workflow route/.test(text)
+            || /当前页面已经完成本地工作区恢复/.test(text)))
+        return 'runtime';
+    if (isSyntheticUserMessageText(text))
+        return 'synthetic';
+    return 'human';
+}
+function isRuntimeInjectedMessage(text) {
+    const trimmed = text.trimStart();
+    return /^Conversation info \(untrusted metadata\):\s*```json/i.test(trimmed)
+        || isRuntimeProtocolPromptText(trimmed)
+        || /^# AGENTS\.md instructions\b/i.test(trimmed)
+        || /^<(?:app-context|environment_context|permissions instructions|collaboration_mode|apps_instructions|plugins_instructions|skills_instructions|recommended_plugins)>/i.test(trimmed);
+}
 function isOpenClawJsonl(records) {
     return records.some((record) => record.type === 'session' && typeof record.id === 'string')
         && records.some((record) => record.type === 'message' && isRecordObject(record.message));
 }
 function parseOpenClawSessionFile(filePath, rawRecords) {
-    const sessionRecord = rawRecords.find((record) => record.type === 'session');
+    const sessionRecord = rawRecords.find((record) => record?.type === 'session');
     const sessionId = typeof sessionRecord?.id === 'string'
         ? sessionRecord.id
-        : filePath.split('/').pop().replace(/\.jsonl$/, '');
+        : basename(filePath, '.jsonl');
     const cwd = typeof sessionRecord?.cwd === 'string' ? sessionRecord.cwd : undefined;
     const sourceMetadata = extractOpenClawSourceMetadata(rawRecords);
-    const records = [];
-    for (const raw of rawRecords) {
-        const converted = convertOpenClawRecord(raw, sessionId, cwd);
-        if (converted) {
-            records.push(converted);
-        }
-        else if (isSessionBoundaryRawRecord(raw)) {
-            records.push({ ...raw, sessionId });
-        }
-    }
-    const first = records.find((record) => typeof record.timestamp === 'string');
-    const last = [...records].reverse().find((record) => typeof record.timestamp === 'string');
+    const events = correlateTraceToolEvents(rawRecords.flatMap((raw, sourceIndex) => raw ? openClawRecordToTraceEvents(raw, sessionId, sourceIndex) : []));
+    const bounds = traceTimestampBounds([
+        ...events.map((event) => event.timestamp),
+        sessionRecord?.timestamp,
+    ]);
     return {
-        sessionId,
+        runId: sessionId,
+        rootRunId: sessionId,
+        traceId: createTraceId({
+            sourceKind: 'openclaw',
+            runId: sessionId,
+            sourcePath: filePath,
+        }),
+        groupPath: dirname(filePath),
+        role: 'standalone',
+        label: basename(filePath),
         sourcePath: filePath,
         sourceKind: 'openclaw',
-        records,
+        events,
         cwd,
         entrypoint: 'openclaw',
         sourceMetadata,
-        startTimestamp: first?.timestamp ?? (typeof sessionRecord?.timestamp === 'string' ? sessionRecord.timestamp : undefined),
-        endTimestamp: last?.timestamp,
+        ...bounds,
     };
 }
 function extractOpenClawSourceMetadata(rawRecords) {
     const meta = {};
     const commands = new Set();
     for (const raw of rawRecords) {
+        if (!raw)
+            continue;
         if (raw.type === 'model_change') {
             const modelChange = raw;
             if (typeof modelChange.provider === 'string')
@@ -255,84 +864,195 @@ function extractBusinessActionNames(text) {
     }
     return names;
 }
-function convertOpenClawRecord(raw, sessionId, cwd) {
-    if (raw.type !== 'message')
-        return null;
+function openClawRecordToTraceEvents(raw, sessionId, sourceIndex) {
+    const sourceType = typeof raw.type === 'string' ? raw.type : 'unknown';
+    const timestamp = normalizeTraceTimestamp(raw.timestamp);
+    const sourceEventId = 'id' in raw && typeof raw.id === 'string' ? raw.id : undefined;
+    const eventId = (suffix) => `${sessionId}:${sourceIndex}:${suffix}`;
+    if (raw.type === 'session') {
+        return [{
+                eventKind: 'lifecycle',
+                eventId: eventId('session-started'),
+                sourceEventId,
+                sourceIndex,
+                sourceType,
+                timestamp,
+                phase: 'session_started',
+            }];
+    }
+    const lifecycle = lifecycleEventFromLegacy(raw, sessionId, sourceIndex, sourceType, timestamp);
+    if (lifecycle)
+        return [lifecycle];
+    if (isKnownOpenClawMetadataRecord(raw))
+        return [];
+    if (raw.type !== 'message') {
+        return [{
+                eventKind: 'unknown',
+                eventId: eventId('unknown'),
+                sourceEventId,
+                sourceIndex,
+                sourceType,
+                timestamp,
+                raw,
+            }];
+    }
     const messageRecord = raw;
     const message = messageRecord.message;
-    if (!message || typeof message.role !== 'string')
-        return null;
-    const uuid = typeof messageRecord.id === 'string' ? messageRecord.id : `${sessionId}-${recordsafeTimestamp(messageRecord.timestamp)}`;
-    const parentUuid = typeof messageRecord.parentId === 'string' ? messageRecord.parentId : null;
-    const timestamp = typeof messageRecord.timestamp === 'string' ? messageRecord.timestamp : new Date().toISOString();
+    if (!message || typeof message.role !== 'string') {
+        return [{
+                eventKind: 'unknown',
+                eventId: eventId('unknown-message'),
+                sourceEventId,
+                sourceIndex,
+                sourceType,
+                timestamp,
+                raw,
+            }];
+    }
     if (message.role === 'user') {
-        return {
-            type: 'user',
-            uuid,
-            parentUuid,
-            sessionId,
+        return splitOpenClawRuntimeMetadata(openClawContentText(message.content))
+            .map((text, partIndex) => ({
+            eventKind: 'message',
+            eventId: eventId(`message-${partIndex}`),
+            sourceEventId,
+            sourceIndex,
+            sourceType,
             timestamp,
-            entrypoint: 'openclaw',
-            message: {
-                role: 'user',
-                content: openClawTextParts(message.content),
-            },
-        };
+            role: 'user',
+            origin: classifyUserMessageOrigin({ entrypoint: 'openclaw' }, text),
+            text,
+        }));
     }
     if (message.role === 'assistant') {
-        return {
-            type: 'assistant',
-            uuid,
-            parentUuid,
-            sessionId,
-            timestamp,
-            cwd,
-            entrypoint: 'openclaw',
-            message: {
+        const events = [];
+        const model = typeof message.model === 'string' ? message.model : undefined;
+        const content = Array.isArray(message.content) ? message.content : [];
+        const text = typeof message.content === 'string'
+            ? message.content
+            : content.flatMap((part) => isRecordObject(part) && part.type === 'text' && typeof part.text === 'string'
+                ? [part.text]
+                : []).join('\n');
+        if (text) {
+            events.push({
+                eventKind: 'message',
+                eventId: eventId('message'),
+                sourceEventId,
+                sourceIndex,
+                sourceType,
+                timestamp,
                 role: 'assistant',
-                model: typeof message.model === 'string' ? message.model : undefined,
-                content: openClawAssistantContent(message.content),
-                stop_reason: typeof message.stopReason === 'string' ? message.stopReason : undefined,
-                usage: openClawUsage(message.usage),
-            },
-        };
+                origin: 'synthetic',
+                text,
+                model,
+            });
+        }
+        content.forEach((part, partIndex) => {
+            if (!isRecordObject(part)
+                || part.type !== 'toolCall'
+                || typeof part.id !== 'string'
+                || typeof part.name !== 'string')
+                return;
+            const sourceName = part.name.trim();
+            // OpenClaw's native shell tool is named `exec`. Keep that protocol fact in
+            // this adapter instead of teaching the source-neutral identity layer that
+            // every custom tool named `exec` is a shell.
+            const tool = sourceName.toLowerCase() === 'exec'
+                ? { name: 'Bash', sourceName }
+                : normalizeToolIdentity({ sourceName });
+            events.push({
+                eventKind: 'tool_call',
+                eventId: eventId(`tool-call-${partIndex}`),
+                sourceEventId,
+                sourceIndex,
+                sourceType,
+                timestamp,
+                callId: part.id,
+                tool,
+                input: normalizeOpenClawToolInput(tool.name, isRecordObject(part.arguments) ? part.arguments : {}),
+                model,
+            });
+        });
+        if (isRecordObject(message.usage)) {
+            const inputTokens = message.usage.input ?? message.usage.input_tokens;
+            const outputTokens = message.usage.output ?? message.usage.output_tokens;
+            const cacheReadTokens = message.usage.cacheRead ?? message.usage.cache_read_input_tokens;
+            const cacheCreationTokens = message.usage.cacheWrite ?? message.usage.cache_creation_input_tokens;
+            if (isValidUsageCounters(inputTokens, outputTokens, cacheReadTokens, cacheCreationTokens)) {
+                events.push({
+                    eventKind: 'usage',
+                    eventId: eventId('usage'),
+                    sourceEventId,
+                    sourceIndex,
+                    sourceType,
+                    timestamp,
+                    model,
+                    inputTokens: tokenCount(inputTokens),
+                    outputTokens: tokenCount(outputTokens),
+                    cacheReadTokens: tokenCount(cacheReadTokens),
+                    cacheCreationTokens: tokenCount(cacheCreationTokens),
+                });
+            }
+            else {
+                events.push({
+                    eventKind: 'unknown',
+                    eventId: eventId('invalid-usage'),
+                    sourceEventId,
+                    sourceIndex,
+                    sourceType,
+                    timestamp,
+                    raw,
+                });
+            }
+        }
+        return events;
     }
     if (message.role === 'toolResult') {
         const toolUseId = typeof message.toolCallId === 'string' ? message.toolCallId : undefined;
-        if (!toolUseId)
-            return null;
+        if (!toolUseId) {
+            return [{
+                    eventKind: 'unknown',
+                    eventId: eventId('orphan-tool-result'),
+                    sourceEventId,
+                    sourceIndex,
+                    sourceType,
+                    timestamp,
+                    raw,
+                }];
+        }
         const content = openClawToolResultText(message.content);
-        return {
-            type: 'user',
-            uuid,
-            parentUuid,
-            sessionId,
-            timestamp,
-            entrypoint: 'openclaw',
-            message: {
-                role: 'user',
-                content: [{
-                        type: 'tool_result',
-                        tool_use_id: toolUseId,
-                        content,
-                        is_error: message.isError === true || isToolResultFailureText(content),
-                    }],
-            },
-        };
+        const hasRuntimeStatus = typeof message.isError === 'boolean';
+        const inferredFailure = !hasRuntimeStatus && isToolResultFailureText(content);
+        return [{
+                eventKind: 'tool_result',
+                eventId: eventId('tool-result'),
+                sourceEventId,
+                sourceIndex,
+                sourceType,
+                timestamp,
+                callId: toolUseId,
+                output: content,
+                status: hasRuntimeStatus
+                    ? message.isError === true ? 'failure' : 'success'
+                    : inferredFailure ? 'failure' : 'unknown',
+                statusSource: hasRuntimeStatus ? 'runtime' : inferredFailure ? 'inferred' : 'unknown',
+            }];
     }
-    return null;
-}
-function isSessionBoundaryRawRecord(raw) {
-    const type = typeof raw.type === 'string' ? raw.type : '';
-    return /^session[._-](?:started|ended)$/i.test(type);
-}
-function recordsafeTimestamp(value) {
-    return typeof value === 'string' ? value.replace(/[^a-zA-Z0-9_-]/g, '') : Math.random().toString(36).slice(2);
+    return [{
+            eventKind: 'unknown',
+            eventId: eventId('unknown-role'),
+            sourceEventId,
+            sourceIndex,
+            sourceType,
+            timestamp,
+            raw,
+        }];
 }
-function openClawTextParts(content) {
-    const text = openClawContentText(content);
-    const split = splitOpenClawRuntimeMetadata(text);
-    return split.map((part) => ({ type: 'text', text: part }));
+function isKnownOpenClawMetadataRecord(raw) {
+    if (raw.type === 'model_change')
+        return true;
+    if (raw.type !== 'custom')
+        return false;
+    return raw.customType === 'model-snapshot';
 }
 function splitOpenClawRuntimeMetadata(text) {
     const match = text.match(/^(Conversation info \(untrusted metadata\):\s*```json[\s\S]*?```\s*)([\s\S]*)$/);
@@ -342,71 +1062,12 @@ function splitOpenClawRuntimeMetadata(text) {
     const rest = match[2].trim();
     return rest ? [metadata, rest] : [metadata];
 }
-function openClawAssistantContent(content) {
-    if (!Array.isArray(content))
-        return [];
-    const parts = [];
-    for (const part of content) {
-        if (!isRecordObject(part) || typeof part.type !== 'string')
-            continue;
-        if (part.type === 'thinking') {
-            parts.push({ type: 'thinking', thinking: typeof part.thinking === 'string' ? part.thinking : '' });
-            continue;
-        }
-        if (part.type === 'text') {
-            parts.push({ type: 'text', text: typeof part.text === 'string' ? part.text : '' });
-            continue;
-        }
-        if (part.type === 'toolCall') {
-            const id = typeof part.id === 'string' ? part.id : undefined;
-            const name = typeof part.name === 'string' ? normalizeOpenClawToolName(part.name) : undefined;
-            if (!id || !name)
-                continue;
-            parts.push({
-                type: 'tool_use',
-                id,
-                name,
-                input: normalizeOpenClawToolInput(name, isRecordObject(part.arguments) ? part.arguments : {}),
-            });
-        }
-    }
-    return parts;
-}
-function normalizeOpenClawToolName(name) {
-    const normalized = name.trim();
-    const lower = normalized.toLowerCase();
-    if (lower === 'read')
-        return 'Read';
-    if (lower === 'grep' || lower === 'search')
-        return 'Grep';
-    // OpenClaw uses exec/run/shell labels for command execution; collapse them for tool-count comparability.
-    if (lower === 'bash' || lower === 'shell' || lower === 'run' || lower === 'exec')
-        return 'Bash';
-    if (lower === 'edit')
-        return 'Edit';
-    if (lower === 'write')
-        return 'Write';
-    return normalized;
-}
 function normalizeOpenClawToolInput(toolName, input) {
     if (toolName === 'Read' && typeof input.path === 'string' && typeof input.file_path !== 'string') {
         return { ...input, file_path: input.path };
     }
     return input;
 }
-function openClawUsage(value) {
-    if (!isRecordObject(value))
-        return undefined;
-    return {
-        input_tokens: numberValue(value.input ?? value.input_tokens),
-        output_tokens: numberValue(value.output ?? value.output_tokens),
-        cache_read_input_tokens: numberValue(value.cacheRead ?? value.cache_read_input_tokens),
-        cache_creation_input_tokens: numberValue(value.cacheWrite ?? value.cache_creation_input_tokens),
-    };
-}
-function numberValue(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
-}
 function openClawToolResultText(content) {
     return openClawContentText(content);
 }
@@ -429,53 +1090,102 @@ function openClawContentText(content) {
 function isRecordObject(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
+function isValidUsageCounters(input, output, cacheRead, cacheCreation) {
+    return isTokenCounter(input)
+        && isTokenCounter(output)
+        && (cacheRead === undefined || isTokenCounter(cacheRead))
+        && (cacheCreation === undefined || isTokenCounter(cacheCreation));
+}
+function isTokenCounter(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
 const MARKDOWN_LOG_BLOCK_RE = /(?:^|\n)---\s*\n## \[([^\]]+)\] 对话记录[^\n]*\n([\s\S]*?)(?=\n---\s*\n## \[|$)/g;
 function parseMarkdownLogFile(filePath) {
+    const fileSize = statSync(filePath).size;
+    if (fileSize > MAX_MARKDOWN_LOG_BYTES) {
+        throw new Error(`trace Markdown 日志超过 ${MAX_MARKDOWN_LOG_BYTES} 字节上限：${filePath}`);
+    }
     const content = readFileSync(filePath, 'utf-8');
-    if (!content.includes('### 用户输入') || !content.includes('### AI 回复'))
-        return [];
+    const sourceRecordCount = (content.match(/^## \[[^\]]+\] 对话记录.*$/gm) ?? []).length;
+    if (!content.includes('### 用户输入') || !content.includes('### AI 回复')) {
+        return {
+            sessions: [],
+            ingestion: {
+                ...emptyTraceIngestionSummary(1),
+                sourceRecordCount,
+                malformedRecordCount: sourceRecordCount,
+            },
+        };
+    }
     const sessions = [];
+    const streamOccurrences = new Map();
     let index = 0;
     for (const match of content.matchAll(MARKDOWN_LOG_BLOCK_RE)) {
         const timestamp = markdownLogTimestampToIso(match[1]);
         const body = match[2] ?? '';
         const blockCwd = body.match(/^\*\*工作目录\*\*:\s*(.+)$/m)?.[1]?.trim();
         const blockSessionId = body.match(/^\*\*会话 ID\*\*:\s*(.+)$/m)?.[1]?.trim();
-        const requestId = body.match(/^\*\*请求 ID\*\*:\s*(.+)$/m)?.[1]?.trim() ?? String(index);
+        const explicitRequestId = body.match(/^\*\*请求 ID\*\*:\s*(.+)$/m)?.[1]?.trim();
         const userText = extractMarkdownLogSection(body, '### 用户输入', '### AI 回复');
         const assistantText = extractMarkdownLogSection(body, '### AI 回复');
         if (!userText && !assistantText)
             continue;
-        const sessionId = blockSessionId || `${filePath.split('/').pop().replace(/\.log$/, '')}:${requestId}`;
+        const contentFingerprint = createHash('sha256')
+            .update(`${userText}\u0000${assistantText}`)
+            .digest('hex')
+            .slice(0, 24);
+        const requestId = explicitRequestId ?? contentFingerprint;
+        const sessionId = blockSessionId || `${basename(filePath, '.log')}:${requestId}`;
+        const streamKey = [
+            blockSessionId ? `session:${blockSessionId}` : '',
+            explicitRequestId ? `request:${explicitRequestId}` : `content:${contentFingerprint}`,
+        ].join('\u0000');
+        const streamOccurrence = streamOccurrences.get(streamKey) ?? 0;
+        streamOccurrences.set(streamKey, streamOccurrence + 1);
         const cwd = blockCwd;
         const skill = extractMarkdownLogSkill(`${userText}\n${assistantText}`);
         const userContent = skill ? `<command-name>/${skill}</command-name>\n${userText}` : userText;
-        const records = [{
-                type: 'user',
-                uuid: `markdown-log-${requestId}-user-${index}`,
-                parentUuid: null,
-                sessionId,
+        const events = [];
+        if (userContent) {
+            events.push({
+                eventKind: 'message',
+                eventId: `markdown-log-${requestId}-user-${index}`,
+                sourceIndex: 0,
+                sourceType: 'markdown:user',
                 timestamp,
-                message: { role: 'user', content: userContent },
-            }, {
-                type: 'assistant',
-                uuid: `markdown-log-${requestId}-assistant-${index}`,
-                parentUuid: `markdown-log-${requestId}-user-${index}`,
-                sessionId,
+                role: 'user',
+                origin: 'human',
+                text: userContent,
+            });
+        }
+        if (assistantText) {
+            events.push({
+                eventKind: 'message',
+                eventId: `markdown-log-${requestId}-assistant-${index}`,
+                sourceIndex: 1,
+                sourceType: 'markdown:assistant',
                 timestamp,
-                cwd,
-                attributionSkill: skill,
-                message: {
-                    role: 'assistant',
-                    content: assistantText ? [{ type: 'text', text: assistantText }] : [],
-                    stop_reason: 'end_turn',
-                },
-            }];
+                role: 'assistant',
+                origin: 'synthetic',
+                text: assistantText,
+                attributionSkill: skill ?? undefined,
+            });
+        }
         sessions.push({
-            sessionId,
+            runId: sessionId,
+            rootRunId: sessionId,
+            traceId: createTraceId({
+                sourceKind: 'markdown_log',
+                runId: sessionId,
+                sourcePath: filePath,
+                streamId: `${streamKey}\u0000occurrence:${streamOccurrence}`,
+            }),
+            groupPath: dirname(filePath),
+            role: 'standalone',
+            label: `${basename(filePath)}#${requestId}`,
             sourcePath: filePath,
             sourceKind: 'markdown_log',
-            records,
+            events,
             cwd,
             entrypoint: 'markdown_log',
             startTimestamp: timestamp,
@@ -483,13 +1193,27 @@ function parseMarkdownLogFile(filePath) {
         });
         index += 1;
     }
-    return sessions;
+    return {
+        sessions,
+        ingestion: {
+            ...emptyTraceIngestionSummary(1),
+            sourceRecordCount,
+            parsedRecordCount: sessions.length,
+            malformedRecordCount: Math.max(0, sourceRecordCount - sessions.length),
+        },
+    };
 }
 function markdownLogTimestampToIso(value) {
-    const m = value.match(/^(\d{4})\/(\d{2})\/(\d{2})\s+(\d{2}):(\d{2}):(\d{2})$/);
+    const m = value.match(/^(\d{4})\/(\d{2})\/(\d{2})\s+(\d{2}):(\d{2}):(\d{2})\s*(Z|[+-]\d{2}:?\d{2})$/);
     if (!m)
-        return new Date().toISOString();
-    return `${m[1]}-${m[2]}-${m[3]}T${m[4]}:${m[5]}:${m[6]}+08:00`;
+        return undefined;
+    const rawOffset = m[7];
+    if (!rawOffset)
+        return undefined;
+    const offset = rawOffset === 'Z' || rawOffset.includes(':')
+        ? rawOffset
+        : `${rawOffset.slice(0, 3)}:${rawOffset.slice(3)}`;
+    return normalizeTraceTimestamp(`${m[1]}-${m[2]}-${m[3]}T${m[4]}:${m[5]}:${m[6]}${offset}`);
 }
 function extractMarkdownLogSection(body, startMarker, endMarker) {
     const start = body.indexOf(startMarker);