@gracker/smartperfetto 1.0.15 → 1.0.17

package/dist/routes/agentRoutes.js

@@ -53,6 +53,7 @@ const htmlReportGenerator_1 = require("../services/htmlReportGenerator");
 const agentReportData_1 = require("../services/agentReportData");
 const persistAgentSession_1 = require("../services/persistAgentSession");
 const comparisonAppendixService_1 = require("../services/comparisonAppendixService");
+const finalResultQualityGate_1 = require("../services/finalResultQualityGate");
 const agentResultNormalizer_1 = require("../services/agentResultNormalizer");
 const reportRoutes_1 = require("./reportRoutes");
 const sessionPersistenceService_1 = require("../services/sessionPersistenceService");
@@ -92,6 +93,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");
@@ -100,6 +102,7 @@ const feedbackEnricher_1 = require("../agentv3/selfImprove/feedbackEnricher");
 const toolNarration_1 = require("../agentv3/toolNarration");
 const analysisPatternMemory_1 = require("../agentv3/analysisPatternMemory");
 const runtimePaths_1 = require("../runtimePaths");
+const COMPLETED_ANALYSIS_SSE_EVENTS_QUALITY_GATE_VERSION = 1;
 const router = express_1.default.Router();
 const REQUEST_ID_HEADER = 'x-request-id';
 const MAX_REQUEST_ID_LENGTH = 128;
@@ -363,6 +366,61 @@ function persistBufferedAgentEvent(session, event) {
         });
     }
 }
+function sanitizePersistedAnalysisCompletedEvent(session, event) {
+    if (event.eventType !== 'analysis_completed')
+        return event;
+    let payload;
+    try {
+        payload = JSON.parse(event.eventData || '{}');
+    }
+    catch {
+        return event;
+    }
+    const data = payload?.data && typeof payload.data === 'object'
+        ? payload.data
+        : payload;
+    const conclusion = typeof data?.conclusion === 'string'
+        ? data.conclusion
+        : typeof data?.answer === 'string'
+            ? data.answer
+            : '';
+    if (!conclusion.trim())
+        return event;
+    const result = {
+        sessionId: session.sessionId,
+        success: data?.success !== false,
+        findings: Array.isArray(data?.findings) ? data.findings : [],
+        hypotheses: Array.isArray(data?.hypotheses) ? data.hypotheses : [],
+        conclusion,
+        confidence: typeof data?.confidence === 'number' ? data.confidence : 0.5,
+        rounds: typeof data?.rounds === 'number' ? data.rounds : 1,
+        totalDurationMs: typeof data?.totalDurationMs === 'number' ? data.totalDurationMs : 0,
+        partial: data?.partial === true ? true : undefined,
+        terminationReason: data?.terminationReason,
+        terminationMessage: data?.terminationMessage,
+        conclusionContract: data?.conclusionContract,
+        claimSupport: data?.claimSupport,
+        claimVerificationResult: data?.claimVerificationResult,
+        identityResolutions: data?.identityResolutions,
+    };
+    const issue = (0, finalResultQualityGate_1.applyFinalResultQualityGate)({ result, query: session.query });
+    if (!issue)
+        return event;
+    const nextData = {
+        ...data,
+        confidence: result.confidence,
+        partial: result.partial,
+        terminationReason: result.terminationReason,
+        terminationMessage: result.terminationMessage,
+    };
+    const nextPayload = payload?.data && typeof payload.data === 'object'
+        ? { ...payload, data: nextData }
+        : { ...payload, ...nextData };
+    return {
+        ...event,
+        eventData: JSON.stringify(nextPayload),
+    };
+}
 function replayPersistedAgentEvents(session, res, lastEventId) {
     const scope = agentEventScopeFromSession(session);
     if (!scope)
@@ -386,9 +444,10 @@ function replayPersistedAgentEvents(session, res, lastEventId) {
     let lastCursor = lastEventId;
     for (const event of events) {
         try {
+            const replayEvent = sanitizePersistedAnalysisCompletedEvent(session, event);
             res.write(`id: ${event.cursor}\n`);
-            res.write(`event: ${event.eventType}\n`);
-            res.write(`data: ${event.eventData}\n\n`);
+            res.write(`event: ${replayEvent.eventType}\n`);
+            res.write(`data: ${replayEvent.eventData}\n\n`);
             replayed++;
             lastCursor = event.cursor;
             if (sessionSseReplay_1.TERMINAL_SSE_EVENT_TYPES.has(event.eventType)) {
@@ -412,6 +471,52 @@ 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 => sanitizePersistedAnalysisCompletedEvent(session, event))
+        .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) {
@@ -530,12 +635,44 @@ function buildTurnSeverityCounts(turn) {
 function toJsonSafe(value) {
     return JSON.parse(JSON.stringify(value, (_key, v) => (typeof v === 'bigint' ? v.toString() : v)));
 }
+function buildDisplayTurnResult(turn) {
+    if (!turn.result)
+        return turn.result;
+    const message = typeof turn.result.message === 'string' ? turn.result.message : '';
+    const resultForGate = {
+        sessionId: turn.id,
+        success: turn.result.success !== false,
+        findings: Array.isArray(turn.findings) ? turn.findings : [],
+        hypotheses: [],
+        conclusion: message,
+        confidence: typeof turn.result.confidence === 'number' ? turn.result.confidence : 0.5,
+        rounds: 1,
+        totalDurationMs: 0,
+        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,
+    };
+    (0, finalResultQualityGate_1.applyFinalResultQualityGate)({ result: resultForGate, query: turn.query });
+    return {
+        ...turn.result,
+        message: resultForGate.conclusion,
+        confidence: resultForGate.confidence,
+        partial: resultForGate.partial,
+        terminationReason: resultForGate.terminationReason,
+        terminationMessage: resultForGate.terminationMessage,
+    };
+}
 function buildTurnSummary(turn) {
-    const confidence = typeof turn.result?.confidence === 'number'
-        ? turn.result.confidence
+    const displayResult = buildDisplayTurnResult(turn);
+    const confidence = typeof displayResult?.confidence === 'number'
+        ? displayResult.confidence
         : undefined;
-    const sanitizedConclusion = typeof turn.result?.message === 'string'
-        ? normalizeNarrativeForClient(turn.result.message)
+    const sanitizedConclusion = typeof displayResult?.message === 'string'
+        ? normalizeNarrativeForClient(displayResult.message)
         : '';
     const conclusionPreview = sanitizedConclusion
         ? sanitizedConclusion.replace(/\s+/g, ' ').slice(0, 240)
@@ -551,7 +688,10 @@ function buildTurnSummary(turn) {
             aspects: Array.isArray(turn.intent?.aspects) ? turn.intent.aspects : [],
         },
         completed: !!turn.completed,
-        success: typeof turn.result?.success === 'boolean' ? turn.result.success : null,
+        success: typeof displayResult?.success === 'boolean' ? displayResult.success : null,
+        partial: displayResult?.partial === true,
+        terminationReason: displayResult?.terminationReason,
+        terminationMessage: displayResult?.terminationMessage,
         confidence,
         findingCount: Array.isArray(turn.findings) ? turn.findings.length : 0,
         severityCounts: buildTurnSeverityCounts(turn),
@@ -560,15 +700,16 @@ function buildTurnSummary(turn) {
 }
 function buildTurnDetail(turn) {
     const summary = buildTurnSummary(turn);
+    const displayResult = buildDisplayTurnResult(turn);
     return {
         ...summary,
         intent: toJsonSafe(turn.intent),
-        result: turn.result
+        result: displayResult
             ? toJsonSafe({
-                ...turn.result,
-                message: typeof turn.result.message === 'string'
-                    ? normalizeNarrativeForClient(turn.result.message)
-                    : turn.result.message,
+                ...displayResult,
+                message: typeof displayResult.message === 'string'
+                    ? normalizeNarrativeForClient(displayResult.message)
+                    : displayResult.message,
             })
             : null,
         findings: toJsonSafe(turn.findings || []),
@@ -607,10 +748,38 @@ 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 annotateRecoveredResultQuality(sessionId, session, result, query) {
+    const issue = (0, finalResultQualityGate_1.applyFinalResultQualityGate)({
+        result,
+        query: query || session.query,
+    });
+    if (!issue)
+        return;
+    const context = enhancedSessionContext_1.sessionContextManager.get(sessionId, session.traceId) ||
+        enhancedSessionContext_1.sessionContextManager.get(sessionId);
+    context?.annotateLatestCompletedTurn({
+        success: result.success,
+        findings: result.findings,
+        message: result.conclusion,
+        confidence: result.confidence,
+        partial: result.partial,
+        terminationReason: result.terminationReason,
+        terminationMessage: result.terminationMessage,
+        conclusionContract: result.conclusionContract,
+        claimSupport: result.claimSupport,
+        claimVerificationResult: result.claimVerificationResult,
+        identityResolutions: result.identityResolutions,
+    });
+}
 function recoverResultForSessionIfNeeded(sessionId, session) {
     if (session.result) {
+        annotateRecoveredResultQuality(sessionId, session, session.result);
         return session.result;
     }
     const resolved = resolveSessionContextForReview(sessionId);
@@ -627,6 +796,7 @@ function recoverResultForSessionIfNeeded(sessionId, session) {
     if (latestTurn?.query) {
         session.query = latestTurn.query;
     }
+    annotateRecoveredResultQuality(sessionId, session, recovered, latestTurn?.query);
     return recovered;
 }
 function buildFallbackIntentFromQuery(query) {
@@ -1146,6 +1316,15 @@ function handleSessionStream(req, res, sessionId) {
         timestamp: Date.now(),
         ...buildStreamObservability(session),
     });
+    if (lastEventId !== null &&
+        (session.status === 'completed' || session.status === 'quota_exceeded')) {
+        recoverResultForSessionIfNeeded(sessionId, session);
+        if (session.result) {
+            sendAgentDrivenResult(res, session);
+            res.end();
+            return;
+        }
+    }
     let ringReplayAfter = lastEventId;
     if (lastEventId !== null) {
         const persistedReplay = replayPersistedAgentEvents(session, res, lastEventId);
@@ -1180,11 +1359,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;
         }
     }
@@ -1260,22 +1436,41 @@ router.get('/:sessionId/status', (req, res) => {
                 query: session.query,
                 findings: recoveredResult.findings,
             });
-            const conclusionContract = recoveredResult.conclusionContract ||
-                (0, agentResultNormalizer_1.deriveConclusionContractForNarrative)(recoveredResult.conclusion, {
-                    mode: recoveredResult.rounds > 1 ? 'focused_answer' : 'initial_report',
-                    sceneId: sceneIdHint,
-                }) ||
+            const conclusionContract = (0, agentResultNormalizer_1.deriveEvidenceBackedConclusionContractForNarrative)(recoveredResult.conclusion, session.dataEnvelopes || [], {
+                existingContract: recoveredResult.conclusionContract,
+                mode: recoveredResult.rounds > 1 ? 'focused_answer' : 'initial_report',
+                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,
@@ -2233,6 +2428,7 @@ async function detectScenesQuick(traceProcessorService, traceId) {
     normalizeNarrativeForClient,
     buildClientFindings,
     buildSessionResultContract,
+    getCompletedPayload: ensureCompletedAnalysisResultPayload,
 });
 // ============================================================================
 // Agent-Driven Analysis Helper Functions (Phase 2-4)
@@ -2311,9 +2507,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) {
@@ -2361,7 +2562,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,
@@ -2440,6 +2641,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) {
@@ -2454,10 +2656,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 = [];
@@ -2496,12 +2694,83 @@ async function runAgentDrivenAnalysis(sessionId, query, traceId, options = {}) {
                 };
             }
         }
+        if (result.success || result.partial === true) {
+            const sceneIdHint = resolveConclusionSceneIdHint({
+                sessionId,
+                query,
+                findings: result.findings,
+            });
+            const normalizedConclusionContract = ((0, agentResultNormalizer_1.deriveEvidenceBackedConclusionContractForNarrative)(result.conclusion, session.dataEnvelopes || [], {
+                existingContract: result.conclusionContract,
+                mode: result.rounds > 1 ? 'focused_answer' : 'initial_report',
+                sceneId: sceneIdHint,
+            }) ||
+                undefined);
+            if (normalizedConclusionContract) {
+                result.conclusionContract = normalizedConclusionContract;
+            }
+            ensureAnalysisQualityArtifacts(session, normalizedConclusionContract);
+        }
+        const finalQualityIssue = (0, finalResultQualityGate_1.applyFinalResultQualityGate)({ result, query });
+        if (finalQualityIssue) {
+            const message = result.terminationMessage || finalQualityIssue.message;
+            logger.warn('AgentDrivenAnalysis', 'Final result quality gate marked result partial', {
+                code: finalQualityIssue.code,
+                conclusionChars: result.conclusion.length,
+                findingsCount: result.findings.length,
+                hasConclusionContract: !!result.conclusionContract,
+                claimVerifierStatus: result.claimVerificationResult?.status,
+                runId: session.activeRun?.runId,
+                requestId: session.activeRun?.requestId,
+            });
+            const update = {
+                type: 'degraded',
+                content: {
+                    module: 'agentRoutes',
+                    fallback: 'final_result_quality_gate',
+                    code: finalQualityIssue.code,
+                    partial: true,
+                    message,
+                },
+                timestamp: Date.now(),
+            };
+            broadcastToAgentDrivenClients(sessionId, update);
+            const conversationStep = buildConversationStepUpdate(session, update);
+            if (conversationStep) {
+                appendConversationStep(session, conversationStep);
+                broadcastToAgentDrivenClients(sessionId, conversationStep);
+            }
+        }
+        const currentTurn = session.runSequence || 1;
+        const latestConclusionHistory = session.conclusionHistory?.[session.conclusionHistory.length - 1];
+        if (latestConclusionHistory?.turn === currentTurn) {
+            latestConclusionHistory.confidence = result.confidence ?? latestConclusionHistory.confidence;
+        }
+        enhancedSessionContext_1.sessionContextManager.get(sessionId, traceId)?.annotateLatestCompletedTurn({
+            success: result.success,
+            findings: result.findings,
+            message: result.conclusion,
+            confidence: result.confidence,
+            partial: result.partial,
+            terminationReason: result.terminationReason,
+            terminationMessage: result.terminationMessage,
+            conclusionContract: result.conclusionContract,
+            claimSupport: result.claimSupport,
+            claimVerificationResult: result.claimVerificationResult,
+            identityResolutions: result.identityResolutions,
+        });
+        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,
@@ -2524,14 +2793,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);
@@ -3945,7 +4211,7 @@ function normalizeNarrativeForClient(narrative) {
 }
 function conclusionHasEvidenceIndex(conclusion) {
     const text = conclusion || '';
-    return /(^|\n)\s*##\s*证据表索引\b/.test(text);
+    return /(^|\n)\s*##\s*证据(?:表)?索引\b/.test(text);
 }
 function markdownCell(value, maxLen = 80) {
     return String(value ?? '')
@@ -3954,19 +4220,7 @@ function markdownCell(value, maxLen = 80) {
         .trim()
         .slice(0, maxLen) || '-';
 }
-function envelopeRowCount(env) {
-    const rows = env?.data?.rows;
-    if (Array.isArray(rows))
-        return String(rows.length);
-    const summaryContent = env?.data?.summary?.content;
-    if (typeof summaryContent === 'string') {
-        const matched = summaryContent.match(/Total rows:\s*(\d+)/i);
-        if (matched)
-            return matched[1];
-    }
-    return '-';
-}
-function buildConclusionEvidenceIndex(envelopes, maxItems = 8) {
+function buildConclusionEvidenceIndex(envelopes, maxItems = 3) {
     if (!Array.isArray(envelopes) || envelopes.length === 0)
         return '';
     const seen = new Set();
@@ -3983,22 +4237,21 @@ function buildConclusionEvidenceIndex(envelopes, maxItems = 8) {
         if (seen.has(key))
             continue;
         seen.add(key);
-        const phase = markdownCell(meta.planPhaseTitle || meta.planPhaseId || '-');
         const source = markdownCell(meta.source || meta.skillId || 'execute_sql');
-        const evidence = markdownCell(meta.evidenceRefId || meta.sourceToolCallId || '-', 48);
-        candidates.push(`| ${phase} | ${title} | ${source} | ${envelopeRowCount(env)} | ${evidence} |`);
+        const evidence = markdownCell(meta.evidenceRefId || meta.sourceToolCallId || '-', 36);
+        candidates.push({ title, source, evidence });
     }
     if (candidates.length === 0)
         return '';
     const rows = candidates.slice(0, maxItems);
     const omitted = Math.max(0, candidates.length - rows.length);
+    const summary = rows
+        .map(item => `${item.title}（${item.source} / ${item.evidence}）`)
+        .join('；');
     return [
-        '## 证据表索引',
+        '## 证据索引',
         '',
-        '| 阶段 | 表/摘要 | 来源 | 行数 | 证据 ID |',
-        '|---|---|---|---:|---|',
-        ...rows,
-        omitted > 0 ? `| - | 其余 ${omitted} 份证据 | - | - | - |` : '',
+        `关键数据来源：${summary}${omitted > 0 ? `；其余 ${omitted} 份结构化证据见报告数据详情。` : '。'}`,
     ].filter(Boolean).join('\n');
 }
 function appendEvidenceIndexIfMissing(conclusion, envelopes) {
@@ -4030,53 +4283,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);
@@ -4100,18 +4367,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,
@@ -4123,9 +4387,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(),
@@ -4137,13 +4402,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,
@@ -4155,7 +4422,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}`);
@@ -4164,7 +4431,7 @@ function sendAgentDrivenResult(res, session) {
             }
         }
     }
-    if (hasEvidenceBackedConclusion) {
+    if (input.hasEvidenceBackedConclusion) {
         try {
             const resultSnapshot = (0, analysisResultSnapshotPipeline_1.persistCompletedAnalysisResultSnapshot)({
                 tenantId: session.tenantId,
@@ -4173,20 +4440,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,
@@ -4209,24 +4479,134 @@ 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 ? ((0, agentResultNormalizer_1.deriveEvidenceBackedConclusionContractForNarrative)(result.conclusion, session.dataEnvelopes || [], {
+            existingContract: result.conclusionContract,
+            mode: result.rounds > 1 ? 'focused_answer' : 'initial_report',
+            sceneId: sceneIdHint,
+        }) ||
+            undefined) : undefined;
+    const qualityArtifacts = hasEvidenceBackedConclusion && !replayOnlyScene
+        ? ensureAnalysisQualityArtifacts(session, normalizedConclusionContract)
+        : {};
+    if (normalizedConclusionContract) {
+        result.conclusionContract = normalizedConclusionContract;
+    }
+    if (!replayOnlyScene) {
+        const readPathQualityIssue = (0, finalResultQualityGate_1.applyFinalResultQualityGate)({ result, query: session.query });
+        if (readPathQualityIssue) {
+            enhancedSessionContext_1.sessionContextManager.get(session.sessionId, session.traceId)?.annotateLatestCompletedTurn({
+                success: result.success,
+                findings: result.findings,
+                message: result.conclusion,
+                confidence: result.confidence,
+                partial: result.partial,
+                terminationReason: result.terminationReason,
+                terminationMessage: result.terminationMessage,
+                conclusionContract: result.conclusionContract,
+                claimSupport: result.claimSupport,
+                claimVerificationResult: result.claimVerificationResult,
+                identityResolutions: result.identityResolutions,
+            });
+        }
+    }
+    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 &&
+        session.completedAnalysisSseEventsQualityGateVersion ===
+            COMPLETED_ANALYSIS_SSE_EVENTS_QUALITY_GATE_VERSION) {
+        return cached;
+    }
+    const completedPayload = ensureCompletedAnalysisResultPayload(session);
+    if (!completedPayload) {
+        const persisted = loadPersistedCompletedAnalysisSseEvents(session);
+        if (persisted.length > 0) {
+            session.completedAnalysisSseEvents = persisted;
+            delete session.completedAnalysisSseEventsQualityGateVersion;
+            return persisted;
+        }
+        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,
@@ -4246,8 +4626,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,
@@ -4257,14 +4637,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: {
@@ -4292,7 +4673,20 @@ function sendAgentDrivenResult(res, session) {
                 observability,
             },
             timestamp: Date.now(),
-        });
+        }));
+    }
+    events.push(appendAndPersistReplayableSessionEvent(session, 'end', {
+        timestamp: Date.now(),
+        ...observability,
+    }));
+    session.completedAnalysisSseEvents = events;
+    session.completedAnalysisSseEventsQualityGateVersion =
+        COMPLETED_ANALYSIS_SSE_EVENTS_QUALITY_GATE_VERSION;
+    return events;
+}
+function sendAgentDrivenResult(res, session) {
+    for (const event of ensureCompletedAnalysisSseEvents(session)) {
+        writeBufferedSessionEvent(res, event);
     }
 }
 (0, agentLogsRoutes_1.registerAgentLogsRoutes)(router);