@gracker/smartperfetto 1.0.18 → 1.0.20

package/dist/agentOpenAI/openAiRuntime.js

@@ -27,9 +27,7 @@ const queryComplexityClassifier_1 = require("../agentv3/queryComplexityClassifie
 const openAiComplexityClassifier_1 = require("./openAiComplexityClassifier");
 const artifactStore_1 = require("../agentv3/artifactStore");
 const analysisPatternMemory_1 = require("../agentv3/analysisPatternMemory");
-const skillNotesInjector_1 = require("../agentv3/selfImprove/skillNotesInjector");
 const traceCompletenessProber_1 = require("../agentv3/traceCompletenessProber");
-const entityCapture_1 = require("../agent/core/entityCapture");
 const outputLanguage_1 = require("../agentv3/outputLanguage");
 const codeAwareOutputRegistry_1 = require("../services/security/codeAwareOutputRegistry");
 const toolNarration_1 = require("../agentv3/toolNarration");
@@ -37,29 +35,17 @@ const openAiConfig_1 = require("./openAiConfig");
 const mimoReasoningCompat_1 = require("./mimoReasoningCompat");
 const openAiToolAdapter_1 = require("./openAiToolAdapter");
 const finalResultQualityGate_1 = require("../services/finalResultQualityGate");
-const OPENAI_SESSION_FRESHNESS_MS = 4 * 60 * 60 * 1000;
+const finalReportContractGate_1 = require("../services/finalReportContractGate");
+const runtimeCommon_1 = require("../agentRuntime/runtimeCommon");
+const OPENAI_SESSION_FRESHNESS_MS = runtimeCommon_1.SDK_SESSION_FRESHNESS_MS;
 const OPENAI_MAX_PLAN_CONTINUATIONS = 3;
-const OPENAI_MAX_FINAL_REPORT_CONTINUATIONS = 1;
+const OPENAI_MAX_FINAL_REPORT_CONTINUATIONS = 4;
 const OPENAI_PLAN_COMPLETE_IDLE_ABORT_MS = 8000;
 function hasAdequateClosedPhaseSummary(phase) {
     if (phase.status !== 'completed' && phase.status !== 'skipped')
         return false;
     return typeof phase.summary === 'string' && phase.summary.trim().length >= claudeMcpServer_1.MIN_PHASE_SUMMARY_CHARS;
 }
-function formatTraceContext(datasets, outputLanguage) {
-    if (!datasets || datasets.length === 0)
-        return '';
-    const parts = datasets.map((d) => {
-        const header = `| ${d.columns.join(' | ')} |`;
-        const sep = `| ${d.columns.map(() => '---').join(' | ')} |`;
-        const rows = d.rows.slice(0, 100).map((r) => `| ${r.map((v) => String(v ?? '-')).join(' | ')} |`);
-        const truncNote = d.rows.length > 100
-            ? (0, outputLanguage_1.localize)(outputLanguage, `\n*(前 100 行，共 ${d.rows.length} 行)*`, `\n*(first 100 rows out of ${d.rows.length})*`)
-            : '';
-        return `### ${d.label}\n${header}\n${sep}\n${rows.join('\n')}${truncNote}`;
-    });
-    return (0, outputLanguage_1.localize)(outputLanguage, `## 前端预查询 Trace 数据\n\n以下数据已由前端查询完毕，直接使用，无需重复 SQL 查询：\n\n${parts.join('\n\n')}`, `## Frontend Pre-queried Trace Data\n\nThe frontend has already queried the following data. Use it directly; do not repeat the same SQL query.\n\n${parts.join('\n\n')}`);
-}
 function parseJsonObject(value) {
     if (typeof value !== 'string')
         return undefined;
@@ -71,25 +57,6 @@ function parseJsonObject(value) {
         return undefined;
     }
 }
-function providerScopeFromOptions(options) {
-    if (!options.tenantId || !options.workspaceId)
-        return undefined;
-    return {
-        tenantId: options.tenantId,
-        workspaceId: options.workspaceId,
-        userId: options.userId,
-    };
-}
-function knowledgeScopeFromOptions(options) {
-    if (!options.tenantId || !options.workspaceId)
-        return undefined;
-    return {
-        tenantId: options.tenantId,
-        workspaceId: options.workspaceId,
-        userId: options.userId,
-        sourceRunId: options.runId,
-    };
-}
 function summarizeToolOutput(value) {
     const text = typeof value === 'string' ? value : JSON.stringify(value);
     if (!text)
@@ -300,12 +267,54 @@ function chooseOpenAiConclusionText(input) {
     }
     return selected;
 }
+function resolveOpenAIRunInput(params) {
+    let effectivePrompt = params.effectivePrompt;
+    if (params.quickMode) {
+        const quickConversationContext = (0, runtimeCommon_1.buildQuickConversationContext)(params.previousTurns, params.config.outputLanguage);
+        if (quickConversationContext) {
+            effectivePrompt = `${quickConversationContext}\n\n${effectivePrompt}`;
+        }
+        return {
+            input: effectivePrompt,
+            effectivePrompt,
+            shouldPersistRemoteSession: false,
+        };
+    }
+    const hasFreshSessionEntry = (0, runtimeCommon_1.isFreshRuntimeEntry)(params.sessionEntry, OPENAI_SESSION_FRESHNESS_MS, params.now ?? Date.now());
+    const freshSessionEntry = hasFreshSessionEntry ? params.sessionEntry : undefined;
+    const usePreviousResponse = params.config.protocol === 'responses'
+        && !!freshSessionEntry?.lastResponseId;
+    if (usePreviousResponse) {
+        return {
+            input: effectivePrompt,
+            effectivePrompt,
+            previousResponseId: freshSessionEntry.lastResponseId,
+            shouldPersistRemoteSession: true,
+        };
+    }
+    if (freshSessionEntry?.history) {
+        return {
+            input: [
+                ...freshSessionEntry.history,
+                { role: 'user', content: effectivePrompt },
+            ],
+            effectivePrompt,
+            shouldPersistRemoteSession: true,
+        };
+    }
+    return {
+        input: effectivePrompt,
+        effectivePrompt,
+        shouldPersistRemoteSession: true,
+    };
+}
 exports.__testing = {
     isMissingOpenAIPreviousResponseError,
     readCompletedStreamFinalOutput,
     sanitizeOpenAiConclusionText,
     chooseOpenAiConclusionText,
     selectOpenAiRecoveryAnswer,
+    resolveOpenAIRunInput,
     isRecoverableOpenAIStreamTermination,
     compactProviderErrorMessage,
 };
@@ -326,11 +335,11 @@ class OpenAIRuntime extends events_1.EventEmitter {
         this.traceProcessorService = traceProcessorService;
     }
     buildSessionMapKey(sessionId, referenceTraceId) {
-        return referenceTraceId ? `${sessionId}:ref:${referenceTraceId}` : sessionId;
+        return (0, runtimeCommon_1.buildRuntimeSessionMapKey)(sessionId, referenceTraceId);
     }
     getSdkSessionId(sessionId, referenceTraceId) {
         const entry = this.sessionMap.get(this.buildSessionMapKey(sessionId, referenceTraceId));
-        return entry && Date.now() - (entry.updatedAt || 0) < OPENAI_SESSION_FRESHNESS_MS
+        return (0, runtimeCommon_1.isFreshRuntimeEntry)(entry, OPENAI_SESSION_FRESHNESS_MS)
             ? entry.lastResponseId
             : undefined;
     }
@@ -343,7 +352,7 @@ class OpenAIRuntime extends events_1.EventEmitter {
         });
     }
     restoreArchitectureCache(traceId, architecture) {
-        this.architectureCache.set(traceId, architecture);
+        (0, runtimeCommon_1.setLruCacheEntry)(this.architectureCache, traceId, architecture);
     }
     forgetOpenAILastResponseId(sessionMapKey, reason) {
         const existing = this.sessionMap.get(sessionMapKey);
@@ -393,7 +402,7 @@ class OpenAIRuntime extends events_1.EventEmitter {
         const startTime = Date.now();
         let accumulatedAnswer = '';
         let rounds = 0;
-        const config = (0, openAiConfig_1.loadOpenAIConfig)(options.providerId, providerScopeFromOptions(options));
+        const config = (0, openAiConfig_1.loadOpenAIConfig)(options.providerId, (0, runtimeCommon_1.providerScopeFromAnalysisOptions)(options));
         const sceneType = (0, sceneClassifier_1.classifyScene)(query);
         const quickMode = await this.classifyModeForRequest(query, sessionId, traceId, options, sceneType, config);
         try {
@@ -402,22 +411,17 @@ class OpenAIRuntime extends events_1.EventEmitter {
                 sceneType,
                 lightweight: quickMode,
             });
-            const promptPrefix = formatTraceContext(options.traceContext, config.outputLanguage);
+            const promptPrefix = (0, runtimeCommon_1.formatTraceContext)(options.traceContext, config.outputLanguage);
             const effectivePrompt = promptPrefix ? `${promptPrefix}\n\n${query}` : query;
             const sessionEntry = this.sessionMap.get(context.sessionMapKey);
-            const hasFreshHistory = !!sessionEntry?.history
-                && Date.now() - sessionEntry.updatedAt < OPENAI_SESSION_FRESHNESS_MS;
-            const usePreviousResponse = config.protocol === 'responses'
-                && !!sessionEntry?.lastResponseId
-                && Date.now() - sessionEntry.updatedAt < OPENAI_SESSION_FRESHNESS_MS;
-            const input = usePreviousResponse
-                ? effectivePrompt
-                : hasFreshHistory
-                    ? [
-                        ...sessionEntry.history,
-                        { role: 'user', content: effectivePrompt },
-                    ]
-                    : effectivePrompt;
+            const runInput = resolveOpenAIRunInput({
+                quickMode,
+                config,
+                sessionEntry,
+                effectivePrompt,
+                previousTurns: context.previousTurns,
+            });
+            const input = runInput.input;
             (0, agents_1.setTracingDisabled)(true);
             const provider = (0, mimoReasoningCompat_1.shouldUseMimoReasoningContentCompat)(config)
                 ? new agents_1.OpenAIProvider({
@@ -464,13 +468,13 @@ class OpenAIRuntime extends events_1.EventEmitter {
                 type: 'progress',
                 content: {
                     phase: 'answering',
-                    message: (0, outputLanguage_1.localize)(config.outputLanguage, `OpenAI Agents SDK 分析中 (${agent.model})...`, `Analyzing with OpenAI Agents SDK (${agent.model})...`),
+                    message: (0, outputLanguage_1.localize)(config.outputLanguage, `AI 分析引擎分析中 (${agent.model})...`, `AI analysis engine is running (${agent.model})...`),
                     runtime: 'openai-agents-sdk',
                     model: agent.model,
                 },
                 timestamp: Date.now(),
             });
-            let currentPreviousResponseId = usePreviousResponse ? sessionEntry.lastResponseId : undefined;
+            let currentPreviousResponseId = runInput.previousResponseId;
             try {
                 let currentInput = input;
                 let conclusion = '';
@@ -527,7 +531,7 @@ class OpenAIRuntime extends events_1.EventEmitter {
                                 type: 'progress',
                                 content: {
                                     phase: 'concluding',
-                                    message: (0, outputLanguage_1.localize)(config.outputLanguage, 'OpenAI plan 已完成，provider 未主动结束 stream，按已完成计划收尾。', 'The OpenAI plan is complete; the provider did not close the stream, so finalizing from the completed plan.'),
+                                    message: (0, outputLanguage_1.localize)(config.outputLanguage, '分析阶段已完成，正在整理最终报告。', 'Analysis phases are complete; preparing the final report.'),
                                 },
                                 timestamp: Date.now(),
                             });
@@ -615,6 +619,8 @@ class OpenAIRuntime extends events_1.EventEmitter {
                             completedByPlanIdle,
                             timedOut,
                             finalReportContinuations,
+                            query,
+                            sceneType,
                         }) && streamHistory.length > 0) {
                             finalReportContinuations++;
                             this.emitUpdate({
@@ -682,7 +688,7 @@ class OpenAIRuntime extends events_1.EventEmitter {
                         (0, finalResultQualityGate_1.looksLikePhaseSummaryFallback)(conclusion)) &&
                     !partial) {
                     partial = true;
-                    terminationMessage = (0, outputLanguage_1.localize)(config.outputLanguage, 'OpenAI plan 已完成，但 provider 没有输出独立最终报告；已退回到阶段摘要，结果信息密度可能不足。', 'The OpenAI plan completed, but the provider did not produce an independent final report; falling back to phase summaries, which may be less informative.');
+                    terminationMessage = (0, outputLanguage_1.localize)(config.outputLanguage, '分析阶段已完成，但模型没有输出独立最终报告；已使用阶段摘要兜底，结果信息密度可能不足。', 'Analysis phases completed, but the model did not produce an independent final report; falling back to phase summaries, which may be less informative.');
                     this.emitUpdate({
                         type: 'degraded',
                         content: {
@@ -711,7 +717,7 @@ class OpenAIRuntime extends events_1.EventEmitter {
                     terminationReason,
                     terminationMessage,
                 };
-                const gateIssue = (0, finalResultQualityGate_1.applyFinalResultQualityGate)({ result, query });
+                const gateIssue = (0, finalResultQualityGate_1.applyFinalResultQualityGate)({ result, query, sceneType });
                 if (gateIssue) {
                     this.emitUpdate({
                         type: 'degraded',
@@ -724,12 +730,14 @@ class OpenAIRuntime extends events_1.EventEmitter {
                         timestamp: Date.now(),
                     });
                 }
-                this.sessionMap.set(context.sessionMapKey, {
-                    history: finalHistory,
-                    lastResponseId: finalLastResponseId,
-                    runState: finalRunState,
-                    updatedAt: Date.now(),
-                });
+                if (runInput.shouldPersistRemoteSession) {
+                    this.sessionMap.set(context.sessionMapKey, {
+                        history: finalHistory,
+                        lastResponseId: finalLastResponseId,
+                        runState: finalRunState,
+                        updatedAt: Date.now(),
+                    });
+                }
                 this.recordTurn({
                     query,
                     sessionId,
@@ -766,33 +774,18 @@ class OpenAIRuntime extends events_1.EventEmitter {
                     });
                 }
                 else if (error instanceof agents_1.MaxTurnsExceededError) {
-                    const partialConclusion = accumulatedAnswer || (0, outputLanguage_1.localize)(config.outputLanguage, '分析达到 OpenAI Agents SDK 轮次上限，尚未形成完整结论。', 'The OpenAI Agents SDK run reached the turn limit before a complete conclusion was produced.');
-                    const findings = (0, claudeFindingExtractor_1.extractFindingsFromText)(partialConclusion);
-                    const confidence = Math.min(0.55, this.estimateConfidence(findings, partialConclusion));
-                    this.emitUpdate({
-                        type: 'degraded',
-                        content: {
-                            module: 'openAiRuntime',
-                            fallback: 'partial_result_after_max_turns',
-                            partial: true,
-                            terminationReason: 'max_turns',
-                            message: (0, outputLanguage_1.localize)(config.outputLanguage, 'OpenAI 分析达到轮次上限，结果可能不完整', 'OpenAI analysis reached the turn limit; result may be incomplete'),
-                        },
-                        timestamp: Date.now(),
-                    });
-                    return {
+                    return this.recordMaxTurnsPartialResult({
+                        error,
+                        query,
                         sessionId,
-                        success: true,
-                        findings,
-                        hypotheses: context.hypotheses.map(h => this.toProtocolHypothesis(h)),
-                        conclusion: partialConclusion,
-                        confidence,
+                        outputLanguage: config.outputLanguage,
+                        accumulatedAnswer,
+                        context,
+                        startTime,
                         rounds,
-                        totalDurationMs: Date.now() - startTime,
-                        partial: true,
-                        terminationReason: 'max_turns',
-                        terminationMessage: error.message,
-                    };
+                        quickMode,
+                        codeAwareMode: options.codeAwareMode,
+                    });
                 }
                 const recoverablePartial = this.recoverPartialResultAfterStreamTermination({
                     error,
@@ -804,6 +797,7 @@ class OpenAIRuntime extends events_1.EventEmitter {
                     query,
                     startTime,
                     rounds,
+                    codeAwareMode: options.codeAwareMode,
                 });
                 if (recoverablePartial) {
                     return recoverablePartial;
@@ -815,7 +809,7 @@ class OpenAIRuntime extends events_1.EventEmitter {
             const message = compactProviderErrorMessage(error);
             this.emitUpdate({
                 type: 'error',
-                content: { message: `OpenAI Agents SDK analysis failed: ${message}` },
+                content: { message: `AI analysis failed: ${message}` },
                 timestamp: Date.now(),
             });
             return {
@@ -823,7 +817,7 @@ class OpenAIRuntime extends events_1.EventEmitter {
                 success: false,
                 findings: [],
                 hypotheses: [],
-                conclusion: (0, outputLanguage_1.localize)(config.outputLanguage, `OpenAI Agents SDK 分析失败：${message}`, `OpenAI Agents SDK analysis failed: ${message}`),
+                conclusion: (0, outputLanguage_1.localize)(config.outputLanguage, `AI 分析失败：${message}`, `AI analysis failed: ${message}`),
                 confidence: 0,
                 rounds,
                 totalDurationMs: Date.now() - startTime,
@@ -866,7 +860,7 @@ class OpenAIRuntime extends events_1.EventEmitter {
         const planState = this.sessionPlans.get(sessionId);
         const artifactStore = this.artifactStores.get(sessionId);
         const sessionEntry = this.sessionMap.get(this.buildSessionMapKey(sessionId, sessionFields.referenceTraceId));
-        const freshSessionEntry = sessionEntry && Date.now() - (sessionEntry.updatedAt || 0) < OPENAI_SESSION_FRESHNESS_MS
+        const freshSessionEntry = (0, runtimeCommon_1.isFreshRuntimeEntry)(sessionEntry, OPENAI_SESSION_FRESHNESS_MS)
             ? sessionEntry
             : undefined;
         return {
@@ -987,12 +981,10 @@ class OpenAIRuntime extends events_1.EventEmitter {
         uncertaintyFlags.splice(0);
         let sqlErrors = this.sessionSqlErrors.get(sessionId);
         if (!sqlErrors) {
-            sqlErrors = (0, claudeMcpServer_1.loadLearnedSqlFixPairs)(5, knowledgeScopeFromOptions(options));
+            sqlErrors = (0, claudeMcpServer_1.loadLearnedSqlFixPairs)(5, (0, runtimeCommon_1.knowledgeScopeFromAnalysisOptions)(options));
             this.sessionSqlErrors.set(sessionId, sqlErrors);
         }
-        const skillNotesBudget = !lightweight && process.env.SELF_IMPROVE_NOTES_INJECT_ENABLED === '1'
-            ? new skillNotesInjector_1.SkillNotesBudget({ mode: 'full' })
-            : undefined;
+        const skillNotesBudget = (0, runtimeCommon_1.createRuntimeSkillNotesBudget)(lightweight);
         const { allowedTools, toolDefinitions } = (0, claudeMcpServer_1.createClaudeMcpServer)({
             sessionId,
             traceId,
@@ -1020,7 +1012,7 @@ class OpenAIRuntime extends events_1.EventEmitter {
             lightweight,
             skillNotesBudget,
             outputLanguage: config.outputLanguage,
-            knowledgeScope: knowledgeScopeFromOptions(options),
+            knowledgeScope: (0, runtimeCommon_1.knowledgeScopeFromAnalysisOptions)(options),
             codeAwareMode: options.codeAwareMode,
             codebaseIds: options.codebaseIds,
         });
@@ -1042,6 +1034,7 @@ class OpenAIRuntime extends events_1.EventEmitter {
             .filter((e) => e.fixedSql)
             .slice(-3)
             .map((e) => ({ errorSql: e.errorSql, errorMessage: e.errorMessage, fixedSql: e.fixedSql }));
+        const traceInfo = this.traceProcessorService.getTrace(traceId);
         const systemPrompt = lightweight
             ? (0, claudeSystemPrompt_1.buildQuickSystemPrompt)({
                 architecture,
@@ -1072,6 +1065,8 @@ class OpenAIRuntime extends events_1.EventEmitter {
                 selectionContext: options.selectionContext,
                 comparison: comparisonContext,
                 traceCompleteness,
+                traceOs: traceInfo?.traceOs,
+                traceFormat: traceInfo?.traceFormat,
                 outputLanguage: config.outputLanguage,
                 codeAwareMode: options.codeAwareMode,
                 codebaseIds: options.codebaseIds,
@@ -1089,7 +1084,7 @@ class OpenAIRuntime extends events_1.EventEmitter {
         };
     }
     async detectArchitecture(traceId, packageName) {
-        const cached = this.architectureCache.get(traceId);
+        const cached = (0, runtimeCommon_1.getLruCacheEntry)(this.architectureCache, traceId);
         if (cached)
             return cached;
         try {
@@ -1100,7 +1095,7 @@ class OpenAIRuntime extends events_1.EventEmitter {
                 packageName,
             });
             if (architecture) {
-                this.architectureCache.set(traceId, architecture);
+                (0, runtimeCommon_1.setLruCacheEntry)(this.architectureCache, traceId, architecture);
                 this.emitUpdate({ type: 'architecture_detected', content: { architecture }, timestamp: Date.now() });
             }
             return architecture;
@@ -1158,15 +1153,16 @@ class OpenAIRuntime extends events_1.EventEmitter {
         };
     }
     async detectVendor(traceId) {
-        const cached = this.vendorCache.get(traceId);
+        const cached = (0, runtimeCommon_1.getLruCacheEntry)(this.vendorCache, traceId);
         if (cached)
             return cached;
         try {
             const adapter = (0, skillAnalysisAdapter_1.getSkillAnalysisAdapter)(this.traceProcessorService);
             await adapter.ensureInitialized();
             const result = await adapter.detectVendor(traceId);
-            if (result.vendor && result.vendor !== 'aosp')
-                this.vendorCache.set(traceId, result.vendor);
+            if (result.vendor && result.vendor !== 'aosp') {
+                (0, runtimeCommon_1.setLruCacheEntry)(this.vendorCache, traceId, result.vendor);
+            }
             return result.vendor;
         }
         catch (error) {
@@ -1175,12 +1171,12 @@ class OpenAIRuntime extends events_1.EventEmitter {
         }
     }
     async detectCompleteness(traceId, architecture) {
-        const cached = this.completenessCache.get(traceId);
+        const cached = (0, runtimeCommon_1.getLruCacheEntry)(this.completenessCache, traceId);
         if (cached)
             return cached;
         try {
             const completeness = await (0, traceCompletenessProber_1.probeTraceCompleteness)(this.traceProcessorService, traceId, architecture?.type);
-            this.completenessCache.set(traceId, completeness);
+            (0, runtimeCommon_1.setLruCacheEntry)(this.completenessCache, traceId, completeness);
             return completeness;
         }
         catch (error) {
@@ -1256,11 +1252,9 @@ class OpenAIRuntime extends events_1.EventEmitter {
         }
         const conclusion = input.conclusion.trim();
         const fallback = input.fallbackConclusion?.trim();
-        if (!fallback)
-            return false;
         if (!conclusion)
             return true;
-        if (isSameConclusionText(conclusion, fallback))
+        if (fallback && isSameConclusionText(conclusion, fallback))
             return true;
         if ((0, finalResultQualityGate_1.looksLikePhaseSummaryFallback)(conclusion))
             return true;
@@ -1268,6 +1262,13 @@ class OpenAIRuntime extends events_1.EventEmitter {
             return true;
         if (looksLikeProcessNarrationParagraph(conclusion))
             return true;
+        if ((0, finalReportContractGate_1.assessFinalReportContractCompleteness)({
+            conclusion,
+            query: input.query,
+            sceneType: input.sceneType,
+        })) {
+            return true;
+        }
         return looksLikeProcessNarrationParagraph(conclusion.split(/\n{2,}/)[0] || '');
     }
     buildFinalReportAfterPlanCompletePrompt(outputLanguage) {
@@ -1281,7 +1282,7 @@ class OpenAIRuntime extends events_1.EventEmitter {
         return template;
     }
     formatPlanCompleteReportContinuationMessage(outputLanguage) {
-        return (0, outputLanguage_1.localize)(outputLanguage, 'OpenAI plan 已完成，但最终正文仍是阶段摘要，继续请求完整最终报告。', 'The OpenAI plan is complete, but the final body is still a phase summary; requesting the complete final report.');
+        return (0, outputLanguage_1.localize)(outputLanguage, '最终报告仍需补齐，继续整理完整结论。', 'The final report still needs completion; continuing to assemble the full conclusion.');
     }
     buildCompletedPlanFallbackConclusion(sessionId, quickMode, outputLanguage) {
         if (quickMode)
@@ -1396,7 +1397,9 @@ class OpenAIRuntime extends events_1.EventEmitter {
         let conclusion = planStatus.complete
             ? conclusionBase
             : this.withIncompletePlanWarning(conclusionBase, planStatus, params.outputLanguage);
-        conclusion = (0, codeAwareOutputRegistry_1.sanitizeCodeAwareText)(params.sessionId, conclusion);
+        if (params.codeAwareMode && params.codeAwareMode !== 'off') {
+            conclusion = (0, codeAwareOutputRegistry_1.sanitizeCodeAwareText)(params.sessionId, conclusion);
+        }
         const findings = (0, claudeFindingExtractor_1.extractFindingsFromText)(conclusion);
         const confidence = Math.min(0.55, this.estimateConfidence(findings, conclusion));
         const terminationReason = planStatus.complete ? 'timeout' : 'plan_incomplete';
@@ -1456,12 +1459,63 @@ class OpenAIRuntime extends events_1.EventEmitter {
             terminationMessage,
         };
     }
+    recordMaxTurnsPartialResult(params) {
+        let partialConclusion = params.accumulatedAnswer || (0, outputLanguage_1.localize)(params.outputLanguage, '分析达到轮次上限，尚未形成完整结论。', 'The analysis reached the turn limit before a complete conclusion was produced.');
+        if (params.codeAwareMode && params.codeAwareMode !== 'off') {
+            partialConclusion = (0, codeAwareOutputRegistry_1.sanitizeCodeAwareText)(params.sessionId, partialConclusion);
+        }
+        const findings = (0, claudeFindingExtractor_1.extractFindingsFromText)(partialConclusion);
+        const confidence = Math.min(0.55, this.estimateConfidence(findings, partialConclusion));
+        const result = {
+            sessionId: params.sessionId,
+            success: true,
+            findings,
+            hypotheses: params.context.hypotheses.map(h => this.toProtocolHypothesis(h)),
+            conclusion: partialConclusion,
+            confidence,
+            rounds: params.rounds,
+            totalDurationMs: Date.now() - params.startTime,
+            partial: true,
+            terminationReason: 'max_turns',
+            terminationMessage: params.error.message,
+        };
+        this.emitUpdate({
+            type: 'degraded',
+            content: {
+                module: 'openAiRuntime',
+                fallback: 'partial_result_after_max_turns',
+                partial: true,
+                terminationReason: 'max_turns',
+                message: (0, outputLanguage_1.localize)(params.outputLanguage, 'OpenAI 分析达到轮次上限，结果可能不完整', 'OpenAI analysis reached the turn limit; result may be incomplete'),
+            },
+            timestamp: Date.now(),
+        });
+        this.recordTurn({
+            query: params.query,
+            sessionId: params.sessionId,
+            result,
+            sessionContext: params.context.sessionContext,
+            previousTurnCount: params.context.previousTurns.length,
+            quickMode: params.quickMode,
+        });
+        this.emitUpdate({
+            type: 'conclusion',
+            content: { conclusion: result.conclusion, durationMs: Date.now() - params.startTime, turns: params.rounds },
+            timestamp: Date.now(),
+        });
+        this.emitUpdate({
+            type: 'answer_token',
+            content: { done: true, totalChars: result.conclusion.length },
+            timestamp: Date.now(),
+        });
+        return result;
+    }
     formatPlanContinuationMessage(status, outputLanguage) {
         if (!status.hasPlan) {
-            return (0, outputLanguage_1.localize)(outputLanguage, 'OpenAI 模型提前结束但尚未提交分析计划，继续执行...', 'The OpenAI model stopped before submitting an analysis plan; continuing...');
+            return (0, outputLanguage_1.localize)(outputLanguage, '继续建立分析计划并补齐必要证据...', 'Continuing by creating the analysis plan and collecting required evidence...');
         }
         const phaseNames = status.pendingPhases.map(p => p.name || p.id).slice(0, 3).join('、');
-        return (0, outputLanguage_1.localize)(outputLanguage, `OpenAI 模型提前结束但 plan 未完成，继续执行剩余阶段：${phaseNames}`, `The OpenAI model stopped before the plan completed; continuing remaining phases: ${phaseNames}`);
+        return (0, outputLanguage_1.localize)(outputLanguage, `继续补齐剩余分析阶段：${phaseNames}`, `Continuing the remaining analysis phases: ${phaseNames}`);
     }
     formatIncompletePlanMessage(status, outputLanguage) {
         if (!status.hasPlan) {
@@ -1585,94 +1639,16 @@ class OpenAIRuntime extends events_1.EventEmitter {
         });
     }
     captureEntitiesFromSkillDisplayResults(displayResults, entityStore) {
-        try {
-            const data = {};
-            for (const dr of displayResults) {
-                if (dr.stepId && dr.data)
-                    data[dr.stepId] = dr.data;
-            }
-            const captured = (0, entityCapture_1.captureEntitiesFromResponses)([{
-                    agentId: 'openai-agent',
-                    success: true,
-                    toolResults: [{ toolName: 'invoke_skill', data }],
-                }]);
-            (0, entityCapture_1.applyCapturedEntities)(entityStore, captured);
-        }
-        catch (error) {
-            console.warn('[OpenAIRuntime] Entity capture failed:', error.message);
-        }
+        (0, runtimeCommon_1.captureSkillDisplayEntities)(displayResults, entityStore, 'openai-agent');
     }
     collectPreviousFindings(sessionContext, maxTurns = 3) {
-        try {
-            const turns = sessionContext.getAllTurns?.() || [];
-            return turns.slice(-maxTurns).flatMap((turn) => turn.findings || []).slice(0, 5);
-        }
-        catch {
-            return [];
-        }
+        return (0, runtimeCommon_1.collectRecentFindings)(sessionContext, { maxTurns, maxFindings: 5 });
     }
     buildEntityContext(entityStore) {
-        try {
-            const lines = [];
-            const frames = entityStore.getAllFrames?.() || [];
-            if (frames.length > 0) {
-                lines.push(`**帧 (${frames.length})**:`);
-                for (const f of frames.slice(0, 15)) {
-                    const parts = [`frame_id=${f.frame_id}`];
-                    if (f.start_ts)
-                        parts.push(`ts=${f.start_ts}`);
-                    if (f.jank_type)
-                        parts.push(`jank=${f.jank_type}`);
-                    if (f.dur_ms)
-                        parts.push(`dur=${f.dur_ms}ms`);
-                    if (f.process_name)
-                        parts.push(`proc=${f.process_name}`);
-                    lines.push(`- ${parts.join(', ')}`);
-                }
-            }
-            const sessions = entityStore.getAllSessions?.() || [];
-            if (sessions.length > 0) {
-                lines.push(`**滑动会话 (${sessions.length})**:`);
-                for (const s of sessions.slice(0, 8)) {
-                    const parts = [`session_id=${s.session_id}`];
-                    if (s.start_ts)
-                        parts.push(`ts=${s.start_ts}`);
-                    if (s.jank_count)
-                        parts.push(`janks=${s.jank_count}`);
-                    if (s.process_name)
-                        parts.push(`proc=${s.process_name}`);
-                    lines.push(`- ${parts.join(', ')}`);
-                }
-            }
-            return lines.length > 0 ? lines.join('\n') : undefined;
-        }
-        catch {
-            return undefined;
-        }
+        return (0, runtimeCommon_1.buildEntityContext)(entityStore);
     }
     toProtocolHypothesis(h) {
-        const statusMap = {
-            formed: 'proposed',
-            confirmed: 'confirmed',
-            rejected: 'rejected',
-        };
-        const confidenceMap = { formed: 0.5, confirmed: 0.85, rejected: 0.1 };
-        return {
-            id: h.id,
-            description: h.statement,
-            status: statusMap[h.status] || 'proposed',
-            confidence: confidenceMap[h.status] ?? 0.5,
-            supportingEvidence: h.evidence && h.status === 'confirmed'
-                ? [{ id: `${h.id}-ev`, type: 'observation', description: h.evidence, source: 'openai', strength: 0.8 }]
-                : [],
-            contradictingEvidence: h.evidence && h.status === 'rejected'
-                ? [{ id: `${h.id}-ev`, type: 'observation', description: h.evidence, source: 'openai', strength: 0.8 }]
-                : [],
-            proposedBy: 'openai',
-            relevantAgents: ['openai'],
-            createdAt: h.formedAt,
-            updatedAt: h.resolvedAt || h.formedAt,
-        };
+        return (0, runtimeCommon_1.toProtocolHypothesis)(h, 'openai');
     }
     emitUpdate(update) {
         this.emit('update', update);