oh-my-knowledge 0.52.3 → 0.54.0

package/dist/dsh-plugin/index.js

@@ -0,0 +1,275 @@
+import { dirname, join, resolve } from 'node:path';
+import { computeVerdict } from '../eval-core/verdict.js';
+import { configVariantsToSpecs, loadEvalConfig } from '../inputs/eval-config.js';
+import { runEvaluation, runMultiple } from '../eval-workflows/run-evaluation.js';
+import { createDshHostExecutor, } from './host-executor.js';
+import { createDshConversationCatalog, dshTraceIngestionSummary, listDshObserveCandidates, readDshObservedGroup, } from './observe.js';
+export const name = 'omk-dsh-plugin';
+export const inject = ['agentPresets', 'agents', 'commands', 'tools'];
+const HELP = [
+    'OMK 已接入当前 DeepSeek Harness。',
+    '',
+    '受控评测：/omk eval <eval.yaml>',
+    '查看最近任务：/omk observe',
+    '打开任务轨迹：/omk observe <session-id>',
+    '',
+    '文档：https://oh-my-knowledge.pages.dev/zh/reference/executors',
+].join('\n');
+const USAGE = '用法：/omk eval <eval.yaml> 或 /omk observe [session-id]；运行 /omk 查看帮助。';
+function unquote(value) {
+    if ((value.startsWith('"') && value.endsWith('"'))
+        || (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+function parseCommand(rawInput) {
+    const normalized = rawInput.trim();
+    if (!normalized || normalized === 'help')
+        return { commandKind: 'help' };
+    const evalMatch = /^\s*eval\s+(.+?)\s*$/u.exec(rawInput);
+    const evalPath = evalMatch?.[1]?.trim();
+    if (evalPath)
+        return { commandKind: 'eval', path: unquote(evalPath) };
+    const observeMatch = /^\s*observe(?:\s+(.+?))?\s*$/u.exec(rawInput);
+    if (!observeMatch)
+        return undefined;
+    const sessionId = observeMatch[1]?.trim();
+    return {
+        commandKind: 'observe',
+        ...(sessionId ? { sessionId: unquote(sessionId) } : {}),
+    };
+}
+function projectRoot(configPath) {
+    return dirname(configPath);
+}
+function modelFor(agent, configured) {
+    const model = configured?.trim() || agent.options.model?.trim();
+    if (!model) {
+        throw new Error('当前 DSH session 没有可继承的模型，且 eval.yaml 未配置 model。');
+    }
+    return model;
+}
+function normalizeJudgeModels(configured, model) {
+    if (!configured || configured.length === 0)
+        return [{ executor: 'dsh-host', model }];
+    return configured.map((judge) => {
+        if (judge.executor === 'dsh-host') {
+            throw new Error('dsh-host 是 OMK 内部执行器标识；评委要复用当前 DSH 时，请使用 executor: dsh 或省略 judgeModels。');
+        }
+        return {
+            ...judge,
+            executor: judge.executor === 'dsh' ? 'dsh-host' : judge.executor,
+        };
+    });
+}
+async function executeEvalCommand(ctx, invocation, requestedPath) {
+    const cwd = invocation.agent.session.header.cwd ?? process.cwd();
+    const configPath = resolve(cwd, requestedPath);
+    const config = loadEvalConfig(configPath);
+    if (config.executor) {
+        return {
+            kind: 'error',
+            text: 'DSH 内运行 OMK 时，被测执行器固定为当前 DSH；请删除 eval.yaml 中的顶层 executor。',
+        };
+    }
+    if (config.effort) {
+        return {
+            kind: 'error',
+            text: 'DSH 的 reasoning effort 是 provider-owned 枚举，当前无法与 OMK 五档无损映射；请删除 eval.yaml 中的 effort，并在 DSH profile 中固定模型推理配置。',
+        };
+    }
+    const model = modelFor(invocation.agent, config.model);
+    const executor = createDshHostExecutor(ctx, {
+        parentAgent: invocation.agent,
+        signal: invocation.signal,
+    });
+    const judgeModels = normalizeJudgeModels(config.judgeModels, model);
+    const currentSessionProvesConnectivity = config.model === undefined
+        && ((config.noJudge ?? false) || judgeModels.every((judge) => (judge.executor === 'dsh-host' && judge.model === model)));
+    const root = projectRoot(configPath);
+    const outputDir = join(root, '.omk', 'reports');
+    const options = {
+        samplesPath: config.samples,
+        skillDir: join(root, 'skills'),
+        variantSpecs: configVariantsToSpecs(config.variants),
+        model,
+        outputDir,
+        noJudge: config.noJudge ?? false,
+        concurrency: config.concurrency ?? 1,
+        timeoutMs: config.timeoutMs,
+        noCache: config.noCache ?? false,
+        executorName: 'dsh-host',
+        executorOverrides: { 'dsh-host': executor },
+        judgeModels,
+        skipConnectivity: currentSessionProvesConnectivity,
+        skipDoctor: config.skipDoctor ?? false,
+        lang: 'zh',
+        mcpConfig: config.mcpConfig,
+        bootstrap: config.bootstrap ?? true,
+        bootstrapSamples: config.bootstrapSamples,
+        holdoutRatio: config.holdoutRatio,
+        judgeRepeat: config.judgeRepeat,
+        lengthDebias: config.lengthDebias,
+        budget: config.budget,
+        strictBaseline: config.strictBaseline,
+        noDiagnostic: config.noDiagnostic,
+    };
+    const result = config.repeat && config.repeat > 1
+        ? await runMultiple({ ...options, repeat: config.repeat })
+        : await runEvaluation(options);
+    const report = result.report;
+    const goldMessages = [];
+    if (config.goldDir) {
+        const { attachGoldAgreementToReport } = await import('../grading/gold-cli.js');
+        const gold = attachGoldAgreementToReport({
+            report,
+            goldDir: config.goldDir,
+            outputDir,
+            samples: config.bootstrapSamples,
+        });
+        if (gold.result && gold.gold) {
+            const alpha = Number.isFinite(gold.result.agreement.alpha)
+                ? gold.result.agreement.alpha.toFixed(3)
+                : '不可计算';
+            goldMessages.push(`Gold 一致性：Krippendorff α=${alpha}，N=${gold.result.agreement.sampleCount}，标注者=${gold.gold.metadata.annotator}`);
+            if (gold.result.contaminationWarning) {
+                goldMessages.push(`⚠ Gold 污染提示：${gold.result.contaminationWarning}`);
+            }
+        }
+        else {
+            goldMessages.push(`⚠ Gold 数据未加载：${gold.loadIssues.join('；') || config.goldDir}`);
+        }
+    }
+    const verdict = computeVerdict(report);
+    return {
+        kind: 'success',
+        text: [
+            `OMK 评测完成：${verdict.level}`,
+            verdict.headline,
+            `报告：${report.id}`,
+            ...(result.filePath ? [`文件：${result.filePath}`] : []),
+            ...goldMessages,
+        ].join('\n'),
+    };
+}
+function persistenceFor(ctx) {
+    const persistence = ctx.get?.('sessionPersistence');
+    if (!persistence) {
+        throw new Error('当前 DSH profile 没有启用 sessionPersistence；/omk eval 仍可使用，但任务轨迹需要配置 JSONL 或 SQLite persistence backend。');
+    }
+    return persistence;
+}
+async function studioUrl(invocation, state) {
+    if (state.serverUrl)
+        return state.serverUrl;
+    const cwd = invocation.agent.session.header.cwd ?? process.cwd();
+    const omkDir = join(cwd, '.omk');
+    const { createReportServer } = await import('../server/report-server.js');
+    state.server = createReportServer({
+        port: 0,
+        reportsDir: join(omkDir, 'reports'),
+        analysesDir: join(omkDir, 'observe-health'),
+        doctorsDir: join(omkDir, 'doctors'),
+        observationsDir: join(omkDir, 'observe-inbox'),
+        jobsDir: join(omkDir, 'jobs'),
+        managedDir: join(omkDir, 'managed'),
+        conversationCatalog: state.catalog,
+    });
+    state.serverUrl = await state.server.start();
+    return state.serverUrl;
+}
+async function executeObserveCommand(ctx, invocation, sessionId, state) {
+    const persistence = persistenceFor(ctx);
+    if (!sessionId) {
+        const candidates = await listDshObserveCandidates(persistence, {
+            excludeSessionId: String(invocation.agent.session.id),
+            signal: invocation.signal,
+        });
+        if (candidates.length === 0) {
+            return {
+                kind: 'success',
+                text: '没有找到可观测的已结束 DSH session。完成一个任务后再运行 /omk observe。',
+            };
+        }
+        return {
+            kind: 'success',
+            text: [
+                '最近可观测的 DSH session：',
+                ...candidates.map((candidate) => (`- ${candidate.sessionId}　${candidate.status}　${candidate.createdAt}${candidate.cwd ? `　${candidate.cwd}` : ''}`)),
+                '',
+                '查看轨迹：/omk observe <session-id>',
+            ].join('\n'),
+        };
+    }
+    const group = await readDshObservedGroup(persistence, sessionId, invocation.signal);
+    const selected = group.traces.find((trace) => trace.session.runId === sessionId);
+    if (!selected)
+        throw new Error(`DSH session 一致快照缺少目标 session：${sessionId}。`);
+    const incomplete = group.traces.filter((trace) => !trace.integrity.complete);
+    if (incomplete.length > 0) {
+        const details = incomplete.map((trace) => {
+            const integrity = trace.integrity;
+            const reasons = [
+                integrity.openTurnCount > 0 ? `未闭合 turn=${integrity.openTurnCount}` : '',
+                integrity.openStepCount > 0 ? `未闭合 step=${integrity.openStepCount}` : '',
+                integrity.unmatchedToolCallCount > 0 ? `缺失 tool result=${integrity.unmatchedToolCallCount}` : '',
+                integrity.unmatchedToolResultCount > 0 ? `孤立 tool result=${integrity.unmatchedToolResultCount}` : '',
+                integrity.status === 'unknown' ? '终态未知' : '',
+            ].filter(Boolean).join('；');
+            return `${trace.session.runId}（${reasons || '完整性检查未通过'}）`;
+        }).join('；');
+        throw new Error(`DSH session group 无法形成完整任务轨迹：${details}。`);
+    }
+    const cwd = invocation.agent.session.header.cwd ?? process.cwd();
+    const observationsDir = join(cwd, '.omk', 'observe-inbox');
+    const { buildObservationInboxReportFromTraceSessions, saveObservationInboxReport, } = await import('../observability/inbox.js');
+    const { loadObservationReviewState } = await import('../observability/review-state.js');
+    const { buildObserveDiagnosticsFromReport } = await import('../diagnosis/observe-producer.js');
+    const report = buildObservationInboxReportFromTraceSessions(`dsh:${group.rootSessionId}`, group.traces.map((trace) => trace.session), dshTraceIngestionSummary(group), { reviewState: loadObservationReviewState(observationsDir) });
+    report.diagnostics = buildObserveDiagnosticsFromReport(report);
+    const inboxPath = saveObservationInboxReport(report, observationsDir);
+    const target = state.catalog.upsert(group);
+    const baseUrl = await studioUrl(invocation, state);
+    const trajectoryUrl = `${baseUrl}/conversations/${encodeURIComponent(target.threadId)}/tasks/${encodeURIComponent(target.turnId)}`;
+    return {
+        kind: 'success',
+        text: [
+            `已只读摄取 DSH session：${sessionId}`,
+            `任务状态：${selected.integrity.status}`,
+            `任务轨迹：${trajectoryUrl}`,
+            `观测收件箱：${inboxPath}`,
+        ].join('\n'),
+    };
+}
+/** Register `/omk eval` and `/omk observe` in every DSH command-capable surface. */
+export function apply(ctx) {
+    const observeState = { catalog: createDshConversationCatalog() };
+    const disposeCommand = ctx.commands.register({
+        name: 'omk',
+        description: '在当前 DeepSeek Harness 中运行 OMK 对照评测或查看任务轨迹',
+        input: { hint: 'eval <eval.yaml> | observe [session-id]' },
+        async handler(invocation) {
+            const command = parseCommand(invocation.rawInput);
+            if (!command)
+                return { kind: 'error', text: USAGE };
+            if (command.commandKind === 'help')
+                return { kind: 'success', text: HELP };
+            try {
+                return command.commandKind === 'eval'
+                    ? await executeEvalCommand(ctx, invocation, command.path)
+                    : await executeObserveCommand(ctx, invocation, command.sessionId, observeState);
+            }
+            catch (error) {
+                return {
+                    kind: 'error',
+                    text: error instanceof Error ? error.message : String(error),
+                };
+            }
+        },
+    });
+    return () => {
+        disposeCommand();
+        void observeState.server?.stop().catch(() => undefined);
+    };
+}

package/dist/dsh-plugin/observe.d.ts

@@ -0,0 +1,47 @@
+import type { TraceIngestionSummary } from '../types/index.js';
+import type { ConversationCatalog } from '../observability/conversation-catalog.js';
+import { type DshSessionEventLike, type DshSessionHeaderLike, type DshTraceAdapterResult } from './trace-adapter.js';
+export interface DshPersistenceSnapshotLike {
+    readonly header: DshSessionHeaderLike;
+    readonly revision: unknown;
+}
+export interface DshSessionInspectionLike {
+    readonly meta: DshSessionHeaderLike;
+    readonly events: readonly DshSessionEventLike[];
+}
+export interface DshSessionPersistenceLike {
+    listSnapshots(signal?: AbortSignal): Promise<readonly DshPersistenceSnapshotLike[]>;
+    inspect(id: string, signal?: AbortSignal): Promise<DshSessionInspectionLike>;
+}
+export interface DshObserveCandidate {
+    sessionId: string;
+    createdAt: string;
+    cwd?: string;
+    status: 'completed' | 'failed' | 'aborted' | 'interrupted';
+}
+export interface DshObservedGroup {
+    rootSessionId: string;
+    selectedSessionId: string;
+    revision: string;
+    traces: DshTraceAdapterResult[];
+    inspections: DshSessionInspectionLike[];
+}
+/** Count every valid DSH logical record as parsed, including chunks consolidated into messages. */
+export declare function dshTraceIngestionSummary(group: DshObservedGroup): TraceIngestionSummary;
+/** Read one root+descendant group through the logical persistence seam without mutating it. */
+export declare function readDshObservedGroup(persistence: DshSessionPersistenceLike, selectedSessionId: string, signal?: AbortSignal): Promise<DshObservedGroup>;
+/** List recent terminal root sessions; the command's own live session stays out of the default result. */
+export declare function listDshObserveCandidates(persistence: DshSessionPersistenceLike, options?: {
+    excludeSessionId?: string;
+    limit?: number;
+    signal?: AbortSignal;
+}): Promise<DshObserveCandidate[]>;
+export interface DshCatalogTarget {
+    threadId: string;
+    turnId: string;
+}
+export interface MutableDshConversationCatalog extends ConversationCatalog {
+    upsert(group: DshObservedGroup): DshCatalogTarget;
+}
+/** Static snapshot catalog used by Studio; importing another session updates it without adding a parallel UI. */
+export declare function createDshConversationCatalog(): MutableDshConversationCatalog;

package/dist/dsh-plugin/observe.js

@@ -0,0 +1,359 @@
+import { durationMsBetween } from '../shared/time.js';
+import { projectTraceSessionTimeline, } from '../observability/experience.js';
+import { reconstructExperienceTurns } from '../observability/turn-index.js';
+import { observationSourceRecordFromLine } from '../observability/source-record-archive.js';
+import { adaptDshSession, } from './trace-adapter.js';
+const MAX_STABLE_READ_ATTEMPTS = 3;
+const DEFAULT_LIST_LIMIT = 8;
+const LIST_INSPECTION_LIMIT = 24;
+const MAX_SOURCE_RECORD_BYTES = 16 * 1024 * 1024;
+/** Count every valid DSH logical record as parsed, including chunks consolidated into messages. */
+export function dshTraceIngestionSummary(group) {
+    const sourceRecordCount = group.inspections.reduce((sum, item) => sum + item.events.length + 1, 0);
+    return {
+        fileCount: group.traces.length,
+        sourceRecordCount,
+        parsedRecordCount: sourceRecordCount,
+        malformedRecordCount: 0,
+        ignoredValueCount: 0,
+        unknownEventCount: group.traces.reduce((sum, item) => sum + item.integrity.unknownEventCount, 0),
+        filteredSessionCount: 0,
+    };
+}
+function snapshotMap(snapshots) {
+    return new Map(snapshots.map((snapshot) => [String(snapshot.header.id), snapshot]));
+}
+function rootSessionId(sessionId, snapshots) {
+    const seen = new Set();
+    let current = sessionId;
+    while (true) {
+        if (seen.has(current))
+            throw new Error(`DSH session lineage 存在循环：${sessionId}。`);
+        seen.add(current);
+        const currentHeader = snapshots.get(current)?.header;
+        if (currentHeader?.origin !== 'subagent')
+            return current;
+        const parent = currentHeader.parentSession;
+        if (!parent)
+            return current;
+        if (!snapshots.has(String(parent))) {
+            throw new Error(`DSH session lineage 缺少 parent session：${String(parent)}。`);
+        }
+        current = String(parent);
+    }
+}
+function groupSessionIds(rootId, snapshots) {
+    const ids = new Set([rootId]);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const [id, snapshot] of snapshots) {
+            const parent = snapshot.header.parentSession ? String(snapshot.header.parentSession) : undefined;
+            if (snapshot.header.origin !== 'subagent' || !parent || !ids.has(parent) || ids.has(id))
+                continue;
+            ids.add(id);
+            changed = true;
+        }
+    }
+    return Array.from(ids).sort((left, right) => {
+        if (left === rootId)
+            return -1;
+        if (right === rootId)
+            return 1;
+        const depthDiff = (snapshots.get(left)?.header.delegationDepth ?? 0)
+            - (snapshots.get(right)?.header.delegationDepth ?? 0);
+        return depthDiff || left.localeCompare(right);
+    });
+}
+function sameRevision(left, right) {
+    return Object.is(left, right);
+}
+function stableGroup(before, after, rootId) {
+    const beforeIds = groupSessionIds(rootId, before);
+    const afterIds = groupSessionIds(rootId, after);
+    if (beforeIds.length !== afterIds.length
+        || beforeIds.some((id, index) => id !== afterIds[index]))
+        return false;
+    return beforeIds.every((id) => {
+        const left = before.get(id);
+        const right = after.get(id);
+        return left !== undefined && right !== undefined && sameRevision(left.revision, right.revision);
+    });
+}
+function revisionLabel(snapshots, ids) {
+    return ids.map((id) => `${id}:${String(snapshots.get(id)?.revision ?? 'missing')}`).join('|');
+}
+/** Read one root+descendant group through the logical persistence seam without mutating it. */
+export async function readDshObservedGroup(persistence, selectedSessionId, signal) {
+    for (let attempt = 1; attempt <= MAX_STABLE_READ_ATTEMPTS; attempt += 1) {
+        signal?.throwIfAborted();
+        const before = snapshotMap(await persistence.listSnapshots(signal));
+        if (!before.has(selectedSessionId))
+            throw new Error(`DSH session 不存在：${selectedSessionId}。`);
+        const rootId = rootSessionId(selectedSessionId, before);
+        const ids = groupSessionIds(rootId, before);
+        const inspections = await Promise.all(ids.map((id) => persistence.inspect(id, signal)));
+        signal?.throwIfAborted();
+        const after = snapshotMap(await persistence.listSnapshots(signal));
+        if (!stableGroup(before, after, rootId))
+            continue;
+        const traces = inspections.map((inspection) => adaptDshSession(inspection.meta, inspection.events, {
+            rootRunId: rootId,
+            role: String(inspection.meta.id) === rootId ? 'main' : 'subagent',
+            groupPath: `dsh:${rootId}`,
+        }));
+        return {
+            rootSessionId: rootId,
+            selectedSessionId,
+            revision: revisionLabel(after, ids),
+            traces,
+            inspections,
+        };
+    }
+    throw new Error(`DSH session 在读取期间持续变化，${MAX_STABLE_READ_ATTEMPTS} 次一致快照均失败：${selectedSessionId}。`);
+}
+async function inspectCandidate(persistence, snapshot, signal) {
+    const sessionId = String(snapshot.header.id);
+    try {
+        const group = await readDshObservedGroup(persistence, sessionId, signal);
+        const trace = group.traces.find((item) => item.session.runId === sessionId);
+        if (!trace)
+            return undefined;
+        if (group.traces.some((item) => !item.integrity.complete))
+            return undefined;
+        const status = trace.integrity.status;
+        if (status !== 'completed' && status !== 'failed' && status !== 'aborted' && status !== 'interrupted') {
+            return undefined;
+        }
+        return {
+            sessionId,
+            createdAt: new Date(snapshot.header.createdAt).toISOString(),
+            cwd: snapshot.header.cwd,
+            status,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** List recent terminal root sessions; the command's own live session stays out of the default result. */
+export async function listDshObserveCandidates(persistence, options = {}) {
+    const limit = Math.max(1, options.limit ?? DEFAULT_LIST_LIMIT);
+    const snapshots = [...await persistence.listSnapshots(options.signal)]
+        .filter((snapshot) => snapshot.header.origin !== 'subagent'
+        && String(snapshot.header.id) !== options.excludeSessionId)
+        .sort((left, right) => right.header.createdAt - left.header.createdAt)
+        .slice(0, Math.max(limit, LIST_INSPECTION_LIMIT));
+    const candidates = [];
+    for (const snapshot of snapshots) {
+        options.signal?.throwIfAborted();
+        const candidate = await inspectCandidate(persistence, snapshot, options.signal);
+        if (candidate)
+            candidates.push(candidate);
+        if (candidates.length >= limit)
+            break;
+    }
+    return candidates;
+}
+function mergedTimeline(group) {
+    const ranked = group.traces.flatMap((trace, traceRank) => (projectTraceSessionTimeline(trace.session).map((event) => ({ event, traceRank }))));
+    ranked.sort((left, right) => {
+        if (left.event.timestamp && right.event.timestamp && left.event.timestamp !== right.event.timestamp) {
+            return left.event.timestamp.localeCompare(right.event.timestamp);
+        }
+        return left.traceRank - right.traceRank || left.event.order - right.event.order;
+    });
+    return ranked.map(({ event }, index) => ({ ...event, order: index * 10 }));
+}
+function attachDescendantsToRootTurns(turns, timeline, rootTraceId) {
+    const rootTurns = turns.filter((turn) => turn.traceId === rootTraceId);
+    const childEvents = timeline.filter((event) => event.traceId !== rootTraceId);
+    if (rootTurns.length === 0 || childEvents.length === 0)
+        return turns;
+    const eventById = new Map(timeline.map((event) => [event.id, event]));
+    return turns.map((turn) => {
+        if (turn.traceId !== rootTraceId)
+            return turn;
+        const related = childEvents.filter((event) => {
+            if (rootTurns.length === 1)
+                return true;
+            if (!event.timestamp || !turn.startTimestamp)
+                return false;
+            return event.timestamp >= turn.startTimestamp
+                && (!turn.endTimestamp || event.timestamp <= turn.endTimestamp);
+        });
+        if (related.length === 0)
+            return turn;
+        const eventIds = Array.from(new Set([...turn.eventIds, ...related.map((event) => event.id)]))
+            .sort((left, right) => (eventById.get(left)?.order ?? 0) - (eventById.get(right)?.order ?? 0));
+        return {
+            ...turn,
+            eventIds,
+            toolCallCount: eventIds.filter((id) => eventById.get(id)?.kind === 'tool_use').length,
+            toolFailureCount: eventIds.filter((id) => {
+                const event = eventById.get(id);
+                return event?.kind === 'tool_result' && (event.toolStatus === 'failure' || event.isError);
+            }).length,
+        };
+    });
+}
+function sourceRecords(group) {
+    let byteCount = 0;
+    let omittedRecordCount = 0;
+    const records = [];
+    group.traces.forEach((trace, traceIndex) => {
+        const inspection = group.inspections[traceIndex];
+        if (!inspection)
+            return;
+        const values = [{ type: 'session/header', ...inspection.meta }, ...inspection.events];
+        values.forEach((value, sourceIndex) => {
+            const raw = JSON.stringify(value);
+            const event = sourceIndex === 0 ? undefined : inspection.events[sourceIndex - 1];
+            const base = observationSourceRecordFromLine(raw, sourceIndex, trace.session.traceId, trace.session.sourcePath);
+            if (byteCount + base.byteCount > MAX_SOURCE_RECORD_BYTES) {
+                omittedRecordCount += 1;
+                return;
+            }
+            records.push({
+                ...base,
+                sourceType: sourceIndex === 0 ? 'session/header' : event?.type ?? 'unknown',
+                sourceEventId: event ? `${String(inspection.meta.id)}:${event.seq}` : String(inspection.meta.id),
+                timestamp: sourceIndex === 0
+                    ? new Date(inspection.meta.createdAt).toISOString()
+                    : event ? new Date(event.time).toISOString() : undefined,
+            });
+            byteCount += base.byteCount;
+        });
+    });
+    return {
+        status: omittedRecordCount > 0 ? 'partial' : 'available',
+        recordCount: records.length,
+        records,
+        omittedRecordCount,
+        byteCount,
+        truncated: omittedRecordCount > 0,
+        ...(omittedRecordCount > 0 ? { reason: 'archive_limit' } : {}),
+    };
+}
+function taskItem(threadId, turn) {
+    return {
+        turnId: turn.turnId,
+        sourceTurnId: turn.sourceTurnId,
+        trajectoryHref: `/conversations/${encodeURIComponent(threadId)}/tasks/${encodeURIComponent(turn.turnId)}`,
+        title: turn.title,
+        startTimestamp: turn.startTimestamp,
+        endTimestamp: turn.endTimestamp,
+        durationMs: durationMsBetween(turn.startTimestamp, turn.endTimestamp),
+        status: turn.status,
+        eventCount: turn.eventIds.length,
+        toolCallCount: turn.toolCallCount,
+        toolFailureCount: turn.toolFailureCount,
+        relatedSkillNames: [],
+    };
+}
+function catalogEntry(group) {
+    const rootTrace = group.traces.find((trace) => trace.session.runId === group.rootSessionId)
+        ?? group.traces[0];
+    if (!rootTrace)
+        throw new Error(`DSH session group 为空：${group.rootSessionId}。`);
+    const timeline = mergedTimeline(group);
+    const turns = attachDescendantsToRootTurns(reconstructExperienceTurns(timeline), timeline, rootTrace.session.traceId);
+    const rootTimeline = timeline.filter((event) => event.traceId === rootTrace.session.traceId);
+    const firstUser = rootTimeline.find((event) => event.kind === 'user_message');
+    const title = firstUser?.fullText?.trim() || firstUser?.snippet?.trim() || `DSH session ${group.rootSessionId}`;
+    const tasks = turns.map((turn) => taskItem(group.rootSessionId, turn));
+    const startTimestamp = rootTrace.session.startTimestamp;
+    const endTimestamp = rootTrace.session.endTimestamp;
+    return {
+        group,
+        turns,
+        timeline,
+        records: sourceRecords(group),
+        conversation: {
+            threadId: group.rootSessionId,
+            sourceThreadId: group.rootSessionId,
+            sourceKind: 'dsh',
+            title: title.replace(/\s+/g, ' ').slice(0, 160),
+            preview: title.replace(/\s+/g, ' ').slice(0, 240),
+            cwd: rootTrace.session.cwd,
+            model: rootTrace.session.sourceMetadata?.model,
+            childThreadCount: Math.max(0, group.traces.length - 1),
+            startTimestamp,
+            endTimestamp,
+            durationMs: durationMsBetween(startTimestamp, endTimestamp),
+            turnCount: tasks.length,
+            toolCallCount: tasks.reduce((sum, task) => sum + task.toolCallCount, 0),
+            toolFailureCount: tasks.reduce((sum, task) => sum + task.toolFailureCount, 0),
+            relatedSkillNames: [],
+            tasks,
+        },
+    };
+}
+/** Static snapshot catalog used by Studio; importing another session updates it without adding a parallel UI. */
+export function createDshConversationCatalog() {
+    const entries = new Map();
+    return {
+        upsert(group) {
+            const entry = catalogEntry(group);
+            entries.set(group.rootSessionId, entry);
+            const selectedTrace = group.traces.find((trace) => trace.session.runId === group.selectedSessionId);
+            const selectedTurn = [...entry.turns].reverse().find((turn) => turn.traceId === selectedTrace?.session.traceId)
+                ?? entry.turns.at(-1);
+            if (!selectedTurn)
+                throw new Error(`DSH session 没有可展示的任务：${group.selectedSessionId}。`);
+            return { threadId: group.rootSessionId, turnId: selectedTurn.turnId };
+        },
+        async listConversations() {
+            const conversations = Array.from(entries.values())
+                .map((entry) => entry.conversation)
+                .sort((left, right) => (right.endTimestamp ?? '').localeCompare(left.endTimestamp ?? ''));
+            return {
+                conversations,
+                totalTurnCount: conversations.reduce((sum, item) => sum + (item.turnCount ?? 0), 0),
+                totalToolCallCount: conversations.reduce((sum, item) => sum + (item.toolCallCount ?? 0), 0),
+                totalToolFailureCount: conversations.reduce((sum, item) => sum + (item.toolFailureCount ?? 0), 0),
+                indexedConversationCount: conversations.length,
+                unarchivedConversationCount: conversations.length,
+                archivedConversationCount: 0,
+                workspaceCount: new Set(conversations.flatMap((item) => item.cwd ? [item.cwd] : [])).size,
+            };
+        },
+        async getConversation(threadId) {
+            return entries.get(threadId)?.conversation;
+        },
+        async loadTaskTrajectory(threadId, turnId) {
+            const entry = entries.get(threadId);
+            const turn = entry?.turns.find((candidate) => candidate.turnId === turnId);
+            if (!entry || !turn)
+                return undefined;
+            const rootTrace = entry.group.traces.find((trace) => trace.session.runId === entry.group.rootSessionId)
+                ?? entry.group.traces[0];
+            if (!rootTrace)
+                return undefined;
+            return {
+                revision: entry.group.revision,
+                status: turn.status,
+                liveObservable: false,
+                session: {
+                    id: `dsh:${threadId}`,
+                    threadId,
+                    sourceThreadId: entry.group.rootSessionId,
+                    sessionId: entry.group.selectedSessionId,
+                    sourceTrace: rootTrace.session.sourcePath,
+                    sourceKind: 'dsh',
+                    entrypoint: 'dsh',
+                    sourceMetadata: rootTrace.session.sourceMetadata,
+                    cwd: rootTrace.session.cwd,
+                    startTimestamp: rootTrace.session.startTimestamp,
+                    endTimestamp: rootTrace.session.endTimestamp,
+                    attributedEventIds: [],
+                    turns: entry.turns,
+                    fullSessionTimeline: entry.timeline,
+                    indicators: { userCorrectionCount: 0 },
+                },
+                ingestion: dshTraceIngestionSummary(entry.group),
+                sourceRecords: entry.records,
+            };
+        },
+    };
+}