@gracker/smartperfetto 1.0.13

package/dist/agentv3/claudeRuntime.js

@@ -0,0 +1,2541 @@
+"use strict";
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (C) 2024-2026 Gracker (Chris)
+// This file is part of SmartPerfetto. See LICENSE for details.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeRuntime = exports.__testing = void 0;
+const events_1 = require("events");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const claude_agent_sdk_1 = require("@anthropic-ai/claude-agent-sdk");
+const skillExecutor_1 = require("../services/skillEngine/skillExecutor");
+const skillLoader_1 = require("../services/skillEngine/skillLoader");
+const skillAnalysisAdapter_1 = require("../services/skillEngine/skillAnalysisAdapter");
+const architectureDetector_1 = require("../agent/detectors/architectureDetector");
+const enhancedSessionContext_1 = require("../agent/context/enhancedSessionContext");
+const claudeMcpServer_1 = require("./claudeMcpServer");
+const claudeSystemPrompt_1 = require("./claudeSystemPrompt");
+const claudeSseBridge_1 = require("./claudeSseBridge");
+const analysisTermination_1 = require("./analysisTermination");
+const claudeFindingExtractor_1 = require("./claudeFindingExtractor");
+const claudeConfig_1 = require("./claudeConfig");
+const focusAppDetector_1 = require("./focusAppDetector");
+const sceneClassifier_1 = require("./sceneClassifier");
+const queryComplexityClassifier_1 = require("./queryComplexityClassifier");
+const claudeAgentDefinitions_1 = require("./claudeAgentDefinitions");
+const sqlKnowledgeBase_1 = require("../services/sqlKnowledgeBase");
+const types_1 = require("./types");
+const artifactStore_1 = require("./artifactStore");
+const toolCallSummary_1 = require("./toolCallSummary");
+const recoveryNoteBuilder_1 = require("./recoveryNoteBuilder");
+const contextTokenMeter_1 = require("./contextTokenMeter");
+const agentMetrics_1 = require("./agentMetrics");
+const analysisPatternMemory_1 = require("./analysisPatternMemory");
+const skillNotesInjector_1 = require("./selfImprove/skillNotesInjector");
+const strategyFingerprint_1 = require("./selfImprove/strategyFingerprint");
+const claudeVerifier_1 = require("./claudeVerifier");
+const runtimePaths_1 = require("../runtimePaths");
+function parseQuickBudgetEnv() {
+    const v = process.env.SELF_IMPROVE_QUICK_NOTES_BUDGET;
+    if (!v)
+        return undefined;
+    const n = Number.parseInt(v, 10);
+    return Number.isFinite(n) && n >= 0 ? n : undefined;
+}
+function parseLeadingJsonObject(text) {
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === '\\') {
+                escaped = true;
+            }
+            else if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+        }
+        else if (char === '{') {
+            depth++;
+        }
+        else if (char === '}') {
+            depth--;
+            if (depth === 0) {
+                try {
+                    const parsed = JSON.parse(text.slice(0, i + 1));
+                    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+                        ? parsed
+                        : null;
+                }
+                catch {
+                    return null;
+                }
+            }
+        }
+    }
+    return null;
+}
+function extractPlanPhaseIdFromToolResult(resultStr) {
+    const candidates = [resultStr];
+    try {
+        const parsed = JSON.parse(resultStr);
+        const entries = Array.isArray(parsed) ? parsed : [parsed];
+        for (const entry of entries) {
+            if (entry && typeof entry === 'object' && typeof entry.text === 'string') {
+                candidates.push(entry.text);
+            }
+        }
+    }
+    catch {
+        // Fall through to leading-object parsing below.
+    }
+    for (const candidate of candidates) {
+        const trimmed = candidate.trim();
+        const parsed = parseLeadingJsonObject(trimmed);
+        const planPhaseId = parsed?.planPhaseId;
+        if (typeof planPhaseId === 'string' && planPhaseId.trim())
+            return planPhaseId.trim();
+    }
+    return undefined;
+}
+const traceCompletenessProber_1 = require("./traceCompletenessProber");
+const entityCapture_1 = require("../agent/core/entityCapture");
+const outputLanguage_1 = require("./outputLanguage");
+const runtimeSnapshotStore_1 = require("../services/runtimeSnapshotStore");
+const enterpriseMigration_1 = require("../services/enterpriseMigration");
+const SESSION_MAP_FILE = (0, runtimePaths_1.backendLogPath)('claude_session_map.json');
+/** Max age for session map entries before pruning (24 hours). */
+const SESSION_MAP_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+/** Claude SDK sessions expire server-side after roughly 4 hours. */
+const SDK_SESSION_FRESHNESS_MS = 4 * 60 * 60 * 1000;
+function enterpriseSessionMapDbWritesEnabled() {
+    return (0, enterpriseMigration_1.enterpriseDbWritesEnabled)();
+}
+function legacySessionMapWritesEnabled() {
+    return (0, enterpriseMigration_1.legacyFilesystemWritesEnabled)();
+}
+function loadPersistedSessionMap() {
+    try {
+        if (fs.existsSync(SESSION_MAP_FILE)) {
+            const data = JSON.parse(fs.readFileSync(SESSION_MAP_FILE, 'utf-8'));
+            const map = new Map();
+            for (const [key, value] of Object.entries(data)) {
+                // Migration: old format stored plain string, new format stores {sdkSessionId, updatedAt}
+                if (typeof value === 'string') {
+                    map.set(key, { sdkSessionId: value, updatedAt: Date.now() });
+                }
+                else if (value && typeof value === 'object') {
+                    const entry = value;
+                    if (typeof entry.sdkSessionId !== 'string')
+                        continue;
+                    const updatedAt = typeof entry.updatedAt === 'number' && Number.isFinite(entry.updatedAt)
+                        ? entry.updatedAt
+                        : Date.now();
+                    const mode = entry.mode === 'full' ? entry.mode : undefined;
+                    map.set(key, { sdkSessionId: entry.sdkSessionId, updatedAt, ...(mode ? { mode } : {}) });
+                }
+            }
+            return map;
+        }
+    }
+    catch {
+        // Ignore — start with empty map
+    }
+    return new Map();
+}
+function loadSessionMapForCurrentMode() {
+    if ((0, enterpriseMigration_1.legacyFilesystemReadAuthorityEnabled)()) {
+        return loadPersistedSessionMap();
+    }
+    try {
+        return (0, runtimeSnapshotStore_1.loadClaudeSessionMapFromRuntimeSnapshots)(SESSION_MAP_MAX_AGE_MS);
+    }
+    catch (err) {
+        console.warn('[ClaudeRuntime] Failed to load runtime_snapshots session map:', err.message);
+    }
+    return new Map();
+}
+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,
+    };
+}
+/**
+ * Debounce timer for session map persistence — avoids blocking event loop on every SDK message.
+ * P2-1: Use a Map keyed by the Map reference to support multiple ClaudeRuntime instances.
+ */
+const saveTimers = new WeakMap();
+const SAVE_DEBOUNCE_MS = 2000;
+function savePersistedSessionMap(map) {
+    const existing = saveTimers.get(map);
+    if (existing)
+        clearTimeout(existing);
+    saveTimers.set(map, setTimeout(() => {
+        saveTimers.delete(map);
+        savePersistedSessionMapSync(map);
+    }, SAVE_DEBOUNCE_MS));
+}
+/** Immediate save — used by debounce timer and for critical operations (session removal). */
+function savePersistedSessionMapSync(map) {
+    try {
+        const dir = path.dirname(SESSION_MAP_FILE);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        // Prune stale entries before saving
+        const now = Date.now();
+        for (const [key, entry] of map) {
+            if (now - entry.updatedAt > SESSION_MAP_MAX_AGE_MS) {
+                map.delete(key);
+            }
+        }
+        const tmpFile = SESSION_MAP_FILE + '.tmp';
+        fs.writeFileSync(tmpFile, JSON.stringify(Object.fromEntries(map)));
+        fs.renameSync(tmpFile, SESSION_MAP_FILE);
+    }
+    catch (err) {
+        console.warn('[ClaudeRuntime] Failed to persist session map:', err.message);
+    }
+}
+// Notes persistence now handled by unified SessionStateSnapshot — no separate disk I/O.
+// The old logs/session_notes/ directory is no longer written to.
+// P2-G1: ALLOWED_TOOLS is now auto-derived from createClaudeMcpServer() return value.
+// No longer hardcoded — adding a new MCP tool automatically includes it.
+/**
+ * Format pre-queried trace datasets as Markdown tables to prepend to the AI prompt.
+ * Mirrors smartperfetto's approach: data is ready upfront so the AI skips basic SQL turns.
+ */
+function formatTraceContext(datasets, outputLanguage = outputLanguage_1.DEFAULT_OUTPUT_LANGUAGE) {
+    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')}`);
+}
+/** Check if an error is retryable (API overload/server errors). */
+function isRetryableError(err) {
+    const msg = err.message || '';
+    // Anthropic API errors: 529 (overload), 500 (server), 503 (service unavailable)
+    return /529|overload|500|server error|503|service unavailable|ECONNRESET|ETIMEDOUT/i.test(msg);
+}
+function getSdkResultErrorMessage(msg) {
+    if (!msg || msg.type !== 'result')
+        return undefined;
+    const subtype = typeof msg.subtype === 'string' ? msg.subtype : 'unknown';
+    if (subtype === 'success' || (0, analysisTermination_1.isSdkMaxTurnsSubtype)(subtype))
+        return undefined;
+    const errors = Array.isArray(msg.errors)
+        ? msg.errors.map(formatSdkError).filter(Boolean)
+        : [];
+    return `Claude analysis error (${subtype}): ${errors.join('; ') || 'Unknown error'}`;
+}
+function formatSdkError(error) {
+    if (typeof error === 'string')
+        return error;
+    if (error instanceof Error)
+        return error.message;
+    if (error && typeof error === 'object') {
+        const maybeMessage = error.message;
+        if (typeof maybeMessage === 'string')
+            return maybeMessage;
+        try {
+            return JSON.stringify(error);
+        }
+        catch {
+            return String(error);
+        }
+    }
+    return String(error);
+}
+function isMissingSdkConversationError(message) {
+    return /No conversation found with session ID/i.test(message);
+}
+function isFreshFullSdkSessionEntry(entry, now = Date.now()) {
+    return !!entry
+        && entry.mode === 'full'
+        && now - (entry.updatedAt || 0) < SDK_SESSION_FRESHNESS_MS;
+}
+function compactForPrompt(value, maxChars) {
+    const text = String(value ?? '').replace(/\s+/g, ' ').trim();
+    if (text.length <= maxChars)
+        return text;
+    return `${text.slice(0, Math.max(0, maxChars - 1))}...`;
+}
+function buildQuickConversationContext(previousTurns, outputLanguage = outputLanguage_1.DEFAULT_OUTPUT_LANGUAGE) {
+    const turns = previousTurns.filter(turn => turn.completed).slice(-3);
+    if (turns.length === 0)
+        return undefined;
+    const lines = [
+        (0, outputLanguage_1.localize)(outputLanguage, '## 最近对话上下文\n\n以下是 SmartPerfetto 本地保存的最近问答，用于理解“继续/刚才/这个”等指代；不要把它当作当前问题的新证据。', '## Recent Conversation Context\n\nThe following recent SmartPerfetto turns are local context for references like "continue", "earlier", or "this"; do not treat them as new evidence for the current question.'),
+    ];
+    for (const turn of turns) {
+        const query = compactForPrompt(turn.query, 220);
+        const answer = compactForPrompt(turn.result?.message || '', 700);
+        const findings = turn.findings
+            .slice(0, 3)
+            .map(f => `[${f.severity}] ${compactForPrompt(f.title, 160)}`)
+            .filter(Boolean);
+        lines.push(`### Turn ${turn.turnIndex + 1}`);
+        lines.push(`- ${(0, outputLanguage_1.localize)(outputLanguage, '用户', 'User')}: ${query}`);
+        if (answer) {
+            lines.push(`- ${(0, outputLanguage_1.localize)(outputLanguage, '上轮回答', 'Previous answer')}: ${answer}`);
+        }
+        if (findings.length > 0) {
+            lines.push(`- ${(0, outputLanguage_1.localize)(outputLanguage, '上轮发现', 'Previous findings')}: ${findings.join('; ')}`);
+        }
+    }
+    return lines.join('\n');
+}
+exports.__testing = {
+    getSdkResultErrorMessage,
+    isMissingSdkConversationError,
+    isFreshFullSdkSessionEntry,
+    buildQuickConversationContext,
+};
+/** Sleep for the given milliseconds. */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Wrap sdkQuery with exponential backoff retry for transient API errors
+ * and expose a `close()` handle so timeout/abort paths can terminate the
+ * SDK subprocess instead of just breaking out of the `for await` loop.
+ *
+ * Without `close()`, a consumer that `break`s out of the iterator leaves
+ * the SDK free to continue executing queued MCP tool calls (e.g.
+ * `execute_sql`). Those "ghost" calls hit trace_processor after the
+ * session logger has closed, producing orphan errors no one handles.
+ */
+function sdkQueryWithRetry(params, options = {}) {
+    const { maxRetries = 2, baseDelayMs = 2000, emitUpdate, outputLanguage = (0, claudeConfig_1.loadClaudeConfig)().outputLanguage } = options;
+    const queryOptions = params.options ?? {};
+    const binaryOpt = (0, claudeConfig_1.getSdkBinaryOption)(queryOptions.env);
+    const mergedParams = binaryOpt.pathToClaudeCodeExecutable
+        ? { ...params, options: { ...queryOptions, ...binaryOpt } }
+        : params;
+    // Tracks the Query instance currently being iterated so `close()` can
+    // forward termination to the underlying SDK subprocess across retries.
+    let currentQuery;
+    let closed = false;
+    // We can't directly retry an async iterable, so we use a generator wrapper.
+    // On the first call to next(), we attempt sdkQuery. If it throws, we retry.
+    async function* retryableStream() {
+        let lastErr;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            if (closed)
+                return;
+            try {
+                currentQuery = (0, claude_agent_sdk_1.query)(mergedParams);
+                // Yield all messages from the stream
+                for await (const msg of currentQuery) {
+                    if (closed)
+                        return;
+                    yield msg;
+                }
+                return; // Success — exit generator
+            }
+            catch (err) {
+                lastErr = err;
+                // If the caller invoked close(), treat the resulting error as
+                // intentional termination rather than a retryable failure.
+                if (closed)
+                    return;
+                if (isRetryableError(lastErr) && attempt < maxRetries) {
+                    const delay = baseDelayMs * Math.pow(2, attempt);
+                    console.warn(`[ClaudeRuntime] API error (attempt ${attempt + 1}/${maxRetries + 1}): ${lastErr.message}. Retrying in ${delay}ms...`);
+                    emitUpdate?.({
+                        type: 'progress',
+                        content: {
+                            phase: 'starting',
+                            message: (0, outputLanguage_1.localize)(outputLanguage, `API 暂时不可用，${Math.round(delay / 1000)}s 后重试 (${attempt + 1}/${maxRetries})...`, `API is temporarily unavailable. Retrying in ${Math.round(delay / 1000)}s (${attempt + 1}/${maxRetries})...`),
+                        },
+                        timestamp: Date.now(),
+                    });
+                    await sleep(delay);
+                    continue;
+                }
+                throw lastErr; // Non-retryable or max retries exceeded
+            }
+        }
+        if (lastErr)
+            throw lastErr;
+    }
+    return {
+        stream: retryableStream(),
+        close: () => {
+            if (closed)
+                return; // Idempotent — safe to call from timeout handler AND finally.
+            closed = true;
+            try {
+                currentQuery?.close();
+            }
+            catch (err) {
+                console.warn('[ClaudeRuntime] sdkQueryWithRetry close() failed (non-fatal):', err.message);
+            }
+        },
+    };
+}
+/**
+ * Claude Agent SDK runtime for SmartPerfetto.
+ * Claude SDK orchestrator implementation behind the shared IOrchestrator contract.
+ * Implements the same EventEmitter + analyze() interface as AgentRuntime.
+ */
+class ClaudeRuntime extends events_1.EventEmitter {
+    constructor(traceProcessorService, config) {
+        super();
+        /** Cache architecture detection results per traceId (deterministic per trace). */
+        this.architectureCache = new Map();
+        /** Cache vendor detection results per traceId (deterministic per trace). */
+        this.vendorCache = new Map();
+        /** Cache trace completeness probe results per traceId (deterministic per trace). */
+        this.completenessCache = new Map();
+        /** Per-session artifact stores — persist across turns within a session. */
+        this.artifactStores = new Map();
+        /** Per-session analysis notes — persist across turns within a session. */
+        this.sessionNotes = new Map();
+        /** Per-session SQL error tracking for error-fix pair learning. */
+        this.sessionSqlErrors = new Map();
+        /** Per-session analysis plans for plan adherence tracking. */
+        this.sessionPlans = new Map();
+        /** Per-session hypotheses for hypothesis-verify cycle (P0-G4). */
+        this.sessionHypotheses = new Map();
+        /** Per-session uncertainty flags for non-blocking human interaction (P1-G1). */
+        this.sessionUncertaintyFlags = new Map();
+        /** Guard against concurrent analyze() calls for the same session. */
+        this.activeAnalyses = new Set();
+        this.traceProcessorService = traceProcessorService;
+        this.config = (0, claudeConfig_1.loadClaudeConfig)(config);
+        this.sessionMap = loadSessionMapForCurrentMode();
+    }
+    /** Restore a previously persisted SDK session mapping (e.g., after server restart). */
+    restoreSessionMapping(smartPerfettoSessionId, sdkSessionId) {
+        this.sessionMap.set(smartPerfettoSessionId, { sdkSessionId, updatedAt: Date.now(), mode: 'full' });
+    }
+    /** Restore a cached architecture detection result (e.g., from session persistence). */
+    restoreArchitectureCache(traceId, architecture) {
+        this.architectureCache.set(traceId, architecture);
+    }
+    /** Get cached architecture for a traceId (used for persistence). */
+    getCachedArchitecture(traceId) {
+        return this.architectureCache.get(traceId);
+    }
+    /** Get SDK session ID for persistence. */
+    getSdkSessionId(smartPerfettoSessionId, referenceTraceId) {
+        const entry = this.sessionMap.get(this.buildSessionMapKey(smartPerfettoSessionId, referenceTraceId));
+        return isFreshFullSdkSessionEntry(entry) ? entry.sdkSessionId : undefined;
+    }
+    buildSessionMapKey(sessionId, referenceTraceId) {
+        return referenceTraceId ? `${sessionId}:ref:${referenceTraceId}` : sessionId;
+    }
+    persistSessionMapEntry(sessionId, traceId, sessionMapKey, entry, options) {
+        if (legacySessionMapWritesEnabled()) {
+            savePersistedSessionMap(this.sessionMap);
+        }
+        if (!enterpriseSessionMapDbWritesEnabled())
+            return;
+        if (!options.tenantId || !options.workspaceId) {
+            console.warn('[ClaudeRuntime] Enterprise session map persistence skipped: missing tenant/workspace scope');
+            return;
+        }
+        try {
+            (0, runtimeSnapshotStore_1.saveClaudeSessionMapToRuntimeSnapshots)({
+                tenantId: options.tenantId,
+                workspaceId: options.workspaceId,
+                userId: options.userId,
+                sessionId,
+                runId: options.runId,
+                traceId,
+            }, sessionMapKey, entry);
+        }
+        catch (err) {
+            console.warn('[ClaudeRuntime] Failed to persist session map to runtime_snapshots:', err.message);
+        }
+    }
+    rememberFullSdkSessionMapping(sessionId, traceId, sessionMapKey, sdkSessionId, options) {
+        const entry = { sdkSessionId, updatedAt: Date.now(), mode: 'full' };
+        this.sessionMap.set(sessionMapKey, entry);
+        this.persistSessionMapEntry(sessionId, traceId, sessionMapKey, entry, options);
+    }
+    forgetSdkSessionMapping(sessionId, sessionMapKey, reason, options = {}) {
+        const removed = this.sessionMap.delete(sessionMapKey);
+        if (legacySessionMapWritesEnabled()) {
+            savePersistedSessionMapSync(this.sessionMap);
+        }
+        if (enterpriseSessionMapDbWritesEnabled()) {
+            try {
+                (0, runtimeSnapshotStore_1.deleteClaudeSessionMapRuntimeSnapshot)(sessionId, sessionMapKey, providerScopeFromOptions(options));
+            }
+            catch (err) {
+                console.warn('[ClaudeRuntime] Failed to delete stale SDK session map from runtime_snapshots:', err.message);
+            }
+        }
+        console.warn(`[ClaudeRuntime] Discarded stale SDK session mapping for ${sessionMapKey}` +
+            `${removed ? '' : ' (not present in memory)'}: ${reason}`);
+    }
+    async retryWithoutSdkResume(params) {
+        this.forgetSdkSessionMapping(params.sessionId, params.sessionMapKey, params.errorMessage, params.options);
+        this.emitUpdate({
+            type: 'degraded',
+            content: {
+                module: 'claudeRuntime',
+                fallback: 'fresh_sdk_session_after_missing_conversation',
+                error: 'missing_sdk_conversation',
+                mode: params.mode,
+                message: (0, outputLanguage_1.localize)(this.config.outputLanguage, 'Claude 远端对话已不可用，已清理旧会话并使用本地持久化上下文重新发起分析...', 'Claude remote conversation is no longer available. Retrying with persisted local context in a fresh SDK session...'),
+            },
+            timestamp: Date.now(),
+        });
+        this.activeAnalyses.delete(params.sessionId);
+        strategyFingerprint_1.runSnapshots.release(params.sessionId);
+        return this.analyze(params.query, params.sessionId, params.traceId, params.options);
+    }
+    removeSessionMapEntries(sessionId) {
+        const referencePrefix = `${sessionId}:ref:`;
+        for (const key of [...this.sessionMap.keys()]) {
+            if (key === sessionId || key.startsWith(referencePrefix)) {
+                this.sessionMap.delete(key);
+            }
+        }
+    }
+    async analyze(query, sessionId, traceId, options = {}) {
+        // Prevent concurrent analyze() calls for the same session
+        if (this.activeAnalyses.has(sessionId)) {
+            throw new Error(`Analysis already in progress for session ${sessionId}`);
+        }
+        this.activeAnalyses.add(sessionId);
+        const startTime = Date.now();
+        const allFindings = [];
+        let conclusionText = '';
+        let sdkSessionId;
+        let rounds = 0;
+        let delegatedRetry = false;
+        const metricsCollector = new agentMetrics_1.AgentMetricsCollector(sessionId);
+        try {
+            // Phase 0: Complexity classification — runs in parallel with early context prep
+            const sessionContext = enhancedSessionContext_1.sessionContextManager.getOrCreate(sessionId, traceId);
+            const previousTurns = sessionContext.getAllTurns?.() || [];
+            const sceneType = (0, sceneClassifier_1.classifyScene)(query);
+            // Freeze the strategy version for the duration of this analyze() call so
+            // a hot-reload mid-flight can't split-brain the agent's reasoning.
+            strategyFingerprint_1.runSnapshots.capture(sessionId, sceneType);
+            const classifierInput = {
+                query,
+                sceneType,
+                hasSelectionContext: !!options.selectionContext,
+                selectionContext: options.selectionContext,
+                hasReferenceTrace: !!options.referenceTraceId,
+                // Only count findings from full (non-simple) turns as "existing findings" for drill-down detection
+                hasExistingFindings: previousTurns.some(t => t.intent?.complexity !== 'simple' && t.findings?.length > 0),
+                // Distinguish: only full analysis turns trigger multi-turn continuity (not prior quick turns)
+                hasPriorFullAnalysis: previousTurns.some(t => t.intent?.complexity !== 'simple'),
+            };
+            const cachedArch = this.architectureCache.get(traceId);
+            // Focus detection runs for every path — kick it off once and let the classifier
+            // (if needed) share the wait. Explicit 'fast'/'full' skips the classifier entirely.
+            const explicitMode = options.analysisMode;
+            const focusPromise = (0, focusAppDetector_1.detectFocusApps)(this.traceProcessorService, traceId).catch((err) => {
+                console.warn('[ClaudeRuntime] Focus app detection failed (graceful):', err.message);
+                return { apps: [], primaryApp: undefined, method: 'none' };
+            });
+            const providerScope = providerScopeFromOptions(options);
+            const runtimeConfig = (0, claudeConfig_1.resolveRuntimeConfig)(this.config, options.providerId, providerScope);
+            let queryComplexity;
+            let classifierSource;
+            let classifierReason;
+            if (explicitMode === 'fast' || explicitMode === 'full') {
+                queryComplexity = explicitMode === 'fast' ? 'quick' : 'full';
+                classifierSource = 'user_explicit';
+                classifierReason = `user requested ${explicitMode}`;
+            }
+            else {
+                const classifierResult = await (0, queryComplexityClassifier_1.classifyQueryComplexity)(classifierInput, runtimeConfig);
+                queryComplexity = classifierResult.complexity;
+                classifierSource = classifierResult.source;
+                classifierReason = classifierResult.reason;
+            }
+            const focusResult = await focusPromise;
+            const displayMode = explicitMode ?? 'auto';
+            console.log(`[ClaudeRuntime] Query complexity: ${queryComplexity} ` +
+                `(mode: ${displayMode}, source: ${classifierSource}, reason: ${classifierReason})`);
+            metricsCollector.recordAnalysisMode(displayMode, classifierSource);
+            // Quick path: lightweight analysis for simple factual queries
+            if (queryComplexity === 'quick') {
+                return await this.analyzeQuick(query, sessionId, traceId, options, {
+                    sceneType,
+                    focusResult,
+                    cachedArch,
+                    sessionContext,
+                    previousTurns,
+                    metricsCollector,
+                    startTime,
+                });
+            }
+            // Full path: original comprehensive analysis pipeline
+            const ctx = await this.prepareAnalysisContext(query, sessionId, traceId, options, {
+                focusResult,
+                sessionContext,
+                previousTurns,
+                sceneType,
+            });
+            const { handleMessage: bridge, getAccumulatedAnswer } = (0, claudeSseBridge_1.createSseBridge)((update) => {
+                this.emitUpdate(update);
+                if (update.type === 'agent_response' && update.content?.result) {
+                    try {
+                        const parsed = typeof update.content.result === 'string'
+                            ? JSON.parse(update.content.result)
+                            : update.content.result;
+                        if (parsed?.success && parsed?.skillId) {
+                            allFindings.push((0, claudeFindingExtractor_1.extractFindingsFromSkillResult)(parsed));
+                        }
+                        if (parsed?.success && parsed?.displayResults) {
+                            this.captureEntitiesFromSkillDisplayResults(parsed.displayResults, ctx.entityStore);
+                        }
+                    }
+                    catch {
+                        // Not a skill result — ignore
+                    }
+                }
+            }, this.config.outputLanguage);
+            this.emitUpdate({
+                type: 'progress',
+                content: {
+                    phase: 'starting',
+                    message: (0, outputLanguage_1.localize)(this.config.outputLanguage, `使用 ${runtimeConfig.model} 开始分析 (effort: ${ctx.effectiveEffort})...`, `Starting analysis with ${runtimeConfig.model} (effort: ${ctx.effectiveEffort})...`),
+                },
+                timestamp: Date.now(),
+            });
+            // Reuse composite key from prepareAnalysisContext for comparison mode session identity isolation
+            const existingSessionMapEntry = this.sessionMap.get(ctx.sessionMapKey);
+            const existingSdkSessionId = isFreshFullSdkSessionEntry(existingSessionMapEntry)
+                ? existingSessionMapEntry.sdkSessionId
+                : undefined;
+            let missingSdkConversationError;
+            if (existingSessionMapEntry && existingSdkSessionId && enterpriseSessionMapDbWritesEnabled()) {
+                this.persistSessionMapEntry(sessionId, traceId, ctx.sessionMapKey, existingSessionMapEntry, options);
+            }
+            // When resuming an SDK session, systemPrompt is ignored by the SDK (mutually exclusive).
+            // Prepend selectionContext directly into the prompt so the AI sees it in the conversation.
+            let effectivePrompt = query;
+            if (existingSdkSessionId && options.selectionContext) {
+                const selSection = (0, claudeSystemPrompt_1.buildSelectionContextSection)(options.selectionContext);
+                if (selSection) {
+                    effectivePrompt = `${selSection}\n\n${query}`;
+                }
+            }
+            // Prepend pre-queried trace data so the AI has all context without spending turns on SQL
+            if (options.traceContext && options.traceContext.length > 0) {
+                const traceSection = formatTraceContext(options.traceContext, this.config.outputLanguage);
+                effectivePrompt = `${traceSection}\n\n${effectivePrompt}`;
+            }
+            const sdkEnv = (0, claudeConfig_1.createSdkEnv)(options.providerId, providerScope);
+            const { stream, close: closeSdk } = sdkQueryWithRetry({
+                prompt: effectivePrompt,
+                options: {
+                    model: runtimeConfig.model,
+                    maxTurns: runtimeConfig.maxTurns,
+                    systemPrompt: ctx.systemPrompt,
+                    mcpServers: { smartperfetto: ctx.mcpServer },
+                    includePartialMessages: true,
+                    permissionMode: 'bypassPermissions',
+                    allowDangerouslySkipPermissions: true,
+                    cwd: runtimeConfig.cwd,
+                    effort: ctx.effectiveEffort,
+                    allowedTools: ctx.allowedTools,
+                    env: sdkEnv,
+                    stderr: (data) => {
+                        console.warn(`[ClaudeRuntime] SDK stderr [${sessionId}]: ${data.trimEnd()}`);
+                    },
+                    ...(runtimeConfig.maxBudgetUsd ? { maxBudgetUsd: runtimeConfig.maxBudgetUsd } : {}),
+                    ...(existingSdkSessionId ? { resume: existingSdkSessionId } : {}),
+                    ...(ctx.agents ? { agents: ctx.agents } : {}),
+                },
+            }, {
+                emitUpdate: (update) => this.emitUpdate(update),
+                outputLanguage: this.config.outputLanguage,
+            });
+            let finalResult;
+            let terminationReason;
+            let terminationMessage;
+            // Safety timeout with stream cancellation via Promise.race.
+            // Per-turn budget is env-configurable (CLAUDE_FULL_PER_TURN_MS, default 60s) so slower
+            // LLMs (DeepSeek / Ollama / GLM) have room per turn without false timeouts.
+            // Scrolling deep-drill (hypothesis + SQL + knowledge + conclusion) still needs ~6-8 min.
+            const timeoutMs = (runtimeConfig.maxTurns || 15) * runtimeConfig.fullPathPerTurnMs;
+            let timedOut = false;
+            // Sub-agent timeout tracking — stop tasks that exceed subAgentTimeoutMs
+            const activeSubAgentTimers = new Map();
+            const subAgentTimeoutMs = runtimeConfig.subAgentTimeoutMs;
+            // P2-1: Turn-level autonomy watchdog — detect repetitive tool failures
+            // P1-G2: Per-tool tracking — each tool gets its own failure tracking
+            const toolCallHistory = [];
+            const WATCHDOG_WINDOW = 3; // consecutive same-tool failures to trigger warning
+            const watchdogFiredTools = new Set(); // tracks which tools have triggered warnings
+            // P0-G16: Circuit breaker — overall tool call failure rate monitoring
+            let circuitBreakerFires = 0;
+            const MAX_CIRCUIT_BREAKER_FIRES = 2;
+            const CIRCUIT_BREAKER_WINDOW = 5;
+            const CIRCUIT_BREAKER_THRESHOLD = 0.6; // 60% failure rate
+            let lastCircuitBreakerFireIdx = -Infinity;
+            // P1: Negative memory — collect failed approaches for cross-session learning
+            const failedApproaches = [];
+            /** Track whether SDK auto-compact has fired during this turn.
+             *  When true, the SDK has summarized prior conversation history,
+             *  potentially losing early-turn details. We log this for diagnostics. */
+            let sdkCompactDetected = false;
+            const turnMetricsList = [];
+            let currentTurnMetrics = null;
+            let turnCounter = 0;
+            let firstTokenReceived = false;
+            // Phase 3-3 of v2.1 (monitor-only): track when the running conversation
+            // crosses the pre-rot threshold so prod can quantify how often we *would*
+            // have benefited from an interrupt+resume cycle. The actual interrupt+
+            // resume orchestration is intentionally not wired yet — see
+            // `docs/archive/context-engineering/v2.1-phase-3-active-compact-design.md`. Disable by setting
+            // `CLAUDE_PRECOMPACT_WARN_ENABLED=false`.
+            let preCompactWarned = false;
+            const preCompactWarnEnabled = process.env.CLAUDE_PRECOMPACT_WARN_ENABLED !== 'false';
+            const emitUpdate = this.emitUpdate.bind(this);
+            const outputLanguage = this.config.outputLanguage;
+            function checkContextPressure() {
+                if (!preCompactWarnEnabled || preCompactWarned)
+                    return;
+                const cumulativeUncached = turnMetricsList.reduce((acc, t) => acc + (t.inputTokens ?? 0), 0);
+                const cumulativeCacheCreation = turnMetricsList.reduce((acc, t) => acc + (t.cacheCreationTokens ?? 0), 0);
+                const cumulativePayloadBytes = turnMetricsList.reduce((acc, t) => acc + t.toolResultPayloadBytes, 0);
+                const decision = (0, contextTokenMeter_1.evaluateThreshold)({
+                    uncachedInputTokens: cumulativeUncached,
+                    cacheCreationInputTokens: cumulativeCacheCreation,
+                    recentToolPayloadBytes: cumulativePayloadBytes,
+                });
+                if (decision.shouldPrecompact) {
+                    preCompactWarned = true;
+                    console.warn(`[ClaudeRuntime] Session ${sessionId}: pre-rot threshold crossed ` +
+                        `(pressure=${decision.pressureTokens} / ${decision.thresholdTokens} tokens, ratio=${decision.pressureRatio.toFixed(2)}). ` +
+                        `Phase 3-3 will eventually interrupt+resume here; for now we only log.`);
+                    emitUpdate({
+                        type: 'progress',
+                        content: {
+                            phase: 'analyzing',
+                            message: (0, outputLanguage_1.localize)(outputLanguage, `⚠️ 接近上下文上限（已用 ${(decision.pressureRatio * 100).toFixed(0)}%），后续轮次可能因压缩丢失细节`, `⚠️ Context window is close to its limit (${(decision.pressureRatio * 100).toFixed(0)}% used); later turns may lose details after compaction`),
+                        },
+                        timestamp: Date.now(),
+                    });
+                }
+            }
+            function findToolCallForResult(toolUseId) {
+                if (toolUseId) {
+                    for (let i = toolCallHistory.length - 1; i >= 0; i--) {
+                        if (toolCallHistory[i].id === toolUseId)
+                            return toolCallHistory[i];
+                    }
+                }
+                for (let i = toolCallHistory.length - 1; i >= 0; i--) {
+                    if (!toolCallHistory[i].completed)
+                        return toolCallHistory[i];
+                }
+                return toolCallHistory[toolCallHistory.length - 1];
+            }
+            function finalizeTurnMetrics() {
+                if (currentTurnMetrics) {
+                    currentTurnMetrics.durationMs = Date.now() - currentTurnMetrics.startMs;
+                    turnMetricsList.push(currentTurnMetrics);
+                    checkContextPressure();
+                }
+            }
+            const processStream = async () => {
+                for await (const msg of stream) {
+                    if (timedOut)
+                        break; // P0-1: Actually cancel stream on timeout
+                    // Detect SDK auto-compact boundary — conversation history was summarized
+                    if (msg.type === 'system' && msg.subtype === 'compact_boundary') {
+                        sdkCompactDetected = true;
+                        console.warn(`[ClaudeRuntime] SDK auto-compact detected for session ${sessionId} — prior turns summarized`);
+                    }
+                    if (msg.session_id && !sdkSessionId) {
+                        sdkSessionId = msg.session_id;
+                        this.rememberFullSdkSessionMapping(sessionId, traceId, ctx.sessionMapKey, sdkSessionId, options);
+                    }
+                    const sdkResultError = getSdkResultErrorMessage(msg);
+                    if (sdkResultError && existingSdkSessionId && isMissingSdkConversationError(sdkResultError)) {
+                        if (msg.type === 'result') {
+                            finalizeTurnMetrics();
+                            currentTurnMetrics = null;
+                            metricsCollector.recordSdkUsage({
+                                usage: msg.usage,
+                                modelUsage: msg.modelUsage,
+                                total_cost_usd: msg.total_cost_usd,
+                            });
+                        }
+                        missingSdkConversationError = sdkResultError;
+                        continue;
+                    }
+                    // Track sub-agent lifecycle for per-agent timeouts
+                    if (msg.type === 'system' && msg.subtype === 'task_started') {
+                        const taskId = msg.task_id;
+                        if (taskId && subAgentTimeoutMs > 0) {
+                            const timer = setTimeout(() => {
+                                console.warn(`[ClaudeRuntime] Sub-agent timeout: stopping task ${taskId} after ${subAgentTimeoutMs / 1000}s`);
+                                activeSubAgentTimers.delete(taskId);
+                                if (typeof stream.stopTask === 'function') {
+                                    stream.stopTask(taskId).catch((err) => {
+                                        console.warn(`[ClaudeRuntime] Failed to stop sub-agent task ${taskId}:`, err.message);
+                                    });
+                                }
+                                // P1-6: Record timeout as a finding so it's reflected in confidence
+                                allFindings.push([{
+                                        id: `sub-agent-timeout-${taskId}`,
+                                        title: (0, outputLanguage_1.localize)(this.config.outputLanguage, '子代理超时', 'Sub-agent timeout'),
+                                        severity: 'medium',
+                                        category: 'sub-agent',
+                                        description: (0, outputLanguage_1.localize)(this.config.outputLanguage, `子代理 ${taskId} 超时 (${subAgentTimeoutMs / 1000}s)，分析可能不完整`, `Sub-agent ${taskId} timed out (${subAgentTimeoutMs / 1000}s); the analysis may be incomplete`),
+                                        confidence: 0.3,
+                                    }]);
+                                this.emitUpdate({
+                                    type: 'progress',
+                                    content: {
+                                        phase: 'analyzing',
+                                        message: (0, outputLanguage_1.localize)(this.config.outputLanguage, `子代理超时 (${subAgentTimeoutMs / 1000}s)，已停止`, `Sub-agent timed out (${subAgentTimeoutMs / 1000}s) and was stopped`),
+                                    },
+                                    timestamp: Date.now(),
+                                });
+                            }, subAgentTimeoutMs);
+                            activeSubAgentTimers.set(taskId, timer);
+                        }
+                    }
+                    if (msg.type === 'system' && msg.subtype === 'task_notification') {
+                        const taskId = msg.task_id;
+                        if (taskId) {
+                            const timer = activeSubAgentTimers.get(taskId);
+                            if (timer) {
+                                clearTimeout(timer);
+                                activeSubAgentTimers.delete(taskId);
+                            }
+                        }
+                        // P1-5: Extract findings from sub-agent completion summaries.
+                        // Without this, sub-agent evidence is only in the conclusion text
+                        // and not merged into allFindings for confidence estimation.
+                        const summary = msg.summary || '';
+                        const status = msg.status || 'completed';
+                        if (status === 'completed' && summary) {
+                            allFindings.push((0, claudeFindingExtractor_1.extractFindingsFromText)(summary));
+                        }
+                    }
+                    // Bridge SDK messages to SSE events
+                    try {
+                        bridge(msg);
+                    }
+                    catch (bridgeErr) {
+                        console.warn('[ClaudeRuntime] SSE bridge error (non-fatal):', bridgeErr.message);
+                    }
+                    // ── Per-turn metrics: track stream_event signals ──
+                    if (msg.type === 'stream_event' && currentTurnMetrics) {
+                        const event = msg.event;
+                        // First token latency
+                        if (!firstTokenReceived &&
+                            event?.type === 'content_block_delta' &&
+                            (event.delta?.type === 'text_delta' || event.delta?.type === 'tool_use')) {
+                            firstTokenReceived = true;
+                            currentTurnMetrics.firstTokenLatencyMs = Date.now() - currentTurnMetrics.startMs;
+                        }
+                        // Extended thinking detection
+                        if (event?.type === 'content_block_start' && event.content_block?.type === 'thinking') {
+                            currentTurnMetrics.hasExtendedThinking = true;
+                        }
+                    }
+                    // assistant message = new turn starts; finalize previous turn + watchdog tracking
+                    if (msg.type === 'assistant' && Array.isArray(msg.message?.content)) {
+                        finalizeTurnMetrics();
+                        turnCounter++;
+                        firstTokenReceived = false;
+                        const toolNames = [];
+                        for (const block of msg.message.content) {
+                            if (block.type === 'tool_use') {
+                                toolNames.push(block.name.replace(claudeMcpServer_1.MCP_NAME_PREFIX, ''));
+                                // P2-1: Watchdog — track tool calls for repetitive failure detection
+                                toolCallHistory.push({
+                                    id: block.id,
+                                    name: block.name,
+                                    success: true,
+                                    startTime: Date.now(),
+                                    input: block.input,
+                                });
+                            }
+                        }
+                        currentTurnMetrics = {
+                            turnIndex: turnCounter,
+                            startMs: Date.now(),
+                            toolCalls: toolNames,
+                            toolResultPayloadBytes: 0,
+                            hasExtendedThinking: false,
+                        };
+                    }
+                    if (msg.type === 'user' && msg.tool_use_result !== undefined) {
+                        const resultBlocks = (0, claudeSseBridge_1.extractSdkToolResultBlocks)(msg);
+                        const observedResults = resultBlocks.length > 0
+                            ? resultBlocks
+                            : [{ result: msg.tool_use_result, isError: undefined, toolUseId: undefined }];
+                        for (const observed of observedResults) {
+                            const resultStr = (0, claudeSseBridge_1.stringifySdkToolResult)(observed.result);
+                            // Per-turn metrics: track tool result payload size
+                            if (currentTurnMetrics) {
+                                currentTurnMetrics.toolResultPayloadBytes += Buffer.byteLength(resultStr, 'utf-8');
+                            }
+                            const isFailed = observed.isError === true ||
+                                resultStr.includes('"success":false') ||
+                                resultStr.includes('"isError":true');
+                            const matchedTool = findToolCallForResult(observed.toolUseId);
+                            if (matchedTool) {
+                                matchedTool.success = !isFailed;
+                                matchedTool.completed = true;
+                                // Record tool execution in metrics collector (stream-observed timing)
+                                const toolName = matchedTool.name.replace(claudeMcpServer_1.MCP_NAME_PREFIX, '');
+                                const durationMs = matchedTool.startTime ? Date.now() - matchedTool.startTime : 0;
+                                metricsCollector.recordToolFromStream(toolName, durationMs, !isFailed);
+                            }
+                            // Check for consecutive same-tool failures (P1-G2: per-tool tracking)
+                            if (toolCallHistory.length >= WATCHDOG_WINDOW) {
+                                const recent = toolCallHistory.slice(-WATCHDOG_WINDOW);
+                                const allSameTool = recent.every(t => t.name === recent[0].name);
+                                const allFailed = recent.every(t => !t.success);
+                                const toolName = recent[0].name.replace(claudeMcpServer_1.MCP_NAME_PREFIX, '');
+                                if (allSameTool && allFailed && !watchdogFiredTools.has(toolName)) {
+                                    watchdogFiredTools.add(toolName);
+                                    console.warn(`[ClaudeRuntime] Watchdog: ${WATCHDOG_WINDOW} consecutive failures for ${toolName}`);
+                                    // P1-2: Inject warning into next MCP tool result (Claude reads this)
+                                    ctx.watchdogWarning.current = (0, outputLanguage_1.localize)(this.config.outputLanguage, `${toolName} 已连续失败 ${WATCHDOG_WINDOW} 次。请切换分析策略：尝试不同的 SQL 查询、使用其他 skill、或调整参数。不要重复相同的失败操作。`, `${toolName} has failed ${WATCHDOG_WINDOW} times in a row. Switch analysis strategy: try a different SQL query, use another skill, or adjust parameters. Do not repeat the same failed action.`);
+                                    // P1: Record for negative memory
+                                    failedApproaches.push({
+                                        type: 'tool_failure',
+                                        approach: `连续调用 ${toolName} ${WATCHDOG_WINDOW} 次均失败`,
+                                        reason: '同一工具重复失败，需要切换策略',
+                                    });
+                                    this.emitUpdate({
+                                        type: 'progress',
+                                        content: {
+                                            phase: 'analyzing',
+                                            message: (0, outputLanguage_1.localize)(this.config.outputLanguage, `⚠ 检测到 ${toolName} 连续 ${WATCHDOG_WINDOW} 次失败，已注入策略切换指令`, `⚠ Detected ${WATCHDOG_WINDOW} consecutive failures for ${toolName}; injected a strategy-switch instruction`),
+                                        },
+                                        timestamp: Date.now(),
+                                    });
+                                }
+                            }
+                            // Track tool call for plan adherence with phase matching (P0-1 + P1-1)
+                            // P1-G5: Best-fit phase-tool matching — search all eligible phases, not just first
+                            if (ctx.analysisPlan.current && matchedTool) {
+                                const plan = ctx.analysisPlan.current;
+                                const shortToolName = matchedTool.name.replace(claudeMcpServer_1.MCP_NAME_PREFIX, '');
+                                const callSummary = (0, toolCallSummary_1.summarizeToolCallInput)(shortToolName, matchedTool.input);
+                                const candidate = {
+                                    toolName: matchedTool.name,
+                                    timestamp: Date.now(),
+                                    ...callSummary,
+                                };
+                                const toolReturnedPhaseId = extractPlanPhaseIdFromToolResult(resultStr);
+                                let matchedPhaseId = toolReturnedPhaseId &&
+                                    plan.phases.some(p => p.id === toolReturnedPhaseId)
+                                    ? toolReturnedPhaseId
+                                    : undefined;
+                                // Priority: MCP-side semantic attribution first, then in_progress phase,
+                                // then any pending phase whose expectations match.
+                                if (!matchedPhaseId) {
+                                    const activePhase = plan.phases.find(p => p.status === 'in_progress');
+                                    if (activePhase && (0, types_1.phaseMatchesCall)(activePhase, candidate)) {
+                                        matchedPhaseId = activePhase.id;
+                                    }
+                                }
+                                if (!matchedPhaseId) {
+                                    const pendingMatch = plan.phases.find(p => p.status === 'pending' && (0, types_1.phaseMatchesCall)(p, candidate));
+                                    matchedPhaseId = pendingMatch?.id;
+                                }
+                                plan.toolCallLog.push({ ...candidate, matchedPhaseId });
+                                // P2-8: Cap toolCallLog to prevent unbounded growth within a turn
+                                if (plan.toolCallLog.length > 100) {
+                                    plan.toolCallLog.splice(0, plan.toolCallLog.length - 100);
+                                }
+                            }
+                            // P0-G16: Circuit breaker — overall failure rate monitoring
+                            // Unlike watchdog (same-tool consecutive failures), this monitors aggregate health.
+                            // Fires when >60% of recent tool calls fail, regardless of which tools.
+                            // P1-G9: Circuit breaker can fire even with pending watchdog warning
+                            // (CB is higher priority — its "simplify scope" message overwrites per-tool warnings)
+                            if (circuitBreakerFires < MAX_CIRCUIT_BREAKER_FIRES
+                                && toolCallHistory.length >= CIRCUIT_BREAKER_WINDOW
+                                && toolCallHistory.length - lastCircuitBreakerFireIdx >= 3) {
+                                const recentWindow = toolCallHistory.slice(-CIRCUIT_BREAKER_WINDOW);
+                                const failCount = recentWindow.filter(t => !t.success).length;
+                                const failRate = failCount / recentWindow.length;
+                                if (failRate >= CIRCUIT_BREAKER_THRESHOLD) {
+                                    circuitBreakerFires++;
+                                    lastCircuitBreakerFireIdx = toolCallHistory.length;
+                                    ctx.watchdogWarning.current = (0, outputLanguage_1.localize)(this.config.outputLanguage, `⚠️ 分析断路器触发：最近 ${CIRCUIT_BREAKER_WINDOW} 次工具调用中 ${failCount} 次失败 (${(failRate * 100).toFixed(0)}%)。` +
+                                        '请：1) 简化分析范围，2) 使用更基础的查询，3) 如果数据不可用则基于已有证据出结论。不要继续尝试失败的操作。', `⚠️ Analysis circuit breaker triggered: ${failCount} of the last ${CIRCUIT_BREAKER_WINDOW} tool calls failed (${(failRate * 100).toFixed(0)}%). ` +
+                                        'Simplify the scope, use more basic queries, and conclude from existing evidence if data is unavailable. Do not keep retrying failed actions.');
+                                    failedApproaches.push({
+                                        type: 'strategy_failure',
+                                        approach: `整体工具调用失败率过高 (${(failRate * 100).toFixed(0)}%)`,
+                                        reason: `最近 ${CIRCUIT_BREAKER_WINDOW} 次调用中 ${failCount} 次失败`,
+                                    });
+                                    this.emitUpdate({
+                                        type: 'progress',
+                                        content: {
+                                            phase: 'analyzing',
+                                            message: (0, outputLanguage_1.localize)(this.config.outputLanguage, `⚠ 分析断路器触发：工具调用失败率 ${(failRate * 100).toFixed(0)}%，建议简化分析范围`, `⚠ Analysis circuit breaker triggered: tool failure rate ${(failRate * 100).toFixed(0)}%; simplify the analysis scope`),
+                                        },
+                                        timestamp: Date.now(),
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    // Per-turn metrics: capture usage from stream_event message_delta (per API turn)
+                    if (msg.type === 'stream_event' && currentTurnMetrics) {
+                        const event = msg.event;
+                        if (event?.type === 'message_delta' && event.usage) {
+                            currentTurnMetrics.outputTokens = event.usage.output_tokens;
+                        }
+                        if (event?.type === 'message_start' && event.message?.usage) {
+                            currentTurnMetrics.inputTokens = event.message.usage.input_tokens;
+                            currentTurnMetrics.cacheReadTokens = event.message.usage.cache_read_input_tokens;
+                            currentTurnMetrics.cacheCreationTokens = event.message.usage.cache_creation_input_tokens;
+                        }
+                    }
+                    if (msg.type === 'result') {
+                        // Finalize last turn metrics before stream ends
+                        finalizeTurnMetrics();
+                        currentTurnMetrics = null;
+                        rounds = msg.num_turns || rounds;
+                        const resultSubtype = msg.subtype;
+                        if (resultSubtype === 'success') {
+                            finalResult = msg.result;
+                        }
+                        else if ((0, analysisTermination_1.isSdkMaxTurnsSubtype)(resultSubtype)) {
+                            terminationReason = analysisTermination_1.MAX_TURNS_TERMINATION_REASON;
+                            terminationMessage = (0, analysisTermination_1.buildMaxTurnsTerminationMessage)({
+                                mode: 'full',
+                                turns: rounds,
+                                maxTurns: this.config.maxTurns,
+                                outputLanguage: this.config.outputLanguage,
+                            });
+                        }
+                        // Record SDK token usage and prompt cache metrics
+                        metricsCollector.recordSdkUsage({
+                            usage: msg.usage,
+                            modelUsage: msg.modelUsage,
+                            total_cost_usd: msg.total_cost_usd,
+                        });
+                    }
+                }
+                // Clean up any remaining sub-agent timers
+                for (const timer of activeSubAgentTimers.values())
+                    clearTimeout(timer);
+                activeSubAgentTimers.clear();
+                // Log per-turn metrics for performance analysis
+                if (turnMetricsList.length > 0) {
+                    const summary = {
+                        totalTurns: turnMetricsList.length,
+                        totalDurationMs: turnMetricsList.reduce((s, t) => s + (t.durationMs || 0), 0),
+                        totalToolCalls: turnMetricsList.reduce((s, t) => s + t.toolCalls.length, 0),
+                        totalPayloadBytes: turnMetricsList.reduce((s, t) => s + t.toolResultPayloadBytes, 0),
+                        turns: turnMetricsList.map(t => ({
+                            turn: t.turnIndex,
+                            durationMs: t.durationMs,
+                            firstTokenMs: t.firstTokenLatencyMs,
+                            tools: t.toolCalls,
+                            payloadBytes: t.toolResultPayloadBytes,
+                            thinking: t.hasExtendedThinking,
+                            inputTokens: t.inputTokens,
+                            outputTokens: t.outputTokens,
+                            cacheReadTokens: t.cacheReadTokens,
+                            cacheCreationTokens: t.cacheCreationTokens,
+                        })),
+                    };
+                    console.log(`[ClaudeRuntime] Turn metrics [${sessionId}]:`, JSON.stringify(summary));
+                    metricsCollector.recordTurnMetrics(summary);
+                }
+            };
+            let safetyTimer;
+            const timeoutPromise = new Promise((_, reject) => {
+                safetyTimer = setTimeout(() => {
+                    timedOut = true;
+                    // Forcefully terminate the SDK subprocess — without this, queued
+                    // MCP tool calls (e.g. execute_sql) keep executing in the background
+                    // after the session logger has closed, producing orphan SQL errors.
+                    closeSdk();
+                    reject(new Error(`Analysis safety timeout after ${timeoutMs / 1000}s`));
+                }, timeoutMs);
+            });
+            try {
+                await Promise.race([processStream(), timeoutPromise]);
+            }
+            catch (err) {
+                if (timedOut) {
+                    console.error('[ClaudeRuntime] Analysis safety timeout reached — SDK subprocess has been closed');
+                    this.emitUpdate({
+                        type: 'progress',
+                        content: {
+                            phase: 'concluding',
+                            message: (0, outputLanguage_1.localize)(this.config.outputLanguage, '分析超时，正在生成已有结果的结论...', 'Analysis timed out. Generating a conclusion from the evidence collected so far...'),
+                        },
+                        timestamp: Date.now(),
+                    });
+                }
+                else if (existingSdkSessionId && isMissingSdkConversationError(err.message || '')) {
+                    missingSdkConversationError = err.message || 'No conversation found with SDK session';
+                }
+                else {
+                    throw err;
+                }
+            }
+            finally {
+                if (safetyTimer)
+                    clearTimeout(safetyTimer);
+                closeSdk();
+            }
+            if (missingSdkConversationError && existingSdkSessionId) {
+                delegatedRetry = true;
+                return await this.retryWithoutSdkResume({
+                    query,
+                    sessionId,
+                    traceId,
+                    options,
+                    sessionMapKey: ctx.sessionMapKey,
+                    errorMessage: missingSdkConversationError,
+                    mode: 'full',
+                });
+            }
+            // Use SDK terminal result if available; fall back to accumulated streamed answer tokens.
+            // On timeout, the SDK result message may never arrive, but answer_token events
+            // were already streamed to the frontend — use that text to populate the report.
+            conclusionText = finalResult || getAccumulatedAnswer() || '';
+            if (!finalResult && conclusionText) {
+                console.warn(`[ClaudeRuntime] Session ${sessionId}: SDK result was empty, recovered ${conclusionText.length} chars from streamed answer tokens`);
+            }
+            allFindings.push((0, claudeFindingExtractor_1.extractFindingsFromText)(conclusionText));
+            let mergedFindings = (0, claudeFindingExtractor_1.mergeFindings)(allFindings);
+            if (conclusionText.trim() && ctx.analysisPlan.current) {
+                const plan = ctx.analysisPlan.current;
+                const conclusionPhase = plan.phases.find(p => p.status === 'pending' &&
+                    p.expectedTools.length === 0 &&
+                    /结论|conclusion|报告|report|总结/.test(`${p.name} ${p.goal}`));
+                if (conclusionPhase) {
+                    const summary = (0, outputLanguage_1.localize)(this.config.outputLanguage, `自动完成阶段：模型已生成最终结论（${conclusionText.length} 字符）。`, `Auto-completed phase: the model produced the final conclusion (${conclusionText.length} chars).`);
+                    conclusionPhase.status = 'completed';
+                    conclusionPhase.completedAt = Date.now();
+                    conclusionPhase.summary = summary;
+                    this.emitUpdate({
+                        type: 'plan_phase_updated',
+                        content: { phaseId: conclusionPhase.id, status: 'completed', summary, phaseName: conclusionPhase.name },
+                        timestamp: Date.now(),
+                    });
+                }
+            }
+            // Log compaction for diagnostics — helps debug cases where Claude seems to lose context
+            if (sdkCompactDetected) {
+                console.warn(`[ClaudeRuntime] Session ${sessionId}: analysis completed after SDK auto-compact. Findings count: ${mergedFindings.length}`);
+                // P1-C1: Write a structured compact recovery note so the next turn's system prompt
+                // carries plan progress + findings + entity context that may have been lost.
+                // Phase 3-2: also preserves the last N raw tool calls as structured digests
+                // so the post-compact agent knows what it was just doing.
+                const sessionNotes = this.sessionNotes.get(sessionId);
+                if (sessionNotes) {
+                    const note = (0, recoveryNoteBuilder_1.buildRecoveryNote)({
+                        plan: ctx.analysisPlan.current ?? undefined,
+                        findings: mergedFindings,
+                        recentToolCalls: ctx.analysisPlan.current?.toolCallLog ?? [],
+                        entitySnapshot: this.buildEntityContext(ctx.entityStore),
+                    });
+                    sessionNotes.push({
+                        section: 'next_step',
+                        content: note.text,
+                        priority: 'high',
+                        timestamp: Date.now(),
+                    });
+                    if (sessionNotes.length > 20)
+                        sessionNotes.shift();
+                    console.log(`[ClaudeRuntime] Compact recovery note: ${note.sectionsIncluded.length} sections, ${note.usedChars} chars (${note.sectionsIncluded.join('/')})`);
+                }
+            }
+            // Verification + reflection-driven retry (P0-2 + P2-2)
+            // Default ON. Up to 2 correction retries, but second only if new/different errors.
+            // Run unconditionally when enabled — plan adherence, hypothesis resolution,
+            // and conclusion-length checks must fire even when zero findings are extracted.
+            console.log(`[ClaudeRuntime] Pre-verification: conclusionText=${conclusionText.length} chars, sdkSessionId=${sdkSessionId ? 'set' : 'MISSING'}, enableVerification=${runtimeConfig.enableVerification}`);
+            if (runtimeConfig.enableVerification) {
+                const MAX_CORRECTION_ATTEMPTS = 2;
+                let previousErrorSignatures = new Set();
+                try {
+                    for (let attempt = 0; attempt < MAX_CORRECTION_ATTEMPTS; attempt++) {
+                        const verification = await (0, claudeVerifier_1.verifyConclusion)(mergedFindings, conclusionText, {
+                            emitUpdate: (update) => this.emitUpdate(update),
+                            enableLLM: true,
+                            plan: ctx.analysisPlan.current,
+                            hypotheses: ctx.hypotheses,
+                            sceneType: ctx.sceneType,
+                            lightModel: runtimeConfig.lightModel,
+                            verifierTimeoutMs: runtimeConfig.verifierTimeoutMs,
+                            outputLanguage: this.config.outputLanguage,
+                        });
+                        console.log(`[ClaudeRuntime] Verification (attempt ${attempt + 1}): ${verification.passed ? 'PASSED' : 'ISSUES FOUND'} (${verification.durationMs}ms, ${verification.heuristicIssues.length} heuristic + ${verification.llmIssues?.length || 0} LLM issues)`);
+                        if (verification.passed || !sdkSessionId)
+                            break;
+                        const allIssues = [...verification.heuristicIssues, ...(verification.llmIssues || [])];
+                        const errorIssues = allIssues.filter(i => i.severity === 'error');
+                        if (errorIssues.length === 0)
+                            break;
+                        // P2-2: Check if these are the SAME errors as last attempt — if so, stop retrying
+                        const currentSignatures = new Set(errorIssues.map(i => `${i.type}:${i.message.substring(0, 60)}`));
+                        if (attempt > 0) {
+                            const newErrors = [...currentSignatures].filter(s => !previousErrorSignatures.has(s));
+                            if (newErrors.length === 0) {
+                                console.log(`[ClaudeRuntime] Reflection retry: same ${errorIssues.length} errors persist after correction, stopping`);
+                                // P1: Record persistent verification failures as negative memory
+                                for (const issue of errorIssues) {
+                                    failedApproaches.push({
+                                        type: 'verification_failure',
+                                        approach: issue.message.substring(0, 150),
+                                        reason: `验证发现持续性问题 (${issue.type})，修正重试未能解决`,
+                                    });
+                                }
+                                break;
+                            }
+                            console.log(`[ClaudeRuntime] Reflection retry: ${newErrors.length} new errors detected, attempting correction ${attempt + 1}`);
+                        }
+                        previousErrorSignatures = currentSignatures;
+                        this.emitUpdate({
+                            type: 'progress',
+                            content: {
+                                phase: 'concluding',
+                                message: (0, outputLanguage_1.localize)(this.config.outputLanguage, `发现 ${errorIssues.length} 个 ERROR 级问题，启动修正重试 (${attempt + 1}/${MAX_CORRECTION_ATTEMPTS})...`, `Found ${errorIssues.length} ERROR-level issue(s). Starting correction retry (${attempt + 1}/${MAX_CORRECTION_ATTEMPTS})...`),
+                            },
+                            timestamp: Date.now(),
+                        });
+                        try {
+                            const correctionPrompt = (0, claudeVerifier_1.generateCorrectionPrompt)(allIssues, conclusionText, this.config.outputLanguage);
+                            // When the conclusion is incomplete (just reasoning notes, no structured report),
+                            // the agent ran out of turns before generating a report. Give substantially more
+                            // budget so the correction can produce a complete structured output.
+                            const conclusionNeedsFullGeneration = (0, claudeVerifier_1.isConclusionIncomplete)(conclusionText);
+                            // P2-2: Give more turn budget on second attempt (may need additional data)
+                            const correctionTurns = conclusionNeedsFullGeneration
+                                ? (attempt === 0 ? 10 : 12) // Full report generation needs more turns
+                                : (attempt === 0 ? 5 : 8); // Normal correction (fixing specific issues)
+                            // Rebuild system prompt with reduced budget for correction retries.
+                            // After SDK auto-compact or verification failure, conversation history is longer,
+                            // so we shrink the system prompt to leave more room (4500 → 3000 tokens).
+                            const correctionSystemPrompt = sdkCompactDetected
+                                ? (0, claudeSystemPrompt_1.buildSystemPrompt)(ctx.analysisContextForRebuild, 3000)
+                                : ctx.systemPrompt;
+                            const { stream: correctionStream, close: closeCorrection } = sdkQueryWithRetry({
+                                prompt: correctionPrompt,
+                                options: {
+                                    model: runtimeConfig.model,
+                                    maxTurns: correctionTurns,
+                                    systemPrompt: correctionSystemPrompt,
+                                    mcpServers: { smartperfetto: ctx.mcpServer },
+                                    includePartialMessages: true,
+                                    permissionMode: 'bypassPermissions',
+                                    allowDangerouslySkipPermissions: true,
+                                    cwd: runtimeConfig.cwd,
+                                    effort: ctx.effectiveEffort,
+                                    allowedTools: ctx.allowedTools,
+                                    resume: sdkSessionId,
+                                    env: sdkEnv,
+                                    stderr: (data) => {
+                                        console.warn(`[ClaudeRuntime] SDK stderr (correction) [${sessionId}]: ${data.trimEnd()}`);
+                                    },
+                                },
+                            }, {
+                                emitUpdate: (update) => this.emitUpdate(update),
+                                outputLanguage: this.config.outputLanguage,
+                            });
+                            // P1-G8: Independent timeout for correction retries — prevents indefinite hangs.
+                            // When generating a full report from scratch (conclusionNeedsFullGeneration),
+                            // each turn needs more time (25s) since structured report output is verbose.
+                            // Normal corrections (fixing specific issues) use 10s per turn.
+                            const correctionTimeoutMs = correctionTurns * (conclusionNeedsFullGeneration ? 25000 : 10000);
+                            let correctionTimedOut = false;
+                            const correctionTimer = setTimeout(() => {
+                                correctionTimedOut = true;
+                                console.warn(`[ClaudeRuntime] Correction retry ${attempt + 1} timed out after ${correctionTimeoutMs}ms`);
+                                // Forcefully terminate the SDK subprocess so any queued MCP
+                                // tool calls (execute_sql, invoke_skill) stop running after
+                                // the main analyze() flow has moved on. Without this, those
+                                // calls hit trace_processor after the session has closed and
+                                // surface as orphan SQL errors with no owner.
+                                closeCorrection();
+                            }, correctionTimeoutMs);
+                            let correctedResult = '';
+                            try {
+                                for await (const msg of correctionStream) {
+                                    if (correctionTimedOut)
+                                        break;
+                                    if (msg.type === 'result' && msg.subtype === 'success') {
+                                        correctedResult = msg.result || '';
+                                        rounds += msg.num_turns || 0;
+                                    }
+                                    // Bridge tool call events (agent_task_dispatched, agent_response)
+                                    // but suppress text/conclusion events to avoid duplicating the report.
+                                    // The corrected conclusion is captured in correctedResult and will
+                                    // replace conclusionText below — no need to stream it again.
+                                    if (msg.type !== 'stream_event' && msg.type !== 'assistant' && msg.type !== 'result') {
+                                        try {
+                                            bridge(msg);
+                                        }
+                                        catch { /* non-fatal */ }
+                                    }
+                                }
+                            }
+                            finally {
+                                clearTimeout(correctionTimer);
+                                // Safety net: guarantee the correction SDK subprocess is
+                                // closed on every exit (success, break, throw). Idempotent.
+                                closeCorrection();
+                            }
+                            if (correctionTimedOut) {
+                                console.warn(`[ClaudeRuntime] Correction attempt ${attempt + 1} timed out, using partial result (${correctedResult.length} chars)`);
+                            }
+                            // P2-G13: Compare correction quality by finding count and coverage, not text length.
+                            // A shorter corrected conclusion with more findings is better than a longer empty one.
+                            const correctedFindings = correctedResult ? (0, claudeFindingExtractor_1.extractFindingsFromText)(correctedResult) : [];
+                            const previousFindingCount = mergedFindings.length;
+                            const hasSubstantiveCorrection = correctedResult && (correctedFindings.length >= previousFindingCount ||
+                                correctedResult.length > 100);
+                            if (hasSubstantiveCorrection) {
+                                conclusionText = correctedResult;
+                                // Re-extract findings from corrected conclusion and re-merge
+                                allFindings.push(correctedFindings);
+                                mergedFindings = (0, claudeFindingExtractor_1.mergeFindings)(allFindings);
+                                console.log(`[ClaudeRuntime] Reflection retry ${attempt + 1}: conclusion corrected (findings: ${previousFindingCount} → ${mergedFindings.length})`);
+                            }
+                            else {
+                                console.log(`[ClaudeRuntime] Reflection retry ${attempt + 1}: correction insufficient (findings: ${correctedFindings.length} vs ${previousFindingCount}), keeping previous`);
+                                break; // No point retrying if correction failed to improve
+                            }
+                        }
+                        catch (correctionErr) {
+                            console.warn(`[ClaudeRuntime] Reflection retry ${attempt + 1} failed (non-blocking):`, correctionErr.message);
+                            break;
+                        }
+                    }
+                }
+                catch (err) {
+                    console.warn('[ClaudeRuntime] Verification failed (non-blocking):', err.message);
+                }
+            }
+            // Fallback: if conclusionText is still incomplete after verification (or verification was skipped),
+            // check if accumulatedAnswer has more content. This handles the case where the SDK result
+            // was a short summary but the streamed answer_tokens contained the full report.
+            const accumulatedAnswer = getAccumulatedAnswer();
+            if ((0, claudeVerifier_1.isConclusionIncomplete)(conclusionText) && accumulatedAnswer.length > conclusionText.length) {
+                console.warn(`[ClaudeRuntime] Session ${sessionId}: conclusionText incomplete (${conclusionText.length} chars), using accumulatedAnswer (${accumulatedAnswer.length} chars) instead`);
+                conclusionText = accumulatedAnswer;
+                // Re-extract findings from the more complete text
+                allFindings.push((0, claudeFindingExtractor_1.extractFindingsFromText)(conclusionText));
+                mergedFindings = (0, claudeFindingExtractor_1.mergeFindings)(allFindings);
+            }
+            const isPartialResult = terminationReason === analysisTermination_1.MAX_TURNS_TERMINATION_REASON;
+            if (isPartialResult) {
+                terminationMessage || (terminationMessage = (0, analysisTermination_1.buildMaxTurnsTerminationMessage)({
+                    mode: 'full',
+                    turns: rounds,
+                    maxTurns: this.config.maxTurns,
+                    outputLanguage: this.config.outputLanguage,
+                }));
+                conclusionText = conclusionText.trim()
+                    ? (0, analysisTermination_1.prependPartialNotice)(conclusionText, terminationMessage, this.config.outputLanguage)
+                    : (0, analysisTermination_1.buildMaxTurnsFallbackConclusion)({
+                        mode: 'full',
+                        turns: rounds,
+                        maxTurns: this.config.maxTurns,
+                        outputLanguage: this.config.outputLanguage,
+                    });
+                allFindings.push((0, claudeFindingExtractor_1.extractFindingsFromText)(conclusionText));
+                mergedFindings = (0, claudeFindingExtractor_1.mergeFindings)(allFindings);
+                failedApproaches.push({
+                    type: 'strategy_failure',
+                    approach: `analysis reached ${this.config.maxTurns} full-mode turns`,
+                    reason: 'SDK returned error_max_turns before a normal success result',
+                });
+                this.emitUpdate({
+                    type: 'degraded',
+                    content: {
+                        module: 'claudeRuntime',
+                        fallback: 'partial_result_after_max_turns',
+                        error: analysisTermination_1.SDK_MAX_TURNS_SUBTYPE,
+                        message: terminationMessage,
+                        partial: true,
+                        terminationReason,
+                        turns: rounds,
+                        maxTurns: this.config.maxTurns,
+                    },
+                    timestamp: Date.now(),
+                });
+            }
+            const baseConfidence = this.estimateConfidence(mergedFindings);
+            const turnConfidence = isPartialResult
+                ? (0, analysisTermination_1.capPartialConfidence)(baseConfidence, mergedFindings.length > 0)
+                : baseConfidence;
+            ctx.sessionContext.addTurn(query, {
+                primaryGoal: query,
+                aspects: [],
+                expectedOutputType: 'diagnosis',
+                complexity: 'complex',
+                followUpType: ctx.previousTurns.length > 0 ? 'extend' : 'initial',
+            }, {
+                agentId: 'claude-agent',
+                success: true,
+                findings: mergedFindings,
+                confidence: turnConfidence,
+                message: conclusionText,
+                partial: isPartialResult || undefined,
+                terminationReason,
+                terminationMessage,
+            }, mergedFindings);
+            ctx.sessionContext.updateWorkingMemoryFromConclusion({
+                turnIndex: ctx.previousTurns.length,
+                query,
+                conclusion: conclusionText,
+                confidence: turnConfidence,
+            });
+            // P2-2: Save analysis pattern to long-term memory (fire-and-forget)
+            // Note: sceneType is from the outer analyze() scope (classified before context prep)
+            const fullFeatures = (0, analysisPatternMemory_1.extractTraceFeatures)({
+                architectureType: ctx.architecture?.type,
+                sceneType,
+                packageName: options.packageName,
+                findingTitles: mergedFindings.map(f => f.title),
+                findingCategories: mergedFindings.map(f => f.category).filter(Boolean),
+            });
+            // Per Self-Improving v3.3 §4.4: full-path patterns now save as
+            // 'provisional' regardless of confidence. The state machine + 24h
+            // auto-confirm decides whether they earn injection weight.
+            if (!isPartialResult && mergedFindings.length > 0) {
+                const insights = (0, analysisPatternMemory_1.extractKeyInsights)(mergedFindings, conclusionText);
+                const patternExtras = {
+                    status: 'provisional',
+                    provenance: {
+                        sessionId,
+                        turnIndex: ctx.previousTurns.length,
+                    },
+                    knowledgeScope: knowledgeScopeFromOptions(options),
+                };
+                (0, analysisPatternMemory_1.saveAnalysisPattern)(fullFeatures, insights, sceneType, ctx.architecture?.type, turnConfidence, patternExtras)
+                    .catch(err => console.warn('[ClaudeRuntime] Pattern save failed:', err.message));
+                // Try to promote any matching quick-path pattern that has been waiting
+                // for full-path verification. Best-effort — failure does not block.
+                (0, analysisPatternMemory_1.promoteQuickPatternIfMatching)({
+                    fullPathFeatures: fullFeatures,
+                    fullPathInsights: insights,
+                    sceneType,
+                    architectureType: ctx.architecture?.type,
+                    verifierPassed: true,
+                    knowledgeScope: knowledgeScopeFromOptions(options),
+                }).catch(err => console.warn('[ClaudeRuntime] Quick→full promote failed:', err.message));
+            }
+            // Derive sql_error FailedApproach entries from persistent SQL errors
+            // (errors that were never auto-fixed during the session — still in the array)
+            const persistentSqlErrors = this.sessionSqlErrors.get(sessionId)?.filter((e) => !e.fixedSql && e.errorMessage) || [];
+            for (const sqlErr of persistentSqlErrors.slice(-3)) { // cap at 3 to avoid noise
+                failedApproaches.push({
+                    type: 'sql_error',
+                    approach: sqlErr.errorSql?.substring(0, 150) || 'unknown SQL',
+                    reason: sqlErr.errorMessage?.substring(0, 150) || 'SQL query error',
+                });
+            }
+            // P1: Save negative patterns to long-term memory (fire-and-forget)
+            if (failedApproaches.length > 0 && fullFeatures.length > 0) {
+                (0, analysisPatternMemory_1.saveNegativePattern)(fullFeatures, failedApproaches, sceneType, ctx.architecture?.type, {
+                    knowledgeScope: knowledgeScopeFromOptions(options),
+                })
+                    .catch(err => console.warn('[ClaudeRuntime] Negative pattern save failed:', err.message));
+            }
+            // P0-1: Export actual hypotheses from this turn (not hardcoded empty array)
+            // Convert agentv3 Hypothesis to agentProtocol Hypothesis format for AnalysisResult
+            const turnHypotheses = (this.sessionHypotheses.get(sessionId) || []).map(h => this.toProtocolHypothesis(h));
+            return {
+                sessionId,
+                success: true,
+                findings: mergedFindings,
+                hypotheses: turnHypotheses,
+                conclusion: conclusionText,
+                confidence: turnConfidence,
+                rounds,
+                totalDurationMs: Date.now() - startTime,
+                partial: isPartialResult || undefined,
+                terminationReason,
+                terminationMessage,
+            };
+        }
+        catch (error) {
+            const rawErrorMessage = error.message || 'Unknown error';
+            const errMsg = (0, claudeConfig_1.explainClaudeRuntimeError)(rawErrorMessage, this.config.outputLanguage, (0, claudeConfig_1.getCredentialSourceHint)(options.providerId, providerScopeFromOptions(options)));
+            const quotaExceeded = (0, claudeConfig_1.isClaudeQuotaError)(rawErrorMessage);
+            console.error('[ClaudeRuntime] Analysis failed:', errMsg);
+            // P1-3: Preserve partial findings and generate partial conclusion on mid-stream errors
+            const partialFindings = (0, claudeFindingExtractor_1.mergeFindings)(allFindings);
+            const hasPartialResults = partialFindings.length > 0;
+            // P0-1: Export actual hypotheses even on error paths
+            const errorHypotheses = (this.sessionHypotheses.get(sessionId) || []).map(h => this.toProtocolHypothesis(h));
+            if (hasPartialResults) {
+                const partialConclusion = (0, outputLanguage_1.localize)(this.config.outputLanguage, `分析过程中出错 (${errMsg})，以下是已收集的部分发现：\n\n`, `An error occurred during analysis (${errMsg}). Partial findings collected so far:\n\n`) +
+                    partialFindings.map(f => `- **[${f.severity.toUpperCase()}]** ${f.title}: ${f.description || ''}`).join('\n');
+                this.emitUpdate({
+                    type: 'progress',
+                    content: {
+                        phase: 'concluding',
+                        message: (0, outputLanguage_1.localize)(this.config.outputLanguage, `分析中断，已保留 ${partialFindings.length} 个部分发现`, `Analysis interrupted; preserved ${partialFindings.length} partial finding(s)`),
+                    },
+                    timestamp: Date.now(),
+                });
+                return {
+                    sessionId,
+                    success: true, // partial success — downstream can check confidence < 1
+                    findings: partialFindings,
+                    hypotheses: errorHypotheses,
+                    conclusion: partialConclusion,
+                    confidence: this.estimateConfidence(partialFindings) * 0.7, // penalize for incomplete
+                    rounds,
+                    totalDurationMs: Date.now() - startTime,
+                    partial: true,
+                    terminationReason: quotaExceeded ? 'max_budget_usd' : 'execution_error',
+                    terminationMessage: errMsg,
+                };
+            }
+            this.emitUpdate({
+                type: 'error',
+                content: {
+                    message: (0, outputLanguage_1.localize)(this.config.outputLanguage, `分析失败: ${errMsg}`, `Analysis failed: ${errMsg}`),
+                },
+                timestamp: Date.now(),
+            });
+            return {
+                sessionId,
+                success: false,
+                findings: partialFindings,
+                hypotheses: errorHypotheses,
+                conclusion: (0, outputLanguage_1.localize)(this.config.outputLanguage, `分析过程中出错: ${errMsg}`, `An error occurred during analysis: ${errMsg}`),
+                confidence: 0,
+                rounds,
+                totalDurationMs: Date.now() - startTime,
+                terminationReason: quotaExceeded ? 'max_budget_usd' : 'execution_error',
+                terminationMessage: errMsg,
+            };
+        }
+        finally {
+            this.activeAnalyses.delete(sessionId);
+            strategyFingerprint_1.runSnapshots.release(sessionId);
+            // Notes persistence now handled by unified SessionStateSnapshot in the route layer.
+            // No separate disk I/O needed here.
+            // Persist session metrics (fire-and-forget, non-blocking)
+            try {
+                if (!delegatedRetry) {
+                    metricsCollector.recordTurn(); // Record final turn
+                    (0, agentMetrics_1.persistSessionMetrics)(metricsCollector.summarize());
+                }
+            }
+            catch (metricsErr) {
+                console.warn('[ClaudeRuntime] Failed to persist metrics:', metricsErr.message);
+            }
+        }
+    }
+    /**
+     * Quick analysis path for simple factual queries.
+     * Minimal context prep, 3 MCP tools, no planning/verification/report.
+     * Target: 3-8s latency, 2k-5k tokens.
+     */
+    async analyzeQuick(query, sessionId, traceId, options, precomputed) {
+        const { sceneType, focusResult, cachedArch, sessionContext, previousTurns, metricsCollector, startTime } = precomputed;
+        let delegatedRetry = false;
+        try {
+            let effectivePackageName = options.packageName;
+            if (!effectivePackageName && focusResult.primaryApp) {
+                effectivePackageName = focusResult.primaryApp;
+            }
+            // Architecture detection + skill registry init in parallel
+            const [architecture, _skillRegistryReady] = await Promise.all([
+                cachedArch ? Promise.resolve(cachedArch) : (async () => {
+                    try {
+                        const detector = (0, architectureDetector_1.createArchitectureDetector)();
+                        const arch = await detector.detect({
+                            traceId,
+                            traceProcessorService: this.traceProcessorService,
+                            packageName: effectivePackageName,
+                        });
+                        if (arch) {
+                            this.architectureCache.set(traceId, arch);
+                            // LRU eviction: match full path's 50-entry cap
+                            if (this.architectureCache.size > 50) {
+                                const firstKey = this.architectureCache.keys().next().value;
+                                if (firstKey)
+                                    this.architectureCache.delete(firstKey);
+                            }
+                        }
+                        return arch;
+                    }
+                    catch (err) {
+                        console.warn('[ClaudeRuntime] Quick: architecture detection failed:', err.message);
+                        return undefined;
+                    }
+                })(),
+                (0, skillLoader_1.ensureSkillRegistryInitialized)(),
+            ]);
+            const skillExecutor = (0, skillExecutor_1.createSkillExecutor)(this.traceProcessorService);
+            skillExecutor.registerSkills(skillLoader_1.skillRegistry.getAllSkills());
+            skillExecutor.setFragmentRegistry(skillLoader_1.skillRegistry.getFragmentCache());
+            const watchdogWarning = { current: null };
+            // Quick path defaults to no skill-notes injection per §8 of the
+            // self-improving design. Operators can opt-in via the env override.
+            const quickNotesBudget = process.env.SELF_IMPROVE_NOTES_INJECT_ENABLED === '1'
+                ? new skillNotesInjector_1.SkillNotesBudget({
+                    mode: 'quick',
+                    quickOverrideTotal: parseQuickBudgetEnv(),
+                })
+                : undefined;
+            const { server: mcpServer, allowedTools } = (0, claudeMcpServer_1.createClaudeMcpServer)({
+                traceId,
+                traceProcessorService: this.traceProcessorService,
+                skillExecutor,
+                packageName: effectivePackageName,
+                emitUpdate: (update) => this.emitUpdate(update),
+                watchdogWarning,
+                sceneType,
+                lightweight: true,
+                skillNotesBudget: quickNotesBudget,
+                outputLanguage: this.config.outputLanguage,
+                knowledgeScope: knowledgeScopeFromOptions(options),
+            });
+            const systemPrompt = (0, claudeSystemPrompt_1.buildQuickSystemPrompt)({
+                architecture,
+                packageName: effectivePackageName,
+                focusApps: focusResult.apps.length > 0 ? focusResult.apps : undefined,
+                focusMethod: focusResult.method,
+                selectionContext: options.selectionContext,
+                outputLanguage: this.config.outputLanguage,
+            });
+            const providerScope = providerScopeFromOptions(options);
+            const quickConfig = (0, claudeConfig_1.createQuickConfig)((0, claudeConfig_1.resolveRuntimeConfig)(this.config, options.providerId, providerScope));
+            const { handleMessage: bridge, getAccumulatedAnswer } = (0, claudeSseBridge_1.createSseBridge)((update) => {
+                this.emitUpdate(update);
+            }, this.config.outputLanguage);
+            this.emitUpdate({
+                type: 'progress',
+                content: {
+                    phase: 'answering',
+                    message: (0, outputLanguage_1.localize)(this.config.outputLanguage, `快速问答模式 (${quickConfig.model})...`, `Fast Q&A mode (${quickConfig.model})...`),
+                },
+                timestamp: Date.now(),
+            });
+            const sdkEnv = (0, claudeConfig_1.createSdkEnv)(options.providerId, providerScope);
+            // Quick calls intentionally do not resume or persist Claude SDK sessions.
+            // The SDK's maxTurns budget is tied to the resumed conversation, while
+            // SmartPerfetto's fast mode budget is a per-question latency guard. Keep
+            // cross-turn context local and compact so quick cannot exhaust or overwrite
+            // the full-mode SDK conversation.
+            let quickPrompt = query;
+            const quickConversationContext = buildQuickConversationContext(previousTurns, this.config.outputLanguage);
+            if (quickConversationContext) {
+                quickPrompt = `${quickConversationContext}\n\n${quickPrompt}`;
+            }
+            // Prepend pre-queried trace data so the AI skips basic SQL turns in fast mode.
+            if (options.traceContext && options.traceContext.length > 0) {
+                quickPrompt = `${formatTraceContext(options.traceContext, this.config.outputLanguage)}\n\n${quickPrompt}`;
+            }
+            const { stream, close: closeSdk } = sdkQueryWithRetry({
+                prompt: quickPrompt,
+                options: {
+                    model: quickConfig.model,
+                    maxTurns: quickConfig.maxTurns,
+                    systemPrompt,
+                    mcpServers: { smartperfetto: mcpServer },
+                    includePartialMessages: true,
+                    permissionMode: 'bypassPermissions',
+                    allowDangerouslySkipPermissions: true,
+                    cwd: quickConfig.cwd,
+                    effort: quickConfig.effort,
+                    allowedTools,
+                    env: sdkEnv,
+                    stderr: (data) => {
+                        console.warn(`[ClaudeRuntime] Quick SDK stderr [${sessionId}]: ${data.trimEnd()}`);
+                    },
+                },
+            }, {
+                emitUpdate: (update) => this.emitUpdate(update),
+                outputLanguage: this.config.outputLanguage,
+            });
+            let finalResult;
+            let quickRounds = 0;
+            let terminationReason;
+            let terminationMessage;
+            // Quick path per-turn budget from env CLAUDE_QUICK_PER_TURN_MS (default 40s/turn).
+            const timeoutMs = quickConfig.maxTurns * quickConfig.quickPathPerTurnMs;
+            let timedOut = false;
+            let safetyTimer;
+            const timeoutPromise = new Promise((_, reject) => {
+                safetyTimer = setTimeout(() => {
+                    timedOut = true;
+                    // Forcefully terminate SDK subprocess so queued MCP tool calls
+                    // stop running after analyzeQuick returns (prevents orphan queries).
+                    closeSdk();
+                    reject(new Error(`Quick analysis timeout after ${timeoutMs / 1000}s`));
+                }, timeoutMs);
+            });
+            const processStream = async () => {
+                for await (const msg of stream) {
+                    if (timedOut)
+                        break;
+                    const sdkResultError = getSdkResultErrorMessage(msg);
+                    if (sdkResultError)
+                        throw new Error(sdkResultError);
+                    try {
+                        bridge(msg);
+                    }
+                    catch { /* non-fatal */ }
+                    if (msg.type === 'result') {
+                        quickRounds = msg.num_turns || quickRounds;
+                        const resultSubtype = msg.subtype;
+                        if (resultSubtype === 'success') {
+                            finalResult = msg.result;
+                        }
+                        else if ((0, analysisTermination_1.isSdkMaxTurnsSubtype)(resultSubtype)) {
+                            terminationReason = analysisTermination_1.MAX_TURNS_TERMINATION_REASON;
+                            terminationMessage = (0, analysisTermination_1.buildMaxTurnsTerminationMessage)({
+                                mode: 'fast',
+                                turns: quickRounds,
+                                maxTurns: quickConfig.maxTurns,
+                                outputLanguage: this.config.outputLanguage,
+                            });
+                        }
+                    }
+                }
+            };
+            try {
+                await Promise.race([processStream(), timeoutPromise]);
+            }
+            catch (err) {
+                if (timedOut) {
+                    console.warn('[ClaudeRuntime] Quick analysis timeout reached — SDK subprocess has been closed');
+                }
+                else {
+                    throw err;
+                }
+            }
+            finally {
+                if (safetyTimer)
+                    clearTimeout(safetyTimer);
+                closeSdk();
+            }
+            let conclusionText = finalResult || getAccumulatedAnswer() || '';
+            let mergedFindings = (0, claudeFindingExtractor_1.mergeFindings)([(0, claudeFindingExtractor_1.extractFindingsFromText)(conclusionText)]);
+            const isPartialResult = terminationReason === analysisTermination_1.MAX_TURNS_TERMINATION_REASON;
+            if (isPartialResult) {
+                terminationMessage || (terminationMessage = (0, analysisTermination_1.buildMaxTurnsTerminationMessage)({
+                    mode: 'fast',
+                    turns: quickRounds,
+                    maxTurns: quickConfig.maxTurns,
+                    outputLanguage: this.config.outputLanguage,
+                }));
+                conclusionText = conclusionText.trim()
+                    ? (0, analysisTermination_1.prependPartialNotice)(conclusionText, terminationMessage, this.config.outputLanguage)
+                    : (0, analysisTermination_1.buildMaxTurnsFallbackConclusion)({
+                        mode: 'fast',
+                        turns: quickRounds,
+                        maxTurns: quickConfig.maxTurns,
+                        outputLanguage: this.config.outputLanguage,
+                    });
+                mergedFindings = (0, claudeFindingExtractor_1.mergeFindings)([(0, claudeFindingExtractor_1.extractFindingsFromText)(conclusionText)]);
+                this.emitUpdate({
+                    type: 'degraded',
+                    content: {
+                        module: 'claudeRuntime',
+                        fallback: 'partial_result_after_max_turns',
+                        error: analysisTermination_1.SDK_MAX_TURNS_SUBTYPE,
+                        message: terminationMessage,
+                        partial: true,
+                        terminationReason,
+                        turns: quickRounds,
+                        maxTurns: quickConfig.maxTurns,
+                    },
+                    timestamp: Date.now(),
+                });
+            }
+            const quickConfidenceBase = mergedFindings.length > 0 ? 0.8 : 0.5;
+            const quickConfidence = isPartialResult
+                ? (0, analysisTermination_1.capPartialConfidence)(quickConfidenceBase, mergedFindings.length > 0)
+                : quickConfidenceBase;
+            if (conclusionText.length > 0 && conclusionText.length < 20) {
+                console.warn(`[ClaudeRuntime] Quick: suspiciously short answer (${conclusionText.length} chars)`);
+            }
+            // Record turn in session context
+            sessionContext.addTurn(query, {
+                primaryGoal: query,
+                aspects: [],
+                expectedOutputType: 'summary',
+                complexity: 'simple',
+                followUpType: previousTurns.length > 0 ? 'extend' : 'initial',
+            }, {
+                agentId: 'claude-agent',
+                success: true,
+                findings: mergedFindings,
+                confidence: quickConfidence,
+                message: conclusionText,
+                partial: isPartialResult || undefined,
+                terminationReason,
+                terminationMessage,
+            }, mergedFindings);
+            console.log(`[ClaudeRuntime] Quick analysis completed: ${quickRounds} rounds, ${Date.now() - startTime}ms, ${conclusionText.length} chars`);
+            // Quick path writes to a separate 7-day bucket — see Self-Improving v3.3 §6.
+            // Insights are weaker (no verifier, 10-turn budget), so they only surface
+            // as fallbacks at injection time. A future full-path run on similar
+            // features may promote the bucket entry to long-term memory.
+            if (!isPartialResult && mergedFindings.length > 0) {
+                const insights = (0, analysisPatternMemory_1.extractKeyInsights)(mergedFindings, conclusionText);
+                const quickFeatures = (0, analysisPatternMemory_1.extractTraceFeatures)({
+                    architectureType: cachedArch?.type,
+                    sceneType,
+                    packageName: effectivePackageName,
+                    findingTitles: mergedFindings.map(f => f.title),
+                    findingCategories: mergedFindings.map(f => f.category).filter(Boolean),
+                });
+                (0, analysisPatternMemory_1.saveQuickPathPattern)(quickFeatures, insights, sceneType, cachedArch?.type, {
+                    status: 'provisional',
+                    provenance: { sessionId, turnIndex: previousTurns.length },
+                    knowledgeScope: knowledgeScopeFromOptions(options),
+                }).catch(err => console.warn('[ClaudeRuntime] Quick pattern save failed:', err.message));
+            }
+            return {
+                sessionId,
+                success: true,
+                findings: mergedFindings,
+                hypotheses: [],
+                conclusion: conclusionText,
+                confidence: quickConfidence,
+                rounds: quickRounds,
+                totalDurationMs: Date.now() - startTime,
+                partial: isPartialResult || undefined,
+                terminationReason,
+                terminationMessage,
+            };
+        }
+        catch (error) {
+            const rawErrorMessage = error.message || 'Unknown error';
+            const errMsg = (0, claudeConfig_1.explainClaudeRuntimeError)(rawErrorMessage, this.config.outputLanguage, (0, claudeConfig_1.getCredentialSourceHint)(options.providerId, providerScopeFromOptions(options)));
+            const quotaExceeded = (0, claudeConfig_1.isClaudeQuotaError)(rawErrorMessage);
+            console.error('[ClaudeRuntime] Quick analysis failed:', errMsg);
+            this.emitUpdate({
+                type: 'error',
+                content: {
+                    message: (0, outputLanguage_1.localize)(this.config.outputLanguage, `快速问答失败: ${errMsg}`, `Fast Q&A failed: ${errMsg}`),
+                },
+                timestamp: Date.now(),
+            });
+            return {
+                sessionId,
+                success: false,
+                findings: [],
+                hypotheses: [],
+                conclusion: (0, outputLanguage_1.localize)(this.config.outputLanguage, `快速问答过程中出错: ${errMsg}`, `An error occurred during fast Q&A: ${errMsg}`),
+                confidence: 0,
+                rounds: 0,
+                totalDurationMs: Date.now() - startTime,
+                terminationReason: quotaExceeded ? 'max_budget_usd' : 'execution_error',
+                terminationMessage: errMsg,
+            };
+        }
+        finally {
+            this.activeAnalyses.delete(sessionId);
+            try {
+                if (!delegatedRetry) {
+                    metricsCollector.recordTurn();
+                    (0, agentMetrics_1.persistSessionMetrics)(metricsCollector.summarize());
+                }
+            }
+            catch (metricsErr) {
+                console.warn('[ClaudeRuntime] Failed to persist quick metrics:', metricsErr.message);
+            }
+        }
+    }
+    removeSession(sessionId) {
+        // Cancel any pending debounced save to prevent stale write after sync save
+        const pendingTimer = saveTimers.get(this.sessionMap);
+        if (pendingTimer) {
+            clearTimeout(pendingTimer);
+            saveTimers.delete(this.sessionMap);
+        }
+        this.removeSessionMapEntries(sessionId);
+        this.artifactStores.delete(sessionId);
+        this.sessionNotes.delete(sessionId);
+        this.sessionSqlErrors.delete(sessionId);
+        this.sessionPlans.delete(sessionId);
+        this.sessionHypotheses.delete(sessionId);
+        this.sessionUncertaintyFlags.delete(sessionId);
+        this.activeAnalyses.delete(sessionId);
+        if (enterpriseSessionMapDbWritesEnabled()) {
+            try {
+                (0, runtimeSnapshotStore_1.deleteClaudeSessionMapRuntimeSnapshots)(sessionId);
+            }
+            catch (err) {
+                console.warn('[ClaudeRuntime] Failed to delete runtime_snapshots session map:', err.message);
+            }
+        }
+        if (legacySessionMapWritesEnabled()) {
+            // Use immediate save — session is being removed, must persist before cleanup completes
+            savePersistedSessionMapSync(this.sessionMap);
+        }
+    }
+    /** Clean up all session-scoped state for a given session. */
+    cleanupSession(sessionId) {
+        this.removeSession(sessionId);
+    }
+    /** P1-R3: Public getter for session notes — used by report generation. */
+    getSessionNotes(sessionId) {
+        return this.sessionNotes.get(sessionId) || [];
+    }
+    /** P1-R3: Public getter for current analysis plan — used by report generation. */
+    getSessionPlan(sessionId) {
+        return this.sessionPlans.get(sessionId)?.current ?? null;
+    }
+    /** P1-R3: Public getter for uncertainty flags — used by report generation. */
+    getSessionUncertaintyFlags(sessionId) {
+        return this.sessionUncertaintyFlags.get(sessionId) || [];
+    }
+    /** P1-1: Public getter for plan history — used for persistence. */
+    getSessionPlanHistory(sessionId) {
+        return this.sessionPlans.get(sessionId)?.history || [];
+    }
+    // ===========================================================================
+    // Snapshot — atomic serialization / deserialization boundary
+    // ===========================================================================
+    /**
+     * Take a snapshot of all session state for atomic persistence.
+     *
+     * Reads from ClaudeRuntime's 7 internal Maps (notes, plans, hypotheses,
+     * flags, artifacts, architectureCache, sessionMap) and merges with
+     * session-level arrays provided by the route layer.
+     *
+     * @param sessionId - The SmartPerfetto session ID
+     * @param traceId - The trace ID
+     * @param sessionFields - Session-level arrays from AnalysisSession (route layer)
+     */
+    takeSnapshot(sessionId, traceId, sessionFields) {
+        const notes = this.sessionNotes.get(sessionId) || [];
+        const planState = this.sessionPlans.get(sessionId);
+        const claudeHypotheses = this.sessionHypotheses.get(sessionId) || [];
+        const flags = this.sessionUncertaintyFlags.get(sessionId) || [];
+        const artifactStore = this.artifactStores.get(sessionId);
+        const architecture = this.architectureCache.get(traceId);
+        const sessionMapEntry = this.sessionMap.get(this.buildSessionMapKey(sessionId, sessionFields.referenceTraceId));
+        const sdkSessionId = isFreshFullSdkSessionEntry(sessionMapEntry)
+            ? sessionMapEntry.sdkSessionId
+            : undefined;
+        return {
+            version: 1,
+            snapshotTimestamp: Date.now(),
+            sessionId,
+            traceId,
+            // Session fields (route layer) — fields match SessionFieldsForSnapshot exactly
+            ...sessionFields,
+            // ClaudeRuntime Maps
+            analysisNotes: notes,
+            analysisPlan: planState?.current ?? null,
+            planHistory: planState?.history ?? [],
+            uncertaintyFlags: flags,
+            claudeHypotheses: claudeHypotheses.length > 0 ? claudeHypotheses : undefined,
+            // Cached detection
+            architecture,
+            ...(sdkSessionId ? { sdkSessionId, sdkSessionMode: 'full' } : {}),
+            agentRuntimeKind: 'claude-agent-sdk',
+            agentRuntimeProviderId: sessionFields.agentRuntimeProviderId,
+            agentRuntimeProviderSnapshotHash: sessionFields.agentRuntimeProviderSnapshotHash,
+            // Artifacts
+            artifacts: artifactStore?.serialize(),
+        };
+    }
+    /**
+     * Restore all ClaudeRuntime Maps from a persisted snapshot.
+     *
+     * Called during session resume to repopulate the 7 internal Maps
+     * that are normally built up during analysis.
+     *
+     * @param sessionId - The SmartPerfetto session ID
+     * @param traceId - The trace ID (for architectureCache key)
+     * @param snapshot - The persisted snapshot to restore from
+     */
+    restoreFromSnapshot(sessionId, traceId, snapshot) {
+        if (snapshot.analysisNotes.length > 0) {
+            this.sessionNotes.set(sessionId, [...snapshot.analysisNotes]);
+        }
+        if (snapshot.analysisPlan || snapshot.planHistory.length > 0) {
+            this.sessionPlans.set(sessionId, {
+                current: snapshot.analysisPlan,
+                history: snapshot.planHistory,
+            });
+        }
+        if (snapshot.claudeHypotheses && snapshot.claudeHypotheses.length > 0) {
+            this.sessionHypotheses.set(sessionId, [...snapshot.claudeHypotheses]);
+        }
+        if (snapshot.uncertaintyFlags.length > 0) {
+            this.sessionUncertaintyFlags.set(sessionId, [...snapshot.uncertaintyFlags]);
+        }
+        if (snapshot.artifacts && snapshot.artifacts.length > 0) {
+            this.artifactStores.set(sessionId, artifactStore_1.ArtifactStore.fromSnapshot(snapshot.artifacts));
+        }
+        if (snapshot.architecture) {
+            this.architectureCache.set(traceId, snapshot.architecture);
+        }
+        if (snapshot.sdkSessionId && snapshot.sdkSessionMode === 'full') {
+            this.sessionMap.set(this.buildSessionMapKey(sessionId, snapshot.referenceTraceId), {
+                sdkSessionId: snapshot.sdkSessionId,
+                updatedAt: snapshot.snapshotTimestamp || Date.now(),
+                mode: 'full',
+            });
+        }
+    }
+    /** P0-1: Convert agentv3 Hypothesis to agentProtocol Hypothesis format for AnalysisResult. */
+    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: 'claude', strength: 0.8 }] : [],
+            contradictingEvidence: h.evidence && h.status === 'rejected' ? [{ id: `${h.id}-ev`, type: 'observation', description: h.evidence, source: 'claude', strength: 0.8 }] : [],
+            proposedBy: 'claude',
+            relevantAgents: ['claude'],
+            createdAt: h.formedAt,
+            updatedAt: h.resolvedAt || h.formedAt,
+        };
+    }
+    reset() {
+        this.architectureCache.clear();
+        this.vendorCache.clear();
+        this.completenessCache.clear();
+        // Also clear all session-scoped stores to prevent unbounded growth
+        this.artifactStores.clear();
+        this.sessionNotes.clear();
+        this.sessionSqlErrors.clear();
+        this.sessionPlans.clear();
+        this.sessionHypotheses.clear();
+        this.sessionUncertaintyFlags.clear();
+        this.activeAnalyses.clear();
+    }
+    emitUpdate(update) {
+        this.emit('update', update);
+    }
+    /**
+     * Collect the most recent findings from previous turns for system prompt injection.
+     * Caps at 5 findings to prevent unbounded prompt growth.
+     */
+    collectPreviousFindings(sessionContext, maxTurns) {
+        try {
+            let turns = sessionContext.getAllTurns?.() || [];
+            if (maxTurns && maxTurns > 0) {
+                turns = turns.slice(-maxTurns);
+            }
+            return turns.flatMap((turn) => turn.findings || []).slice(-5);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Build a compact entity context string for the system prompt.
+     * Gives Claude awareness of known frames/sessions for drill-down resolution.
+     */
+    buildEntityContext(entityStore) {
+        try {
+            const stats = entityStore.getStats();
+            if (stats.totalEntityCount === 0)
+                return undefined;
+            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(', ')}`);
+                }
+                if (frames.length > 15)
+                    lines.push(`- ...及其他 ${frames.length - 15} 帧`);
+            }
+            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;
+        }
+    }
+    /**
+     * Prepare all context needed for a Claude analysis run.
+     * Extracts focus app detection, architecture detection, session context,
+     * scene classification, MCP server creation, and system prompt building
+     * into a single cohesive preparation phase.
+     */
+    async prepareAnalysisContext(query, sessionId, traceId, options, precomputed) {
+        // Phase 0: Selection context logging
+        if (options.selectionContext) {
+            const sc = options.selectionContext;
+            const detail = sc.kind === 'area'
+                ? `startNs=${sc.startNs}, endNs=${sc.endNs}`
+                : `eventId=${sc.eventId}, ts=${sc.ts}`;
+            console.log(`[ClaudeRuntime] Selection context received: kind=${sc.kind}, ${detail}`);
+        }
+        // Phase 0.5: Detect focus apps from trace data (reuse precomputed if available)
+        let effectivePackageName = options.packageName;
+        const focusResult = precomputed?.focusResult ?? await (0, focusAppDetector_1.detectFocusApps)(this.traceProcessorService, traceId);
+        if (focusResult.primaryApp) {
+            if (!effectivePackageName) {
+                effectivePackageName = focusResult.primaryApp;
+                console.log(`[ClaudeRuntime] Auto-detected focus app: ${effectivePackageName} (via ${focusResult.method})`);
+            }
+            else {
+                console.log(`[ClaudeRuntime] User-provided packageName: ${effectivePackageName}, also detected: ${focusResult.apps.map(a => a.packageName).join(', ')}`);
+            }
+            this.emitUpdate({
+                type: 'progress',
+                content: {
+                    phase: 'starting',
+                    message: (0, outputLanguage_1.localize)(this.config.outputLanguage, `检测到焦点应用: ${focusResult.primaryApp} (${focusResult.method})`, `Detected focus app: ${focusResult.primaryApp} (${focusResult.method})`),
+                },
+                timestamp: Date.now(),
+            });
+        }
+        // Phase 1: Skill executor setup
+        const skillExecutor = (0, skillExecutor_1.createSkillExecutor)(this.traceProcessorService);
+        await (0, skillLoader_1.ensureSkillRegistryInitialized)();
+        skillExecutor.registerSkills(skillLoader_1.skillRegistry.getAllSkills());
+        skillExecutor.setFragmentRegistry(skillLoader_1.skillRegistry.getFragmentCache());
+        // Phase 2: Architecture detection (LRU cached per traceId)
+        let architecture = this.architectureCache.get(traceId);
+        if (architecture) {
+            // LRU touch: delete and re-insert to move to end of Map iteration order
+            this.architectureCache.delete(traceId);
+            this.architectureCache.set(traceId, architecture);
+        }
+        else {
+            try {
+                const detector = (0, architectureDetector_1.createArchitectureDetector)();
+                architecture = await detector.detect({
+                    traceId,
+                    traceProcessorService: this.traceProcessorService,
+                    packageName: effectivePackageName,
+                });
+                if (architecture) {
+                    this.architectureCache.set(traceId, architecture);
+                    // LRU eviction: remove oldest entry (first key in Map)
+                    if (this.architectureCache.size > 50) {
+                        const firstKey = this.architectureCache.keys().next().value;
+                        if (firstKey)
+                            this.architectureCache.delete(firstKey);
+                    }
+                }
+                this.emitUpdate({ type: 'architecture_detected', content: { architecture }, timestamp: Date.now() });
+            }
+            catch (err) {
+                console.warn('[ClaudeRuntime] Architecture detection failed:', err.message);
+            }
+        }
+        // Phase 2.5: Vendor detection (LRU cached per traceId, reuses SkillAnalysisAdapter.detectVendor)
+        let detectedVendor = this.vendorCache.get(traceId) ?? null;
+        if (!detectedVendor) {
+            try {
+                const adapter = (0, skillAnalysisAdapter_1.getSkillAnalysisAdapter)(this.traceProcessorService);
+                await adapter.ensureInitialized();
+                const vendorResult = await adapter.detectVendor(traceId);
+                detectedVendor = vendorResult.vendor;
+                if (detectedVendor && detectedVendor !== 'aosp') {
+                    this.vendorCache.set(traceId, detectedVendor);
+                    // LRU eviction: match architectureCache limit
+                    if (this.vendorCache.size > 50) {
+                        const firstKey = this.vendorCache.keys().next().value;
+                        if (firstKey)
+                            this.vendorCache.delete(firstKey);
+                    }
+                }
+            }
+            catch (err) {
+                console.warn('[ClaudeRuntime] Vendor detection failed:', err.message);
+            }
+        }
+        // Phase 2.8: Comparison context (dual-trace mode)
+        let comparisonContext;
+        const referenceTraceId = options.referenceTraceId;
+        if (referenceTraceId) {
+            console.log(`[ClaudeRuntime] Comparison mode: current=${traceId}, reference=${referenceTraceId}`);
+            this.emitUpdate({
+                type: 'progress',
+                content: {
+                    phase: 'starting',
+                    message: (0, outputLanguage_1.localize)(this.config.outputLanguage, '对比模式：正在检测参考 Trace...', 'Comparison mode: detecting the reference trace...'),
+                },
+                timestamp: Date.now(),
+            });
+            // Detect reference trace focus app, architecture, AND capability handshake in parallel
+            const capSql = "SELECT name FROM sqlite_master WHERE type IN ('table', 'view') AND (name LIKE 'android_%' OR name LIKE 'linux_%' OR name LIKE 'sched_%' OR name LIKE 'slices_%')";
+            const [refFocusResult, refArchitecture, currentTables, refTables] = await Promise.all([
+                (0, focusAppDetector_1.detectFocusApps)(this.traceProcessorService, referenceTraceId).catch(() => ({ apps: [], method: 'none', primaryApp: undefined })),
+                (async () => {
+                    let refArch = this.architectureCache.get(referenceTraceId);
+                    if (!refArch) {
+                        try {
+                            const detector = (0, architectureDetector_1.createArchitectureDetector)();
+                            refArch = await detector.detect({
+                                traceId: referenceTraceId,
+                                traceProcessorService: this.traceProcessorService,
+                                packageName: undefined,
+                            }) ?? undefined;
+                            if (refArch)
+                                this.architectureCache.set(referenceTraceId, refArch);
+                        }
+                        catch { /* non-fatal */ }
+                    }
+                    return refArch;
+                })(),
+                this.traceProcessorService.query(traceId, capSql).catch((e) => { console.warn('[ClaudeRuntime] Capability query failed for current trace:', e.message); return null; }),
+                this.traceProcessorService.query(referenceTraceId, capSql).catch((e) => { console.warn('[ClaudeRuntime] Capability query failed for reference trace:', e.message); return null; }),
+            ]);
+            // Capability handshake: compute intersection of available tables on both trace processors
+            // null = query failed (unhealthy processor), non-null = actual result
+            let commonCapabilities = [];
+            let capabilityDiff;
+            if (currentTables && refTables) {
+                const currentSet = new Set(currentTables.rows.map((r) => r[0]));
+                const refSet = new Set(refTables.rows.map((r) => r[0]));
+                commonCapabilities = [...currentSet].filter(t => refSet.has(t));
+                const currentOnly = [...currentSet].filter(t => !refSet.has(t));
+                const referenceOnly = [...refSet].filter(t => !currentSet.has(t));
+                if (currentOnly.length > 0 || referenceOnly.length > 0) {
+                    capabilityDiff = { currentOnly, referenceOnly };
+                }
+            }
+            else {
+                console.warn('[ClaudeRuntime] Capability handshake incomplete — one or both trace processors unhealthy');
+            }
+            comparisonContext = {
+                referenceTraceId,
+                referencePackageName: refFocusResult.primaryApp,
+                referenceFocusApps: refFocusResult.apps.length > 0 ? refFocusResult.apps : undefined,
+                referenceArchitecture: refArchitecture,
+                commonCapabilities,
+                capabilityDiff,
+            };
+            console.log(`[ClaudeRuntime] Comparison context built: refApp=${refFocusResult.primaryApp || 'unknown'}, ` +
+                `refArch=${refArchitecture?.type || 'unknown'}, commonCaps=${commonCapabilities.length}, ` +
+                `capDiff=${capabilityDiff ? `cur=${capabilityDiff.currentOnly.length}/ref=${capabilityDiff.referenceOnly.length}` : 'none'}`);
+        }
+        // Phase 2.9: Trace data completeness probe (cached per traceId, ~50ms first run)
+        let traceCompleteness = this.completenessCache.get(traceId);
+        if (!traceCompleteness) {
+            try {
+                traceCompleteness = await (0, traceCompletenessProber_1.probeTraceCompleteness)(this.traceProcessorService, traceId, architecture?.type);
+                this.completenessCache.set(traceId, traceCompleteness);
+                if (this.completenessCache.size > 50) {
+                    const firstKey = this.completenessCache.keys().next().value;
+                    if (firstKey)
+                        this.completenessCache.delete(firstKey);
+                }
+            }
+            catch (err) {
+                console.warn('[ClaudeRuntime] Trace completeness probe failed (non-fatal):', err.message);
+            }
+        }
+        // Phase 3: Session context + conversation history (reuse precomputed if available)
+        const sessionContext = precomputed?.sessionContext ?? enhancedSessionContext_1.sessionContextManager.getOrCreate(sessionId, traceId);
+        const previousTurns = precomputed?.previousTurns ?? (sessionContext.getAllTurns?.() || []);
+        // Composite key for comparison mode session identity isolation
+        const sessionMapKey = this.buildSessionMapKey(sessionId, referenceTraceId);
+        const sessionMapEntry = this.sessionMap.get(sessionMapKey);
+        const existingSdkSession = isFreshFullSdkSessionEntry(sessionMapEntry)
+            ? sessionMapEntry.sdkSessionId
+            : undefined;
+        // P0-3: SDK sessions on Anthropic's side expire after ~4 hours.
+        // If the local sessionMap entry is stale, treat it as expired and inject full manual context.
+        // Without this check, `hasActiveResume` stays true for stale entries, causing the system
+        // to skip both SDK context (expired) AND manual context injection → silent context loss.
+        const hasActiveResume = !!existingSdkSession;
+        const previousFindings = hasActiveResume
+            ? [] // SDK already has these in conversation history
+            : this.collectPreviousFindings(sessionContext);
+        const conversationSummary = previousTurns.length > 0 && !hasActiveResume
+            ? sessionContext.generatePromptContext(2000)
+            : undefined;
+        // Phase 4: Entity store + entity context for drill-down
+        const entityStore = sessionContext.getEntityStore();
+        const entityContext = this.buildEntityContext(entityStore);
+        // Phase 5: Scene classification + effort resolution (reuse precomputed if available)
+        const sceneType = precomputed?.sceneType ?? (0, sceneClassifier_1.classifyScene)(query);
+        const effectiveEffort = (0, claudeConfig_1.resolveEffort)(this.config, sceneType);
+        // Phase 5.5: Pattern memory — match similar historical traces (P2-2)
+        const traceFeatures = (0, analysisPatternMemory_1.extractTraceFeatures)({
+            architectureType: architecture?.type,
+            sceneType,
+            packageName: effectivePackageName,
+        });
+        const patternContext = (0, analysisPatternMemory_1.buildPatternContextSection)(traceFeatures, knowledgeScopeFromOptions(options));
+        const negativePatternContext = (0, analysisPatternMemory_1.buildNegativePatternSection)(traceFeatures, knowledgeScopeFromOptions(options));
+        // Phase 6: Session-scoped artifact store + analysis notes
+        if (!this.artifactStores.has(sessionId)) {
+            this.artifactStores.set(sessionId, new artifactStore_1.ArtifactStore());
+        }
+        const artifactStore = this.artifactStores.get(sessionId);
+        // Notes restored from SessionStateSnapshot on resume — no separate disk I/O.
+        let notes = this.sessionNotes.get(sessionId);
+        if (!notes) {
+            notes = [];
+            this.sessionNotes.set(sessionId, notes);
+        }
+        // Phase 6.5: Session-scoped analysis plan (P0-1: Planning capability)
+        if (!this.sessionPlans.has(sessionId)) {
+            this.sessionPlans.set(sessionId, { current: null, history: [] });
+        }
+        const analysisPlan = this.sessionPlans.get(sessionId);
+        // P1-B1: Preserve plan history (max 3 recent plans) for deeper cross-turn context
+        if (analysisPlan.current) {
+            analysisPlan.history.push(analysisPlan.current);
+            if (analysisPlan.history.length > 3)
+                analysisPlan.history.shift();
+        }
+        const previousPlan = analysisPlan.current ?? undefined;
+        analysisPlan.current = null;
+        // Phase 6.6: Watchdog feedback ref — shared between runtime watchdog and MCP tools
+        const watchdogWarning = { current: null };
+        // Phase 6.7: Session-scoped hypotheses for hypothesis-verify cycle (P0-G4)
+        if (!this.sessionHypotheses.has(sessionId)) {
+            this.sessionHypotheses.set(sessionId, []);
+        }
+        const hypotheses = this.sessionHypotheses.get(sessionId);
+        // Reset for new turn (hypotheses are per-turn, resolved within each analysis cycle)
+        hypotheses.splice(0);
+        // Phase 6.8: Session-scoped uncertainty flags (P1-G1)
+        if (!this.sessionUncertaintyFlags.has(sessionId)) {
+            this.sessionUncertaintyFlags.set(sessionId, []);
+        }
+        const uncertaintyFlags = this.sessionUncertaintyFlags.get(sessionId);
+        uncertaintyFlags.splice(0); // Reset per turn
+        // Phase 7: SQL error tracking for in-context learning
+        // Seed new sessions with previously learned fix pairs from disk (cross-session learning)
+        let sqlErrors = this.sessionSqlErrors.get(sessionId);
+        if (!sqlErrors) {
+            sqlErrors = (0, claudeMcpServer_1.loadLearnedSqlFixPairs)(5, knowledgeScopeFromOptions(options));
+            this.sessionSqlErrors.set(sessionId, sqlErrors);
+        }
+        // Phase 8: MCP server with all session-scoped state
+        // P2-G1: Destructure to get both server and auto-derived allowedTools
+        const fullNotesBudget = process.env.SELF_IMPROVE_NOTES_INJECT_ENABLED === '1'
+            ? new skillNotesInjector_1.SkillNotesBudget({ mode: 'full' })
+            : undefined;
+        const { server: mcpServer, allowedTools } = (0, claudeMcpServer_1.createClaudeMcpServer)({
+            traceId,
+            traceProcessorService: this.traceProcessorService,
+            skillExecutor,
+            packageName: effectivePackageName,
+            emitUpdate: (update) => this.emitUpdate(update),
+            onSkillResult: (result) => {
+                if (result.displayResults) {
+                    this.captureEntitiesFromSkillDisplayResults(result.displayResults, entityStore);
+                }
+            },
+            analysisNotes: notes,
+            artifactStore,
+            cachedArchitecture: architecture,
+            cachedVendor: detectedVendor,
+            recentSqlErrors: sqlErrors,
+            analysisPlan,
+            watchdogWarning,
+            hypotheses,
+            sceneType,
+            uncertaintyFlags,
+            referenceTraceId,
+            comparisonContext,
+            skillNotesBudget: fullNotesBudget,
+            outputLanguage: this.config.outputLanguage,
+            knowledgeScope: knowledgeScopeFromOptions(options),
+        });
+        // Phase 9: (removed — skillCatalog was populated but never used in prompt;
+        //           Claude uses list_skills MCP tool on demand instead)
+        // Phase 10: Knowledge base context (non-fatal — Claude can use lookup_sql_schema tool)
+        let knowledgeBaseContext;
+        try {
+            const kb = await (0, sqlKnowledgeBase_1.getExtendedKnowledgeBase)();
+            knowledgeBaseContext = kb.getContextForAI(query, 8);
+        }
+        catch {
+            // Non-fatal
+        }
+        // Phase 11: Sub-agent definitions (feature-gated)
+        let agents;
+        if (this.config.enableSubAgents && sceneType !== 'anr') {
+            agents = (0, claudeAgentDefinitions_1.buildAgentDefinitions)(sceneType, {
+                architecture,
+                packageName: effectivePackageName,
+                allowedTools,
+                subAgentModel: this.config.subAgentModel,
+            });
+        }
+        // Phase 12: SQL error-fix pairs for prompt injection
+        const sqlErrorFixPairs = sqlErrors
+            .filter((e) => e.fixedSql)
+            .slice(-3)
+            .map((e) => ({ errorSql: e.errorSql, errorMessage: e.errorMessage, fixedSql: e.fixedSql }));
+        // Phase 13: System prompt assembly
+        const traceInfo = this.traceProcessorService.getTrace(traceId);
+        const analysisContextForRebuild = {
+            query,
+            architecture,
+            packageName: effectivePackageName,
+            focusApps: focusResult.apps.length > 0 ? focusResult.apps : undefined,
+            focusMethod: focusResult.method,
+            previousFindings,
+            conversationSummary,
+            knowledgeBaseContext,
+            entityContext,
+            sceneType,
+            analysisNotes: notes.length > 0 ? notes : undefined,
+            availableAgents: agents ? Object.keys(agents) : undefined,
+            sqlErrorFixPairs: sqlErrorFixPairs.length > 0 ? sqlErrorFixPairs : undefined,
+            patternContext,
+            negativePatternContext,
+            previousPlan,
+            planHistory: analysisPlan.history.length > 0 ? analysisPlan.history : undefined,
+            selectionContext: options.selectionContext,
+            comparison: comparisonContext,
+            traceCompleteness,
+            traceOs: traceInfo?.traceOs,
+            traceFormat: traceInfo?.traceFormat,
+            outputLanguage: this.config.outputLanguage,
+        };
+        const systemPrompt = (0, claudeSystemPrompt_1.buildSystemPrompt)(analysisContextForRebuild);
+        return {
+            mcpServer,
+            systemPrompt,
+            effectiveEffort,
+            agents,
+            sessionContext,
+            previousTurns,
+            entityStore,
+            analysisPlan,
+            architecture,
+            watchdogWarning,
+            hypotheses,
+            sceneType,
+            allowedTools, // P2-G1: auto-derived from MCP server registration
+            analysisContextForRebuild, // Used by correction retry to rebuild prompt with reduced budget
+            sessionMapKey, // Composite key for comparison mode session identity isolation
+        };
+    }
+    estimateConfidence(findings) {
+        if (findings.length === 0)
+            return 0.3;
+        const avg = findings.reduce((sum, f) => sum + (f.confidence ?? 0.5), 0) / findings.length;
+        return Math.min(1, Math.max(0, avg));
+    }
+    /** Capture entities from skill displayResults into EntityStore for multi-turn drill-down. */
+    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: 'claude-agent',
+                    success: true,
+                    toolResults: [{ toolName: 'invoke_skill', data }],
+                }]);
+            (0, entityCapture_1.applyCapturedEntities)(entityStore, captured);
+        }
+        catch (err) {
+            console.warn('[ClaudeRuntime] Entity capture failed:', err.message);
+        }
+    }
+}
+exports.ClaudeRuntime = ClaudeRuntime;
+//# sourceMappingURL=claudeRuntime.js.map