oh-my-knowledge 0.51.2 → 0.52.0

package/dist/server/report-server.js

@@ -8,6 +8,8 @@ import { renderSkillHealthReport } from '../renderer/skill-health-renderer.js';
 import { renderDoctorDetail } from '../renderer/doctor-detail-renderer.js';
 import { assessHealth, renderSkillDetail } from '../renderer/skill-detail-renderer.js';
 import { renderObservationInboxPage } from '../renderer/observation-inbox-renderer.js';
+import { renderKnowledgeDebuggerPage } from '../renderer/knowledge-debugger-renderer.js';
+import { buildConversationActivitySnapshot, renderConversationDetailPage, renderConversationIndexPage, } from '../renderer/conversation-renderer.js';
 import { DEFAULT_LANG, e, t, layout } from '../renderer/layout.js';
 import { loadAllManagedRecords, resolveManagedDir, managedDir as projectManagedDir, listManagedRows, buildVersionScores } from '../managed/index.js';
 import { renderManagedList, renderManagedHistory } from '../renderer/managed-history-renderer.js';
@@ -26,6 +28,9 @@ import { confidenceOf, toolStabilityOf, } from '../observability/skill-health-an
 import { parseSkillHealthReport } from '../observability/skill-health-report.js';
 import { DEFAULT_OBSERVATIONS_DIR, findObservationInboxItem, formatObservationShow, queryObservationInbox } from '../observability/inbox.js';
 import { buildObservationInboxViewModel } from '../observability/inbox-view-model.js';
+import { buildKnowledgeDebuggerViewModel } from '../observability/knowledge-debugger.js';
+import { createCodexConversationCatalog, } from '../observability/conversation-catalog.js';
+import { loadObservationSourceRecordArchive, summarizeObservationSourceRecordArchive, } from '../observability/source-record-archive.js';
 import { activeStudioDiagnostics } from '../diagnosis/studio-projection.js';
 import { deleteObservationReviewState, loadObservationReviewState, ObservationReviewStateValidationError, updateObservationReviewState, } from '../observability/review-state.js';
 const DEFAULT_PORT = 7799;
@@ -685,9 +690,19 @@ export function formatListenError(p, err) {
     // EADDRINUSE or unknown — let caller try the omk-takeover flow.
     return null;
 }
-export function createReportServer({ port, host: hostOption, reportsDir, analysesDir, doctorsDir, observationsDir = DEFAULT_OBSERVATIONS_DIR, jobsDir = DEFAULT_JOBS_DIR, managedDir, store, jobStore, includeObserveCards = false, includeDoctorCards = false } = {}) {
+function findKnowledgeDebuggerContext(observationsDir, experienceSessionId) {
+    const inbox = buildObservationInboxViewModel(observationsDir);
+    const report = inbox.reports.find((candidate) => candidate.experience?.sessions.some((session) => session.id === experienceSessionId));
+    const session = report?.experience?.sessions.find((candidate) => candidate.id === experienceSessionId);
+    if (!report || !session)
+        return undefined;
+    const sourceRecordRef = report.meta.sourceRecordArchives?.find((candidate) => candidate.experienceSessionId === experienceSessionId);
+    return { report, session, sourceRecordRef };
+}
+export function createReportServer({ port, host: hostOption, reportsDir, analysesDir, doctorsDir, observationsDir = DEFAULT_OBSERVATIONS_DIR, jobsDir = DEFAULT_JOBS_DIR, managedDir, store, jobStore, conversationCatalog, includeObserveCards = false, includeDoctorCards = false } = {}) {
     let server = null;
     let serverUrl = null;
+    const liveStreamClosers = new Set();
     // reports store:显式注入 store > 显式 reportsDir(eval serve 的本次 outputDir / 测试 / 覆盖,固定单目录)
     // > 缺省 indexed(机器级总览:当前项目 + 全局 live ∪ 别项目的索引卡片,按 id dedup)。indexed 在 store 层做
     // merge,底层 createFileStore 的 mtime 指纹自动反映内容变化,一次构建即可。
@@ -696,6 +711,7 @@ export function createReportServer({ port, host: hostOption, reportsDir, analyse
             ? createFileStore(reportsDir)
             : createIndexedReportStore({ projectDir: projectReportsDir(), globalDir: globalReportsDir() }));
     const resolvedJobStore = jobStore || createFileJobStore(jobsDir);
+    const resolvedConversationCatalog = conversationCatalog ?? createCodexConversationCatalog();
     // 受管根目录按**请求**解析,不在启动时冻结 —— 否则长会话里会跟 omk list 分叉:Studio 启动时项目 .omk/managed
     // 还空、回退到 global,随后用户在项目里首次 omk install,omk list 下次会切到 project,而冻结了 root 的 Studio
     // 仍盯着旧 global,页面与 CLI 不一致。cwd 在进程内不变,变的是目录里有没有记录,故每次请求重判。
@@ -773,8 +789,12 @@ export function createReportServer({ port, host: hostOption, reportsDir, analyse
                 res.writeHead(200, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({ ok: true }));
                 // Graceful shutdown after response sent
-                setTimeout(() => { if (server)
-                    server.close(); }, 100);
+                setTimeout(() => {
+                    for (const close of [...liveStreamClosers])
+                        close();
+                    if (server)
+                        server.close();
+                }, 100);
                 return;
             }
             if (path === '/api/reports') {
@@ -872,6 +892,245 @@ export function createReportServer({ port, host: hostOption, reportsDir, analyse
                 res.end(html);
                 return;
             }
+            if (path === '/api/conversations/activity') {
+                const snapshot = buildConversationActivitySnapshot(await resolvedConversationCatalog.listConversations());
+                res.writeHead(200, {
+                    'Content-Type': 'application/json; charset=utf-8',
+                    'Cache-Control': 'no-store',
+                });
+                res.end(JSON.stringify(snapshot));
+                return;
+            }
+            if (path === '/conversations') {
+                const html = renderConversationIndexPage(await resolvedConversationCatalog.listConversations(), lang);
+                res.writeHead(200, {
+                    'Content-Type': 'text/html; charset=utf-8',
+                    'Cache-Control': 'no-store',
+                });
+                res.end(html);
+                return;
+            }
+            const conversationTaskLiveMatch = path.match(/^\/api\/conversations\/([^/]+)\/tasks\/([^/]+)\/live$/);
+            if (conversationTaskLiveMatch) {
+                let threadId = '';
+                let turnId = '';
+                try {
+                    threadId = decodeURIComponent(conversationTaskLiveMatch[1]);
+                    turnId = decodeURIComponent(conversationTaskLiveMatch[2]);
+                }
+                catch { /* invalid path */ }
+                const initial = threadId && turnId
+                    ? await resolvedConversationCatalog.loadTaskTrajectory(threadId, turnId)
+                    : undefined;
+                if (!initial) {
+                    res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify({ error: 'task_trajectory_not_found' }));
+                    return;
+                }
+                if (!resolvedConversationCatalog.observeTaskTrajectory) {
+                    res.writeHead(501, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify({ error: 'live_task_trajectory_unavailable' }));
+                    return;
+                }
+                res.writeHead(200, {
+                    'Content-Type': 'text/event-stream; charset=utf-8',
+                    'Cache-Control': 'no-cache, no-transform',
+                    Connection: 'keep-alive',
+                    'X-Accel-Buffering': 'no',
+                });
+                res.flushHeaders();
+                let closed = false;
+                let unsubscribe;
+                const lifecycle = new AbortController();
+                const heartbeat = setInterval(() => {
+                    if (!res.destroyed && !res.writableEnded)
+                        res.write(': keepalive\n\n');
+                }, 15_000);
+                heartbeat.unref?.();
+                const close = () => {
+                    if (closed)
+                        return;
+                    closed = true;
+                    clearInterval(heartbeat);
+                    lifecycle.abort();
+                    unsubscribe?.();
+                    liveStreamClosers.delete(close);
+                    if (!res.destroyed && !res.writableEnded)
+                        res.end();
+                };
+                liveStreamClosers.add(close);
+                req.once('close', close);
+                res.once('close', close);
+                try {
+                    unsubscribe = await resolvedConversationCatalog.observeTaskTrajectory(threadId, turnId, {
+                        next: (trajectory) => {
+                            if (closed || res.destroyed || res.writableEnded)
+                                return;
+                            res.write(`id: ${trajectory.revision}\n`);
+                            res.write('event: trajectory\n');
+                            res.write(`data: ${JSON.stringify({
+                                revision: trajectory.revision,
+                                status: trajectory.status,
+                                liveObservable: trajectory.liveObservable,
+                            })}\n\n`);
+                        },
+                        complete: close,
+                        error: (cause) => {
+                            if (!closed && !res.destroyed && !res.writableEnded) {
+                                res.write('event: trajectory-error\n');
+                                res.write(`data: ${JSON.stringify({ error: getErrorMessage(cause) })}\n\n`);
+                            }
+                            close();
+                        },
+                    }, { signal: lifecycle.signal });
+                    if (closed)
+                        unsubscribe();
+                }
+                catch (cause) {
+                    if (!closed && !res.destroyed && !res.writableEnded) {
+                        res.write('event: trajectory-error\n');
+                        res.write(`data: ${JSON.stringify({ error: getErrorMessage(cause) })}\n\n`);
+                    }
+                    close();
+                }
+                return;
+            }
+            const conversationTaskMatch = path.match(/^\/conversations\/([^/]+)\/tasks\/([^/]+)$/);
+            if (conversationTaskMatch) {
+                let threadId = '';
+                let turnId = '';
+                try {
+                    threadId = decodeURIComponent(conversationTaskMatch[1]);
+                    turnId = decodeURIComponent(conversationTaskMatch[2]);
+                }
+                catch { /* invalid path */ }
+                const trajectory = threadId && turnId
+                    ? await resolvedConversationCatalog.loadTaskTrajectory(threadId, turnId)
+                    : undefined;
+                if (!trajectory) {
+                    res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+                    res.end(lang === 'en' ? 'task trajectory not found' : '任务轨迹不存在');
+                    return;
+                }
+                const sourceRecords = {
+                    ...trajectory.sourceRecords,
+                    records: [],
+                };
+                const html = renderKnowledgeDebuggerPage(buildKnowledgeDebuggerViewModel(trajectory.session, turnId, trajectory.ingestion, sourceRecords), lang, {
+                    sourceRecordsEndpoint: `/api/conversations/${encodeURIComponent(threadId)}/tasks/${encodeURIComponent(turnId)}/source-records`,
+                    ...(trajectory.liveObservable && resolvedConversationCatalog.observeTaskTrajectory ? {
+                        live: {
+                            endpoint: `/api/conversations/${encodeURIComponent(threadId)}/tasks/${encodeURIComponent(turnId)}/live`,
+                            revision: trajectory.revision,
+                        },
+                    } : {}),
+                });
+                res.writeHead(200, {
+                    'Content-Type': 'text/html; charset=utf-8',
+                    'Cache-Control': 'no-store',
+                });
+                res.end(html);
+                return;
+            }
+            const conversationTaskSourceMatch = path.match(/^\/api\/conversations\/([^/]+)\/tasks\/([^/]+)\/source-records$/);
+            if (conversationTaskSourceMatch) {
+                let threadId = '';
+                let turnId = '';
+                try {
+                    threadId = decodeURIComponent(conversationTaskSourceMatch[1]);
+                    turnId = decodeURIComponent(conversationTaskSourceMatch[2]);
+                }
+                catch { /* invalid path */ }
+                const trajectory = threadId && turnId
+                    ? await resolvedConversationCatalog.loadTaskTrajectory(threadId, turnId)
+                    : undefined;
+                if (!trajectory) {
+                    res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify({ error: 'task_trajectory_not_found' }));
+                    return;
+                }
+                res.writeHead(200, {
+                    'Content-Type': 'application/json; charset=utf-8',
+                    'Cache-Control': 'no-store',
+                });
+                res.end(JSON.stringify(trajectory.sourceRecords));
+                return;
+            }
+            const conversationDetailMatch = path.match(/^\/conversations\/([^/]+)$/);
+            if (conversationDetailMatch) {
+                let threadId = '';
+                try {
+                    threadId = decodeURIComponent(conversationDetailMatch[1]);
+                }
+                catch { /* invalid path */ }
+                const conversation = threadId ? await resolvedConversationCatalog.getConversation(threadId) : undefined;
+                if (!conversation) {
+                    res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+                    res.end(lang === 'en' ? 'conversation not found' : '对话不存在');
+                    return;
+                }
+                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(renderConversationDetailPage(conversation, lang));
+                return;
+            }
+            const knowledgeDebuggerMatch = path.match(/^\/observe-debugger\/(.+)$/);
+            if (knowledgeDebuggerMatch) {
+                let experienceSessionId = '';
+                try {
+                    experienceSessionId = decodeURIComponent(knowledgeDebuggerMatch[1]);
+                }
+                catch { /* invalid path */ }
+                const context = experienceSessionId
+                    ? findKnowledgeDebuggerContext(observationsDir, experienceSessionId)
+                    : undefined;
+                if (!context) {
+                    res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+                    res.end(lang === 'en' ? 'experience session not found' : '观测会话不存在');
+                    return;
+                }
+                const targetTurnId = parsed.searchParams.get('turnId')?.trim();
+                if (!targetTurnId) {
+                    const langQuery = lang === DEFAULT_LANG ? '' : '?lang=en';
+                    res.writeHead(302, {
+                        Location: `/conversations/${encodeURIComponent(context.session.threadId)}${langQuery}`,
+                    });
+                    res.end();
+                    return;
+                }
+                if (!context.session.turns.some((turn) => turn.turnId === targetTurnId)) {
+                    res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+                    res.end(lang === 'en' ? 'task turn not found' : '任务不存在');
+                    return;
+                }
+                const html = renderKnowledgeDebuggerPage(buildKnowledgeDebuggerViewModel(context.session, targetTurnId, context.report.meta.ingestion, summarizeObservationSourceRecordArchive(context.sourceRecordRef)), lang, {
+                    sourceRecordsEndpoint: `/api/observe-debugger/${encodeURIComponent(experienceSessionId)}/source-records`,
+                });
+                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(html);
+                return;
+            }
+            const knowledgeDebuggerSourceMatch = path.match(/^\/api\/observe-debugger\/(.+)\/source-records$/);
+            if (knowledgeDebuggerSourceMatch) {
+                let experienceSessionId = '';
+                try {
+                    experienceSessionId = decodeURIComponent(knowledgeDebuggerSourceMatch[1]);
+                }
+                catch { /* invalid path */ }
+                const context = experienceSessionId
+                    ? findKnowledgeDebuggerContext(observationsDir, experienceSessionId)
+                    : undefined;
+                if (!context) {
+                    res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify({ error: 'experience_session_not_found' }));
+                    return;
+                }
+                res.writeHead(200, {
+                    'Content-Type': 'application/json; charset=utf-8',
+                    'Cache-Control': 'no-store',
+                });
+                res.end(JSON.stringify(loadObservationSourceRecordArchive(context.sourceRecordRef, observationsDir)));
+                return;
+            }
             if (path === '/api/observe-inbox') {
                 const severity = parsed.searchParams.get('severity');
                 const skill = parsed.searchParams.get('skill');
@@ -1155,10 +1414,17 @@ export function createReportServer({ port, host: hostOption, reportsDir, analyse
                 res.end(renderRunList(runs, lang));
                 return;
             }
-            // 根路径走 skill-centric 列表页 — studio 顶级实体是 skill。
-            // insightsBySkill 在 buildSkillIndex 里跟 SkillIndex 一起算好并享受同一份缓存,
-            // list renderer 直接消费,不再每请求 N×detectInsights 重算。
+            // Studio 先呈现机器上的 Codex 主对话，再从某次对话进入原生 turn 任务轨迹。
+            // /conversations 保留为同义入口，避免旧书签失效。
             if (path === '/') {
+                const html = renderConversationIndexPage(await resolvedConversationCatalog.listConversations(), lang);
+                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(html);
+                return;
+            }
+            // 原 skill-centric 工作台迁到 /knowledge。insightsBySkill 在 buildSkillIndex 里
+            // 跟 SkillIndex 一起算好并享受同一份缓存，renderer 只负责呈现。
+            if (path === '/knowledge') {
                 const runs = await reportStore.list();
                 const idx = buildSkillIndex(runs, analysesDir, doctorsDir, observationsDir, skillIndexOptions());
                 res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
@@ -1308,6 +1574,8 @@ export function createReportServer({ port, host: hostOption, reportsDir, analyse
     async function stop() {
         if (!server)
             return;
+        for (const close of [...liveStreamClosers])
+            close();
         await new Promise((resolve) => server.close(() => resolve()));
         server = null;
         serverUrl = null;

package/dist/types/observability.d.ts

@@ -214,6 +214,55 @@ export interface ObservationSessionTimeRange {
     endTimestamp?: string;
     durationMs?: number;
 }
+export type ObservationSourceRecordArchiveStatus = 'available' | 'partial' | 'unavailable';
+export type ObservationSourceRecordArchiveReason = 'no_record_ranges' | 'source_missing' | 'unsupported_source' | 'read_failed' | 'archive_limit';
+/**
+ * A report only retains a relative pointer to its bounded source-record archive.
+ * The archive itself stays beside the report so Studio never follows an
+ * arbitrary absolute path supplied by report JSON.
+ */
+export interface ObservationSourceRecordArchiveRef {
+    experienceSessionId: string;
+    status: ObservationSourceRecordArchiveStatus;
+    relativePath?: string;
+    recordCount: number;
+    omittedRecordCount: number;
+    byteCount: number;
+    truncated: boolean;
+    reason?: ObservationSourceRecordArchiveReason;
+}
+export interface ObservationSourceRecord {
+    sourceIndex: number;
+    traceId: string;
+    sourceTrace: string;
+    sourceType: string;
+    sourceEventId?: string;
+    timestamp?: string;
+    raw: string;
+    byteCount: number;
+    truncated: boolean;
+    redacted: boolean;
+}
+export interface ObservationSourceRecordArchive {
+    archiveKind: 'observe-source-records';
+    schemaVersion: 1;
+    experienceSessionId: string;
+    generatedAt: string;
+    records: ObservationSourceRecord[];
+    omittedRecordCount: number;
+    byteCount: number;
+    truncated: boolean;
+}
+export interface ObservationSourceRecordArchiveView {
+    status: ObservationSourceRecordArchiveStatus;
+    /** Total retained records, even when `records` is intentionally lazy. */
+    recordCount: number;
+    records: ObservationSourceRecord[];
+    omittedRecordCount: number;
+    byteCount: number;
+    truncated: boolean;
+    reason?: ObservationSourceRecordArchiveReason | 'archive_invalid';
+}
 export interface ObservationInboxReport {
     kind: 'observe-inbox';
     schemaVersion: 2;
@@ -236,6 +285,7 @@ export interface ObservationInboxReport {
         skillToolCallCounts?: Record<string, Record<string, number>>;
         timestampedSegmentCount?: number;
         timestampCoverage?: number;
+        sourceRecordArchives?: ObservationSourceRecordArchiveRef[];
     };
     items: ObservationInboxItem[];
     experience?: ObservationExperienceReport;
@@ -257,7 +307,7 @@ export interface BuildObservationInboxReportOptions {
 }
 export type ExperienceReviewPriority = 'review_first' | 'sample_review' | 'routine_sample';
 export type ExperienceGoalSliceReasonCode = 'skill_segment_boundary' | 'explicit_user_goal_shift' | 'default_session_slice';
-export type ExperienceEvidenceKind = 'user_message' | 'synthetic_user_event' | 'assistant_message' | 'tool_use' | 'tool_result' | 'skill_context' | 'runtime_context' | 'observation';
+export type ExperienceEvidenceKind = 'user_message' | 'synthetic_user_event' | 'assistant_message' | 'model_activity' | 'agent_activity' | 'tool_use' | 'tool_result' | 'skill_context' | 'runtime_context' | 'lifecycle' | 'observation';
 export type ExperienceAssistiveInferenceCode = 'review_recommended' | 'sample_recommended' | 'positive_signal_observed' | 'user_switched_topic_neutral' | 'no_obvious_issue_from_rules' | 'insufficient_human_context';
 export type ExperienceAssistiveInferenceConfidence = 'low' | 'medium' | 'high';
 export type ExperienceAssistiveInferenceCautionCode = 'no_llm_judge' | 'rule_only' | 'runtime_context_excluded' | 'skill_context_excluded' | 'no_human_user_message' | 'limited_timeline_window';
@@ -297,21 +347,187 @@ export interface ExperienceEvidenceRef {
     logicalMessageIndex?: number;
     sourceLineIndex?: number;
     messageUuid?: string;
+    /** Source-native record classification retained after normalization. */
+    sourceType?: string;
+    /** Source-neutral identity for one agent turn, when the trace exposes it. */
+    turnId?: string;
     /** Source-neutral identity for one concrete tool-call occurrence. */
     callInstanceId?: string;
     toolUseId?: string;
     timestamp?: string;
     role?: 'user' | 'assistant' | 'tool' | 'other';
+    modelActivityKind?: 'reasoning';
+    contentVisibility?: 'plaintext' | 'opaque';
+    contentSource?: 'summary' | 'content' | 'text';
+    runtimeKind?: 'session_context' | 'execution_context' | 'settings' | 'goal' | 'context_compaction' | 'usage';
     label?: string;
     snippet?: string;
 }
 export interface ExperienceTimelineEvent extends ExperienceEvidenceRef {
     order: number;
+    /** Model explicitly associated with this normalized event by the source adapter. */
+    model?: string;
     toolName?: string;
     toolStatus?: ToolCallStatus;
     isError?: boolean;
     fullText?: string;
 }
+export type DebugKnowledgeKind = 'project_instruction' | 'skill' | 'runtime_evidence';
+export type DebugKnowledgeAccessKind = 'injected' | 'read' | 'returned';
+export type TaskReplayStepKind = 'user_request' | 'user_message' | 'user_correction' | 'runtime_context' | 'skill_context' | 'tool_exchange' | 'unmatched_tool_result' | 'assistant_message' | 'model_activity' | 'lifecycle' | 'observation' | 'system_event';
+export type TaskReplayIntegrityCode = 'task_boundary_unavailable' | 'timeline_truncated' | 'malformed_records' | 'ignored_values' | 'unknown_events' | 'unmatched_tool_calls' | 'unmatched_tool_results' | 'missing_timestamps';
+export type TaskWindowBasis = 'turn_id' | 'turn_lifecycle' | 'user_message' | 'unresolved';
+export type ExperienceTurnStatus = 'completed' | 'aborted' | 'interrupted' | 'open' | 'unknown';
+/**
+ * One user-visible task inside a source thread. `turnId` is the stable,
+ * source-neutral identity used by Studio routes. `sourceTurnId` preserves the
+ * runtime-native identity when the source exposes one.
+ */
+export interface ExperienceTurnSummary {
+    turnId: string;
+    sourceTurnId?: string;
+    boundaryBasis: Exclude<TaskWindowBasis, 'unresolved'>;
+    traceId?: string;
+    sourceTrace: string;
+    startTimestamp?: string;
+    endTimestamp?: string;
+    status: ExperienceTurnStatus;
+    title: string;
+    eventIds: string[];
+    userMessageCount: number;
+    assistantMessageCount: number;
+    toolCallCount: number;
+    toolFailureCount: number;
+}
+export interface ConversationTaskItem {
+    turnId: string;
+    sourceTurnId?: string;
+    /** Existing observe reports retain their report-scoped session route. */
+    experienceSessionId?: string;
+    /** Preferred source-neutral task trajectory route. */
+    trajectoryHref?: string;
+    title: string;
+    startTimestamp?: string;
+    endTimestamp?: string;
+    durationMs?: number;
+    status: ExperienceTurnStatus;
+    eventCount: number;
+    toolCallCount: number;
+    toolFailureCount: number;
+    relatedSkillNames: string[];
+}
+export interface ConversationListItem {
+    threadId: string;
+    sourceThreadId: string;
+    sourceKind: ObservationSourceKind;
+    title: string;
+    preview?: string;
+    cwd?: string;
+    model?: string;
+    reasoningEffort?: string;
+    archived?: boolean;
+    tokensUsed?: number;
+    childThreadCount?: number;
+    startTimestamp?: string;
+    endTimestamp?: string;
+    durationMs?: number;
+    /** Undefined until the selected rollout has been indexed. */
+    turnCount?: number;
+    toolCallCount?: number;
+    toolFailureCount?: number;
+    relatedSkillNames: string[];
+    tasks: ConversationTaskItem[];
+}
+export interface ConversationIndexViewModel {
+    conversations: ConversationListItem[];
+    totalTurnCount: number;
+    totalToolCallCount: number;
+    totalToolFailureCount: number;
+    indexedConversationCount?: number;
+    unarchivedConversationCount?: number;
+    archivedConversationCount?: number;
+    workspaceCount?: number;
+}
+/**
+ * Source-neutral task trajectory input. Observe reports carry more review and
+ * Skill-attribution fields, but the debugger only requires this trace slice.
+ */
+export interface TaskTrajectorySession {
+    id: string;
+    threadId: string;
+    sourceThreadId: string;
+    sessionId: string;
+    sourceTrace: string;
+    sourceKind: ObservationSourceKind;
+    entrypoint?: string;
+    sourceMetadata?: TraceSourceMetadata;
+    cwd?: string;
+    startTimestamp?: string;
+    endTimestamp?: string;
+    attributedEventIds: string[];
+    turns: ExperienceTurnSummary[];
+    fullSessionTimeline: ExperienceTimelineEvent[];
+    indicators?: Pick<ExperienceReviewIndicators, 'userCorrectionCount'>;
+    sessionStory?: ExperienceSessionStory;
+}
+export interface TaskWindowScope {
+    basis: TaskWindowBasis;
+    turnId?: string;
+    normalizedEventCount: number;
+    semanticEventCount: number;
+    attributedEventCount: number;
+    matchedAttributedEventCount: number;
+    truncated: boolean;
+}
+export interface DebugKnowledgeEvidence {
+    id: string;
+    knowledgeKind: DebugKnowledgeKind;
+    accessKind: DebugKnowledgeAccessKind;
+    label: string;
+    sourceLocator?: string;
+    contentHash?: string;
+    firstSeen?: string;
+    lastSeen?: string;
+    accessCount: number;
+    evidenceRefs: ExperienceEvidenceRef[];
+}
+export interface TaskReplayStep {
+    id: string;
+    order: number;
+    stepKind: TaskReplayStepKind;
+    timestamp?: string;
+    title: string;
+    events: ExperienceTimelineEvent[];
+    toolStatus?: ToolCallStatus;
+    knowledgeEvidenceIds: string[];
+}
+export interface TaskReplayIntegrityNotice {
+    code: TaskReplayIntegrityCode;
+    count: number;
+}
+export interface KnowledgeDebuggerViewModel {
+    session: TaskTrajectorySession;
+    taskScope: TaskWindowScope;
+    summary: {
+        userGoal?: string;
+        finalResponse?: string;
+        observedStartTimestamp?: string;
+        observedEndTimestamp?: string;
+        toolCallCount: number;
+        toolFailureCount: number;
+        hasUserCorrection: boolean;
+        /** Distinct models observed inside the attributed task window, in first-seen order. */
+        observedModels: string[];
+    };
+    steps: TaskReplayStep[];
+    normalizedEvents: ExperienceTimelineEvent[];
+    sourceRecords: ObservationSourceRecordArchiveView;
+    knowledgeEvidence: DebugKnowledgeEvidence[];
+    integrity: {
+        status: 'complete' | 'partial';
+        notices: TaskReplayIntegrityNotice[];
+    };
+}
 export interface ExperienceTimelineBranch {
     id: string;
     label: string;
@@ -747,6 +963,10 @@ export interface ExperienceInvocation {
 export interface ExperienceSessionSummary {
     id: string;
     skillName: string;
+    /** Stable source-neutral identity for the root conversation/thread. */
+    threadId: string;
+    /** Runtime-native thread/run identity retained for inspection. */
+    sourceThreadId: string;
     sessionId: string;
     sourceTrace: string;
     sourceKind: ObservationSourceKind;
@@ -773,6 +993,10 @@ export interface ExperienceSessionSummary {
     relatedObservationIds: string[];
     timelineRef?: string;
     timelinePreviewEventIds?: string[];
+    /** Hydrated exact event relation derived from invocation timelineEventIds. */
+    attributedEventIds: string[];
+    /** All observable tasks in this thread, independent of Skill attribution. */
+    turns: ExperienceTurnSummary[];
     timelinePreview: ExperienceTimelineEvent[];
     fullSessionTimeline: ExperienceTimelineEvent[];
     timelineTree?: ExperienceTimelineTree;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "oh-my-knowledge",
-  "version": "0.51.2",
+  "version": "0.52.0",
   "packageManager": "yarn@4.16.0",
-  "description": "Evaluation framework for LLM knowledge inputs — prompts, RAG corpora, skills, agent workflows. Fix the model, vary the artifact. Built-in statistical rigor: bootstrap CI, Krippendorff α, length-debias, saturation curves.",
+  "description": "OMK — Observe. Measure. Know. Evidence-backed knowledge changes for AI applications.",
   "type": "module",
   "bin": {
     "omk": "dist/cli/index.js"
@@ -75,6 +75,9 @@
     "benchmark",
     "skill-evaluation",
     "knowledge-engineering",
+    "knowledge-artifacts",
+    "release-evidence",
+    "llm-observability",
     "prompt-engineering",
     "codex",
     "codex-cli",
@@ -98,9 +101,9 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.143",
     "@anthropic-ai/sdk": "^0.115.0",
     "@inquirer/prompts": "^8.4.3",
-    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "@oclif/core": "^4",
-    "@openai/codex-sdk": "0.145.0",
+    "@openai/codex-sdk": "0.146.0",
     "ajv": "^8.18.0",
     "chart.js": "^4.5.1",
     "es-module-lexer": "^2.0.0",
@@ -117,7 +120,7 @@
     "eslint": "^10.1.0",
     "husky": "^9.1.7",
     "lint-staged": "17.2.0",
-    "npm-run-all2": "^9.0.1",
+    "npm-run-all2": "^9.0.3",
     "typescript": "^6.0.2",
     "typescript-eslint": "^8.58.0",
     "vitepress": "^1.6.4",