@gracker/smartperfetto 1.0.14 → 1.0.16

package/dist/routes/agentRoutes.js

@@ -92,6 +92,7 @@ const analysisRunStore_1 = require("../services/analysisRunStore");
 const agentAnalyzeSessionService_1 = require("../assistant/application/agentAnalyzeSessionService");
 const assistantResultContract_1 = require("../assistant/contracts/assistantResultContract");
 const analysisResultSnapshotPipeline_1 = require("../services/analysisResultSnapshotPipeline");
+const claimVerificationRunner_1 = require("../services/verifier/claimVerificationRunner");
 // DataEnvelope types for v2.0 data contract
 const dataContract_1 = require("../types/dataContract");
 const skillExecutor_1 = require("../services/skillEngine/skillExecutor");
@@ -412,6 +413,51 @@ function sendReplayableSessionEvent(session, res, eventType, payload) {
     streamProjector.sendEvent(res, eventType, payload, event.seqId);
     return event.seqId;
 }
+function appendAndPersistReplayableSessionEvent(session, eventType, payload) {
+    const event = (0, sessionSseReplay_1.appendReplayableSseEvent)(session, eventType, payload);
+    persistBufferedAgentEvent(session, {
+        cursor: event.seqId,
+        eventType: event.eventType,
+        eventData: event.eventData,
+        createdAt: Date.now(),
+    });
+    return event;
+}
+function writeBufferedSessionEvent(res, event) {
+    res.write(`id: ${event.seqId}\n`);
+    res.write(`event: ${event.eventType}\n`);
+    res.write(`data: ${event.eventData}\n\n`);
+}
+function loadPersistedCompletedAnalysisSseEvents(session) {
+    const scope = agentEventScopeFromSession(session);
+    if (!scope)
+        return [];
+    const events = (0, agentEventStore_1.listSerializedAgentEventsAfter)(scope, scope.runId, 0)
+        .filter(event => event.eventType === 'snapshot_created' ||
+        event.eventType === 'analysis_completed' ||
+        event.eventType === 'scene_reconstruction_completed' ||
+        event.eventType === 'end')
+        .map(event => ({
+        seqId: event.cursor,
+        eventType: event.eventType,
+        eventData: event.eventData,
+    }));
+    if (!events.some(event => event.eventType === 'analysis_completed') ||
+        !events.some(event => event.eventType === 'end')) {
+        return [];
+    }
+    session.sseEventSeq = Math.max(session.sseEventSeq || 0, ...events.map(event => event.seqId));
+    const existing = new Set(session.sseEventBuffer.map(event => `${event.seqId}:${event.eventType}`));
+    for (const event of events) {
+        const key = `${event.seqId}:${event.eventType}`;
+        if (!existing.has(key))
+            session.sseEventBuffer.push(event);
+    }
+    if (session.sseEventBuffer.length > streamProjector_1.SSE_RING_BUFFER_SIZE) {
+        session.sseEventBuffer.splice(0, session.sseEventBuffer.length - streamProjector_1.SSE_RING_BUFFER_SIZE);
+    }
+    return events;
+}
 function resolveSessionContextForReview(sessionId) {
     const activeSession = assistantAppService.getSession(sessionId);
     if (activeSession) {
@@ -607,6 +653,10 @@ function buildRecoveredResultFromContext(sessionId, context) {
         partial: turn.result.partial,
         terminationReason: turn.result.terminationReason,
         terminationMessage: turn.result.terminationMessage,
+        conclusionContract: turn.result.conclusionContract,
+        claimSupport: turn.result.claimSupport,
+        claimVerificationResult: turn.result.claimVerificationResult,
+        identityResolutions: turn.result.identityResolutions,
     };
 }
 function recoverResultForSessionIfNeeded(sessionId, session) {
@@ -902,6 +952,8 @@ async function handleAnalyzeRequest(req, res, requestedSessionIdOverride) {
             sessionForRun.referenceTraceId = effectiveReferenceTraceId;
             sessionForRun.comparisonSource = 'raw_trace_pair';
         }
+        sessionForRun.codeAwareMode = options.codeAwareMode;
+        sessionForRun.codebaseIds = Array.isArray(options.codebaseIds) ? options.codebaseIds : undefined;
         const runContext = startSessionRun(sessionForRun, query, requestId);
         sessionForRun.logger.setMetadata({
             requestId: runContext.requestId,
@@ -1178,11 +1230,8 @@ function handleSessionStream(req, res, sessionId) {
         recoverResultForSessionIfNeeded(sessionId, session);
         if (session.result) {
             sendAgentDrivenResult(res, session);
-            sendReplayableSessionEvent(session, res, 'end', {
-                timestamp: Date.now(),
-                ...buildStreamObservability(session),
-            });
             res.end();
+            assistantAppService.removeSseClient(sessionId, res);
             return;
         }
     }
@@ -1264,16 +1313,35 @@ router.get('/:sessionId/status', (req, res) => {
                     sceneId: sceneIdHint,
                 }) ||
                 undefined;
+            const qualityArtifacts = recoveredResult.claimSupport &&
+                recoveredResult.claimVerificationResult &&
+                recoveredResult.identityResolutions
+                ? {
+                    claimSupport: recoveredResult.claimSupport,
+                    claimVerificationResult: recoveredResult.claimVerificationResult,
+                    identityResolutions: recoveredResult.identityResolutions,
+                }
+                : ensureAnalysisQualityArtifacts(session, conclusionContract, recoveredResult);
+            const completedPayload = ensureCompletedAnalysisResultPayload(session);
+            const finalArtifacts = completedPayload?.finalArtifacts;
+            const normalizedCompletedConclusion = completedPayload?.normalizedConclusion || conclusion;
+            const normalizedCompletedContract = completedPayload?.normalizedConclusionContract || conclusionContract;
             response.result = {
-                answer: conclusion,
-                conclusion,
-                conclusionContract,
+                answer: normalizedCompletedConclusion,
+                conclusion: normalizedCompletedConclusion,
+                conclusionContract: normalizedCompletedContract,
+                claimSupport: qualityArtifacts.claimSupport,
+                claimVerificationResult: qualityArtifacts.claimVerificationResult,
+                identityResolutions: qualityArtifacts.identityResolutions,
                 confidence: recoveredResult.confidence,
                 totalDurationMs: recoveredResult.totalDurationMs,
                 rounds: recoveredResult.rounds,
                 partial: recoveredResult.partial,
                 terminationReason: recoveredResult.terminationReason,
                 terminationMessage: recoveredResult.terminationMessage,
+                reportUrl: finalArtifacts?.reportUrl,
+                reportError: finalArtifacts?.reportError,
+                resultSnapshotId: finalArtifacts?.resultSnapshotId,
                 findings: recoveredResult.findings,
                 findingsCount: recoveredResult.findings.length,
                 resultContract,
@@ -2231,6 +2299,7 @@ async function detectScenesQuick(traceProcessorService, traceId) {
     normalizeNarrativeForClient,
     buildClientFindings,
     buildSessionResultContract,
+    getCompletedPayload: ensureCompletedAnalysisResultPayload,
 });
 // ============================================================================
 // Agent-Driven Analysis Helper Functions (Phase 2-4)
@@ -2309,9 +2378,14 @@ async function runAgentDrivenAnalysis(sessionId, query, traceId, options = {}) {
         console.log(`[AgentRoutes.AgentDriven] Received event: ${update.type}`, update.content?.phase);
         logger.debug('Stream', `Update: ${update.type}`, update.content);
         const normalizedUpdate = augmentConclusionUpdateWithEvidenceIndex(session, normalizeAgentDrivenUpdate(update));
-        // Broadcast the original event so the frontend receives raw events
-        // (answer_token, thought, agent_response, conclusion, etc.) for rendering.
-        broadcastToAgentDrivenClients(sessionId, normalizedUpdate);
+        // Final narrative is emitted through analysis_completed after deterministic
+        // evidence/claim verification has run. Suppress early conclusion events so
+        // clients do not render an unverified terminal answer.
+        const shouldBroadcastOriginalUpdate = normalizedUpdate.type !== 'conclusion' &&
+            normalizedUpdate.type !== 'answer_token';
+        if (shouldBroadcastOriginalUpdate) {
+            broadcastToAgentDrivenClients(sessionId, normalizedUpdate);
+        }
         // Also derive a conversation_step for the timeline/observability layer.
         const conversationStep = buildConversationStepUpdate(session, normalizedUpdate);
         if (conversationStep) {
@@ -2359,7 +2433,7 @@ async function runAgentDrivenAnalysis(sessionId, query, traceId, options = {}) {
         // (answer_token, thought, conclusion, etc.) are already broadcast above
         // and remapping would cause duplicate delivery to the frontend.
         const eventType = mapToAgentDrivenEventType(normalizedUpdate);
-        if (eventType !== normalizedUpdate.type) {
+        if (shouldBroadcastOriginalUpdate && eventType !== normalizedUpdate.type) {
             broadcastToAgentDrivenClients(sessionId, {
                 type: eventType,
                 content: normalizedUpdate.content,
@@ -2427,6 +2501,8 @@ async function runAgentDrivenAnalysis(sessionId, query, traceId, options = {}) {
                 traceContext: options.traceContext,
                 referenceTraceId: options.referenceTraceId,
                 providerId: options.providerId,
+                codeAwareMode: options.codeAwareMode,
+                codebaseIds: Array.isArray(options.codebaseIds) ? options.codebaseIds : undefined,
                 tenantId: session.tenantId,
                 workspaceId: session.workspaceId,
                 userId: session.userId,
@@ -2436,6 +2512,7 @@ async function runAgentDrivenAnalysis(sessionId, query, traceId, options = {}) {
         });
         console.log('[AgentRoutes.AgentDriven] analyze completed, success:', result.success);
         session.result = result;
+        delete session.completedAnalysisFinalArtifacts;
         // Accumulate hypotheses across turns (deduplicate by id)
         const existingIds = new Set(session.hypotheses.map(h => h.id));
         for (const h of result.hypotheses) {
@@ -2450,10 +2527,6 @@ async function runAgentDrivenAnalysis(sessionId, query, traceId, options = {}) {
             }
         }
         const terminalRunStatus = terminalRunStatusForResult(result);
-        session.status = terminalRunStatus === 'quota_exceeded'
-            ? 'quota_exceeded'
-            : result.success ? 'completed' : 'failed';
-        markSessionRunStatus(session, terminalRunStatus);
         // Record conclusion in cross-turn history
         if (!session.conclusionHistory)
             session.conclusionHistory = [];
@@ -2492,12 +2565,35 @@ async function runAgentDrivenAnalysis(sessionId, query, traceId, options = {}) {
                 };
             }
         }
+        if (result.success || result.partial === true) {
+            const sceneIdHint = resolveConclusionSceneIdHint({
+                sessionId,
+                query,
+                findings: result.findings,
+            });
+            const normalizedConclusionContract = (result.conclusionContract ||
+                (0, agentResultNormalizer_1.deriveConclusionContractForNarrative)(result.conclusion, {
+                    mode: result.rounds > 1 ? 'focused_answer' : 'initial_report',
+                    sceneId: sceneIdHint,
+                }) ||
+                undefined);
+            if (normalizedConclusionContract) {
+                result.conclusionContract = normalizedConclusionContract;
+            }
+            ensureAnalysisQualityArtifacts(session, normalizedConclusionContract);
+        }
+        session.status = terminalRunStatus === 'quota_exceeded'
+            ? 'quota_exceeded'
+            : result.success ? 'completed' : 'failed';
+        markSessionRunStatus(session, terminalRunStatus);
         // Log completion details
         logger.info('AgentDrivenAnalysis', 'Agent-driven analysis completed', {
             confidence: result.confidence,
             rounds: result.rounds,
             findingsCount: result.findings.length,
             hypothesesCount: result.hypotheses.length,
+            claimSupportCount: result.claimSupport?.length || 0,
+            claimVerifierStatus: result.claimVerificationResult?.status,
             partial: result.partial,
             terminationReason: result.terminationReason,
             runId: session.activeRun?.runId,
@@ -2520,14 +2616,11 @@ async function runAgentDrivenAnalysis(sessionId, query, traceId, options = {}) {
         // Send final result
         const clientCount = session.sseClients.length;
         logger.info('AgentRoutes', 'Sending agent-driven result', { clientCount });
+        ensureCompletedAnalysisSseEvents(session);
         session.sseClients.forEach((client, index) => {
             try {
                 logger.info('AgentRoutes', `Sending agent-driven result to client ${index + 1}/${clientCount}`);
                 sendAgentDrivenResult(client, session);
-                sendReplayableSessionEvent(session, client, 'end', {
-                    timestamp: Date.now(),
-                    ...buildStreamObservability(session),
-                });
             }
             catch (e) {
                 logger.error('AgentRoutes', `Error sending agent-driven result to client ${index + 1}`, e);
@@ -4026,53 +4119,67 @@ function augmentConclusionUpdateWithEvidenceIndex(session, update) {
         },
     };
 }
-/**
- * Send agent-driven analysis result to SSE client
- */
-function sendAgentDrivenResult(res, session) {
-    const result = session.result;
+function ensureAnalysisQualityArtifacts(session, conclusionContract, resultOverride) {
+    const result = resultOverride || session.result;
     if (!result)
-        return;
-    const observability = buildStreamObservability(session);
-    const replayOnlyScene = isSceneReplayOnlyQuery(session.query);
-    const hasEvidenceBackedConclusion = result.success || result.partial === true;
-    const normalizedConclusion = replayOnlyScene
-        ? buildSceneReplayNarrative(session.scenes || [])
-        : hasEvidenceBackedConclusion ? appendEvidenceIndexIfMissing(normalizeNarrativeForClient(result.conclusion), session.dataEnvelopes || []) : normalizeNarrativeForClient(result.conclusion);
-    const sceneIdHint = replayOnlyScene
-        ? undefined
-        : resolveConclusionSceneIdHint({
-            sessionId: session.sessionId,
-            query: session.query,
-            findings: result.findings,
+        return {};
+    if (result.claimSupport &&
+        result.claimVerificationResult &&
+        result.identityResolutions) {
+        session.claimSupport = result.claimSupport;
+        session.claimVerificationResult = result.claimVerificationResult;
+        session.identityResolutions = result.identityResolutions;
+        const context = enhancedSessionContext_1.sessionContextManager.get(session.sessionId, session.traceId);
+        context?.annotateLatestCompletedTurn({
+            conclusionContract,
+            claimSupport: result.claimSupport,
+            claimVerificationResult: result.claimVerificationResult,
+            identityResolutions: result.identityResolutions,
         });
-    // Fallback: re-derive contract if the orchestrator didn't populate it.
-    // Note: mode heuristic uses rounds (available here) as proxy for turnCount
-    // (which only the orchestrator knows). Both signal "multi-interaction" analysis.
-    const normalizedConclusionContract = replayOnlyScene
-        ? undefined
-        : hasEvidenceBackedConclusion ? (result.conclusionContract ||
-            (0, agentResultNormalizer_1.deriveConclusionContractForNarrative)(result.conclusion, {
-                mode: result.rounds > 1 ? 'focused_answer' : 'initial_report',
-                sceneId: sceneIdHint,
-            }) ||
-            undefined) : undefined;
-    const resultForClient = normalizedConclusion === result.conclusion && normalizedConclusionContract === result.conclusionContract
-        ? result
-        : { ...result, conclusion: normalizedConclusion, conclusionContract: normalizedConclusionContract };
-    const clientFindings = replayOnlyScene ? [] : buildClientFindings(result.findings, session.scenes || []);
-    const resultContract = buildSessionResultContract(session, clientFindings);
-    // Generate HTML report
-    let reportUrl;
-    let reportError;
-    const reportId = `agent-report-${session.sessionId}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    let resultSnapshotId;
-    let resultSnapshotEventData;
-    let reportLease = null;
-    if (!hasEvidenceBackedConclusion) {
-        reportError = `analysis did not complete successfully (${result.terminationReason || 'failed'})`;
+        return {
+            claimSupport: result.claimSupport,
+            claimVerificationResult: result.claimVerificationResult,
+            identityResolutions: result.identityResolutions,
+        };
+    }
+    const artifacts = (0, claimVerificationRunner_1.runClaimVerification)({
+        conclusionContract,
+        dataEnvelopes: session.dataEnvelopes || [],
+        comparisonReportSection: session.comparisonReportSection,
+        policy: 'record_only',
+    });
+    result.claimSupport = artifacts.claimSupport;
+    result.claimVerificationResult = artifacts.claimVerificationResult;
+    result.identityResolutions = artifacts.identityResolutions;
+    const context = enhancedSessionContext_1.sessionContextManager.get(session.sessionId, session.traceId);
+    context?.annotateLatestCompletedTurn({
+        conclusionContract,
+        claimSupport: artifacts.claimSupport,
+        claimVerificationResult: artifacts.claimVerificationResult,
+        identityResolutions: artifacts.identityResolutions,
+    });
+    session.claimSupport = artifacts.claimSupport;
+    session.claimVerificationResult = artifacts.claimVerificationResult;
+    session.identityResolutions = artifacts.identityResolutions;
+    return {
+        claimSupport: artifacts.claimSupport,
+        claimVerificationResult: artifacts.claimVerificationResult,
+        identityResolutions: artifacts.identityResolutions,
+    };
+}
+function ensureCompletedAnalysisFinalArtifacts(session, input) {
+    const cached = session.completedAnalysisFinalArtifacts;
+    if (cached)
+        return cached;
+    const result = input.result;
+    const finalArtifacts = { generatedAt: Date.now() };
+    let reportId;
+    if (!input.hasEvidenceBackedConclusion) {
+        finalArtifacts.reportError = `analysis did not complete successfully (${result.terminationReason || 'failed'})`;
     }
     else {
+        let reportLease = null;
+        reportId = `agent-report-${session.sessionId}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
         try {
             if (enterpriseLeasesEnabled()) {
                 const scope = leaseScopeFromSession(session);
@@ -4096,18 +4203,15 @@ function sendAgentDrivenResult(res, session) {
                 }
             }
             const generator = (0, htmlReportGenerator_1.getHTMLReportGenerator)();
-            // Report assembly (cumulative findings dedup, empty-conclusion fallback,
-            // snapshot-first analysisNotes/Plan/Flags) lives in the shared builder so
-            // the CLI path produces identical output.
             const reportData = (0, agentReportData_1.buildAgentDrivenReportData)({
                 session,
-                result: resultForClient,
+                result: input.resultForClient,
             });
             console.log(`[AgentRoutes] Generating HTML report, data keys:`, {
                 hasResult: !!result,
-                conclusionLength: normalizedConclusion?.length || 0,
-                conclusionPreview: (normalizedConclusion || '').substring(0, 100),
-                hasConclusionContract: !!normalizedConclusionContract,
+                conclusionLength: input.normalizedConclusion?.length || 0,
+                conclusionPreview: (input.normalizedConclusion || '').substring(0, 100),
+                hasConclusionContract: !!input.normalizedConclusionContract,
                 findingsCount: result.findings?.length || 0,
                 hypothesesCount: session.hypotheses?.length || 0,
                 dialogueCount: session.agentDialogue?.length || 0,
@@ -4119,9 +4223,10 @@ function sendAgentDrivenResult(res, session) {
                 snapshotNotes: session._lastSnapshot?.analysisNotes?.length ?? 'n/a',
                 snapshotPlan: !!session._lastSnapshot?.analysisPlan,
                 snapshotFlags: session._lastSnapshot?.uncertaintyFlags?.length ?? 'n/a',
+                claimSupportCount: input.qualityArtifacts.claimSupport?.length || 0,
+                claimVerifierStatus: input.qualityArtifacts.claimVerificationResult?.status,
             });
             const html = generator.generateAgentDrivenHTML(reportData);
-            // Store report
             (0, reportRoutes_1.persistReport)(reportId, {
                 html,
                 generatedAt: Date.now(),
@@ -4133,13 +4238,15 @@ function sendAgentDrivenResult(res, session) {
                 userId: session.userId,
                 visibility: 'private',
             });
-            reportUrl = `/api/reports/${reportId}`;
+            finalArtifacts.reportId = reportId;
+            finalArtifacts.reportUrl = `/api/reports/${reportId}`;
             console.log(`[AgentRoutes] Generated agent-driven HTML report: ${reportId} (${html.length} bytes)`);
         }
         catch (error) {
-            reportError = error.message || 'Unknown error';
+            reportId = undefined;
+            finalArtifacts.reportError = error.message || 'Unknown error';
             console.error('[AgentRoutes] Failed to generate agent-driven HTML report:', {
-                error: reportError,
+                error: finalArtifacts.reportError,
                 stack: error.stack?.split('\n').slice(0, 5).join('\n'),
                 resultConclusion: result?.conclusion ? `${result.conclusion.length} chars` : 'EMPTY/NULL',
                 resultConfidence: result?.confidence,
@@ -4151,7 +4258,7 @@ function sendAgentDrivenResult(res, session) {
                 const scope = leaseScopeFromSession(session);
                 if (scope) {
                     try {
-                        (0, traceProcessorLeaseStore_1.getTraceProcessorLeaseStore)().releaseHolder(scope, reportLease.id, 'report_generation', reportId);
+                        (0, traceProcessorLeaseStore_1.getTraceProcessorLeaseStore)().releaseHolder(scope, reportLease.id, 'report_generation', finalArtifacts.reportId || reportId || 'report_generation');
                     }
                     catch (releaseError) {
                         console.warn(`[AgentRoutes] Failed to release report_generation lease ${reportLease.id}: ${releaseError.message}`);
@@ -4160,7 +4267,7 @@ function sendAgentDrivenResult(res, session) {
             }
         }
     }
-    if (hasEvidenceBackedConclusion) {
+    if (input.hasEvidenceBackedConclusion) {
         try {
             const resultSnapshot = (0, analysisResultSnapshotPipeline_1.persistCompletedAnalysisResultSnapshot)({
                 tenantId: session.tenantId,
@@ -4169,20 +4276,23 @@ function sendAgentDrivenResult(res, session) {
                 traceId: session.traceId,
                 sessionId: session.sessionId,
                 runId: session.lastRun?.runId || session.activeRun?.runId,
-                reportId: reportUrl ? reportId : undefined,
+                reportId: finalArtifacts.reportId,
                 query: session.query,
                 traceLabel: session.traceId,
-                conclusion: normalizedConclusion,
-                conclusionContract: normalizedConclusionContract,
+                conclusion: input.normalizedConclusion,
+                conclusionContract: input.normalizedConclusionContract,
+                claimSupport: input.qualityArtifacts.claimSupport,
+                claimVerificationResult: input.qualityArtifacts.claimVerificationResult,
+                identityResolutions: input.qualityArtifacts.identityResolutions,
                 confidence: result.confidence,
                 partial: result.partial,
                 terminationReason: result.terminationReason,
                 terminationMessage: result.terminationMessage,
                 dataEnvelopes: session.dataEnvelopes,
             });
-            resultSnapshotId = resultSnapshot?.id;
+            finalArtifacts.resultSnapshotId = resultSnapshot?.id;
             if (resultSnapshot) {
-                resultSnapshotEventData = {
+                finalArtifacts.resultSnapshotEventData = {
                     snapshotId: resultSnapshot.id,
                     status: resultSnapshot.status,
                     sceneType: resultSnapshot.sceneType,
@@ -4205,24 +4315,108 @@ function sendAgentDrivenResult(res, session) {
             });
         }
     }
-    if (resultSnapshotEventData) {
-        sendReplayableSessionEvent(session, res, 'snapshot_created', {
+    session.completedAnalysisFinalArtifacts = finalArtifacts;
+    return finalArtifacts;
+}
+function ensureCompletedAnalysisResultPayload(session) {
+    const result = session.result;
+    if (!result)
+        return undefined;
+    const replayOnlyScene = isSceneReplayOnlyQuery(session.query);
+    const hasEvidenceBackedConclusion = result.success || result.partial === true;
+    const normalizedConclusion = replayOnlyScene
+        ? buildSceneReplayNarrative(session.scenes || [])
+        : hasEvidenceBackedConclusion ? appendEvidenceIndexIfMissing(normalizeNarrativeForClient(result.conclusion), session.dataEnvelopes || []) : normalizeNarrativeForClient(result.conclusion);
+    const sceneIdHint = replayOnlyScene
+        ? undefined
+        : resolveConclusionSceneIdHint({
+            sessionId: session.sessionId,
+            query: session.query,
+            findings: result.findings,
+        });
+    const normalizedConclusionContract = replayOnlyScene
+        ? undefined
+        : hasEvidenceBackedConclusion ? (result.conclusionContract ||
+            (0, agentResultNormalizer_1.deriveConclusionContractForNarrative)(result.conclusion, {
+                mode: result.rounds > 1 ? 'focused_answer' : 'initial_report',
+                sceneId: sceneIdHint,
+            }) ||
+            undefined) : undefined;
+    const qualityArtifacts = hasEvidenceBackedConclusion && !replayOnlyScene
+        ? ensureAnalysisQualityArtifacts(session, normalizedConclusionContract)
+        : {};
+    const resultForClient = normalizedConclusion === result.conclusion &&
+        normalizedConclusionContract === result.conclusionContract &&
+        qualityArtifacts.claimSupport === result.claimSupport &&
+        qualityArtifacts.claimVerificationResult === result.claimVerificationResult &&
+        qualityArtifacts.identityResolutions === result.identityResolutions
+        ? result
+        : {
+            ...result,
+            conclusion: normalizedConclusion,
+            conclusionContract: normalizedConclusionContract,
+            ...qualityArtifacts,
+        };
+    const clientFindings = replayOnlyScene ? [] : buildClientFindings(result.findings, session.scenes || []);
+    const resultContract = buildSessionResultContract(session, clientFindings);
+    const finalArtifacts = ensureCompletedAnalysisFinalArtifacts(session, {
+        result,
+        hasEvidenceBackedConclusion,
+        normalizedConclusion,
+        normalizedConclusionContract,
+        qualityArtifacts,
+        resultForClient: resultForClient,
+    });
+    return {
+        result,
+        replayOnlyScene,
+        normalizedConclusion,
+        normalizedConclusionContract,
+        qualityArtifacts,
+        clientFindings,
+        resultContract,
+        finalArtifacts,
+    };
+}
+/**
+ * Send agent-driven analysis result to SSE client
+ */
+function ensureCompletedAnalysisSseEvents(session) {
+    const cached = session.completedAnalysisSseEvents;
+    if (cached?.length)
+        return cached;
+    const persisted = loadPersistedCompletedAnalysisSseEvents(session);
+    if (persisted.length > 0) {
+        session.completedAnalysisSseEvents = persisted;
+        return persisted;
+    }
+    const completedPayload = ensureCompletedAnalysisResultPayload(session);
+    if (!completedPayload)
+        return [];
+    const { result, normalizedConclusion, normalizedConclusionContract, qualityArtifacts, clientFindings, resultContract, finalArtifacts, } = completedPayload;
+    const observability = buildStreamObservability(session);
+    const events = [];
+    if (finalArtifacts.resultSnapshotEventData) {
+        events.push(appendAndPersistReplayableSessionEvent(session, 'snapshot_created', {
             type: 'snapshot_created',
             architecture: 'agent-driven',
             ...observability,
-            data: resultSnapshotEventData,
+            data: finalArtifacts.resultSnapshotEventData,
             timestamp: Date.now(),
-        });
+        }));
     }
     // Send analysis_completed event with full result. Keep it replayable so a
     // reconnect between conclusion and report generation can recover reportUrl.
-    sendReplayableSessionEvent(session, res, 'analysis_completed', {
+    events.push(appendAndPersistReplayableSessionEvent(session, 'analysis_completed', {
         type: 'analysis_completed',
         architecture: 'agent-driven',
         ...observability,
         data: {
             conclusion: normalizedConclusion,
             conclusionContract: normalizedConclusionContract,
+            claimSupport: qualityArtifacts.claimSupport,
+            claimVerificationResult: qualityArtifacts.claimVerificationResult,
+            identityResolutions: qualityArtifacts.identityResolutions,
             confidence: result.confidence,
             rounds: result.rounds,
             totalDurationMs: result.totalDurationMs,
@@ -4242,8 +4436,8 @@ function sendAgentDrivenResult(res, session) {
             agentDialogueCount: session.agentDialogue.length,
             conversationTimelineCount: session.conversationSteps.length,
             conversationTimeline: session.conversationSteps,
-            reportUrl,
-            reportError,
+            reportUrl: finalArtifacts.reportUrl,
+            reportError: finalArtifacts.reportError,
             comparisonReportSection: session.comparisonReportSection
                 ? {
                     source: session.comparisonReportSection.source,
@@ -4253,14 +4447,15 @@ function sendAgentDrivenResult(res, session) {
                     evidencePack: session.comparisonReportSection.evidencePack,
                 }
                 : undefined,
-            resultSnapshotId,
+            resultSnapshotId: finalArtifacts.resultSnapshotId,
             observability,
+            terminalRunStatus: session.status === 'quota_exceeded' ? 'quota_exceeded' : 'completed',
         },
         timestamp: Date.now(),
-    });
+    }));
     // Backward-compatible scene reconstruction payload (used by the legacy /scene-reconstruct clients).
     if ((session.scenes?.length || 0) > 0 || (session.trackEvents?.length || 0) > 0) {
-        sendReplayableSessionEvent(session, res, 'scene_reconstruction_completed', {
+        events.push(appendAndPersistReplayableSessionEvent(session, 'scene_reconstruction_completed', {
             type: 'scene_reconstruction_completed',
             ...observability,
             data: {
@@ -4288,7 +4483,18 @@ function sendAgentDrivenResult(res, session) {
                 observability,
             },
             timestamp: Date.now(),
-        });
+        }));
+    }
+    events.push(appendAndPersistReplayableSessionEvent(session, 'end', {
+        timestamp: Date.now(),
+        ...observability,
+    }));
+    session.completedAnalysisSseEvents = events;
+    return events;
+}
+function sendAgentDrivenResult(res, session) {
+    for (const event of ensureCompletedAnalysisSseEvents(session)) {
+        writeBufferedSessionEvent(res, event);
     }
 }
 (0, agentLogsRoutes_1.registerAgentLogsRoutes)(router);