@gracker/smartperfetto 1.0.20 → 1.0.22

package/dist/routes/agentRoutes.js

@@ -68,8 +68,12 @@ const conclusionSceneTemplates_1 = require("../agent/core/conclusionSceneTemplat
 const analysisNarrative_1 = require("../utils/analysisNarrative");
 const agentSceneReconstructRoutes_1 = require("./agentSceneReconstructRoutes");
 const sceneStoryService_1 = require("../agent/scene/sceneStoryService");
+const buildSmartChatReport_1 = require("../agent/scene/buildSmartChatReport");
+const smartDeepDiveDispatch_1 = require("../agent/scene/smartDeepDiveDispatch");
+const smartCancelBridge_1 = require("../agent/scene/smartCancelBridge");
 const sceneReportStore_1 = require("../services/sceneReport/sceneReportStore");
 const sceneReportMemoryCache_1 = require("../services/sceneReport/sceneReportMemoryCache");
+const sceneJobArtifactStore_1 = require("../services/sceneReport/sceneJobArtifactStore");
 const traceHash_1 = require("../agent/scene/traceHash");
 const sceneTraceDurationProbe_1 = require("../agent/scene/sceneTraceDurationProbe");
 const config_1 = require("../config");
@@ -85,6 +89,8 @@ const agentReportRoutes_1 = require("./agentReportRoutes");
 const agentResumeRoutes_1 = require("./agentResumeRoutes");
 const agentSessionCatalogRoutes_1 = require("./agentSessionCatalogRoutes");
 const agentTeachingRoutes_1 = require("./agentTeachingRoutes");
+const normalizeAnalyzeOptions_1 = require("./agent/normalizeAnalyzeOptions");
+const finalizeAgentDrivenSession_1 = require("./agent/finalizeAgentDrivenSession");
 const assistantApplicationService_1 = require("../assistant/application/assistantApplicationService");
 const streamProjector_1 = require("../assistant/stream/streamProjector");
 const sessionSseReplay_1 = require("../assistant/stream/sessionSseReplay");
@@ -271,6 +277,7 @@ router.use((req, res, next) => {
 router.use(auth_1.authenticate);
 const assistantAppService = new assistantApplicationService_1.AssistantApplicationService();
 const streamProjector = new streamProjector_1.StreamProjector();
+const smartCancelBridge = new smartCancelBridge_1.SmartCancelBridge();
 function agentEventScopeFromSession(session) {
     const run = session.activeRun || session.lastRun;
     if (!(0, config_1.resolveFeatureConfig)().enterprise ||
@@ -903,7 +910,7 @@ async function handleAnalyzeRequest(req, res, requestedSessionIdOverride) {
     try {
         const requestId = getRequestId(req);
         const requestContext = (0, auth_1.requireRequestContext)(req);
-        const { traceId, query, sessionId: bodyRequestedSessionId, options = {}, selectionContext: rawSelectionContext, referenceTraceId, traceContext: rawTraceContext, providerId, } = req.body;
+        const { traceId, query, sessionId: bodyRequestedSessionId, options: rawOptions = {}, selectionContext: rawSelectionContext, referenceTraceId, traceContext: rawTraceContext, providerId, } = req.body;
         const requestedSessionId = requestedSessionIdOverride || bodyRequestedSessionId;
         if (!(0, rbac_1.hasRbacPermission)(requestContext, 'agent:run')) {
             (0, rbac_1.sendForbidden)(res, 'Starting analysis requires agent:run permission');
@@ -937,6 +944,24 @@ async function handleAnalyzeRequest(req, res, requestedSessionIdOverride) {
             });
             return;
         }
+        let options;
+        try {
+            options = (0, normalizeAnalyzeOptions_1.normalizeAnalyzeOptions)(rawOptions, {
+                endpoint: requestedSessionIdOverride ? '/sessions/:id/runs' : '/analyze',
+                hasReferenceTraceId: !!referenceTraceId,
+            });
+        }
+        catch (error) {
+            if (error instanceof normalizeAnalyzeOptions_1.AnalyzeOptionsError) {
+                res.status(error.httpStatus).json({
+                    success: false,
+                    error: error.message,
+                    code: error.code,
+                });
+                return;
+            }
+            throw error;
+        }
         if (requestedSessionId && !requestedSessionIsVisible(requestedSessionId, requestContext)) {
             (0, resourceOwnership_1.sendResourceNotFound)(res, 'Session not found');
             return;
@@ -1080,6 +1105,49 @@ async function handleAnalyzeRequest(req, res, requestedSessionIdOverride) {
             runId: runContext.runId,
             runSequence: runContext.sequence,
         });
+        if (options.preset === 'smart') {
+            runSmartAnalysis(sessionId, query, traceId, {
+                runContext,
+                traceProcessorService,
+                smartAction: options.smartAction ?? 'preview',
+                smartSelection: options.smartSelection,
+                forceRefresh: options.forceRefresh === true,
+                analysisMode: options.analysisMode,
+                blockedStrategyIds,
+                owner: (0, resourceOwnership_1.ownerFieldsFromContext)(requestContext),
+            }).catch((error) => {
+                const session = assistantAppService.getSession(sessionId);
+                if (session) {
+                    session.logger.error('AgentRoutes', 'Smart analysis failed', error);
+                    session.status = 'failed';
+                    session.error = error.message;
+                    markSessionRunStatus(session, 'failed', error.message);
+                    broadcastToAgentDrivenClients(sessionId, {
+                        type: 'error',
+                        content: { message: error.message, error: error.message },
+                        timestamp: Date.now(),
+                    });
+                }
+            });
+            res.json({
+                success: true,
+                sessionId,
+                message: isNewSession ? 'Smart analysis started' : 'Smart analysis started',
+                isNewSession,
+                providerSnapshotChanged: preparedSession?.providerSnapshotChanged || undefined,
+                architecture: 'agent-driven',
+                preset: 'smart',
+                runId: runContext.runId,
+                requestId: runContext.requestId,
+                runSequence: runContext.sequence,
+                observability: {
+                    runId: runContext.runId,
+                    requestId: runContext.requestId,
+                    runSequence: runContext.sequence,
+                },
+            });
+            return;
+        }
         let agentRunLease = null;
         let referenceAgentRunLease = null;
         let agentRunLeaseDecision = null;
@@ -1840,6 +1908,10 @@ router.post('/:sessionId/cancel', (req, res) => {
         return;
     // Mark session as failed/cancelled
     if (session.status === 'running' || session.status === 'pending') {
+        const smartCancelled = smartCancelBridge.cancel(sessionId);
+        if (smartCancelled)
+            smartCancelBridge.tryClaimTerminal(sessionId);
+        const sceneCancelled = sceneStoryService.cancel(sessionId);
         session.status = 'failed';
         session.error = 'Cancelled by user';
         markSessionRunStatus(session, 'failed', 'Cancelled by user');
@@ -1857,7 +1929,11 @@ router.post('/:sessionId/cancel', (req, res) => {
             catch { /* client may already be closed */ }
         }
         session.sseClients = [];
-        session.logger.info('AgentRoutes', 'Session cancelled by user', { sessionId });
+        session.logger.info('AgentRoutes', 'Session cancelled by user', {
+            sessionId,
+            smartCancelled,
+            sceneCancelled,
+        });
     }
     return res.json({ success: true, sessionId, status: session.status });
 });
@@ -2000,6 +2076,7 @@ router.get('/:sessionId/focus', (req, res) => {
 // traces (no content hash, so they live for the lifetime of the backend).
 const sceneReportStore = new sceneReportStore_1.FileSystemSceneReportStore(config_1.sceneStoryConfig.reportDir);
 const sceneReportMemoryCache = new sceneReportMemoryCache_1.SceneReportMemoryCache(config_1.sceneStoryConfig.memoryCacheMaxSize);
+const sceneJobArtifactStore = new sceneJobArtifactStore_1.FileSystemSceneJobArtifactStore(config_1.sceneStoryConfig.jobArtifactDir);
 // Singleton — sceneStoryService holds per-session JobRunner state for cancel
 // lookup, so it must outlive a single request. SkillExecutor is still created
 // per-request inside the route handler.
@@ -2008,6 +2085,7 @@ const sceneStoryService = new sceneStoryService_1.SceneStoryService({
     getSession: (id) => assistantAppService.getSession(id),
     reportStore: sceneReportStore,
     memoryCache: sceneReportMemoryCache,
+    jobArtifactStore: sceneJobArtifactStore,
     computeHash: (traceId) => (0, traceHash_1.computeTraceContentHash)((0, traceProcessorService_1.getTraceProcessorService)(), traceId),
     probeDuration: (traceId) => (0, sceneTraceDurationProbe_1.probeTraceDuration)((0, traceProcessorService_1.getTraceProcessorService)(), traceId),
 });
@@ -2043,6 +2121,196 @@ const SCENE_EXTRACTION_STEP_IDS = new Set([
     'jank_events',
     'clean_timeline',
 ]);
+async function runSmartAnalysis(sessionId, query, traceId, options) {
+    const session = assistantAppService.getSession(sessionId);
+    if (!session)
+        return;
+    const startedAt = Date.now();
+    session.activeRun = {
+        ...options.runContext,
+        query,
+        status: 'running',
+        startedAt: options.runContext.startedAt || startedAt,
+    };
+    session.lastRun = { ...session.activeRun };
+    session.status = 'running';
+    session.lastActivityAt = Date.now();
+    persistSessionRunState(session, 'running');
+    const runHeartbeatInterval = startSessionRunHeartbeat(session);
+    const cancelToken = smartCancelBridge.create(sessionId);
+    let dispatchedToAgentDeepDive = false;
+    session.logger.info('SmartAnalysis', 'Starting smart analysis', {
+        query,
+        traceId,
+        smartAction: options.smartAction,
+        smartSelection: options.smartSelection,
+        runId: session.activeRun?.runId,
+        requestId: session.activeRun?.requestId,
+    });
+    try {
+        await (0, skillLoader_1.ensureSkillRegistryInitialized)();
+        const skillExecutor = new skillExecutor_1.SkillExecutor(options.traceProcessorService);
+        skillExecutor.registerSkills(skillLoader_1.skillRegistry.getAllSkills());
+        let report = null;
+        if (options.smartAction === 'analyze') {
+            report = await resolveSmartPreviewReportForSelection({
+                session,
+                selection: options.smartSelection,
+                traceId,
+                owner: options.owner,
+            });
+        }
+        if (!report) {
+            report = await sceneStoryService.start({
+                sessionId,
+                traceId,
+                skillExecutor,
+                owner: options.owner,
+                options: {
+                    routeProfile: 'smart',
+                    previewOnly: true,
+                    forceRefresh: options.smartAction === 'preview'
+                        ? true
+                        : options.forceRefresh,
+                    cancelToken,
+                },
+            });
+        }
+        if (!report) {
+            throw new Error(session.error || 'Smart analysis failed before report finalization');
+        }
+        if (options.smartAction === 'preview') {
+            const result = (0, buildSmartChatReport_1.buildSmartSceneSelectionReport)({
+                sessionId,
+                report,
+                totalDurationMs: Date.now() - startedAt,
+            });
+            if (!smartCancelBridge.tryClaimTerminal(sessionId)) {
+                session.logger.warn('SmartAnalysis', 'Skipping late smart preview terminal', {
+                    sessionId,
+                    runId: session.activeRun?.runId,
+                });
+                return;
+            }
+            completeAgentDrivenSessionWithResult({
+                sessionId,
+                query,
+                traceId,
+                session,
+                result,
+                logComponent: 'SmartAnalysis',
+            });
+            return;
+        }
+        const dispatch = (0, smartDeepDiveDispatch_1.buildSmartDeepDiveDispatch)({
+            report,
+            selection: options.smartSelection ?? { scope: 'all' },
+        });
+        if (!dispatch) {
+            throw new Error('所选范围没有匹配到可深钻场景，请返回场景盘点后重新选择。');
+        }
+        session.logger.info('SmartAnalysis', 'Dispatching smart selection to agent deep dive', {
+            query: dispatch.query,
+            selectedSceneCount: dispatch.selectedScenes.length,
+            packageName: dispatch.packageName,
+            previewReportId: report.reportId,
+            runId: session.activeRun?.runId,
+            requestId: session.activeRun?.requestId,
+        });
+        broadcastToAgentDrivenClients(sessionId, {
+            type: 'progress',
+            content: {
+                phase: 'smart_deep_dive_dispatch',
+                message: `已选中 ${dispatch.selectedScenes.length} 个场景，进入详细分析`,
+            },
+            timestamp: Date.now(),
+        });
+        dispatchedToAgentDeepDive = true;
+        await runAgentDrivenAnalysis(sessionId, dispatch.query, traceId, {
+            traceProcessorService: options.traceProcessorService,
+            runContext: options.runContext,
+            blockedStrategyIds: options.blockedStrategyIds,
+            selectionContext: dispatch.selectionContext,
+            traceContext: dispatch.traceContext,
+            packageName: dispatch.packageName,
+            analysisMode: resolveSmartDeepDiveAnalysisMode(options.analysisMode),
+            generateTracks: false,
+        });
+    }
+    catch (error) {
+        session.status = 'failed';
+        session.error = error.message || String(error);
+        markSessionRunStatus(session, 'failed', session.error);
+        session.logger.error('SmartAnalysis', 'Smart analysis failed', error);
+        if (!dispatchedToAgentDeepDive && smartCancelBridge.tryClaimTerminal(sessionId)) {
+            broadcastToAgentDrivenClients(sessionId, {
+                type: 'error',
+                content: { message: session.error, error: session.error },
+                timestamp: Date.now(),
+            });
+        }
+    }
+    finally {
+        smartCancelBridge.release(sessionId);
+        if (runHeartbeatInterval) {
+            clearInterval(runHeartbeatInterval);
+        }
+    }
+}
+function resolveSmartDeepDiveAnalysisMode(mode) {
+    return mode === 'fast' ? 'fast' : 'full';
+}
+async function resolveSmartPreviewReportForSelection(input) {
+    const requestedReportId = input.selection?.reportId || input.selection?.sceneSnapshotId;
+    const sessionReport = input.session.sceneStoryReport;
+    if (isUsableSmartPreviewReport(sessionReport, input.traceId, input.owner, requestedReportId)) {
+        return sessionReport;
+    }
+    if (!requestedReportId)
+        return null;
+    const persisted = await sceneStoryService.getReport(requestedReportId);
+    if (isUsableSmartPreviewReport(persisted, input.traceId, input.owner, requestedReportId)) {
+        return persisted;
+    }
+    return null;
+}
+function isUsableSmartPreviewReport(report, traceId, owner, requestedReportId) {
+    if (!report)
+        return false;
+    if (requestedReportId && report.reportId !== requestedReportId)
+        return false;
+    if (report.traceId !== traceId)
+        return false;
+    return (0, resourceOwnership_1.ownersMatch)(report, owner);
+}
+function completeAgentDrivenSessionWithResult(input) {
+    (0, finalizeAgentDrivenSession_1.finalizeAgentDrivenSession)(input, {
+        applyFinalResultQualityGate: finalResultQualityGate_1.applyFinalResultQualityGate,
+        broadcast: broadcastToAgentDrivenClients,
+        buildConversationStepUpdate,
+        appendConversationStep,
+        annotateLatestCompletedTurn: (sessionId, traceId, result) => {
+            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,
+            });
+        },
+        terminalRunStatusForResult,
+        markSessionRunStatus,
+        persistAgentTurn: persistAgentSession_1.persistAgentTurn,
+        ensureCompletedAnalysisSseEvents,
+        sendAgentDrivenResult,
+    });
+}
 function objectRowsToEnvelopePayload(rows) {
     if (!Array.isArray(rows) || rows.length === 0) {
         return { columns: [], rows: [] };
@@ -2640,33 +2908,6 @@ async function runAgentDrivenAnalysis(sessionId, query, traceId, options = {}) {
             return runWithTraceProcessorLease(analyze);
         });
         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) {
-            if (!existingIds.has(h.id)) {
-                session.hypotheses.push(h);
-            }
-            else {
-                // Update existing hypothesis with latest status
-                const idx = session.hypotheses.findIndex(eh => eh.id === h.id);
-                if (idx >= 0)
-                    session.hypotheses[idx] = h;
-            }
-        }
-        const terminalRunStatus = terminalRunStatusForResult(result);
-        // Record conclusion in cross-turn history
-        if (!session.conclusionHistory)
-            session.conclusionHistory = [];
-        if (result.conclusion) {
-            session.conclusionHistory.push({
-                turn: session.runSequence || 1,
-                conclusion: result.conclusion,
-                confidence: result.confidence ?? 0,
-                timestamp: Date.now(),
-            });
-        }
         // Ensure trackEvents/scenes are computed for completed sessions (even without SSE clients)
         if (shouldGenerateTracks) {
             updateSceneReconstructionArtifactsFromEnvelopes(session, session.dataEnvelopes);
@@ -2709,101 +2950,16 @@ async function runAgentDrivenAnalysis(sessionId, query, traceId, options = {}) {
             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);
-            }
+            ensureAnalysisQualityArtifacts(session, normalizedConclusionContract, result);
         }
-        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,
-            requestId: session.activeRun?.requestId,
-            runSequence: session.activeRun?.sequence,
-        });
-        // Persist session state via shared helper — see services/persistAgentSession.ts.
-        // CLI's cliAnalyzeService routes through the same function.
-        (0, persistAgentSession_1.persistAgentTurn)({
-            session,
+        completeAgentDrivenSessionWithResult({
             sessionId,
-            traceId,
             query,
-            result: { conclusion: result.conclusion, totalDurationMs: result.totalDurationMs },
-            logger,
-            // Preserve the legacy component label so any log filters / alerts keyed
-            // on 'AgentDrivenAnalysis' keep matching persist-related events.
+            traceId,
+            session,
+            result,
             logComponent: 'AgentDrivenAnalysis',
         });
-        // 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);
-            }
-            catch (e) {
-                logger.error('AgentRoutes', `Error sending agent-driven result to client ${index + 1}`, e);
-            }
-        });
-        logger.close();
     }
     catch (error) {
         session.status = 'failed';
@@ -4488,6 +4644,7 @@ function ensureCompletedAnalysisResultPayload(session) {
         return undefined;
     const replayOnlyScene = isSceneReplayOnlyQuery(session.query);
     const hasEvidenceBackedConclusion = result.success || result.partial === true;
+    const isSmartResult = result.conclusionContract?.metadata?.sceneId === 'smart';
     const normalizedConclusion = replayOnlyScene
         ? buildSceneReplayNarrative(session.scenes || [])
         : hasEvidenceBackedConclusion ? appendEvidenceIndexIfMissing(normalizeNarrativeForClient(result.conclusion), session.dataEnvelopes || []) : normalizeNarrativeForClient(result.conclusion);
@@ -4500,12 +4657,14 @@ function ensureCompletedAnalysisResultPayload(session) {
         });
     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;
+        : isSmartResult
+            ? result.conclusionContract
+            : 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)
         : {};
@@ -4613,6 +4772,7 @@ function ensureCompletedAnalysisSseEvents(session) {
             partial: result.partial,
             terminationReason: result.terminationReason,
             terminationMessage: result.terminationMessage,
+            smartScenePreview: result.smartScenePreview,
             findings: clientFindings,
             resultContract,
             hypotheses: result.hypotheses.map((h) => ({