noteconnection 1.7.0 → 1.9.0

package/dist/src/export/WorkspaceExportBundle.test.js

@@ -0,0 +1,1541 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const WorkspaceExportBundle_1 = require("./WorkspaceExportBundle");
+describe('WorkspaceExportBundle', () => {
+    test('builds deterministic slim bundles with readiness failures when projections lack indexed units', () => {
+        const bundle = (0, WorkspaceExportBundle_1.buildWorkspaceExportBundle)({
+            request: {
+                workspaceId: 'optics',
+                exportProfileId: 'mobile-slim',
+            },
+            workspace: {
+                workspaceId: 'optics',
+                corpusId: 'optics',
+                name: 'optics',
+                sourcePathPrefix: 'knowledge_base/optics',
+                languages: ['zh', 'en'],
+                exportProfileId: 'mobile-slim',
+                status: 'active',
+                createdAt: '2026-05-26T00:00:00.000Z',
+                updatedAt: '2026-05-26T00:00:00.000Z',
+            },
+            bindings: [],
+            resources: [],
+            projections: [
+                {
+                    projectionId: 'projection_1',
+                    resourceId: 'resource_1',
+                    projectionKind: 'knowledge_document',
+                    stableKey: 'knowledge_document:doc_a',
+                    status: 'active',
+                    documentId: 'doc_a',
+                    sourcePath: 'Knowledge_Base/optics/doc_a.md',
+                    workspaceId: 'optics',
+                    corpusId: 'optics',
+                    metadata: {},
+                    createdAt: '2026-05-26T00:00:00.000Z',
+                    updatedAt: '2026-05-26T00:00:00.000Z',
+                    deletedAt: null,
+                },
+            ],
+            indexSummary: {
+                totalUnits: 0,
+                totalSegments: 0,
+                states: {
+                    pending: 0,
+                    indexing: 0,
+                    indexed: 0,
+                    failed: 0,
+                    disabled: 0,
+                },
+                activeDocuments: 0,
+                activeAtomUnits: 0,
+            },
+            units: [],
+            segments: [],
+            atoms: [],
+            evidenceSpans: [],
+            relationEdges: [],
+            temporalEdges: [],
+            sessionStates: [],
+            conversationSessions: [],
+            conversationTurns: [],
+            conversationInvocations: [],
+            workflowArtifacts: [],
+            memoryEntries: [],
+            memoryAuditRecords: [],
+            generatedAt: '2026-05-26T00:00:00.000Z',
+        });
+        const secondBundle = (0, WorkspaceExportBundle_1.buildWorkspaceExportBundle)({
+            request: {
+                workspaceId: 'optics',
+                exportProfileId: 'mobile-slim',
+            },
+            workspace: bundle.workspace,
+            bindings: bundle.bindings,
+            resources: bundle.resources,
+            projections: bundle.projections,
+            indexSummary: bundle.index.summary,
+            units: bundle.index.units,
+            segments: bundle.index.segments,
+            atoms: bundle.graph.atoms,
+            evidenceSpans: bundle.graph.evidenceSpans,
+            relationEdges: bundle.graph.relationEdges,
+            temporalEdges: bundle.graph.temporalEdges,
+            sessionStates: bundle.runtime.sessionStates,
+            conversationSessions: bundle.runtime.conversationSessions,
+            conversationTurns: bundle.runtime.conversationTurns,
+            conversationInvocations: bundle.runtime.conversationInvocations,
+            workflowArtifacts: bundle.runtime.workflowArtifacts,
+            memoryEntries: bundle.memory.entries,
+            memoryAuditRecords: bundle.memory.auditRecords,
+            generatedAt: '2026-05-26T00:00:00.000Z',
+        });
+        expect(bundle.manifest.packagingMode).toBe('slim');
+        expect(bundle.readiness.ready).toBe(false);
+        expect(bundle.readiness.missingIndexedProjectionIds).toEqual(['projection_1']);
+        expect(bundle.manifest.deterministicHash).toBe(secondBundle.manifest.deterministicHash);
+    });
+    test('preserves conversation graph context in exported runtime turns', () => {
+        const bundle = (0, WorkspaceExportBundle_1.buildWorkspaceExportBundle)({
+            request: {
+                workspaceId: 'optics',
+                exportProfileId: 'mobile-slim',
+            },
+            workspace: {
+                workspaceId: 'optics',
+                corpusId: 'optics',
+                name: 'optics',
+                sourcePathPrefix: 'knowledge_base/optics',
+                languages: ['zh', 'en'],
+                exportProfileId: 'mobile-slim',
+                status: 'active',
+                createdAt: '2026-05-26T00:00:00.000Z',
+                updatedAt: '2026-05-26T00:00:00.000Z',
+            },
+            bindings: [],
+            resources: [],
+            projections: [],
+            indexSummary: {
+                totalUnits: 0,
+                totalSegments: 0,
+                states: {
+                    pending: 0,
+                    indexing: 0,
+                    indexed: 0,
+                    failed: 0,
+                    disabled: 0,
+                },
+                activeDocuments: 0,
+                activeAtomUnits: 0,
+            },
+            units: [],
+            segments: [],
+            atoms: [],
+            evidenceSpans: [],
+            relationEdges: [],
+            temporalEdges: [],
+            sessionStates: [],
+            conversationSessions: [
+                {
+                    sessionId: 'session_graph_context',
+                    userId: 'user_graph_context',
+                    workspaceId: 'optics',
+                    corpusId: 'optics',
+                    namespace: 'conversation',
+                    createdAt: '2026-05-26T00:00:00.000Z',
+                    updatedAt: '2026-05-26T00:00:00.000Z',
+                    turnIds: ['turn_graph_context_1'],
+                },
+            ],
+            conversationTurns: [
+                {
+                    turnId: 'turn_graph_context_1',
+                    invocationId: 'invocation_graph_context_1',
+                    sessionId: 'session_graph_context',
+                    userId: 'user_graph_context',
+                    createdAt: '2026-05-26T00:00:00.000Z',
+                    updatedAt: '2026-05-26T00:00:00.000Z',
+                    request: {
+                        userId: 'user_graph_context',
+                        sessionId: 'session_graph_context',
+                        message: 'compare reflection vs absorption',
+                    },
+                    response: {
+                        userId: 'user_graph_context',
+                        sessionId: 'session_graph_context',
+                        assistantMessage: 'Reflection differs from absorption.',
+                        answer: 'Reflection differs from absorption.',
+                        assistantBlocks: [],
+                        knowledgePoints: [
+                            {
+                                atomId: 'atom_reflection',
+                                atomIds: ['atom_reflection'],
+                                documentId: 'doc_reflection',
+                                sourcePath: 'Knowledge_Base/optics/reflection.md',
+                                title: 'Reflection',
+                                summary: 'Reflection redirects optical energy.',
+                                evidenceSnippet: 'Reflection redirects optical energy.',
+                                score: 0.9,
+                                citation: null,
+                                capabilities: [],
+                                relationPath: [
+                                    {
+                                        edgeId: 'edge_reflection_reference',
+                                        sourceAtomId: 'atom_reflection',
+                                        targetAtomId: 'atom_transmission',
+                                        relationKind: 'reference',
+                                        confidence: 0.8,
+                                    },
+                                ],
+                                relationPathAtomIds: ['atom_transmission'],
+                                relationKinds: ['reference'],
+                                temporalValidity: {
+                                    isValid: true,
+                                    checkedAt: '2026-05-26T00:00:00.000Z',
+                                    reasons: ['atom_active'],
+                                },
+                            },
+                        ],
+                        citations: [],
+                        recalledMemories: [],
+                        memoryActions: [],
+                        summary: {
+                            generatedAt: '2026-05-26T00:00:00.000Z',
+                            topK: 6,
+                            returnedKnowledgePoints: 1,
+                            returnedCitations: 0,
+                            recalledMemoryCount: 0,
+                            appliedMemoryCount: 0,
+                            queryEvidenceCoverageRatioPct: 0,
+                        },
+                        trace: {
+                            sessionId: 'session_graph_context',
+                            invocationId: 'invocation_graph_context_1',
+                            retrieval: {
+                                retrievalModes: ['keyword', 'graph'],
+                                asOf: '2026-05-26T00:00:00.000Z',
+                                totalActiveAtoms: 1,
+                                modeWeights: {
+                                    keyword: 0.5,
+                                    graph: 0.5,
+                                    temporal: 0,
+                                },
+                                latencyMs: 4,
+                                evidenceCoverageRatio: 0,
+                            },
+                            recalledMemoryCount: 0,
+                            appliedMemoryCount: 0,
+                            usedScope: {
+                                source: 'scoped',
+                                workspaceId: 'optics',
+                                corpusId: 'optics',
+                                documentIds: ['doc_reflection'],
+                                atomIds: ['atom_reflection'],
+                                sourcePathPrefixes: ['Knowledge_Base/optics'],
+                                languages: ['en'],
+                                matchedAtomCount: 1,
+                            },
+                            graphContext: {
+                                anchorAtomId: 'atom_reflection',
+                                anchorTitle: 'Reflection',
+                                anchorDocumentId: 'doc_reflection',
+                                supportingAtomIds: ['atom_transmission'],
+                                supportingTitles: ['Transmission'],
+                                relationKinds: ['reference'],
+                                relationSummaries: [
+                                    {
+                                        relationKind: 'reference',
+                                        edgeIds: ['edge_reflection_reference'],
+                                        sourceAtomIds: ['atom_reflection'],
+                                        targetAtomIds: ['atom_transmission'],
+                                        averageConfidence: 0.8,
+                                    },
+                                ],
+                                knowledgePointRelations: [
+                                    {
+                                        edgeId: 'edge_reflection_reference',
+                                        relationKind: 'reference',
+                                        sourceAtomId: 'atom_reflection',
+                                        sourceTitle: 'Reflection',
+                                        targetAtomId: 'atom_transmission',
+                                        targetTitle: 'Transmission',
+                                        confidence: 0.8,
+                                    },
+                                ],
+                                connectionPaths: [
+                                    {
+                                        sourceAtomId: 'atom_foundation',
+                                        sourceTitle: 'Foundation Note',
+                                        targetAtomId: 'atom_reflection',
+                                        targetTitle: 'Reflection',
+                                        pathAtomIds: ['atom_foundation', 'atom_bridge', 'atom_reflection'],
+                                        pathTitles: ['Foundation Note', 'Bridge Layer', 'Reflection'],
+                                        pathEdges: [
+                                            {
+                                                fromAtomId: 'atom_foundation',
+                                                toAtomId: 'atom_bridge',
+                                                relationKind: 'prerequisite',
+                                            },
+                                            {
+                                                fromAtomId: 'atom_bridge',
+                                                toAtomId: 'atom_reflection',
+                                                relationKind: 'reference',
+                                            },
+                                        ],
+                                        length: 2,
+                                    },
+                                ],
+                                predecessorWindow: [
+                                    {
+                                        atomId: 'atom_bridge',
+                                        title: 'Bridge Layer',
+                                        relationKind: 'prerequisite',
+                                        confidence: 0.91,
+                                    },
+                                ],
+                                successorWindow: [
+                                    {
+                                        atomId: 'atom_application',
+                                        title: 'Application Example',
+                                        relationKind: 'sequence',
+                                        confidence: 0.73,
+                                    },
+                                ],
+                                evidenceSourceRefs: [
+                                    'Knowledge_Base/optics/foundation.md:8',
+                                    'Knowledge_Base/optics/reflection.md:12',
+                                ],
+                                diagnostics: {
+                                    graphOpsAvailable: true,
+                                    usedFallback: false,
+                                    selectedAnchorReason: 'title_mention',
+                                    candidateCount: 3,
+                                    supportNodeCount: 2,
+                                    supportNodeLimit: 3,
+                                    pathDepthLimit: 6,
+                                    missingConnectionPathSourceAtomIds: [],
+                                    missingPredecessorAtomIds: [],
+                                    missingSuccessorAtomIds: [],
+                                },
+                                temporalValidity: {
+                                    checkedAt: '2026-05-26T00:00:00.000Z',
+                                    allPointsValid: true,
+                                    warningReasons: [],
+                                    invalidKnowledgePointTitles: [],
+                                    edgeKinds: ['supersedes'],
+                                    details: [
+                                        {
+                                            edgeId: 'temporal_reflection_supersedes',
+                                            edgeKind: 'supersedes',
+                                            sourceAtomId: 'atom_reflection_old',
+                                            targetAtomId: 'atom_reflection',
+                                            validFrom: '2026-05-25T00:00:00.000Z',
+                                            isActive: true,
+                                        },
+                                    ],
+                                },
+                            },
+                        },
+                    },
+                },
+            ],
+            conversationInvocations: [],
+            workflowArtifacts: [],
+            memoryEntries: [],
+            memoryAuditRecords: [],
+            generatedAt: '2026-05-26T00:00:00.000Z',
+        });
+        expect(bundle.runtime.conversationTurns).toHaveLength(1);
+        expect(bundle.runtime.conversationTurns[0].response.trace.graphContext).toEqual(expect.objectContaining({
+            anchorAtomId: 'atom_reflection',
+            relationKinds: ['reference'],
+            relationSummaries: expect.arrayContaining([
+                expect.objectContaining({
+                    relationKind: 'reference',
+                    sourceAtomIds: ['atom_reflection'],
+                }),
+            ]),
+            knowledgePointRelations: expect.arrayContaining([
+                expect.objectContaining({
+                    relationKind: 'reference',
+                    sourceTitle: 'Reflection',
+                    targetTitle: 'Transmission',
+                }),
+            ]),
+            connectionPaths: expect.arrayContaining([
+                expect.objectContaining({
+                    sourceTitle: 'Foundation Note',
+                    targetTitle: 'Reflection',
+                    pathTitles: ['Foundation Note', 'Bridge Layer', 'Reflection'],
+                    length: 2,
+                }),
+            ]),
+            predecessorWindow: expect.arrayContaining([
+                expect.objectContaining({
+                    atomId: 'atom_bridge',
+                    title: 'Bridge Layer',
+                    relationKind: 'prerequisite',
+                }),
+            ]),
+            successorWindow: expect.arrayContaining([
+                expect.objectContaining({
+                    atomId: 'atom_application',
+                    title: 'Application Example',
+                    relationKind: 'sequence',
+                }),
+            ]),
+            evidenceSourceRefs: ['Knowledge_Base/optics/foundation.md:8', 'Knowledge_Base/optics/reflection.md:12'],
+            diagnostics: expect.objectContaining({
+                graphOpsAvailable: true,
+                selectedAnchorReason: 'title_mention',
+                pathDepthLimit: 6,
+            }),
+            temporalValidity: expect.objectContaining({
+                edgeKinds: ['supersedes'],
+                details: expect.arrayContaining([
+                    expect.objectContaining({
+                        edgeId: 'temporal_reflection_supersedes',
+                        edgeKind: 'supersedes',
+                        sourceAtomId: 'atom_reflection_old',
+                    }),
+                ]),
+            }),
+        }));
+    });
+    test('deep clones RAG context and sufficiency review in exported runtime turns', () => {
+        const ragContextPack = {
+            replayId: 'ragctx_0123456789abcdef',
+            query: 'what is water glass?',
+            generatedAt: '2026-05-26T00:00:00.000Z',
+            sourceBoundary: 'full_document',
+            budget: {
+                maxFragments: 8,
+                maxCharsPerFragment: 800,
+                maxTotalChars: 2400,
+            },
+            fragments: [
+                {
+                    fragmentId: 'fragment_water_glass_direct',
+                    role: 'direct_support',
+                    text: 'A water glass is a transparent drinking vessel that contains water.',
+                    atomId: 'atom_water_glass',
+                    documentId: 'doc_water_glass',
+                    sourcePath: 'Knowledge_Base/waterglass/water-glass.md',
+                    title: 'Water Glass',
+                    headingPath: ['Water Glass', 'Definition'],
+                    startLine: 3,
+                    endLine: 3,
+                    charCount: 64,
+                    tokenEstimate: 16,
+                    truncated: false,
+                    citationIds: ['evidence_water_glass'],
+                    relationEdgeIds: [],
+                    score: 0.92,
+                    sourceBoundary: 'direct_span_only',
+                },
+            ],
+            sourceDecisions: [
+                {
+                    documentId: 'doc_water_glass',
+                    sourcePath: 'Knowledge_Base/waterglass/water-glass.md',
+                    sourceBoundary: 'full_document',
+                    status: 'read',
+                    charsRead: 240,
+                    fragmentsSelected: 1,
+                },
+            ],
+            totalCharCount: 64,
+            tokenEstimate: 16,
+        };
+        const ragSufficiencyReview = {
+            reviewedAt: '2026-05-26T00:00:00.000Z',
+            status: 'sufficient',
+            score: 0.86,
+            reasons: ['answerable_from_context'],
+            deterministic: false,
+            recoveryAttempted: false,
+            llmJudgeUsed: true,
+            degradationState: 'none',
+        };
+        const ragRecovery = {
+            attempted: true,
+            strategy: 'expanded_context_pack',
+            reason: 'borderline',
+            beforeStatus: 'borderline',
+            afterStatus: 'sufficient',
+            beforeScore: 0.58,
+            afterScore: 0.86,
+            beforeReasons: ['document_augmentation_missing'],
+            afterReasons: ['answerable_from_context'],
+            beforeFragmentCount: 14,
+            afterFragmentCount: 16,
+            addedFragmentCount: 2,
+            addedRoleCounts: {
+                parent_context: 2,
+            },
+            beforeSourceDecisionStatusCounts: {
+                fragment_dropped: 3,
+            },
+            afterSourceDecisionStatusCounts: {
+                fragment_dropped: 1,
+                fragment_included: 15,
+            },
+        };
+        const ragFailureClassifications = [
+            {
+                stage: 'context_assembly',
+                code: 'context_budget_limited',
+                severity: 'warning',
+                message: 'RAG context was budget-limited before release.',
+                evidence: ['fragment_dropped'],
+            },
+        ];
+        const answerClaimCitations = [
+            {
+                claimId: 'answer_claim_1',
+                text: 'A water glass is a transparent drinking vessel.',
+                citationIds: ['evidence_water_glass'],
+                fragmentIds: ['fragment_water_glass_direct'],
+                sourcePaths: ['Knowledge_Base/waterglass/water-glass.md'],
+                supportStatus: 'supported',
+            },
+        ];
+        const bundle = (0, WorkspaceExportBundle_1.buildWorkspaceExportBundle)({
+            request: {
+                workspaceId: 'waterglass',
+                exportProfileId: 'mobile-slim',
+            },
+            workspace: {
+                workspaceId: 'waterglass',
+                corpusId: 'waterglass',
+                name: 'waterglass',
+                sourcePathPrefix: 'Knowledge_Base/waterglass',
+                languages: ['en'],
+                exportProfileId: 'mobile-slim',
+                status: 'active',
+                createdAt: '2026-05-26T00:00:00.000Z',
+                updatedAt: '2026-05-26T00:00:00.000Z',
+            },
+            bindings: [],
+            resources: [],
+            projections: [],
+            indexSummary: {
+                totalUnits: 0,
+                totalSegments: 0,
+                states: {
+                    pending: 0,
+                    indexing: 0,
+                    indexed: 0,
+                    failed: 0,
+                    disabled: 0,
+                },
+                activeDocuments: 0,
+                activeAtomUnits: 0,
+            },
+            units: [],
+            segments: [],
+            atoms: [],
+            evidenceSpans: [],
+            relationEdges: [],
+            temporalEdges: [],
+            sessionStates: [],
+            conversationSessions: [],
+            conversationTurns: [
+                {
+                    turnId: 'turn_rag_context_1',
+                    invocationId: 'invocation_rag_context_1',
+                    sessionId: 'session_rag_context',
+                    userId: 'user_rag_context',
+                    createdAt: '2026-05-26T00:00:00.000Z',
+                    updatedAt: '2026-05-26T00:00:00.000Z',
+                    request: {
+                        userId: 'user_rag_context',
+                        sessionId: 'session_rag_context',
+                        message: 'what is water glass?',
+                    },
+                    response: {
+                        userId: 'user_rag_context',
+                        sessionId: 'session_rag_context',
+                        assistantMessage: 'A water glass is a transparent drinking vessel.',
+                        answer: 'A water glass is a transparent drinking vessel.',
+                        assistantBlocks: [],
+                        knowledgePoints: [],
+                        citations: [],
+                        recalledMemories: [],
+                        memoryActions: [],
+                        summary: {
+                            generatedAt: '2026-05-26T00:00:00.000Z',
+                            topK: 6,
+                            returnedKnowledgePoints: 0,
+                            returnedCitations: 0,
+                            recalledMemoryCount: 0,
+                            appliedMemoryCount: 0,
+                            queryEvidenceCoverageRatioPct: 0,
+                        },
+                        trace: {
+                            sessionId: 'session_rag_context',
+                            invocationId: 'invocation_rag_context_1',
+                            retrieval: {
+                                retrievalModes: ['keyword'],
+                                asOf: '2026-05-26T00:00:00.000Z',
+                                totalActiveAtoms: 1,
+                                modeWeights: {
+                                    keyword: 1,
+                                    graph: 0,
+                                    temporal: 0,
+                                },
+                                latencyMs: 2,
+                                evidenceCoverageRatio: 1,
+                            },
+                            recalledMemoryCount: 0,
+                            appliedMemoryCount: 0,
+                            usedScope: {
+                                source: 'scoped',
+                                workspaceId: 'waterglass',
+                                corpusId: 'waterglass',
+                                documentIds: ['doc_water_glass'],
+                                atomIds: ['atom_water_glass'],
+                                sourcePathPrefixes: ['Knowledge_Base/waterglass'],
+                                languages: ['en'],
+                                matchedAtomCount: 1,
+                            },
+                            ragContextPack,
+                            ragSufficiencyReview,
+                            ragRecovery,
+                            ragFailureClassifications,
+                            answerClaimCitations,
+                        },
+                    },
+                },
+            ],
+            conversationInvocations: [],
+            workflowArtifacts: [],
+            memoryEntries: [],
+            memoryAuditRecords: [],
+            generatedAt: '2026-05-26T00:00:00.000Z',
+        });
+        ragContextPack.fragments[0].text = 'mutated after export';
+        ragContextPack.sourceDecisions[0].reason = 'mutated_after_export';
+        ragSufficiencyReview.reasons.push('mutated_after_export');
+        ragRecovery.addedRoleCounts.parent_context = 999;
+        ragRecovery.beforeReasons.push('mutated_after_export');
+        ragRecovery.afterReasons.push('mutated_after_export');
+        ragRecovery.beforeSourceDecisionStatusCounts.fragment_dropped = 999;
+        ragRecovery.afterSourceDecisionStatusCounts.fragment_included = 999;
+        ragFailureClassifications[0].evidence.push('mutated_after_export');
+        answerClaimCitations[0].citationIds.push('mutated_after_export');
+        answerClaimCitations[0].fragmentIds.push('mutated_after_export');
+        answerClaimCitations[0].sourcePaths.push('mutated_after_export');
+        const exportedTrace = bundle.runtime.conversationTurns[0].response.trace;
+        expect(exportedTrace.ragContextPack.replayId).toBe('ragctx_0123456789abcdef');
+        expect(exportedTrace.ragContextPack.fragments[0].text).toBe('A water glass is a transparent drinking vessel that contains water.');
+        expect(exportedTrace.ragContextPack.sourceDecisions[0].reason).toBeUndefined();
+        expect(exportedTrace.ragSufficiencyReview.reasons).toEqual(['answerable_from_context']);
+        expect(exportedTrace.ragRecovery.addedRoleCounts.parent_context).toBe(2);
+        expect(exportedTrace.ragRecovery.beforeReasons).toEqual(['document_augmentation_missing']);
+        expect(exportedTrace.ragRecovery.afterReasons).toEqual(['answerable_from_context']);
+        expect(exportedTrace.ragRecovery.beforeSourceDecisionStatusCounts.fragment_dropped).toBe(3);
+        expect(exportedTrace.ragRecovery.afterSourceDecisionStatusCounts.fragment_included).toBe(15);
+        expect(exportedTrace.ragFailureClassifications).toEqual([
+            expect.objectContaining({
+                stage: 'context_assembly',
+                code: 'context_budget_limited',
+                evidence: ['fragment_dropped'],
+            }),
+        ]);
+        expect(exportedTrace.answerClaimCitations).toEqual([
+            expect.objectContaining({
+                claimId: 'answer_claim_1',
+                citationIds: ['evidence_water_glass'],
+                fragmentIds: ['fragment_water_glass_direct'],
+                sourcePaths: ['Knowledge_Base/waterglass/water-glass.md'],
+                supportStatus: 'supported',
+            }),
+        ]);
+    });
+    test('adds durable knowledge-run graph reports to the exported runtime surface', () => {
+        const bundle = (0, WorkspaceExportBundle_1.buildWorkspaceExportBundle)({
+            request: {
+                workspaceId: 'optics',
+                exportProfileId: 'mobile-slim',
+            },
+            workspace: {
+                workspaceId: 'optics',
+                corpusId: 'optics',
+                name: 'optics',
+                sourcePathPrefix: 'knowledge_base/optics',
+                languages: ['zh', 'en'],
+                exportProfileId: 'mobile-slim',
+                status: 'active',
+                createdAt: '2026-05-26T00:00:00.000Z',
+                updatedAt: '2026-05-26T00:00:00.000Z',
+            },
+            bindings: [],
+            resources: [],
+            projections: [],
+            indexSummary: {
+                totalUnits: 0,
+                totalSegments: 0,
+                states: {
+                    pending: 0,
+                    indexing: 0,
+                    indexed: 0,
+                    failed: 0,
+                    disabled: 0,
+                },
+                activeDocuments: 0,
+                activeAtomUnits: 0,
+            },
+            units: [],
+            segments: [],
+            atoms: [],
+            evidenceSpans: [],
+            relationEdges: [],
+            temporalEdges: [],
+            sessionStates: [],
+            conversationSessions: [],
+            conversationTurns: [],
+            conversationInvocations: [],
+            workflowArtifacts: [
+                {
+                    artifactId: 'workflow_artifact_knowledge_run_2',
+                    kind: 'knowledge_run',
+                    sessionId: 'session_knowledge_run_2',
+                    userId: 'user_optics',
+                    workspaceId: 'optics',
+                    corpusId: 'optics',
+                    title: 'Knowledge run: Absorption',
+                    sourceResourceIds: ['resource_absorption'],
+                    sourceProjectionIds: ['projection_absorption'],
+                    summary: 'Generated 2 evidence claim(s) and 1 review card(s) with status caution.',
+                    payload: {
+                        answerReleaseReview: {
+                            reviewedAt: '2026-05-27T00:00:00.000Z',
+                            decision: 'revise',
+                            revised: true,
+                            originalAnswer: 'No scoped knowledge points matched "Absorption".',
+                            publicAnswer: 'Absorption: optical energy is attenuated inside the material.',
+                            reason: 'Draft answer had usable evidence but required contraction before public release.',
+                            failedGateIds: ['claim_grounding_alignment', 'internal_diagnostic_leakage'],
+                            leakedInternalFragments: ['No scoped knowledge points matched'],
+                            gates: [],
+                        },
+                        knowledgeRun: {
+                            runId: 'knowledge_run_2',
+                            generatedAt: '2026-05-27T00:00:00.000Z',
+                            status: 'caution',
+                            scope: {
+                                source: 'scoped',
+                                workspaceId: 'optics',
+                                corpusId: 'optics',
+                                documentIds: [],
+                                atomIds: [],
+                                sourcePathPrefixes: ['Knowledge_Base/optics'],
+                                languages: ['en'],
+                                matchedAtomCount: 2,
+                                scopeSource: 'explicit_request',
+                            },
+                            quality: {
+                                score: 72,
+                                status: 'caution',
+                                gates: [],
+                            },
+                            summary: {
+                                claimCount: 2,
+                                weakClaimCount: 1,
+                                reviewCardCount: 1,
+                                completedReviewCardCount: 0,
+                                remainingReviewCardCount: 1,
+                            },
+                        },
+                        graphContext: {
+                            anchorAtomId: 'atom_absorption',
+                            anchorTitle: 'Absorption',
+                            supportingAtomIds: ['atom_attenuation'],
+                            supportingTitles: ['Attenuation coupling'],
+                            relationKinds: ['contrast'],
+                            relationSummaries: [],
+                            connectionPaths: [],
+                            predecessorWindow: [],
+                            successorWindow: [],
+                            evidenceSourceRefs: ['Knowledge_Base/optics/absorption.md:18'],
+                            diagnostics: {
+                                graphOpsAvailable: false,
+                                usedFallback: true,
+                                selectedAnchorReason: 'retrieval_score',
+                                candidateCount: 2,
+                                supportNodeCount: 1,
+                                supportNodeLimit: 2,
+                                pathDepthLimit: 6,
+                                missingConnectionPathSourceAtomIds: ['atom_attenuation'],
+                                missingPredecessorAtomIds: [],
+                                missingSuccessorAtomIds: ['atom_absorption_future'],
+                            },
+                            temporalValidity: {
+                                checkedAt: '2026-05-27T00:00:00.000Z',
+                                allPointsValid: false,
+                                warningReasons: ['temporal_edge_expired'],
+                                invalidKnowledgePointTitles: ['Attenuation coupling'],
+                            },
+                        },
+                    },
+                    status: 'active',
+                    createdAt: '2026-05-27T00:00:00.000Z',
+                    updatedAt: '2026-05-27T00:00:00.000Z',
+                },
+                {
+                    artifactId: 'workflow_artifact_knowledge_run_1',
+                    kind: 'knowledge_run',
+                    sessionId: 'session_knowledge_run_1',
+                    userId: 'user_optics',
+                    workspaceId: 'optics',
+                    corpusId: 'optics',
+                    title: 'Knowledge run: Reflection',
+                    sourceResourceIds: ['resource_reflection'],
+                    sourceProjectionIds: ['projection_reflection'],
+                    summary: 'Generated 1 evidence claim(s) and 1 review card(s) with status pass.',
+                    payload: {
+                        knowledgeRun: {
+                            runId: 'knowledge_run_1',
+                            generatedAt: '2026-05-28T00:00:00.000Z',
+                            status: 'pass',
+                            scope: {
+                                source: 'scoped',
+                                workspaceId: 'optics',
+                                corpusId: 'optics',
+                                documentIds: [],
+                                atomIds: [],
+                                sourcePathPrefixes: ['Knowledge_Base/optics'],
+                                languages: ['en'],
+                                matchedAtomCount: 1,
+                                scopeSource: 'explicit_request',
+                            },
+                            quality: {
+                                score: 100,
+                                status: 'pass',
+                                gates: [],
+                            },
+                            summary: {
+                                claimCount: 1,
+                                weakClaimCount: 0,
+                                reviewCardCount: 1,
+                                completedReviewCardCount: 0,
+                                remainingReviewCardCount: 1,
+                            },
+                            answerReleaseReview: {
+                                reviewedAt: '2026-05-28T00:00:00.000Z',
+                                decision: 'release',
+                                revised: false,
+                                originalAnswer: 'Reflection redirects optical energy.',
+                                publicAnswer: 'Reflection redirects optical energy.',
+                                reason: 'Draft answer satisfied the public-release gates.',
+                                failedGateIds: [],
+                                leakedInternalFragments: [],
+                                gates: [],
+                            },
+                            graphAnswerPlan: {
+                                intent: 'definition',
+                                depth: 'standard',
+                                anchorAtomId: 'atom_reflection',
+                                leadClaimId: 'claim_reflection',
+                                requiredRoles: ['definition', 'mechanism'],
+                                omittedCandidates: [],
+                                answerTaskPlan: {
+                                    schemaVersion: '1',
+                                    primarySubject: 'Reflection',
+                                    requestedDepth: 'standard',
+                                    subtasks: [
+                                        { subtaskId: 'definition', kind: 'definition', subject: 'Reflection', required: true, expectedOutput: 'direct_answer' },
+                                        { subtaskId: 'learning_route', kind: 'learning_route', subject: 'Reflection', required: true, expectedOutput: 'ordered_nodes' },
+                                    ],
+                                    learningRoute: [
+                                        { nodeId: 'atom_foundation', title: 'Foundation', role: 'prerequisite', order: 1, orderingBasis: 'explicit_prerequisite', evidenceRefs: ['edge_1'], reason: 'foundation' },
+                                        { nodeId: 'atom_reflection', title: 'Reflection', role: 'core', order: 2, orderingBasis: 'explicit_prerequisite', evidenceRefs: ['claim_reflection'], reason: 'core' },
+                                        { nodeId: 'atom_measurement', title: 'Measurement', role: 'application', order: 3, orderingBasis: 'source_order', evidenceRefs: ['claim_measurement'], reason: 'application' },
+                                    ],
+                                },
+                                claims: [
+                                    { claimId: 'claim_reflection', required: true },
+                                    { claimId: 'claim_mechanism', required: true },
+                                ],
+                            },
+                            graphAnswerCoverage: {
+                                passed: true,
+                                applicable: true,
+                                requiredClaimIds: ['claim_reflection', 'claim_mechanism'],
+                                coveredClaimIds: ['claim_reflection', 'claim_mechanism'],
+                                missingRequiredClaimIds: [],
+                                coverageScore: 1,
+                            },
+                            answerTaskCoverage: {
+                                passed: true,
+                                applicable: true,
+                                coveredSubtaskIds: ['definition', 'learning_route'],
+                                missingRequiredSubtaskIds: [],
+                                subtaskCoverage: [],
+                                learningRouteNodeCount: 3,
+                                coverageScore: 1,
+                            },
+                        },
+                        graphContext: {
+                            anchorAtomId: 'atom_reflection',
+                            anchorTitle: 'Reflection',
+                            supportingAtomIds: ['atom_foundation'],
+                            supportingTitles: ['Foundation Note'],
+                            relationKinds: ['prerequisite'],
+                            relationSummaries: [],
+                            connectionPaths: [
+                                {
+                                    sourceAtomId: 'atom_foundation',
+                                    sourceTitle: 'Foundation Note',
+                                    targetAtomId: 'atom_reflection',
+                                    targetTitle: 'Reflection',
+                                    pathAtomIds: ['atom_foundation', 'atom_reflection'],
+                                    pathTitles: ['Foundation Note', 'Reflection'],
+                                    pathEdges: [],
+                                    length: 1,
+                                },
+                            ],
+                            predecessorWindow: [
+                                {
+                                    atomId: 'atom_foundation',
+                                    title: 'Foundation Note',
+                                    relationKind: 'prerequisite',
+                                    confidence: 0.91,
+                                },
+                            ],
+                            successorWindow: [],
+                            evidenceSourceRefs: ['Knowledge_Base/optics/reflection.md:12'],
+                            diagnostics: {
+                                graphOpsAvailable: true,
+                                usedFallback: false,
+                                selectedAnchorReason: 'title_mention',
+                                candidateCount: 1,
+                                supportNodeCount: 1,
+                                supportNodeLimit: 2,
+                                pathDepthLimit: 6,
+                                missingConnectionPathSourceAtomIds: [],
+                                missingPredecessorAtomIds: [],
+                                missingSuccessorAtomIds: [],
+                            },
+                            temporalValidity: {
+                                checkedAt: '2026-05-28T00:00:00.000Z',
+                                allPointsValid: true,
+                                warningReasons: [],
+                                invalidKnowledgePointTitles: [],
+                            },
+                        },
+                    },
+                    status: 'active',
+                    createdAt: '2026-05-28T00:00:00.000Z',
+                    updatedAt: '2026-05-28T00:00:00.000Z',
+                },
+            ],
+            memoryEntries: [],
+            memoryAuditRecords: [],
+            generatedAt: '2026-05-28T00:00:00.000Z',
+        });
+        expect(bundle.runtime.knowledgeRunReports).toEqual([
+            expect.objectContaining({
+                artifactId: 'workflow_artifact_knowledge_run_1',
+                runId: 'knowledge_run_1',
+                qualityStatus: 'pass',
+                qualityScore: 100,
+                answerReleaseReview: expect.objectContaining({
+                    reviewedAt: '2026-05-28T00:00:00.000Z',
+                    decision: 'release',
+                    revised: false,
+                    failedGateIds: [],
+                    leakedInternalFragmentCount: 0,
+                    reason: 'Draft answer satisfied the public-release gates.',
+                }),
+                graphSignal: expect.objectContaining({
+                    graphOpsAvailable: true,
+                    usedFallback: false,
+                    connectionPathCount: 1,
+                    temporalWarningCount: 0,
+                    missingLookupCount: 0,
+                }),
+                graphAnswerPlan: {
+                    intent: 'definition',
+                    depth: 'standard',
+                    anchorAtomId: 'atom_reflection',
+                    claimCount: 2,
+                    requiredClaimCount: 2,
+                    requiredRoles: ['definition', 'mechanism'],
+                    coverageScore: 1,
+                    missingRequiredClaimIds: [],
+                },
+                answerTask: {
+                    primarySubject: 'Reflection',
+                    subtaskCount: 2,
+                    requiredSubtaskCount: 2,
+                    missingRequiredSubtaskIds: [],
+                    learningRouteNodeCount: 3,
+                    coverageScore: 1,
+                },
+            }),
+            expect.objectContaining({
+                artifactId: 'workflow_artifact_knowledge_run_2',
+                runId: 'knowledge_run_2',
+                qualityStatus: 'caution',
+                qualityScore: 72,
+                answerReleaseReview: expect.objectContaining({
+                    reviewedAt: '2026-05-27T00:00:00.000Z',
+                    decision: 'revise',
+                    revised: true,
+                    failedGateIds: ['claim_grounding_alignment', 'internal_diagnostic_leakage'],
+                    leakedInternalFragmentCount: 1,
+                    reason: 'Draft answer had usable evidence but required contraction before public release.',
+                }),
+                graphSignal: expect.objectContaining({
+                    graphOpsAvailable: false,
+                    usedFallback: true,
+                    connectionPathCount: 0,
+                    temporalWarningCount: 1,
+                    missingLookupCount: 2,
+                }),
+            }),
+        ]);
+        expect(bundle.runtime.knowledgeRunAnswerReleaseAuditSummary).toEqual({
+            totalRuns: 2,
+            reviewedRunCount: 2,
+            unreviewedRunCount: 0,
+            decisionCounts: {
+                release: 1,
+                revise: 1,
+                abstain: 0,
+                other: 0,
+            },
+            revisedRunCount: 1,
+            runsWithFailedGates: 1,
+            runsWithLeakedInternalFragments: 1,
+            leakedInternalFragmentTotalCount: 1,
+            failedGateCounts: [
+                {
+                    gateId: 'claim_grounding_alignment',
+                    count: 1,
+                },
+                {
+                    gateId: 'internal_diagnostic_leakage',
+                    count: 1,
+                },
+            ],
+            latestReviewedAt: '2026-05-28T00:00:00.000Z',
+            reviewTrend: {
+                windowSize: 4,
+                recentWindow: {
+                    reviewedRunCount: 2,
+                    decisionCounts: {
+                        release: 1,
+                        revise: 1,
+                        abstain: 0,
+                        other: 0,
+                    },
+                    revisedRunCount: 1,
+                    runsWithFailedGates: 1,
+                    runsWithLeakedInternalFragments: 1,
+                    latestReviewedAt: '2026-05-28T00:00:00.000Z',
+                    earliestReviewedAt: '2026-05-27T00:00:00.000Z',
+                },
+                priorWindow: {
+                    reviewedRunCount: 0,
+                    decisionCounts: {
+                        release: 0,
+                        revise: 0,
+                        abstain: 0,
+                        other: 0,
+                    },
+                    revisedRunCount: 0,
+                    runsWithFailedGates: 0,
+                    runsWithLeakedInternalFragments: 0,
+                    latestReviewedAt: '',
+                    earliestReviewedAt: '',
+                },
+            },
+            failedGateAging: [
+                {
+                    gateId: 'claim_grounding_alignment',
+                    failureCount: 1,
+                    latestReviewedAt: '2026-05-27T00:00:00.000Z',
+                    oldestReviewedAt: '2026-05-27T00:00:00.000Z',
+                    reviewedRunsSinceLastFailure: 1,
+                    occurrencesInRecentWindow: 1,
+                },
+                {
+                    gateId: 'internal_diagnostic_leakage',
+                    failureCount: 1,
+                    latestReviewedAt: '2026-05-27T00:00:00.000Z',
+                    oldestReviewedAt: '2026-05-27T00:00:00.000Z',
+                    reviewedRunsSinceLastFailure: 1,
+                    occurrencesInRecentWindow: 1,
+                },
+            ],
+            comparison: {
+                metricShifts: [
+                    {
+                        metricId: 'reviewed_runs',
+                        recentValue: 2,
+                        priorValue: 0,
+                        delta: 2,
+                    },
+                    {
+                        metricId: 'release_decisions',
+                        recentValue: 1,
+                        priorValue: 0,
+                        delta: 1,
+                    },
+                    {
+                        metricId: 'revise_decisions',
+                        recentValue: 1,
+                        priorValue: 0,
+                        delta: 1,
+                    },
+                    {
+                        metricId: 'abstain_decisions',
+                        recentValue: 0,
+                        priorValue: 0,
+                        delta: 0,
+                    },
+                    {
+                        metricId: 'other_decisions',
+                        recentValue: 0,
+                        priorValue: 0,
+                        delta: 0,
+                    },
+                    {
+                        metricId: 'revised_runs',
+                        recentValue: 1,
+                        priorValue: 0,
+                        delta: 1,
+                    },
+                    {
+                        metricId: 'failed_gate_runs',
+                        recentValue: 1,
+                        priorValue: 0,
+                        delta: 1,
+                    },
+                    {
+                        metricId: 'leaked_runs',
+                        recentValue: 1,
+                        priorValue: 0,
+                        delta: 1,
+                    },
+                ],
+                gateShifts: [
+                    {
+                        gateId: 'claim_grounding_alignment',
+                        recentWindowCount: 1,
+                        priorWindowCount: 0,
+                        delta: 1,
+                        failureCount: 1,
+                        latestReviewedAt: '2026-05-27T00:00:00.000Z',
+                        reviewedRunsSinceLastFailure: 1,
+                    },
+                    {
+                        gateId: 'internal_diagnostic_leakage',
+                        recentWindowCount: 1,
+                        priorWindowCount: 0,
+                        delta: 1,
+                        failureCount: 1,
+                        latestReviewedAt: '2026-05-27T00:00:00.000Z',
+                        reviewedRunsSinceLastFailure: 1,
+                    },
+                ],
+                latestPair: {
+                    latestRunId: 'knowledge_run_1',
+                    previousRunId: 'knowledge_run_2',
+                    latestReviewedAt: '2026-05-28T00:00:00.000Z',
+                    previousReviewedAt: '2026-05-27T00:00:00.000Z',
+                    latestDecision: 'release',
+                    previousDecision: 'revise',
+                    decisionChanged: true,
+                    latestRevised: false,
+                    previousRevised: true,
+                    revisedChanged: true,
+                    latestLeakedInternalFragmentCount: 0,
+                    previousLeakedInternalFragmentCount: 1,
+                    leakedInternalFragmentDelta: -1,
+                    newlyFailedGateIds: [],
+                    resolvedFailedGateIds: ['claim_grounding_alignment', 'internal_diagnostic_leakage'],
+                    persistentFailedGateIds: [],
+                },
+            },
+        });
+    });
+    test('keeps knowledge-run export reports backward-compatible when answer release review is absent', () => {
+        const bundle = (0, WorkspaceExportBundle_1.buildWorkspaceExportBundle)({
+            request: {
+                workspaceId: 'optics',
+                exportProfileId: 'mobile-slim',
+            },
+            workspace: {
+                workspaceId: 'optics',
+                corpusId: 'optics',
+                name: 'optics',
+                sourcePathPrefix: 'knowledge_base/optics',
+                languages: ['zh', 'en'],
+                exportProfileId: 'mobile-slim',
+                status: 'active',
+                createdAt: '2026-05-28T00:00:00.000Z',
+                updatedAt: '2026-05-28T00:00:00.000Z',
+            },
+            bindings: [],
+            resources: [],
+            projections: [],
+            indexSummary: {
+                totalUnits: 0,
+                totalSegments: 0,
+                states: {
+                    pending: 0,
+                    indexing: 0,
+                    indexed: 0,
+                    failed: 0,
+                    disabled: 0,
+                },
+                activeDocuments: 0,
+                activeAtomUnits: 0,
+            },
+            units: [],
+            segments: [],
+            atoms: [],
+            evidenceSpans: [],
+            relationEdges: [],
+            temporalEdges: [],
+            sessionStates: [],
+            conversationSessions: [],
+            conversationTurns: [],
+            conversationInvocations: [],
+            workflowArtifacts: [
+                {
+                    artifactId: 'workflow_artifact_knowledge_run_without_review',
+                    kind: 'knowledge_run',
+                    sessionId: 'session_knowledge_run_without_review',
+                    userId: 'user_optics',
+                    workspaceId: 'optics',
+                    corpusId: 'optics',
+                    title: 'Knowledge run: No review',
+                    sourceResourceIds: [],
+                    sourceProjectionIds: [],
+                    summary: 'Generated 1 evidence claim(s) with legacy payload shape.',
+                    payload: {
+                        knowledgeRun: {
+                            runId: 'knowledge_run_without_review',
+                            generatedAt: '2026-05-28T00:00:00.000Z',
+                            status: 'pass',
+                            scope: {
+                                source: 'scoped',
+                                workspaceId: 'optics',
+                                corpusId: 'optics',
+                                documentIds: [],
+                                atomIds: [],
+                                sourcePathPrefixes: ['Knowledge_Base/optics'],
+                                languages: ['en'],
+                                matchedAtomCount: 1,
+                                scopeSource: 'explicit_request',
+                            },
+                            quality: {
+                                score: 90,
+                                status: 'pass',
+                                gates: [],
+                            },
+                            summary: {
+                                claimCount: 1,
+                                weakClaimCount: 0,
+                                reviewCardCount: 0,
+                                completedReviewCardCount: 0,
+                                remainingReviewCardCount: 0,
+                            },
+                        },
+                        graphContext: {
+                            diagnostics: {
+                                graphOpsAvailable: true,
+                                usedFallback: false,
+                                selectedAnchorReason: 'title_mention',
+                                supportNodeCount: 0,
+                                supportNodeLimit: 0,
+                                pathDepthLimit: 0,
+                                missingConnectionPathSourceAtomIds: [],
+                                missingPredecessorAtomIds: [],
+                                missingSuccessorAtomIds: [],
+                            },
+                            temporalValidity: {
+                                checkedAt: '2026-05-28T00:00:00.000Z',
+                                allPointsValid: true,
+                                warningReasons: [],
+                                invalidKnowledgePointTitles: [],
+                            },
+                        },
+                    },
+                    status: 'active',
+                    createdAt: '2026-05-28T00:00:00.000Z',
+                    updatedAt: '2026-05-28T00:00:00.000Z',
+                },
+            ],
+            memoryEntries: [],
+            memoryAuditRecords: [],
+            generatedAt: '2026-05-28T00:00:00.000Z',
+        });
+        expect(bundle.runtime.knowledgeRunReports).toHaveLength(1);
+        expect(bundle.runtime.knowledgeRunReports[0]).toEqual(expect.objectContaining({
+            artifactId: 'workflow_artifact_knowledge_run_without_review',
+            runId: 'knowledge_run_without_review',
+            qualityStatus: 'pass',
+            qualityScore: 90,
+        }));
+        expect(Object.prototype.hasOwnProperty.call(bundle.runtime.knowledgeRunReports[0], 'answerReleaseReview')).toBe(false);
+        expect(bundle.runtime.knowledgeRunAnswerReleaseAuditSummary).toEqual({
+            totalRuns: 1,
+            reviewedRunCount: 0,
+            unreviewedRunCount: 1,
+            decisionCounts: {
+                release: 0,
+                revise: 0,
+                abstain: 0,
+                other: 0,
+            },
+            revisedRunCount: 0,
+            runsWithFailedGates: 0,
+            runsWithLeakedInternalFragments: 0,
+            leakedInternalFragmentTotalCount: 0,
+            failedGateCounts: [],
+            latestReviewedAt: '',
+            reviewTrend: {
+                windowSize: 4,
+                recentWindow: {
+                    reviewedRunCount: 0,
+                    decisionCounts: {
+                        release: 0,
+                        revise: 0,
+                        abstain: 0,
+                        other: 0,
+                    },
+                    revisedRunCount: 0,
+                    runsWithFailedGates: 0,
+                    runsWithLeakedInternalFragments: 0,
+                    latestReviewedAt: '',
+                    earliestReviewedAt: '',
+                },
+                priorWindow: {
+                    reviewedRunCount: 0,
+                    decisionCounts: {
+                        release: 0,
+                        revise: 0,
+                        abstain: 0,
+                        other: 0,
+                    },
+                    revisedRunCount: 0,
+                    runsWithFailedGates: 0,
+                    runsWithLeakedInternalFragments: 0,
+                    latestReviewedAt: '',
+                    earliestReviewedAt: '',
+                },
+            },
+            failedGateAging: [],
+            comparison: {
+                metricShifts: [
+                    {
+                        metricId: 'reviewed_runs',
+                        recentValue: 0,
+                        priorValue: 0,
+                        delta: 0,
+                    },
+                    {
+                        metricId: 'release_decisions',
+                        recentValue: 0,
+                        priorValue: 0,
+                        delta: 0,
+                    },
+                    {
+                        metricId: 'revise_decisions',
+                        recentValue: 0,
+                        priorValue: 0,
+                        delta: 0,
+                    },
+                    {
+                        metricId: 'abstain_decisions',
+                        recentValue: 0,
+                        priorValue: 0,
+                        delta: 0,
+                    },
+                    {
+                        metricId: 'other_decisions',
+                        recentValue: 0,
+                        priorValue: 0,
+                        delta: 0,
+                    },
+                    {
+                        metricId: 'revised_runs',
+                        recentValue: 0,
+                        priorValue: 0,
+                        delta: 0,
+                    },
+                    {
+                        metricId: 'failed_gate_runs',
+                        recentValue: 0,
+                        priorValue: 0,
+                        delta: 0,
+                    },
+                    {
+                        metricId: 'leaked_runs',
+                        recentValue: 0,
+                        priorValue: 0,
+                        delta: 0,
+                    },
+                ],
+                gateShifts: [],
+                latestPair: null,
+            },
+        });
+    });
+    test('derives graph-focus reports from session-state panel diagnostics', () => {
+        const bundle = (0, WorkspaceExportBundle_1.buildWorkspaceExportBundle)({
+            request: {
+                workspaceId: 'optics',
+                exportProfileId: 'mobile-slim',
+            },
+            workspace: {
+                workspaceId: 'optics',
+                corpusId: 'optics',
+                name: 'optics',
+                sourcePathPrefix: 'knowledge_base/optics',
+                languages: ['zh', 'en'],
+                exportProfileId: 'mobile-slim',
+                status: 'active',
+                createdAt: '2026-05-28T00:00:00.000Z',
+                updatedAt: '2026-05-28T00:00:00.000Z',
+            },
+            bindings: [],
+            resources: [],
+            projections: [],
+            indexSummary: {
+                totalUnits: 0,
+                totalSegments: 0,
+                states: {
+                    pending: 0,
+                    indexing: 0,
+                    indexed: 0,
+                    failed: 0,
+                    disabled: 0,
+                },
+                activeDocuments: 0,
+                activeAtomUnits: 0,
+            },
+            units: [],
+            segments: [],
+            atoms: [],
+            evidenceSpans: [],
+            relationEdges: [],
+            temporalEdges: [],
+            sessionStates: [
+                {
+                    sessionStateId: 'session_state_1',
+                    sessionId: 'session_optics_1',
+                    userId: 'user_optics',
+                    workspaceId: 'optics',
+                    corpusId: 'optics',
+                    mode: 'grounded_conversation',
+                    activeResourceIds: [],
+                    activeProjectionIds: [],
+                    retrievalSettings: {
+                        topK: 6,
+                        queryBackend: 'local_hybrid',
+                        persistMemory: true,
+                    },
+                    memorySettings: {
+                        namespace: 'conversation',
+                        enabled: true,
+                    },
+                    exportProfileId: 'mobile-slim',
+                    panelState: {
+                        graphFocusReports: [
+                            {
+                                recordedAt: '2026-05-28T00:00:00.000Z',
+                                title: 'Blocks Citation',
+                                requestedSourcePath: 'Knowledge_Base/optics/old.md',
+                                resolvedSourcePath: 'Knowledge_Base/optics/blocks.md',
+                                candidateSourcePaths: [
+                                    'Knowledge_Base/optics/old.md',
+                                    'Knowledge_Base/optics/blocks.md',
+                                ],
+                                attemptedSourcePaths: [
+                                    'Knowledge_Base/optics/old.md',
+                                    'Knowledge_Base/optics/blocks.md',
+                                ],
+                                fallbackSourcePathUsed: true,
+                                matchedSpanCount: 1,
+                                highlightTermCount: 1,
+                                highlightedNodeCount: 1,
+                                markdownRuntimeAvailable: true,
+                                storageProviderAvailable: true,
+                                readSucceeded: true,
+                                renderSucceeded: true,
+                                usedFallback: false,
+                                failureReason: '',
+                            },
+                            {
+                                recordedAt: '2026-05-28T00:05:00.000Z',
+                                title: 'Missing Runtime',
+                                requestedSourcePath: 'Knowledge_Base/optics/missing.md',
+                                resolvedSourcePath: '',
+                                candidateSourcePaths: ['Knowledge_Base/optics/missing.md'],
+                                attemptedSourcePaths: [],
+                                fallbackSourcePathUsed: false,
+                                matchedSpanCount: 1,
+                                highlightTermCount: 1,
+                                highlightedNodeCount: 0,
+                                markdownRuntimeAvailable: false,
+                                storageProviderAvailable: false,
+                                readSucceeded: false,
+                                renderSucceeded: false,
+                                usedFallback: true,
+                                failureReason: 'missing_markdown_runtime',
+                            },
+                        ],
+                    },
+                    createdAt: '2026-05-28T00:00:00.000Z',
+                    updatedAt: '2026-05-28T00:05:00.000Z',
+                },
+            ],
+            conversationSessions: [],
+            conversationTurns: [],
+            conversationInvocations: [],
+            workflowArtifacts: [],
+            memoryEntries: [],
+            memoryAuditRecords: [],
+            generatedAt: '2026-05-28T00:05:00.000Z',
+        });
+        expect(bundle.runtime.graphFocusReports).toEqual([
+            expect.objectContaining({
+                sessionStateId: 'session_state_1',
+                sessionId: 'session_optics_1',
+                title: 'Blocks Citation',
+                requestedSourcePath: 'Knowledge_Base/optics/old.md',
+                resolvedSourcePath: 'Knowledge_Base/optics/blocks.md',
+                signal: expect.objectContaining({
+                    usedFallback: false,
+                    fallbackSourcePathUsed: true,
+                    candidateSourcePathCount: 2,
+                    attemptedSourcePathCount: 2,
+                    renderSucceeded: true,
+                }),
+            }),
+            expect.objectContaining({
+                sessionStateId: 'session_state_1',
+                sessionId: 'session_optics_1',
+                title: 'Missing Runtime',
+                requestedSourcePath: 'Knowledge_Base/optics/missing.md',
+                resolvedSourcePath: '',
+                signal: expect.objectContaining({
+                    usedFallback: true,
+                    fallbackSourcePathUsed: false,
+                    candidateSourcePathCount: 1,
+                    attemptedSourcePathCount: 0,
+                    renderSucceeded: false,
+                    failureReason: 'missing_markdown_runtime',
+                }),
+            }),
+        ]);
+    });
+});