oh-my-knowledge 0.53.0 → 0.54.0

package/README.md

@@ -16,6 +16,8 @@ Observe real-world performance, measure version differences, and determine wheth
 
 **Same model. Same evaluation samples. Only the knowledge artifact changes.**
 
+**DeepSeek Harness users:** install OMK as a native bundle, reuse the current profile for controlled evaluations, and open persisted DSH task trajectories in Studio. [Set up the DSH host plugin →](docs/reference/executors.md#deepseek-harness-prefer-the-host-plugin)
+
 ![omk knowledge artifact evaluation flow: doctor / eval / observe / sample / evolve loop](./docs/public/omk-knowledge-flow-en-animated.gif)
 
 📖 **Full documentation: [oh-my-knowledge.pages.dev](https://oh-my-knowledge.pages.dev)** (searchable, English / 简体中文)
@@ -186,7 +188,13 @@ dsh plugin --profile web add oh-my-knowledge
 dsh --profile web
 ```
 
-Then run `/omk eval eval.yaml` inside DSH. Each sample gets an isolated DSH session while OMK still owns the report and statistics. See the [executor guide](docs/reference/executors.md#deepseek-harness-prefer-the-host-plugin).
+Inside DSH:
+
+- `/omk eval eval.yaml` runs every sample in an isolated DSH session while OMK owns the report and statistics;
+- `/omk observe` lists recent terminal sessions;
+- `/omk observe <session-id>` reads a consistent snapshot and returns its Studio Task Trajectory URL.
+
+Observe uses the profile's `sessionPersistence` directly, so users do not export or locate JSONL / SQLite files. The first version is offline-only and does not live-follow a session that is still being written. See the [executor guide](docs/reference/executors.md#deepseek-harness-prefer-the-host-plugin) and [observe guide](docs/guides/observe-production.md#inspect-a-task-inside-deepseek-harness).
 
 ## Documentation
 

package/README.zh.md

@@ -16,6 +16,8 @@
 
 **相同模型，相同评测用例，只改变知识载体。**
 
+**DeepSeek Harness 用户：** OMK 可作为原生 bundle 安装，复用当前 profile 做受控评测，并在 Studio 打开已持久化的 DSH 任务轨迹。[接入 DSH 宿主插件 →](docs/zh/reference/executors.md#deepseek-harness优先使用宿主插件)
+
 ![omk 知识载体评测流程：doctor / eval / observe / sample / evolve 闭环](./docs/public/omk-knowledge-flow-animated.gif)
 
 📖 **完整文档：[oh-my-knowledge.pages.dev/zh](https://oh-my-knowledge.pages.dev/zh/)**（可搜索，可切换英文）
@@ -186,7 +188,13 @@ dsh plugin --profile web add oh-my-knowledge
 dsh --profile web
 ```
 
-进入 DSH 后运行 `/omk eval eval.yaml`。每条用例会使用独立 DSH session，报告仍由 OMK 生成。详见[执行器文档](docs/zh/reference/executors.md#deepseek-harness优先使用宿主插件)。
+进入 DSH 后：
+
+- `/omk eval eval.yaml`：每条用例使用独立 DSH session，报告仍由 OMK 生成；
+- `/omk observe`：列出最近已结束的 session；
+- `/omk observe <session-id>`：只读摄取一致快照，并返回 Studio 任务轨迹链接。
+
+observe 直接使用 profile 的 `sessionPersistence`，无需导出或定位 JSONL／SQLite 文件；首版不实时跟随正在写入的 session。详见[执行器文档](docs/zh/reference/executors.md#deepseek-harness优先使用宿主插件)与[观测指南](docs/zh/guides/observe-production.md#在-deepseek-harness-中查看任务轨迹)。
 
 ## 文档
 

package/dist/assets/agent-skills/omk/SKILL.md

@@ -31,6 +31,8 @@ Codex 是 omk 的一等 runtime。运行在 Codex 任务中时，`omk eval` / `d
 
 如果当前 DSH profile 已安装 `oh-my-knowledge` bundle，使用 `/omk eval <eval.yaml>`。该路径直接复用现有 DSH 的模型、凭证、工具与 sandbox，并为每条用例创建隔离 session；不要要求用户另起 DSH runtime。
 
+查看真实 DSH 任务轨迹时，先运行 `/omk observe` 列出最近已结束的 session，再运行 `/omk observe <session-id>`。OMK 通过当前 profile 的 `sessionPersistence` 只读摄取一致快照，并返回 Studio 任务轨迹链接；不要求用户导出或定位 JSONL／SQLite 文件。首版不实时跟随正在写入的 session，也不默认选择发起 observe 命令的当前 session。
+
 ## 第二步：理解用户意图
 
 根据用户的描述，匹配对应的操作：

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

@@ -1,4 +1,5 @@
 import { type DshAgentLike, type DshHostContextLike } from './host-executor.js';
+import { type DshSessionPersistenceLike } from './observe.js';
 interface DshCommandInvocationLike {
     readonly agent: DshAgentLike;
     readonly rawInput: string;
@@ -10,6 +11,7 @@ type DshCommandResultLike = Readonly<Record<'kind', 'success'> & {
     text: string;
 }>;
 interface DshPluginContextLike extends DshHostContextLike {
+    get?(name: 'sessionPersistence'): DshSessionPersistenceLike | undefined;
     readonly commands: {
         register(definition: {
             readonly name: string;
@@ -23,6 +25,6 @@ interface DshPluginContextLike extends DshHostContextLike {
 }
 export declare const name = "omk-dsh-plugin";
 export declare const inject: string[];
-/** Register `/omk eval <eval.yaml>` in every DSH command-capable surface. */
-export declare function apply(ctx: DshPluginContextLike): void;
+/** Register `/omk eval` and `/omk observe` in every DSH command-capable surface. */
+export declare function apply(ctx: DshPluginContextLike): () => void;
 export {};

package/dist/dsh-plugin/index.js

@@ -3,22 +3,43 @@ 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 USAGE = '用法：/omk eval <eval.yaml>';
-function commandPath(rawInput) {
-    const match = /^\s*eval\s+(.+?)\s*$/u.exec(rawInput);
-    if (!match)
-        return undefined;
-    const value = match[1]?.trim();
-    if (!value)
-        return undefined;
+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);
 }
@@ -132,18 +153,112 @@ async function executeEvalCommand(ctx, invocation, requestedPath) {
         ].join('\n'),
     };
 }
-/** Register `/omk eval <eval.yaml>` in every DSH command-capable surface. */
+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) {
-    ctx.commands.register({
+    const observeState = { catalog: createDshConversationCatalog() };
+    const disposeCommand = ctx.commands.register({
         name: 'omk',
-        description: '在当前 DeepSeek Harness 中运行 OMK 对照评测',
-        input: { hint: 'eval <eval.yaml>' },
+        description: '在当前 DeepSeek Harness 中运行 OMK 对照评测或查看任务轨迹',
+        input: { hint: 'eval <eval.yaml> | observe [session-id]' },
         async handler(invocation) {
-            const path = commandPath(invocation.rawInput);
-            if (!path)
+            const command = parseCommand(invocation.rawInput);
+            if (!command)
                 return { kind: 'error', text: USAGE };
+            if (command.commandKind === 'help')
+                return { kind: 'success', text: HELP };
             try {
-                return await executeEvalCommand(ctx, invocation, path);
+                return command.commandKind === 'eval'
+                    ? await executeEvalCommand(ctx, invocation, command.path)
+                    : await executeObserveCommand(ctx, invocation, command.sessionId, observeState);
             }
             catch (error) {
                 return {
@@ -153,4 +268,8 @@ export function apply(ctx) {
             }
         },
     });
+    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,
+            };
+        },
+    };
+}