noteconnection 1.7.0 → 1.8.0

package/dist/src/export/WorkspaceExportBundle.js

@@ -0,0 +1,1130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildWorkspaceExportBundle = buildWorkspaceExportBundle;
+const crypto_1 = require("crypto");
+const PlatformCapabilities_1 = require("../platform/PlatformCapabilities");
+const RenderMaterializer_1 = require("../platform/RenderMaterializer");
+function compareStrings(left, right) {
+    return String(left || '').localeCompare(String(right || ''));
+}
+function cloneJsonRecord(value) {
+    return { ...value };
+}
+function cloneRagContextPack(pack) {
+    if (!pack) {
+        return undefined;
+    }
+    return {
+        ...pack,
+        budget: { ...pack.budget },
+        fragments: pack.fragments.map((fragment) => ({
+            ...fragment,
+            headingPath: [...fragment.headingPath],
+            citationIds: [...fragment.citationIds],
+            relationEdgeIds: Array.isArray(fragment.relationEdgeIds)
+                ? [...fragment.relationEdgeIds]
+                : fragment.relationEdgeIds,
+        })),
+        sourceDecisions: pack.sourceDecisions.map((decision) => ({ ...decision })),
+    };
+}
+function cloneRagSufficiencyReview(review) {
+    if (!review) {
+        return undefined;
+    }
+    return {
+        ...review,
+        reasons: [...review.reasons],
+    };
+}
+function cloneRagEvidenceRecoveryTrace(recovery) {
+    if (!recovery) {
+        return undefined;
+    }
+    return {
+        ...recovery,
+        addedRoleCounts: { ...recovery.addedRoleCounts },
+        beforeReasons: Array.isArray(recovery.beforeReasons)
+            ? recovery.beforeReasons.slice()
+            : recovery.beforeReasons,
+        afterReasons: Array.isArray(recovery.afterReasons)
+            ? recovery.afterReasons.slice()
+            : recovery.afterReasons,
+        beforeSourceDecisionStatusCounts: recovery.beforeSourceDecisionStatusCounts
+            ? { ...recovery.beforeSourceDecisionStatusCounts }
+            : recovery.beforeSourceDecisionStatusCounts,
+        afterSourceDecisionStatusCounts: recovery.afterSourceDecisionStatusCounts
+            ? { ...recovery.afterSourceDecisionStatusCounts }
+            : recovery.afterSourceDecisionStatusCounts,
+    };
+}
+function cloneRagFailureClassifications(classifications) {
+    if (!Array.isArray(classifications)) {
+        return undefined;
+    }
+    return classifications.map((classification) => ({
+        ...classification,
+        evidence: Array.isArray(classification.evidence)
+            ? classification.evidence.slice()
+            : [],
+    }));
+}
+function cloneAnswerClaimCitations(claims) {
+    if (!Array.isArray(claims)) {
+        return undefined;
+    }
+    return claims.map((claim) => ({
+        ...claim,
+        citationIds: Array.isArray(claim.citationIds) ? claim.citationIds.slice() : [],
+        fragmentIds: Array.isArray(claim.fragmentIds) ? claim.fragmentIds.slice() : [],
+        sourcePaths: Array.isArray(claim.sourcePaths) ? claim.sourcePaths.slice() : [],
+    }));
+}
+function sortAndCloneBindings(bindings) {
+    return bindings
+        .slice()
+        .sort((left, right) => compareStrings(left.bindingId, right.bindingId))
+        .map((binding) => ({ ...binding }));
+}
+function sortAndCloneResources(resources) {
+    return resources
+        .slice()
+        .sort((left, right) => compareStrings(left.resourceId, right.resourceId))
+        .map((resource) => ({
+        ...resource,
+        metadata: cloneJsonRecord(resource.metadata || {}),
+    }));
+}
+function sortAndCloneProjections(projections) {
+    return projections
+        .slice()
+        .sort((left, right) => compareStrings(left.projectionId, right.projectionId))
+        .map((projection) => ({
+        ...projection,
+        metadata: cloneJsonRecord(projection.metadata || {}),
+    }));
+}
+function sortAndCloneUnits(units) {
+    return units
+        .slice()
+        .sort((left, right) => compareStrings(left.unitId, right.unitId))
+        .map((unit) => ({
+        ...unit,
+        segmentIds: [...unit.segmentIds],
+    }));
+}
+function sortAndCloneSegments(segments) {
+    return segments
+        .slice()
+        .sort((left, right) => compareStrings(left.segmentId, right.segmentId))
+        .map((segment) => ({ ...segment }));
+}
+function sortAndCloneAtoms(atoms) {
+    return atoms
+        .slice()
+        .sort((left, right) => compareStrings(left.id, right.id))
+        .map((atom) => ({
+        ...atom,
+        keywords: [...atom.keywords],
+        evidenceSpanIds: [...atom.evidenceSpanIds],
+        metadata: {
+            ...atom.metadata,
+            sectionPath: [...atom.metadata.sectionPath],
+        },
+    }));
+}
+function sortAndCloneEvidenceSpans(evidenceSpans) {
+    return evidenceSpans
+        .slice()
+        .sort((left, right) => compareStrings(left.id, right.id))
+        .map((span) => ({ ...span }));
+}
+function sortAndCloneRelationEdges(relationEdges) {
+    return relationEdges
+        .slice()
+        .sort((left, right) => compareStrings(left.id, right.id))
+        .map((edge) => ({
+        ...edge,
+        evidenceSpanIds: [...edge.evidenceSpanIds],
+        temporal: { ...edge.temporal },
+    }));
+}
+function sortAndCloneTemporalEdges(temporalEdges) {
+    return temporalEdges
+        .slice()
+        .sort((left, right) => compareStrings(left.id, right.id))
+        .map((edge) => ({ ...edge }));
+}
+function sortAndCloneSessionStates(sessionStates) {
+    return sessionStates
+        .slice()
+        .sort((left, right) => compareStrings(left.sessionStateId, right.sessionStateId))
+        .map((state) => ({
+        ...state,
+        activeResourceIds: [...state.activeResourceIds],
+        activeProjectionIds: [...state.activeProjectionIds],
+        retrievalSettings: { ...state.retrievalSettings },
+        memorySettings: { ...state.memorySettings },
+        panelState: cloneJsonRecord(state.panelState || {}),
+    }));
+}
+function sortAndCloneConversationSessions(records) {
+    return records
+        .slice()
+        .sort((left, right) => compareStrings(left.sessionId, right.sessionId))
+        .map((record) => ({
+        ...record,
+        turnIds: [...record.turnIds],
+    }));
+}
+function sortAndCloneConversationTurns(records) {
+    return records
+        .slice()
+        .sort((left, right) => compareStrings(left.turnId, right.turnId))
+        .map((record) => ({
+        ...record,
+        request: { ...record.request },
+        response: {
+            ...record.response,
+            knowledgePoints: record.response.knowledgePoints.map((point) => ({
+                ...point,
+                capabilities: [...point.capabilities],
+                citation: point.citation ? { ...point.citation } : null,
+                citations: Array.isArray(point.citations)
+                    ? point.citations.map((citation) => ({ ...citation }))
+                    : point.citations,
+                matchedSpans: Array.isArray(point.matchedSpans)
+                    ? point.matchedSpans.map((span) => ({
+                        ...span,
+                        citation: span.citation ? { ...span.citation } : null,
+                    }))
+                    : point.matchedSpans,
+                relationPath: Array.isArray(point.relationPath)
+                    ? point.relationPath.map((edge) => ({ ...edge }))
+                    : point.relationPath,
+                relationPathAtomIds: Array.isArray(point.relationPathAtomIds)
+                    ? [...point.relationPathAtomIds]
+                    : point.relationPathAtomIds,
+                relationKinds: Array.isArray(point.relationKinds)
+                    ? [...point.relationKinds]
+                    : point.relationKinds,
+                temporalValidity: point.temporalValidity
+                    ? {
+                        ...point.temporalValidity,
+                        reasons: Array.isArray(point.temporalValidity.reasons)
+                            ? [...point.temporalValidity.reasons]
+                            : [],
+                        details: Array.isArray(point.temporalValidity.details)
+                            ? point.temporalValidity.details.map((detail) => ({ ...detail }))
+                            : [],
+                    }
+                    : point.temporalValidity,
+            })),
+            citations: record.response.citations.map((citation) => ({ ...citation })),
+            recalledMemories: record.response.recalledMemories.map((memory) => ({
+                ...memory,
+                tags: [...memory.tags],
+                references: [...memory.references],
+            })),
+            memoryActions: record.response.memoryActions.map((action) => ({ ...action })),
+            summary: { ...record.response.summary },
+            trace: {
+                ...record.response.trace,
+                retrieval: {
+                    ...record.response.trace.retrieval,
+                    retrievalModes: [...record.response.trace.retrieval.retrievalModes],
+                    modeWeights: { ...record.response.trace.retrieval.modeWeights },
+                    planner: record.response.trace.retrieval.planner
+                        ? {
+                            ...record.response.trace.retrieval.planner,
+                            titleLikeQueries: [...(record.response.trace.retrieval.planner.titleLikeQueries || [])],
+                            titleHitDocumentIds: [...(record.response.trace.retrieval.planner.titleHitDocumentIds || [])],
+                        }
+                        : undefined,
+                    scope: record.response.trace.retrieval.scope ? {
+                        ...record.response.trace.retrieval.scope,
+                        documentIds: [...record.response.trace.retrieval.scope.documentIds],
+                        atomIds: [...record.response.trace.retrieval.scope.atomIds],
+                        sourcePathPrefixes: [...record.response.trace.retrieval.scope.sourcePathPrefixes],
+                        languages: [...record.response.trace.retrieval.scope.languages],
+                    } : undefined,
+                },
+                usedScope: {
+                    ...record.response.trace.usedScope,
+                    documentIds: [...record.response.trace.usedScope.documentIds],
+                    atomIds: [...record.response.trace.usedScope.atomIds],
+                    sourcePathPrefixes: [...record.response.trace.usedScope.sourcePathPrefixes],
+                    languages: [...record.response.trace.usedScope.languages],
+                    readiness: record.response.trace.usedScope.readiness
+                        ? { ...record.response.trace.usedScope.readiness }
+                        : undefined,
+                    missDiagnostics: record.response.trace.usedScope.missDiagnostics
+                        ? {
+                            ...record.response.trace.usedScope.missDiagnostics,
+                            titleLikeQueries: [...(record.response.trace.usedScope.missDiagnostics.titleLikeQueries || [])],
+                            titleHitDocumentIds: [...(record.response.trace.usedScope.missDiagnostics.titleHitDocumentIds || [])],
+                        }
+                        : undefined,
+                },
+                workspaceReadiness: record.response.trace.workspaceReadiness
+                    ? { ...record.response.trace.workspaceReadiness }
+                    : undefined,
+                missDiagnostics: record.response.trace.missDiagnostics
+                    ? {
+                        ...record.response.trace.missDiagnostics,
+                        titleLikeQueries: [...(record.response.trace.missDiagnostics.titleLikeQueries || [])],
+                        titleHitDocumentIds: [...(record.response.trace.missDiagnostics.titleHitDocumentIds || [])],
+                    }
+                    : undefined,
+                planner: record.response.trace.planner
+                    ? {
+                        ...record.response.trace.planner,
+                        titleLikeQueries: [...(record.response.trace.planner.titleLikeQueries || [])],
+                        titleHitDocumentIds: [...(record.response.trace.planner.titleHitDocumentIds || [])],
+                    }
+                    : undefined,
+                graphContext: record.response.trace.graphContext
+                    ? {
+                        ...record.response.trace.graphContext,
+                        supportingAtomIds: Array.isArray(record.response.trace.graphContext.supportingAtomIds)
+                            ? [...record.response.trace.graphContext.supportingAtomIds]
+                            : [],
+                        supportingTitles: Array.isArray(record.response.trace.graphContext.supportingTitles)
+                            ? [...record.response.trace.graphContext.supportingTitles]
+                            : [],
+                        relationKinds: Array.isArray(record.response.trace.graphContext.relationKinds)
+                            ? [...record.response.trace.graphContext.relationKinds]
+                            : [],
+                        relationSummaries: Array.isArray(record.response.trace.graphContext.relationSummaries)
+                            ? record.response.trace.graphContext.relationSummaries.map((summary) => ({
+                                ...summary,
+                                edgeIds: Array.isArray(summary.edgeIds) ? [...summary.edgeIds] : [],
+                                sourceAtomIds: Array.isArray(summary.sourceAtomIds) ? [...summary.sourceAtomIds] : [],
+                                targetAtomIds: Array.isArray(summary.targetAtomIds) ? [...summary.targetAtomIds] : [],
+                            }))
+                            : [],
+                        knowledgePointRelations: Array.isArray(record.response.trace.graphContext.knowledgePointRelations)
+                            ? record.response.trace.graphContext.knowledgePointRelations.map((relation) => ({
+                                ...relation,
+                            }))
+                            : [],
+                        connectionPaths: Array.isArray(record.response.trace.graphContext.connectionPaths)
+                            ? record.response.trace.graphContext.connectionPaths.map((connectionPath) => ({
+                                ...connectionPath,
+                                pathAtomIds: Array.isArray(connectionPath.pathAtomIds) ? [...connectionPath.pathAtomIds] : [],
+                                pathTitles: Array.isArray(connectionPath.pathTitles) ? [...connectionPath.pathTitles] : [],
+                                pathEdges: Array.isArray(connectionPath.pathEdges)
+                                    ? connectionPath.pathEdges.map((edge) => ({ ...edge }))
+                                    : [],
+                            }))
+                            : [],
+                        predecessorWindow: Array.isArray(record.response.trace.graphContext.predecessorWindow)
+                            ? record.response.trace.graphContext.predecessorWindow.map((node) => ({
+                                ...node,
+                            }))
+                            : [],
+                        successorWindow: Array.isArray(record.response.trace.graphContext.successorWindow)
+                            ? record.response.trace.graphContext.successorWindow.map((node) => ({
+                                ...node,
+                            }))
+                            : [],
+                        evidenceSourceRefs: Array.isArray(record.response.trace.graphContext.evidenceSourceRefs)
+                            ? [...record.response.trace.graphContext.evidenceSourceRefs]
+                            : [],
+                        diagnostics: record.response.trace.graphContext.diagnostics
+                            ? {
+                                ...record.response.trace.graphContext.diagnostics,
+                                missingConnectionPathSourceAtomIds: Array.isArray(record.response.trace.graphContext.diagnostics.missingConnectionPathSourceAtomIds)
+                                    ? [...record.response.trace.graphContext.diagnostics.missingConnectionPathSourceAtomIds]
+                                    : [],
+                                missingPredecessorAtomIds: Array.isArray(record.response.trace.graphContext.diagnostics.missingPredecessorAtomIds)
+                                    ? [...record.response.trace.graphContext.diagnostics.missingPredecessorAtomIds]
+                                    : [],
+                                missingSuccessorAtomIds: Array.isArray(record.response.trace.graphContext.diagnostics.missingSuccessorAtomIds)
+                                    ? [...record.response.trace.graphContext.diagnostics.missingSuccessorAtomIds]
+                                    : [],
+                            }
+                            : undefined,
+                        temporalValidity: record.response.trace.graphContext.temporalValidity
+                            ? {
+                                ...record.response.trace.graphContext.temporalValidity,
+                                warningReasons: Array.isArray(record.response.trace.graphContext.temporalValidity.warningReasons)
+                                    ? [...record.response.trace.graphContext.temporalValidity.warningReasons]
+                                    : [],
+                                invalidKnowledgePointTitles: Array.isArray(record.response.trace.graphContext.temporalValidity.invalidKnowledgePointTitles)
+                                    ? [...record.response.trace.graphContext.temporalValidity.invalidKnowledgePointTitles]
+                                    : [],
+                                edgeKinds: Array.isArray(record.response.trace.graphContext.temporalValidity.edgeKinds)
+                                    ? [...record.response.trace.graphContext.temporalValidity.edgeKinds]
+                                    : [],
+                                details: Array.isArray(record.response.trace.graphContext.temporalValidity.details)
+                                    ? record.response.trace.graphContext.temporalValidity.details.map((detail) => ({ ...detail }))
+                                    : [],
+                            }
+                            : undefined,
+                    }
+                    : undefined,
+                ragContextPack: cloneRagContextPack(record.response.trace.ragContextPack),
+                ragSufficiencyReview: cloneRagSufficiencyReview(record.response.trace.ragSufficiencyReview),
+                ragRecovery: cloneRagEvidenceRecoveryTrace(record.response.trace.ragRecovery),
+                ragFailureClassifications: cloneRagFailureClassifications(record.response.trace.ragFailureClassifications),
+                answerClaimCitations: cloneAnswerClaimCitations(record.response.trace.answerClaimCitations),
+            },
+        },
+    }));
+}
+function sortAndCloneConversationInvocations(records) {
+    return records
+        .slice()
+        .sort((left, right) => compareStrings(left.invocationId, right.invocationId))
+        .map((record) => ({ ...record }));
+}
+function sortAndCloneWorkflowArtifacts(records) {
+    return records
+        .slice()
+        .sort((left, right) => compareStrings(left.artifactId, right.artifactId))
+        .map((record) => ({
+        ...record,
+        sourceResourceIds: [...record.sourceResourceIds],
+        sourceProjectionIds: [...record.sourceProjectionIds],
+        payload: cloneJsonRecord(record.payload || {}),
+    }));
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function normalizeCount(value) {
+    return Number.isFinite(Number(value)) ? Math.max(0, Math.floor(Number(value))) : 0;
+}
+function normalizeOptionalScore(value) {
+    return Number.isFinite(Number(value)) ? Number(Number(value).toFixed(2)) : null;
+}
+function normalizeBoolean(value) {
+    return value === true;
+}
+function normalizeString(value) {
+    return String(value || '').trim();
+}
+function normalizeStringArray(value) {
+    return Array.isArray(value)
+        ? value.map((entry) => normalizeString(entry)).filter(Boolean)
+        : [];
+}
+function buildAnswerReleaseReviewSummary(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const reviewedAt = normalizeString(value.reviewedAt);
+    const decision = normalizeString(value.decision).toLowerCase();
+    const revised = normalizeBoolean(value.revised);
+    const failedGateIds = normalizeStringArray(value.failedGateIds);
+    const leakedInternalFragmentCount = normalizeStringArray(value.leakedInternalFragments).length;
+    const reason = normalizeString(value.reason);
+    if (!reviewedAt
+        && !decision
+        && revised !== true
+        && failedGateIds.length <= 0
+        && leakedInternalFragmentCount <= 0
+        && !reason) {
+        return null;
+    }
+    return {
+        reviewedAt,
+        decision,
+        revised,
+        failedGateIds,
+        leakedInternalFragmentCount,
+        reason,
+    };
+}
+function buildKnowledgeRunReports(records) {
+    return records
+        .filter((record) => record.kind === 'knowledge_run')
+        .map((record) => {
+        const payload = record.payload && typeof record.payload === 'object'
+            ? record.payload
+            : {};
+        const knowledgeRun = payload.knowledgeRun && typeof payload.knowledgeRun === 'object'
+            ? payload.knowledgeRun
+            : {};
+        const runSummary = knowledgeRun.summary && typeof knowledgeRun.summary === 'object'
+            ? knowledgeRun.summary
+            : {};
+        const quality = knowledgeRun.quality && typeof knowledgeRun.quality === 'object'
+            ? knowledgeRun.quality
+            : {};
+        const scope = knowledgeRun.scope && typeof knowledgeRun.scope === 'object'
+            ? knowledgeRun.scope
+            : {};
+        const answerReleaseReview = buildAnswerReleaseReviewSummary(knowledgeRun.answerReleaseReview ?? payload.answerReleaseReview);
+        const graphContext = payload.graphContext && typeof payload.graphContext === 'object'
+            ? payload.graphContext
+            : {};
+        const diagnostics = graphContext.diagnostics && typeof graphContext.diagnostics === 'object'
+            ? graphContext.diagnostics
+            : {};
+        const temporalValidity = graphContext.temporalValidity && typeof graphContext.temporalValidity === 'object'
+            ? graphContext.temporalValidity
+            : {};
+        const connectionPathCount = Array.isArray(graphContext.connectionPaths)
+            ? graphContext.connectionPaths.filter((value) => Boolean(value && typeof value === 'object')).length
+            : 0;
+        const temporalWarningCount = Array.isArray(temporalValidity.warningReasons)
+            ? temporalValidity.warningReasons.map((value) => String(value || '').trim()).filter(Boolean).length
+            : 0;
+        const missingLookupCount = ((Array.isArray(diagnostics.missingConnectionPathSourceAtomIds)
+            ? diagnostics.missingConnectionPathSourceAtomIds.map((value) => String(value || '').trim()).filter(Boolean).length
+            : 0)
+            + (Array.isArray(diagnostics.missingPredecessorAtomIds)
+                ? diagnostics.missingPredecessorAtomIds.map((value) => String(value || '').trim()).filter(Boolean).length
+                : 0)
+            + (Array.isArray(diagnostics.missingSuccessorAtomIds)
+                ? diagnostics.missingSuccessorAtomIds.map((value) => String(value || '').trim()).filter(Boolean).length
+                : 0));
+        return {
+            artifactId: record.artifactId,
+            runId: String(knowledgeRun.runId || payload.runId || '').trim(),
+            generatedAt: String(knowledgeRun.generatedAt || record.updatedAt || record.createdAt || '').trim(),
+            artifactTitle: record.title,
+            artifactStatus: String(record.status || '').trim(),
+            workspaceId: record.workspaceId,
+            corpusId: record.corpusId,
+            qualityStatus: String(quality.status || knowledgeRun.status || '').trim(),
+            qualityScore: normalizeOptionalScore(quality.score),
+            claimCount: normalizeCount(runSummary.claimCount),
+            weakClaimCount: normalizeCount(runSummary.weakClaimCount),
+            reviewCardCount: normalizeCount(runSummary.reviewCardCount),
+            completedReviewCardCount: normalizeCount(runSummary.completedReviewCardCount),
+            remainingReviewCardCount: normalizeCount(runSummary.remainingReviewCardCount),
+            scopeSource: String(scope.scopeSource || scope.source || '').trim(),
+            graphSignal: {
+                graphOpsAvailable: diagnostics.graphOpsAvailable === true,
+                usedFallback: diagnostics.usedFallback === true,
+                selectedAnchorReason: String(diagnostics.selectedAnchorReason || '').trim(),
+                connectionPathCount,
+                temporalWarningCount,
+                supportNodeCount: normalizeCount(diagnostics.supportNodeCount),
+                supportNodeLimit: normalizeCount(diagnostics.supportNodeLimit),
+                pathDepthLimit: Number.isFinite(Number(diagnostics.pathDepthLimit))
+                    ? Math.max(0, Math.floor(Number(diagnostics.pathDepthLimit)))
+                    : null,
+                missingLookupCount,
+            },
+            ...(answerReleaseReview ? { answerReleaseReview } : {}),
+        };
+    });
+}
+function normalizeAnswerReleaseDecisionBucket(decisionLike) {
+    const normalized = normalizeString(decisionLike).toLowerCase();
+    if (normalized === 'release' || normalized === 'revise' || normalized === 'abstain') {
+        return normalized;
+    }
+    return 'other';
+}
+const ANSWER_RELEASE_AUDIT_TREND_WINDOW_SIZE = 4;
+function buildEmptyAnswerReleaseDecisionCounts() {
+    return {
+        release: 0,
+        revise: 0,
+        abstain: 0,
+        other: 0,
+    };
+}
+function buildEmptyAnswerReleaseAuditWindow() {
+    return {
+        reviewedRunCount: 0,
+        decisionCounts: buildEmptyAnswerReleaseDecisionCounts(),
+        revisedRunCount: 0,
+        runsWithFailedGates: 0,
+        runsWithLeakedInternalFragments: 0,
+        latestReviewedAt: '',
+        earliestReviewedAt: '',
+    };
+}
+function buildAnswerReleaseAuditTimelineEntries(reports) {
+    return reports
+        .flatMap((report) => {
+        const review = report && typeof report.answerReleaseReview === 'object'
+            ? report.answerReleaseReview
+            : null;
+        if (!review) {
+            return [];
+        }
+        const reviewedAt = normalizeString(review.reviewedAt);
+        const uniqueFailedGateIds = Array.from(new Set((Array.isArray(review.failedGateIds) ? review.failedGateIds : [])
+            .map((gateId) => normalizeString(gateId))
+            .filter(Boolean)));
+        const leakedInternalFragmentCount = normalizeCount(review.leakedInternalFragmentCount);
+        return [{
+                artifactId: normalizeString(report.artifactId),
+                runId: normalizeString(report.runId),
+                generatedAt: normalizeString(report.generatedAt),
+                reviewedAt,
+                sortTimestamp: reviewedAt || normalizeString(report.generatedAt),
+                review,
+                uniqueFailedGateIds,
+                leakedInternalFragmentCount,
+            }];
+    })
+        .sort((left, right) => {
+        const timestampOrder = compareStrings(right.sortTimestamp, left.sortTimestamp);
+        if (timestampOrder !== 0) {
+            return timestampOrder;
+        }
+        const reviewedAtOrder = compareStrings(right.reviewedAt, left.reviewedAt);
+        if (reviewedAtOrder !== 0) {
+            return reviewedAtOrder;
+        }
+        const generatedAtOrder = compareStrings(right.generatedAt, left.generatedAt);
+        if (generatedAtOrder !== 0) {
+            return generatedAtOrder;
+        }
+        const runIdOrder = compareStrings(left.runId, right.runId);
+        if (runIdOrder !== 0) {
+            return runIdOrder;
+        }
+        return compareStrings(left.artifactId, right.artifactId);
+    });
+}
+function buildAnswerReleaseAuditWindow(entries) {
+    if (entries.length <= 0) {
+        return buildEmptyAnswerReleaseAuditWindow();
+    }
+    const decisionCounts = buildEmptyAnswerReleaseDecisionCounts();
+    let revisedRunCount = 0;
+    let runsWithFailedGates = 0;
+    let runsWithLeakedInternalFragments = 0;
+    entries.forEach((entry) => {
+        decisionCounts[normalizeAnswerReleaseDecisionBucket(entry.review.decision)] += 1;
+        if (entry.review.revised === true) {
+            revisedRunCount += 1;
+        }
+        if (entry.uniqueFailedGateIds.length > 0) {
+            runsWithFailedGates += 1;
+        }
+        if (entry.leakedInternalFragmentCount > 0) {
+            runsWithLeakedInternalFragments += 1;
+        }
+    });
+    return {
+        reviewedRunCount: entries.length,
+        decisionCounts,
+        revisedRunCount,
+        runsWithFailedGates,
+        runsWithLeakedInternalFragments,
+        latestReviewedAt: entries[0].reviewedAt,
+        earliestReviewedAt: entries[entries.length - 1].reviewedAt,
+    };
+}
+function buildAnswerReleaseAuditTrend(entries) {
+    const recentWindowEntries = entries.slice(0, ANSWER_RELEASE_AUDIT_TREND_WINDOW_SIZE);
+    const priorWindowEntries = entries.slice(ANSWER_RELEASE_AUDIT_TREND_WINDOW_SIZE, ANSWER_RELEASE_AUDIT_TREND_WINDOW_SIZE * 2);
+    return {
+        windowSize: ANSWER_RELEASE_AUDIT_TREND_WINDOW_SIZE,
+        recentWindow: buildAnswerReleaseAuditWindow(recentWindowEntries),
+        priorWindow: buildAnswerReleaseAuditWindow(priorWindowEntries),
+    };
+}
+function buildAnswerReleaseAuditMetricShifts(recentWindow, priorWindow) {
+    const metricDefinitions = [
+        {
+            metricId: 'reviewed_runs',
+            readValue: (windowSummary) => windowSummary.reviewedRunCount,
+        },
+        {
+            metricId: 'release_decisions',
+            readValue: (windowSummary) => windowSummary.decisionCounts.release,
+        },
+        {
+            metricId: 'revise_decisions',
+            readValue: (windowSummary) => windowSummary.decisionCounts.revise,
+        },
+        {
+            metricId: 'abstain_decisions',
+            readValue: (windowSummary) => windowSummary.decisionCounts.abstain,
+        },
+        {
+            metricId: 'other_decisions',
+            readValue: (windowSummary) => windowSummary.decisionCounts.other,
+        },
+        {
+            metricId: 'revised_runs',
+            readValue: (windowSummary) => windowSummary.revisedRunCount,
+        },
+        {
+            metricId: 'failed_gate_runs',
+            readValue: (windowSummary) => windowSummary.runsWithFailedGates,
+        },
+        {
+            metricId: 'leaked_runs',
+            readValue: (windowSummary) => windowSummary.runsWithLeakedInternalFragments,
+        },
+    ];
+    return metricDefinitions.map(({ metricId, readValue }) => {
+        const recentValue = normalizeCount(readValue(recentWindow));
+        const priorValue = normalizeCount(readValue(priorWindow));
+        return {
+            metricId,
+            recentValue,
+            priorValue,
+            delta: recentValue - priorValue,
+        };
+    });
+}
+function buildAnswerReleaseAuditWindowGateCounts(entries) {
+    const gateCounts = new Map();
+    entries.forEach((entry) => {
+        entry.uniqueFailedGateIds.forEach((gateId) => {
+            gateCounts.set(gateId, (gateCounts.get(gateId) || 0) + 1);
+        });
+    });
+    return gateCounts;
+}
+function buildAnswerReleaseAuditGateAging(entries) {
+    const gateAging = new Map();
+    entries.forEach((entry, index) => {
+        if (entry.uniqueFailedGateIds.length <= 0) {
+            return;
+        }
+        entry.uniqueFailedGateIds.forEach((gateId) => {
+            const existing = gateAging.get(gateId);
+            if (!existing) {
+                gateAging.set(gateId, {
+                    gateId,
+                    failureCount: 1,
+                    latestReviewedAt: entry.reviewedAt,
+                    oldestReviewedAt: entry.reviewedAt,
+                    reviewedRunsSinceLastFailure: index,
+                    occurrencesInRecentWindow: index < ANSWER_RELEASE_AUDIT_TREND_WINDOW_SIZE ? 1 : 0,
+                });
+                return;
+            }
+            existing.failureCount += 1;
+            existing.oldestReviewedAt = entry.reviewedAt || existing.oldestReviewedAt;
+            if (index < ANSWER_RELEASE_AUDIT_TREND_WINDOW_SIZE) {
+                existing.occurrencesInRecentWindow += 1;
+            }
+        });
+    });
+    return Array.from(gateAging.values()).sort((left, right) => {
+        if (left.reviewedRunsSinceLastFailure !== right.reviewedRunsSinceLastFailure) {
+            return left.reviewedRunsSinceLastFailure - right.reviewedRunsSinceLastFailure;
+        }
+        if (left.occurrencesInRecentWindow !== right.occurrencesInRecentWindow) {
+            return right.occurrencesInRecentWindow - left.occurrencesInRecentWindow;
+        }
+        if (left.failureCount !== right.failureCount) {
+            return right.failureCount - left.failureCount;
+        }
+        const latestReviewedAtOrder = compareStrings(right.latestReviewedAt, left.latestReviewedAt);
+        if (latestReviewedAtOrder !== 0) {
+            return latestReviewedAtOrder;
+        }
+        return compareStrings(left.gateId, right.gateId);
+    });
+}
+function buildAnswerReleaseAuditGateShifts(entries) {
+    const recentWindowEntries = entries.slice(0, ANSWER_RELEASE_AUDIT_TREND_WINDOW_SIZE);
+    const priorWindowEntries = entries.slice(ANSWER_RELEASE_AUDIT_TREND_WINDOW_SIZE, ANSWER_RELEASE_AUDIT_TREND_WINDOW_SIZE * 2);
+    const recentGateCounts = buildAnswerReleaseAuditWindowGateCounts(recentWindowEntries);
+    const priorGateCounts = buildAnswerReleaseAuditWindowGateCounts(priorWindowEntries);
+    const gateAgingById = new Map(buildAnswerReleaseAuditGateAging(entries).map((entry) => [entry.gateId, entry]));
+    const gateIds = Array.from(new Set([
+        ...recentGateCounts.keys(),
+        ...priorGateCounts.keys(),
+        ...gateAgingById.keys(),
+    ]));
+    return gateIds
+        .map((gateId) => {
+        const recentWindowCount = normalizeCount(recentGateCounts.get(gateId) || 0);
+        const priorWindowCount = normalizeCount(priorGateCounts.get(gateId) || 0);
+        const gateAging = gateAgingById.get(gateId);
+        return {
+            gateId,
+            recentWindowCount,
+            priorWindowCount,
+            delta: recentWindowCount - priorWindowCount,
+            failureCount: normalizeCount(gateAging?.failureCount || 0),
+            latestReviewedAt: normalizeString(gateAging?.latestReviewedAt || ''),
+            reviewedRunsSinceLastFailure: normalizeCount(gateAging?.reviewedRunsSinceLastFailure || 0),
+        };
+    })
+        .sort((left, right) => {
+        const leftHasRecentWindowFailure = left.recentWindowCount > 0 ? 0 : 1;
+        const rightHasRecentWindowFailure = right.recentWindowCount > 0 ? 0 : 1;
+        if (leftHasRecentWindowFailure !== rightHasRecentWindowFailure) {
+            return leftHasRecentWindowFailure - rightHasRecentWindowFailure;
+        }
+        const deltaMagnitudeOrder = Math.abs(right.delta) - Math.abs(left.delta);
+        if (deltaMagnitudeOrder !== 0) {
+            return deltaMagnitudeOrder;
+        }
+        if (left.reviewedRunsSinceLastFailure !== right.reviewedRunsSinceLastFailure) {
+            return left.reviewedRunsSinceLastFailure - right.reviewedRunsSinceLastFailure;
+        }
+        if (left.failureCount !== right.failureCount) {
+            return right.failureCount - left.failureCount;
+        }
+        if (left.recentWindowCount !== right.recentWindowCount) {
+            return right.recentWindowCount - left.recentWindowCount;
+        }
+        const latestReviewedAtOrder = compareStrings(right.latestReviewedAt, left.latestReviewedAt);
+        if (latestReviewedAtOrder !== 0) {
+            return latestReviewedAtOrder;
+        }
+        return compareStrings(left.gateId, right.gateId);
+    });
+}
+function buildAnswerReleaseAuditLatestPair(entries) {
+    if (entries.length < 2) {
+        return null;
+    }
+    const latestEntry = entries[0];
+    const previousEntry = entries[1];
+    const latestFailedGateIds = new Set(latestEntry.uniqueFailedGateIds);
+    const previousFailedGateIds = new Set(previousEntry.uniqueFailedGateIds);
+    return {
+        latestRunId: normalizeString(latestEntry.runId),
+        previousRunId: normalizeString(previousEntry.runId),
+        latestReviewedAt: normalizeString(latestEntry.reviewedAt),
+        previousReviewedAt: normalizeString(previousEntry.reviewedAt),
+        latestDecision: normalizeAnswerReleaseDecisionBucket(latestEntry.review.decision),
+        previousDecision: normalizeAnswerReleaseDecisionBucket(previousEntry.review.decision),
+        decisionChanged: normalizeAnswerReleaseDecisionBucket(latestEntry.review.decision)
+            !== normalizeAnswerReleaseDecisionBucket(previousEntry.review.decision),
+        latestRevised: latestEntry.review.revised === true,
+        previousRevised: previousEntry.review.revised === true,
+        revisedChanged: (latestEntry.review.revised === true) !== (previousEntry.review.revised === true),
+        latestLeakedInternalFragmentCount: normalizeCount(latestEntry.leakedInternalFragmentCount),
+        previousLeakedInternalFragmentCount: normalizeCount(previousEntry.leakedInternalFragmentCount),
+        leakedInternalFragmentDelta: normalizeCount(latestEntry.leakedInternalFragmentCount)
+            - normalizeCount(previousEntry.leakedInternalFragmentCount),
+        newlyFailedGateIds: latestEntry.uniqueFailedGateIds.filter((gateId) => !previousFailedGateIds.has(gateId)),
+        resolvedFailedGateIds: previousEntry.uniqueFailedGateIds.filter((gateId) => !latestFailedGateIds.has(gateId)),
+        persistentFailedGateIds: latestEntry.uniqueFailedGateIds.filter((gateId) => previousFailedGateIds.has(gateId)),
+    };
+}
+function buildAnswerReleaseAuditComparison(entries) {
+    const recentWindowEntries = entries.slice(0, ANSWER_RELEASE_AUDIT_TREND_WINDOW_SIZE);
+    const priorWindowEntries = entries.slice(ANSWER_RELEASE_AUDIT_TREND_WINDOW_SIZE, ANSWER_RELEASE_AUDIT_TREND_WINDOW_SIZE * 2);
+    const recentWindow = buildAnswerReleaseAuditWindow(recentWindowEntries);
+    const priorWindow = buildAnswerReleaseAuditWindow(priorWindowEntries);
+    return {
+        metricShifts: buildAnswerReleaseAuditMetricShifts(recentWindow, priorWindow),
+        gateShifts: buildAnswerReleaseAuditGateShifts(entries),
+        latestPair: buildAnswerReleaseAuditLatestPair(entries),
+    };
+}
+function buildKnowledgeRunAnswerReleaseAuditSummary(reports) {
+    const decisionCounts = buildEmptyAnswerReleaseDecisionCounts();
+    const failedGateCounts = new Map();
+    let reviewedRunCount = 0;
+    let revisedRunCount = 0;
+    let runsWithFailedGates = 0;
+    let runsWithLeakedInternalFragments = 0;
+    let leakedInternalFragmentTotalCount = 0;
+    let latestReviewedAt = '';
+    const timelineEntries = buildAnswerReleaseAuditTimelineEntries(reports);
+    reports.forEach((report) => {
+        const review = report && typeof report.answerReleaseReview === 'object'
+            ? report.answerReleaseReview
+            : null;
+        if (!review) {
+            return;
+        }
+        reviewedRunCount += 1;
+        decisionCounts[normalizeAnswerReleaseDecisionBucket(review.decision)] += 1;
+        if (review.revised === true) {
+            revisedRunCount += 1;
+        }
+        const uniqueFailedGateIds = Array.from(new Set((Array.isArray(review.failedGateIds) ? review.failedGateIds : [])
+            .map((gateId) => normalizeString(gateId))
+            .filter(Boolean)));
+        if (uniqueFailedGateIds.length > 0) {
+            runsWithFailedGates += 1;
+            uniqueFailedGateIds.forEach((gateId) => {
+                failedGateCounts.set(gateId, (failedGateCounts.get(gateId) || 0) + 1);
+            });
+        }
+        const leakedInternalFragmentCount = normalizeCount(review.leakedInternalFragmentCount);
+        if (leakedInternalFragmentCount > 0) {
+            runsWithLeakedInternalFragments += 1;
+            leakedInternalFragmentTotalCount += leakedInternalFragmentCount;
+        }
+        const reviewedAt = normalizeString(review.reviewedAt);
+        if (reviewedAt && (!latestReviewedAt || compareStrings(reviewedAt, latestReviewedAt) > 0)) {
+            latestReviewedAt = reviewedAt;
+        }
+    });
+    return {
+        totalRuns: reports.length,
+        reviewedRunCount,
+        unreviewedRunCount: Math.max(0, reports.length - reviewedRunCount),
+        decisionCounts,
+        revisedRunCount,
+        runsWithFailedGates,
+        runsWithLeakedInternalFragments,
+        leakedInternalFragmentTotalCount,
+        failedGateCounts: Array.from(failedGateCounts.entries())
+            .map(([gateId, count]) => ({
+            gateId,
+            count,
+        }))
+            .sort((left, right) => {
+            if (left.count !== right.count) {
+                return right.count - left.count;
+            }
+            return compareStrings(left.gateId, right.gateId);
+        }),
+        latestReviewedAt,
+        reviewTrend: buildAnswerReleaseAuditTrend(timelineEntries),
+        failedGateAging: buildAnswerReleaseAuditGateAging(timelineEntries),
+        comparison: buildAnswerReleaseAuditComparison(timelineEntries),
+    };
+}
+function buildGraphFocusReports(sessionStates) {
+    return sessionStates
+        .flatMap((state) => {
+        const panelState = isRecord(state.panelState) ? state.panelState : {};
+        const reports = Array.isArray(panelState.graphFocusReports)
+            ? panelState.graphFocusReports.filter((entry) => isRecord(entry))
+            : [];
+        return reports.map((entry) => {
+            const candidateSourcePaths = normalizeStringArray(entry.candidateSourcePaths);
+            const attemptedSourcePaths = normalizeStringArray(entry.attemptedSourcePaths);
+            return {
+                sessionStateId: state.sessionStateId,
+                sessionId: state.sessionId,
+                userId: state.userId,
+                workspaceId: state.workspaceId,
+                corpusId: state.corpusId,
+                mode: state.mode,
+                recordedAt: normalizeString(entry.recordedAt) || state.updatedAt,
+                title: normalizeString(entry.title),
+                requestedSourcePath: normalizeString(entry.requestedSourcePath),
+                resolvedSourcePath: normalizeString(entry.resolvedSourcePath),
+                signal: {
+                    usedFallback: normalizeBoolean(entry.usedFallback),
+                    fallbackSourcePathUsed: normalizeBoolean(entry.fallbackSourcePathUsed),
+                    matchedSpanCount: normalizeCount(entry.matchedSpanCount),
+                    highlightTermCount: normalizeCount(entry.highlightTermCount),
+                    highlightedNodeCount: normalizeCount(entry.highlightedNodeCount),
+                    candidateSourcePathCount: candidateSourcePaths.length,
+                    attemptedSourcePathCount: attemptedSourcePaths.length,
+                    markdownRuntimeAvailable: normalizeBoolean(entry.markdownRuntimeAvailable),
+                    storageProviderAvailable: normalizeBoolean(entry.storageProviderAvailable),
+                    readSucceeded: normalizeBoolean(entry.readSucceeded),
+                    renderSucceeded: normalizeBoolean(entry.renderSucceeded),
+                    failureReason: normalizeString(entry.failureReason),
+                },
+            };
+        });
+    })
+        .sort((left, right) => {
+        const recordedAtOrder = compareStrings(left.recordedAt, right.recordedAt);
+        if (recordedAtOrder !== 0) {
+            return recordedAtOrder;
+        }
+        const sessionOrder = compareStrings(left.sessionStateId, right.sessionStateId);
+        if (sessionOrder !== 0) {
+            return sessionOrder;
+        }
+        return compareStrings(left.requestedSourcePath, right.requestedSourcePath);
+    });
+}
+function sortAndCloneMemoryEntries(records) {
+    return records
+        .slice()
+        .sort((left, right) => {
+        const userOrder = compareStrings(left.userId, right.userId);
+        if (userOrder !== 0) {
+            return userOrder;
+        }
+        const layerOrder = compareStrings(left.layer, right.layer);
+        if (layerOrder !== 0) {
+            return layerOrder;
+        }
+        return compareStrings(left.entry.key, right.entry.key);
+    })
+        .map((record) => ({
+        userId: record.userId,
+        layer: record.layer,
+        entry: {
+            ...record.entry,
+            tags: [...record.entry.tags],
+            references: [...record.entry.references],
+        },
+    }));
+}
+function sortAndCloneMemoryAuditRecords(records) {
+    return records
+        .slice()
+        .sort((left, right) => compareStrings(left.auditId, right.auditId))
+        .map((record) => ({ ...record }));
+}
+function buildWorkspaceExportBundle(input) {
+    const capabilities = (0, PlatformCapabilities_1.resolvePlatformCapabilities)({
+        exportProfileId: input.request.exportProfileId || input.workspace.exportProfileId,
+    });
+    const render = (0, RenderMaterializer_1.resolveRenderMaterializationDecision)({
+        exportProfileId: capabilities.exportProfileId,
+        platformTarget: capabilities.platformTarget,
+        includeSvg: true,
+    });
+    const bindings = sortAndCloneBindings(input.bindings);
+    const resources = sortAndCloneResources(input.resources);
+    const projections = sortAndCloneProjections(input.projections);
+    const units = sortAndCloneUnits(input.units);
+    const segments = sortAndCloneSegments(input.segments);
+    const atoms = sortAndCloneAtoms(input.atoms);
+    const evidenceSpans = sortAndCloneEvidenceSpans(input.evidenceSpans);
+    const relationEdges = sortAndCloneRelationEdges(input.relationEdges);
+    const temporalEdges = sortAndCloneTemporalEdges(input.temporalEdges);
+    const sessionStates = sortAndCloneSessionStates(input.sessionStates);
+    const conversationSessions = sortAndCloneConversationSessions(input.conversationSessions);
+    const conversationTurns = sortAndCloneConversationTurns(input.conversationTurns);
+    const conversationInvocations = sortAndCloneConversationInvocations(input.conversationInvocations);
+    const workflowArtifacts = sortAndCloneWorkflowArtifacts(input.workflowArtifacts);
+    const knowledgeRunReports = buildKnowledgeRunReports(workflowArtifacts);
+    const knowledgeRunAnswerReleaseAuditSummary = buildKnowledgeRunAnswerReleaseAuditSummary(knowledgeRunReports);
+    const graphFocusReports = buildGraphFocusReports(sessionStates);
+    const memoryEntries = sortAndCloneMemoryEntries(input.memoryEntries);
+    const memoryAuditRecords = sortAndCloneMemoryAuditRecords(input.memoryAuditRecords);
+    const activeProjectionIds = projections
+        .filter((projection) => projection.status === 'active')
+        .map((projection) => projection.projectionId);
+    const indexedProjectionIds = new Set(units
+        .filter((unit) => unit.state === 'indexed' && unit.segmentIds.length > 0)
+        .map((unit) => unit.projectionId));
+    const missingIndexedProjectionIds = activeProjectionIds.filter((projectionId) => !indexedProjectionIds.has(projectionId));
+    const reasons = [];
+    if (missingIndexedProjectionIds.length > 0) {
+        reasons.push(`Missing indexed segments for ${missingIndexedProjectionIds.length} active projection(s).`);
+    }
+    if (!render.responseArtifact || !capabilities.render.supportsPngArtifacts) {
+        reasons.push('Resolved export profile does not provide a render artifact path.');
+    }
+    const deterministicPayload = {
+        workspace: {
+            ...input.workspace,
+            languages: [...input.workspace.languages].sort(compareStrings),
+        },
+        capabilities,
+        render,
+        bindings,
+        resources,
+        projections,
+        index: {
+            summary: input.indexSummary,
+            units,
+            segments,
+        },
+        graph: {
+            atoms,
+            evidenceSpans,
+            relationEdges,
+            temporalEdges,
+        },
+        runtime: {
+            sessionStates,
+            conversationSessions,
+            conversationTurns,
+            conversationInvocations,
+            workflowArtifacts,
+            knowledgeRunReports,
+            knowledgeRunAnswerReleaseAuditSummary,
+            graphFocusReports,
+        },
+        memory: {
+            entries: memoryEntries,
+            auditRecords: memoryAuditRecords,
+        },
+    };
+    const deterministicHash = (0, crypto_1.createHash)('sha256')
+        .update(JSON.stringify(deterministicPayload))
+        .digest('hex');
+    const bundleId = `workspace_export_${deterministicHash.slice(0, 12)}`;
+    return {
+        manifest: {
+            bundleId,
+            workspaceId: input.workspace.workspaceId,
+            corpusId: input.workspace.corpusId,
+            exportProfileId: capabilities.exportProfileId,
+            platformTarget: capabilities.platformTarget,
+            packagingMode: capabilities.retrieval.supportsSidecar ? 'full' : 'slim',
+            generatedAt: input.generatedAt,
+            deterministicHash,
+            counts: {
+                bindings: bindings.length,
+                resources: resources.length,
+                projections: projections.length,
+                units: units.length,
+                segments: segments.length,
+                atoms: atoms.length,
+                evidenceSpans: evidenceSpans.length,
+                relationEdges: relationEdges.length,
+                temporalEdges: temporalEdges.length,
+                sessionStates: sessionStates.length,
+                conversationSessions: conversationSessions.length,
+                conversationTurns: conversationTurns.length,
+                conversationInvocations: conversationInvocations.length,
+                workflowArtifacts: workflowArtifacts.length,
+                memoryEntries: memoryEntries.length,
+                memoryAuditRecords: memoryAuditRecords.length,
+            },
+        },
+        workspace: {
+            ...input.workspace,
+            languages: [...input.workspace.languages].sort(compareStrings),
+        },
+        capabilities,
+        readiness: {
+            ready: reasons.length <= 0,
+            reasons,
+            activeProjectionCount: activeProjectionIds.length,
+            indexedProjectionCount: indexedProjectionIds.size,
+            missingIndexedProjectionIds,
+            indexSummary: {
+                ...input.indexSummary,
+                states: { ...input.indexSummary.states },
+            },
+            render: {
+                responseArtifact: render.responseArtifact,
+                rendererPreference: render.rendererPreference,
+                includeSvg: render.includeSvg,
+                vectorSuppressed: render.vectorSuppressed,
+            },
+        },
+        bindings,
+        resources,
+        projections,
+        index: {
+            summary: {
+                ...input.indexSummary,
+                states: { ...input.indexSummary.states },
+            },
+            units,
+            segments,
+        },
+        graph: {
+            atoms,
+            evidenceSpans,
+            relationEdges,
+            temporalEdges,
+        },
+        runtime: {
+            sessionStates,
+            conversationSessions,
+            conversationTurns,
+            conversationInvocations,
+            workflowArtifacts,
+            knowledgeRunReports,
+            knowledgeRunAnswerReleaseAuditSummary,
+            graphFocusReports,
+        },
+        memory: {
+            entries: memoryEntries,
+            auditRecords: memoryAuditRecords,
+        },
+    };
+}