@agenthippo-ai/agenthippo 0.1.0

package/out/analytics/dashboard/queryRunner.js

@@ -0,0 +1,994 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+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.QueryRunnerImpl = exports.QueryRunnerError = void 0;
+const vscode = __importStar(require("vscode"));
+const path = __importStar(require("path"));
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const index_1 = require("../../utils/index");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+class QueryRunnerError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'QueryRunnerError';
+    }
+}
+exports.QueryRunnerError = QueryRunnerError;
+// -----------------------------------------------------------------------------
+// Implementation
+// -----------------------------------------------------------------------------
+const CACHE_TTL = 30_000;
+const INDEXED_DB_FILENAME = 'analytics.duckdb';
+const INDEXED_DB_REQUIRED_TABLE = 'spans';
+const INDEXED_DB_REQUIRED_COLUMNS = ['trace_id', 'start_ms', 'duration_ms', 'cost', 'model', 'session_id', 'project_id', 'agent_id'];
+const DEFAULT_DUCKDB_MEMORY_LIMIT_MB = 1024;
+const DEFAULT_DUCKDB_THREADS = 2;
+const DEFAULT_DUCKDB_QUERY_TIMEOUT_SECONDS = 30;
+const DEFAULT_DUCKDB_MAX_RESULT_ROWS = 5000;
+const MIN_DUCKDB_MEMORY_MB = 64;
+const MIN_DUCKDB_THREADS = 1;
+const MIN_DUCKDB_TIMEOUT_SECONDS = 5;
+const MIN_DUCKDB_MAX_RESULT_ROWS = 100;
+const MAX_DUCKDB_MAX_RESULT_ROWS = 100_000;
+const DEFAULT_DUCKDB_TEMP_DIRECTORY = path.join((0, index_1.getAgentideHome)(), 'analytics', 'tmp', 'duckdb');
+const FLEET_SESSIONS_TABLE = 'fleet_sessions';
+class QueryRunnerImpl {
+    outputChannel;
+    cache = new Map();
+    duckdbPath;
+    indexedDbPath;
+    schemaValidated = false;
+    fleetSchemaReady = false;
+    fleetSchemaEnsurePromise;
+    activeDuckDbQueries = 0;
+    duckDbQueryWaiters = [];
+    maxDuckDbConcurrentQueries = 1;
+    lastLoggedRuntimeProfile;
+    analyticsConfig;
+    tracesDir = path.join((0, index_1.getAgentideHome)(), 'analytics', 'traces');
+    constructor(outputChannel) {
+        this.outputChannel = outputChannel;
+    }
+    async ensureDuckDB() {
+        if (this.duckdbPath) {
+            return this.duckdbPath;
+        }
+        const candidates = process.platform === 'win32'
+            ? ['duckdb', 'duckdb.exe', path.join((0, index_1.getAgentideHome)(), 'bin', 'duckdb.exe'), path.join((0, index_1.getAgentideHome)(), 'bin', 'duckdb')]
+            : ['duckdb', path.join((0, index_1.getAgentideHome)(), 'bin', 'duckdb'), '/opt/homebrew/bin/duckdb', '/usr/local/bin/duckdb', '/usr/bin/duckdb'];
+        for (const candidate of candidates) {
+            try {
+                await execFileAsync(candidate, ['--version'], { timeout: 5000 });
+                this.duckdbPath = candidate;
+                this.outputChannel.appendLine(`[QueryRunner] Using DuckDB at: ${candidate}`);
+                return candidate;
+            }
+            catch {
+                // continue
+            }
+        }
+        const installHint = process.platform === 'win32'
+            ? 'Run Setup Spotlight first (it installs ~/.agent-hippo/bin/duckdb.exe)'
+            : 'Run Setup Spotlight first or install with: brew install duckdb';
+        throw new QueryRunnerError(`DuckDB not found. ${installHint}`, 'DUCKDB_NOT_FOUND');
+    }
+    getIndexedDbPath() {
+        return path.join(this.tracesDir, INDEXED_DB_FILENAME);
+    }
+    getAnalyticsConfig() {
+        if (this.analyticsConfig) {
+            return this.analyticsConfig;
+        }
+        const config = vscode.workspace.getConfiguration('agentide.analytics');
+        const memoryLimitMb = Math.max(MIN_DUCKDB_MEMORY_MB, Number(config.get('duckdb.memoryLimitMb', DEFAULT_DUCKDB_MEMORY_LIMIT_MB)) || DEFAULT_DUCKDB_MEMORY_LIMIT_MB);
+        const threads = Math.max(MIN_DUCKDB_THREADS, Number(config.get('duckdb.threads', DEFAULT_DUCKDB_THREADS)) || DEFAULT_DUCKDB_THREADS);
+        const timeoutSeconds = Math.max(MIN_DUCKDB_TIMEOUT_SECONDS, Number(config.get('duckdb.queryTimeoutSeconds', DEFAULT_DUCKDB_QUERY_TIMEOUT_SECONDS)) || DEFAULT_DUCKDB_QUERY_TIMEOUT_SECONDS);
+        const maxResultRows = Math.max(MIN_DUCKDB_MAX_RESULT_ROWS, Math.min(MAX_DUCKDB_MAX_RESULT_ROWS, Number(config.get('duckdb.maxResultRows', DEFAULT_DUCKDB_MAX_RESULT_ROWS)) || DEFAULT_DUCKDB_MAX_RESULT_ROWS));
+        const tempDirectory = (config.get('duckdb.tempDirectory', '') || '').trim() || DEFAULT_DUCKDB_TEMP_DIRECTORY;
+        this.analyticsConfig = { memoryLimitMb, threads, queryTimeoutMs: timeoutSeconds * 1000, maxResultRows, tempDirectory };
+        return this.analyticsConfig;
+    }
+    sqlLiteral(value) {
+        return '\'' + value.replace(/'/g, '\'\'') + '\'';
+    }
+    normalizeFilters(filters) {
+        const scope = filters?.scope === 'workspace' ? 'workspace' : 'global';
+        const projectId = filters?.projectId?.trim() || undefined;
+        const agentId = filters?.agentId?.trim() || undefined;
+        return { scope, projectId, agentId };
+    }
+    buildTraceFilterConditions(filters, alias) {
+        const normalized = this.normalizeFilters(filters);
+        const prefix = alias ? `${alias}.` : '';
+        const conditions = [];
+        if (normalized.scope === 'workspace') {
+            if (!normalized.projectId) {
+                conditions.push('1 = 0');
+            }
+            else {
+                conditions.push(`(${prefix}project_id = ${this.sqlLiteral(normalized.projectId)} OR ${prefix}project_id IS NULL)`);
+            }
+        }
+        if (normalized.agentId) {
+            conditions.push(`${prefix}agent_id = ${this.sqlLiteral(normalized.agentId)}`);
+        }
+        return conditions;
+    }
+    buildFilterCacheKey(filters) {
+        const normalized = this.normalizeFilters(filters);
+        return `${normalized.scope}|${normalized.projectId ?? ''}|${normalized.agentId ?? ''}`;
+    }
+    buildRuntimeSettingsSql() {
+        const cfg = this.getAnalyticsConfig();
+        const lines = [`SET memory_limit='${cfg.memoryLimitMb}MB';`, `SET threads=${cfg.threads};`, 'SET preserve_insertion_order=false;'];
+        if (cfg.tempDirectory) {
+            lines.push(`SET temp_directory=${this.sqlLiteral(cfg.tempDirectory)};`);
+        }
+        return lines.join('\n');
+    }
+    logRuntimeProfileOnce() {
+        const cfg = this.getAnalyticsConfig();
+        const profile = `${cfg.memoryLimitMb}|${cfg.threads}|${cfg.queryTimeoutMs}|${cfg.maxResultRows}|${cfg.tempDirectory}`;
+        if (this.lastLoggedRuntimeProfile === profile) {
+            return;
+        }
+        this.lastLoggedRuntimeProfile = profile;
+        this.outputChannel.appendLine(`[QueryRunner] DuckDB runtime profile: memory=${cfg.memoryLimitMb}MB threads=${cfg.threads} timeoutMs=${cfg.queryTimeoutMs} maxRows=${cfg.maxResultRows} tempDir=${cfg.tempDirectory}`);
+    }
+    async ensureIndexedDbReady(duckdb) {
+        if (this.indexedDbPath && this.schemaValidated) {
+            return this.indexedDbPath;
+        }
+        const dbPath = this.getIndexedDbPath();
+        try {
+            await fs_1.promises.access(dbPath, fs_1.constants.R_OK);
+        }
+        catch {
+            throw new QueryRunnerError(`Indexed analytics DB not found at ${dbPath}. Run Setup Spotlight or re-index traces.`, 'INDEX_UNAVAILABLE');
+        }
+        const cfg = this.getAnalyticsConfig();
+        await fs_1.promises.mkdir(cfg.tempDirectory, { recursive: true }).catch(() => undefined);
+        const requiredColumns = INDEXED_DB_REQUIRED_COLUMNS.map(col => this.sqlLiteral(col)).join(', ');
+        const validationSql = `${this.buildRuntimeSettingsSql()}\nSELECT (SELECT COUNT(*) FROM information_schema.tables WHERE table_name = '${INDEXED_DB_REQUIRED_TABLE}') AS table_count, (SELECT COUNT(*) FROM information_schema.columns WHERE table_name = '${INDEXED_DB_REQUIRED_TABLE}' AND column_name IN (${requiredColumns})) AS column_count;`;
+        try {
+            const { stdout } = await execFileAsync(duckdb, ['-readonly', dbPath, '-json', '-c', validationSql], { timeout: cfg.queryTimeoutMs, maxBuffer: 1024 * 1024 });
+            const rows = stdout.trim() ? JSON.parse(stdout) : [];
+            const row = rows[0];
+            if (!row || Number(row.table_count) < 1 || Number(row.column_count) < INDEXED_DB_REQUIRED_COLUMNS.length) {
+                throw new QueryRunnerError('Indexed analytics DB schema is stale or incomplete. Re-index traces and refresh.', 'INDEX_UNAVAILABLE');
+            }
+        }
+        catch (error) {
+            if (error instanceof QueryRunnerError) {
+                throw error;
+            }
+            throw new QueryRunnerError(`Indexed analytics DB is unreadable at ${dbPath}. Run Setup Spotlight or re-index traces.`, 'INDEX_UNAVAILABLE');
+        }
+        this.schemaValidated = true;
+        this.indexedDbPath = dbPath;
+        return dbPath;
+    }
+    clampLimit(limit) {
+        return Math.max(1, Math.min(this.getAnalyticsConfig().maxResultRows, Math.floor(limit || 1)));
+    }
+    async acquireDuckDbQuerySlot() {
+        while (this.activeDuckDbQueries >= this.maxDuckDbConcurrentQueries) {
+            await new Promise(resolve => this.duckDbQueryWaiters.push(resolve));
+        }
+        this.activeDuckDbQueries += 1;
+    }
+    releaseDuckDbQuerySlot() {
+        this.activeDuckDbQueries = Math.max(0, this.activeDuckDbQueries - 1);
+        const next = this.duckDbQueryWaiters.shift();
+        next?.();
+    }
+    async runDuckDB(sqlBody) {
+        const duckdb = await this.ensureDuckDB();
+        await this.acquireDuckDbQuerySlot();
+        try {
+            const dbPath = await this.ensureIndexedDbReady(duckdb);
+            this.logRuntimeProfileOnce();
+            const sql = `${this.buildRuntimeSettingsSql()}\n${sqlBody}`;
+            const cfg = this.getAnalyticsConfig();
+            const { stdout, stderr } = await execFileAsync(duckdb, ['-readonly', dbPath, '-json', '-c', sql], { timeout: cfg.queryTimeoutMs, maxBuffer: 10 * 1024 * 1024 });
+            if (stderr && !stderr.includes('Warning')) {
+                this.outputChannel.appendLine(`[QueryRunner] DuckDB stderr: ${stderr}`);
+            }
+            if (!stdout.trim()) {
+                return [];
+            }
+            return JSON.parse(stdout);
+        }
+        catch (error) {
+            if (error instanceof QueryRunnerError) {
+                throw error;
+            }
+            if (error instanceof Error && error.message.includes('timeout')) {
+                throw new QueryRunnerError(`Query timed out (>${Math.floor(this.getAnalyticsConfig().queryTimeoutMs / 1000)}s)`, 'TIMEOUT');
+            }
+            throw new QueryRunnerError(`Query failed: ${error}`, 'QUERY_ERROR');
+        }
+        finally {
+            this.releaseDuckDbQuerySlot();
+        }
+    }
+    sqlNullableLiteral(value) {
+        if (value === undefined || value === null) {
+            return 'NULL';
+        }
+        return this.sqlLiteral(String(value));
+    }
+    sqlBool(value) {
+        return value ? 'TRUE' : 'FALSE';
+    }
+    isDuckDbLockError(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return message.includes('Could not set lock on file')
+            || message.includes('Conflicting lock is held');
+    }
+    isFleetSchemaMismatchError(error) {
+        if (this.isDuckDbLockError(error)) {
+            return false;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return message.includes('ON CONFLICT')
+            || message.includes('Constraint')
+            || message.includes('conflict target')
+            || message.includes('unique constraint')
+            || message.includes('PRIMARY KEY')
+            || message.includes('primary key');
+    }
+    async sleep(ms) {
+        await new Promise(resolve => setTimeout(resolve, ms));
+    }
+    async runDuckDBExecForFleet(sqlBody) {
+        const duckdb = await this.ensureDuckDB();
+        await this.acquireDuckDbQuerySlot();
+        try {
+            const dbPath = await this.ensureIndexedDbReady(duckdb);
+            const cfg = this.getAnalyticsConfig();
+            const sql = `${this.buildRuntimeSettingsSql()}\n${sqlBody}`;
+            await execFileAsync(duckdb, [dbPath, '-json', '-c', sql], {
+                timeout: cfg.queryTimeoutMs,
+                maxBuffer: 10 * 1024 * 1024,
+            });
+        }
+        finally {
+            this.releaseDuckDbQuerySlot();
+        }
+    }
+    async runDuckDBExecForFleetWithLockRetry(sqlBody, options) {
+        const maxWaitMs = Math.max(0, Math.floor(options?.maxWaitMs ?? 2000));
+        const startedAt = Date.now();
+        let attempt = 0;
+        while (true) {
+            try {
+                await this.runDuckDBExecForFleet(sqlBody);
+                return;
+            }
+            catch (error) {
+                if (!this.isDuckDbLockError(error)) {
+                    throw error;
+                }
+                const elapsed = Date.now() - startedAt;
+                if (elapsed >= maxWaitMs) {
+                    throw error;
+                }
+                const delay = Math.min(250, 30 * Math.pow(2, attempt));
+                attempt += 1;
+                await this.sleep(delay);
+            }
+        }
+    }
+    getFromCache(key) {
+        const entry = this.cache.get(key);
+        if (entry && entry.expiresAt > Date.now()) {
+            return entry.data;
+        }
+        this.cache.delete(key);
+        return null;
+    }
+    setCache(key, data) {
+        this.cache.set(key, { data, expiresAt: Date.now() + CACHE_TTL });
+    }
+    invalidateCache() {
+        this.cache.clear();
+        this.analyticsConfig = undefined;
+    }
+    async getCostSummary(filters) {
+        const cacheKey = `costSummary:${this.buildFilterCacheKey(filters)}`;
+        const cached = this.getFromCache(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        try {
+            const conditions = ['cost IS NOT NULL', ...this.buildTraceFilterConditions(filters)];
+            const whereClause = conditions.join(' AND ');
+            const rows = await this.runDuckDB(`
+SELECT
+	COALESCE(SUM(cost), 0) as totalCost,
+	COUNT(*) as totalRequests,
+	COALESCE(AVG(duration_ms), 0) as avgDurationMs,
+	COALESCE(SUM(input_tokens), 0) as totalInputTokens,
+	COALESCE(SUM(output_tokens), 0) as totalOutputTokens,
+	COALESCE((SELECT model FROM spans WHERE ${whereClause} GROUP BY model ORDER BY SUM(cost) DESC LIMIT 1), 'unknown') as topModel
+FROM spans
+WHERE ${whereClause}`);
+            const row = rows[0] ?? { totalCost: 0, totalRequests: 0, avgDurationMs: 0, totalInputTokens: 0, totalOutputTokens: 0, topModel: 'unknown' };
+            this.setCache(cacheKey, row);
+            return row;
+        }
+        catch (error) {
+            if (error instanceof QueryRunnerError && error.code === 'INDEX_UNAVAILABLE') {
+                return { totalCost: 0, totalRequests: 0, avgDurationMs: 0, totalInputTokens: 0, totalOutputTokens: 0, topModel: 'unknown' };
+            }
+            throw error;
+        }
+    }
+    async getRecentSessions(limit = 10, filters) {
+        const safeLimit = this.clampLimit(limit);
+        const cacheKey = `recentSessions:${safeLimit}:${this.buildFilterCacheKey(filters)}`;
+        const cached = this.getFromCache(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        try {
+            const conditions = ['session_id IS NOT NULL', 'cost IS NOT NULL', ...this.buildTraceFilterConditions(filters)];
+            const rows = await this.runDuckDB(`
+SELECT
+	session_id as sessionId,
+	agent_id as agentId,
+	SUM(cost) as totalCost,
+	COUNT(*) as requestCount,
+	AVG(duration_ms) as avgDurationMs,
+	MIN(to_timestamp(start_ms / 1000)) as startedAt
+FROM spans
+WHERE ${conditions.join(' AND ')}
+GROUP BY session_id, agent_id
+ORDER BY MAX(start_ms) DESC
+LIMIT ${safeLimit}`);
+            this.setCache(cacheKey, rows);
+            return rows;
+        }
+        catch (error) {
+            if (error instanceof QueryRunnerError && error.code === 'INDEX_UNAVAILABLE') {
+                return [];
+            }
+            throw error;
+        }
+    }
+    async getFleetSessions(limit = 200, filters) {
+        const safeLimit = this.clampLimit(limit);
+        const cacheKey = `fleetSessions:${safeLimit}:${this.buildFilterCacheKey(filters)}`;
+        const cached = this.getFromCache(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        try {
+            const conditions = ['session_id IS NOT NULL', ...this.buildTraceFilterConditions(filters)];
+            const sqlWithEngine = `
+SELECT
+	session_id as sessionId,
+	agent_id as agentId,
+	to_timestamp(start_ms / 1000) as startedAt,
+	to_timestamp((start_ms + COALESCE(duration_ms, 0)) / 1000) as endedAt,
+	0 as turns,
+	0 as totalTokens,
+	COALESCE(model, 'unknown') as model,
+	COALESCE(engine, '') as engine
+FROM spans
+WHERE ${conditions.join(' AND ')}
+QUALIFY row_number() OVER (
+	PARTITION BY session_id
+	ORDER BY start_ms DESC
+) = 1
+ORDER BY start_ms DESC
+LIMIT ${safeLimit}`;
+            const sqlWithoutEngine = `
+SELECT
+	session_id as sessionId,
+	agent_id as agentId,
+	to_timestamp(start_ms / 1000) as startedAt,
+	to_timestamp((start_ms + COALESCE(duration_ms, 0)) / 1000) as endedAt,
+	0 as turns,
+	0 as totalTokens,
+	COALESCE(model, 'unknown') as model
+FROM spans
+WHERE ${conditions.join(' AND ')}
+QUALIFY row_number() OVER (
+	PARTITION BY session_id
+	ORDER BY start_ms DESC
+) = 1
+ORDER BY start_ms DESC
+LIMIT ${safeLimit}`;
+            let rows;
+            try {
+                rows = await this.runDuckDB(sqlWithEngine);
+            }
+            catch (engineErr) {
+                const msg = engineErr instanceof Error ? engineErr.message : String(engineErr);
+                if (msg.includes('engine') || msg.includes('column') || msg.includes('referenced')) {
+                    rows = await this.runDuckDB(sqlWithoutEngine);
+                    rows = rows.map((r) => ({ ...r, engine: '' }));
+                }
+                else {
+                    throw engineErr;
+                }
+            }
+            this.setCache(cacheKey, rows);
+            return rows;
+        }
+        catch (error) {
+            if (error instanceof QueryRunnerError && error.code === 'INDEX_UNAVAILABLE') {
+                return [];
+            }
+            throw error;
+        }
+    }
+    async getModelBreakdown(filters) {
+        const cacheKey = `modelBreakdown:${this.buildFilterCacheKey(filters)}`;
+        const cached = this.getFromCache(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        try {
+            const conditions = ['cost IS NOT NULL', ...this.buildTraceFilterConditions(filters)];
+            const rows = await this.runDuckDB(`
+SELECT COALESCE(model, 'unknown') as model, SUM(cost) as cost, COUNT(*) as requestCount
+FROM spans
+WHERE ${conditions.join(' AND ')}
+GROUP BY model
+ORDER BY cost DESC`);
+            const totalCost = rows.reduce((sum, row) => sum + Number(row.cost || 0), 0);
+            const result = rows.map(row => ({ ...row, percentage: totalCost > 0 ? (row.cost / totalCost) * 100 : 0 }));
+            this.setCache(cacheKey, result);
+            return result;
+        }
+        catch (error) {
+            if (error instanceof QueryRunnerError && error.code === 'INDEX_UNAVAILABLE') {
+                return [];
+            }
+            throw error;
+        }
+    }
+    async getCostTrend(days = 7, filters) {
+        const cacheKey = `costTrend:${days}:${this.buildFilterCacheKey(filters)}`;
+        const cached = this.getFromCache(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        try {
+            const conditions = ['cost IS NOT NULL', `start_ms > (EXTRACT(EPOCH FROM (CURRENT_TIMESTAMP - INTERVAL '${Math.max(1, Math.floor(days || 1))} days')) * 1000)`, ...this.buildTraceFilterConditions(filters)];
+            const rows = await this.runDuckDB(`
+SELECT strftime(to_timestamp(start_ms / 1000), '%Y-%m-%d') as date, SUM(cost) as cost, COUNT(*) as requestCount
+FROM spans
+WHERE ${conditions.join(' AND ')}
+GROUP BY date
+ORDER BY date ASC`);
+            this.setCache(cacheKey, rows);
+            return rows;
+        }
+        catch (error) {
+            if (error instanceof QueryRunnerError && error.code === 'INDEX_UNAVAILABLE') {
+                return [];
+            }
+            throw error;
+        }
+    }
+    async getAgentIds(filters) {
+        const normalized = this.normalizeFilters(filters);
+        const scopeOnlyFilters = { scope: normalized.scope, projectId: normalized.projectId };
+        const cacheKey = `agentIds:${this.buildFilterCacheKey(scopeOnlyFilters)}`;
+        const cached = this.getFromCache(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        try {
+            const conditions = ['agent_id IS NOT NULL', ...this.buildTraceFilterConditions(scopeOnlyFilters)];
+            const rows = await this.runDuckDB(`
+SELECT DISTINCT agent_id as agentId
+FROM spans
+WHERE ${conditions.join(' AND ')}
+ORDER BY agent_id ASC`);
+            const ids = rows.map(row => row.agentId).filter((value) => Boolean(value));
+            this.setCache(cacheKey, ids);
+            return ids;
+        }
+        catch (error) {
+            if (error instanceof QueryRunnerError && error.code === 'INDEX_UNAVAILABLE') {
+                return [];
+            }
+            throw error;
+        }
+    }
+    async hasData(filters) {
+        const cacheKey = `hasData:${this.buildFilterCacheKey(filters)}`;
+        const cached = this.getFromCache(cacheKey);
+        if (cached !== null) {
+            return cached;
+        }
+        try {
+            const conditions = ['cost IS NOT NULL', ...this.buildTraceFilterConditions(filters)];
+            const rows = await this.runDuckDB(`SELECT COUNT(*) as count FROM spans WHERE ${conditions.join(' AND ')}`);
+            const hasData = Number(rows[0]?.count ?? 0) > 0;
+            this.setCache(cacheKey, hasData);
+            return hasData;
+        }
+        catch (error) {
+            if (error instanceof QueryRunnerError && error.code === 'INDEX_UNAVAILABLE') {
+                this.setCache(cacheKey, false);
+                return false;
+            }
+            return false;
+        }
+    }
+    async getDataHash(filters) {
+        const cacheKey = `dataHash:${this.buildFilterCacheKey(filters)}`;
+        const cached = this.getFromCache(cacheKey);
+        if (cached !== null) {
+            return cached;
+        }
+        try {
+            const conditions = ['cost IS NOT NULL', ...this.buildTraceFilterConditions(filters)];
+            const rows = await this.runDuckDB(`
+SELECT
+	COUNT(*) as spanCount,
+	COALESCE(CAST(SUM(start_ms) AS BIGINT), 0) as startSum,
+	COALESCE(CAST(SUM(CAST(cost * 1000000 AS BIGINT)) AS BIGINT), 0) as costMicros,
+	COALESCE(MAX(start_ms), 0) as latestStartMs
+FROM spans
+WHERE ${conditions.join(' AND ')}`);
+            const row = rows[0];
+            if (!row || Number(row.spanCount) === 0) {
+                this.setCache(cacheKey, '');
+                return '';
+            }
+            const hash = [Number(row.spanCount), Number(row.startSum), Number(row.costMicros), Number(row.latestStartMs)].join('-');
+            this.setCache(cacheKey, hash);
+            return hash;
+        }
+        catch (error) {
+            if (error instanceof QueryRunnerError && error.code === 'INDEX_UNAVAILABLE') {
+                this.setCache(cacheKey, '');
+                return '';
+            }
+            return '';
+        }
+    }
+    async getDashboardBootstrap(filters) {
+        const normalized = this.normalizeFilters(filters);
+        const scopeFilters = { scope: normalized.scope, projectId: normalized.projectId };
+        const [hasData, dataHash, agentIds, summary] = await Promise.all([
+            this.hasData(filters),
+            this.getDataHash(filters),
+            this.getAgentIds(scopeFilters),
+            this.getCostSummary(filters),
+        ]);
+        return { summary, agentIds, hasData, dataHash };
+    }
+    async getDuckDbBinaryPath() {
+        return await this.ensureDuckDB();
+    }
+    async getAnalyticsDbPath() {
+        const duckdb = await this.ensureDuckDB();
+        return await this.ensureIndexedDbReady(duckdb);
+    }
+    async ensureFleetSchema() {
+        if (this.fleetSchemaReady) {
+            return;
+        }
+        if (!this.fleetSchemaEnsurePromise) {
+            this.fleetSchemaEnsurePromise = this.ensureFleetSchemaInternal()
+                .then(() => {
+                this.fleetSchemaReady = true;
+            })
+                .finally(() => {
+                this.fleetSchemaEnsurePromise = undefined;
+            });
+        }
+        await this.fleetSchemaEnsurePromise;
+    }
+    async ensureFleetSchemaInternal() {
+        const createTableSql = `
+CREATE TABLE IF NOT EXISTS ${FLEET_SESSIONS_TABLE} (
+	source VARCHAR NOT NULL,
+	session_id VARCHAR NOT NULL,
+	agent_id VARCHAR,
+	status VARCHAR NOT NULL,
+	started_at VARCHAR,
+	ended_at VARCHAR,
+	card_title VARCHAR,
+	task_title VARCHAR,
+	model VARCHAR,
+	engine VARCHAR,
+	channel_type VARCHAR,
+	channel_target VARCHAR,
+	turns BIGINT,
+	total_tokens BIGINT,
+	disconnect_capable BOOLEAN,
+	updated_at TIMESTAMP,
+	PRIMARY KEY (source, session_id)
+);
+`;
+        // 1) Create table if missing.
+        await this.runDuckDBExecForFleetWithLockRetry(createTableSql, { maxWaitMs: 2000 });
+        // 2) Validate uniqueness/constraint shape supports ON CONFLICT (source, session_id).
+        //    Older dev DBs may exist with a different PK shape, which would break Fleet upserts.
+        const schemaCheckSql = `
+BEGIN;
+INSERT INTO ${FLEET_SESSIONS_TABLE} (
+	source,
+	session_id,
+	status,
+	started_at,
+	ended_at,
+	card_title,
+	task_title,
+	model,
+	engine,
+	channel_type,
+	channel_target,
+	turns,
+	total_tokens,
+	disconnect_capable,
+	updated_at
+) VALUES (
+	'__schema_check__',
+	'__schema_check__',
+	'in_progress',
+	'',
+	'',
+	NULL,
+	'',
+	'unknown',
+	'',
+	'none',
+	'',
+	0,
+	0,
+	FALSE,
+	current_timestamp
+)
+ON CONFLICT (source, session_id) DO UPDATE SET
+	updated_at = current_timestamp;
+DELETE FROM ${FLEET_SESSIONS_TABLE}
+WHERE source = '__schema_check__' AND session_id = '__schema_check__';
+COMMIT;
+`;
+        try {
+            await this.runDuckDBExecForFleetWithLockRetry(schemaCheckSql, { maxWaitMs: 2000 });
+        }
+        catch (error) {
+            if (!this.isFleetSchemaMismatchError(error)) {
+                throw error;
+            }
+            // 3) Migration fallback: re-create fleet_sessions with the correct PK,
+            //    preserving card_title when possible.
+            const migrationSql = `
+BEGIN;
+CREATE TABLE IF NOT EXISTS ${FLEET_SESSIONS_TABLE}__new (
+	source VARCHAR NOT NULL,
+	session_id VARCHAR NOT NULL,
+	agent_id VARCHAR,
+	status VARCHAR NOT NULL,
+	started_at VARCHAR,
+	ended_at VARCHAR,
+	card_title VARCHAR,
+	task_title VARCHAR,
+	model VARCHAR,
+	engine VARCHAR,
+	channel_type VARCHAR,
+	channel_target VARCHAR,
+	turns BIGINT,
+	total_tokens BIGINT,
+	disconnect_capable BOOLEAN,
+	updated_at TIMESTAMP,
+	PRIMARY KEY (source, session_id)
+);
+
+INSERT INTO ${FLEET_SESSIONS_TABLE}__new (
+	source, session_id, agent_id, status, started_at, ended_at, card_title, task_title,
+	model, engine, channel_type, channel_target, turns, total_tokens, disconnect_capable, updated_at
+)
+SELECT
+	source,
+	session_id,
+	agent_id,
+	CASE WHEN status IS NULL OR TRIM(CAST(status AS VARCHAR)) = '' THEN 'in_progress' ELSE CAST(status AS VARCHAR) END AS status,
+	started_at,
+	ended_at,
+	card_title,
+	task_title,
+	model,
+	engine,
+	channel_type,
+	channel_target,
+	turns,
+	total_tokens,
+	disconnect_capable,
+	COALESCE(updated_at, current_timestamp)
+FROM ${FLEET_SESSIONS_TABLE};
+
+DROP TABLE ${FLEET_SESSIONS_TABLE};
+ALTER TABLE ${FLEET_SESSIONS_TABLE}__new RENAME TO ${FLEET_SESSIONS_TABLE};
+COMMIT;
+`;
+            this.outputChannel.appendLine(`[QueryRunner] Migrating fleet_sessions schema to (source, session_id) PK (legacy DB detected).`);
+            await this.runDuckDBExecForFleetWithLockRetry(migrationSql, { maxWaitMs: 5000 });
+        }
+    }
+    async readFleetSessions(options) {
+        await this.ensureFleetSchema();
+        const sources = options?.sources?.filter(s => typeof s === 'string' && s.trim() !== '') ?? [];
+        const sourceCondition = sources.length > 0
+            ? `WHERE source IN (${sources.map(s => this.sqlLiteral(String(s))).join(', ')})`
+            : '';
+        const sql = `
+SELECT
+	source as source,
+	session_id as sessionId,
+	agent_id as agentId,
+	status as status,
+	started_at as startedAt,
+	ended_at as endedAt,
+	card_title as cardTitle,
+	task_title as taskTitle,
+	model as model,
+	engine as engine,
+	channel_type as channelType,
+	channel_target as channelTarget,
+	turns as turns,
+	total_tokens as totalTokens,
+	disconnect_capable as disconnectCapable,
+	updated_at as updatedAt
+FROM ${FLEET_SESSIONS_TABLE}
+${sourceCondition}
+ORDER BY updated_at DESC`;
+        const rows = await this.runDuckDB(sql);
+        return rows.map((r) => {
+            const status = String(r.status ?? '').trim();
+            const disconnect = r.disconnectCapable;
+            const startedAt = typeof r.startedAt === 'string' ? r.startedAt : String(r.startedAt ?? '');
+            const endedAt = typeof r.endedAt === 'string' ? r.endedAt : String(r.endedAt ?? '');
+            return {
+                source: typeof r.source === 'string' ? r.source : String(r.source ?? ''),
+                sessionId: typeof r.sessionId === 'string' ? r.sessionId : String(r.sessionId ?? ''),
+                agentId: typeof r.agentId === 'string' && r.agentId.trim() ? r.agentId : undefined,
+                status: status === 'scheduled' ? 'scheduled' : status === 'done' ? 'done' : 'in_progress',
+                startedAt,
+                endedAt,
+                cardTitle: typeof r.cardTitle === 'string' ? r.cardTitle : undefined,
+                taskTitle: typeof r.taskTitle === 'string' ? r.taskTitle : String(r.taskTitle ?? ''),
+                model: typeof r.model === 'string' ? r.model : String(r.model ?? ''),
+                engine: typeof r.engine === 'string' ? r.engine : String(r.engine ?? ''),
+                channelType: typeof r.channelType === 'string' ? r.channelType : String(r.channelType ?? 'none'),
+                channelTarget: typeof r.channelTarget === 'string' ? r.channelTarget : String(r.channelTarget ?? ''),
+                turns: Number(r.turns ?? 0),
+                totalTokens: Number(r.totalTokens ?? 0),
+                disconnectCapable: disconnect === true || disconnect === 1 || disconnect === 'true',
+                updatedAt: typeof r.updatedAt === 'string' ? r.updatedAt : String(r.updatedAt ?? new Date().toISOString()),
+            };
+        });
+    }
+    async writeFleetSessions(sourceId, rows) {
+        if (!Array.isArray(rows)) {
+            return;
+        }
+        await this.ensureFleetSchema();
+        const safeSourceId = String(sourceId ?? '').trim() || 'local';
+        const sessionIds = Array.from(new Set(rows
+            .map(r => String(r.sessionId ?? '').trim())
+            .filter(Boolean)));
+        const existingTitles = new Map();
+        if (sessionIds.length > 0) {
+            const titleSql = `
+SELECT
+	session_id as sessionId,
+	card_title as cardTitle
+FROM ${FLEET_SESSIONS_TABLE}
+WHERE source = ${this.sqlLiteral(safeSourceId)}
+	AND session_id IN (${sessionIds.map(id => this.sqlLiteral(id)).join(', ')})
+`;
+            const titleRows = await this.runDuckDB(titleSql);
+            for (const row of titleRows) {
+                const key = String(row.sessionId ?? '').trim();
+                const value = row.cardTitle == null ? '' : String(row.cardTitle);
+                if (key && value.trim()) {
+                    existingTitles.set(key, value);
+                }
+            }
+        }
+        if (rows.length === 0) {
+            return;
+        }
+        const clearSql = `
+DELETE FROM ${FLEET_SESSIONS_TABLE}
+WHERE source = ${this.sqlLiteral(safeSourceId)};
+`;
+        await this.runDuckDBExecForFleetWithLockRetry(clearSql, { maxWaitMs: 2000 });
+        const chunkSize = 200;
+        for (let i = 0; i < rows.length; i += chunkSize) {
+            const chunk = rows.slice(i, i + chunkSize);
+            const values = chunk.map(r => {
+                const u = r.updatedAt != null && r.updatedAt !== '' ? this.sqlLiteral(r.updatedAt) : 'current_timestamp';
+                const preservedCardTitle = existingTitles.get(String(r.sessionId ?? '').trim());
+                const resolvedCardTitle = preservedCardTitle ?? r.cardTitle;
+                const incomingCardTitle = resolvedCardTitle !== undefined ? this.sqlNullableLiteral(resolvedCardTitle) : 'NULL';
+                return `(
+${this.sqlLiteral(safeSourceId)},
+${this.sqlLiteral(r.sessionId)},
+${r.agentId ? this.sqlLiteral(r.agentId) : 'NULL'},
+${this.sqlLiteral(r.status)},
+${this.sqlLiteral(r.startedAt ?? '')},
+${this.sqlLiteral(r.endedAt ?? '')},
+${incomingCardTitle},
+${this.sqlLiteral(r.taskTitle ?? '')},
+${this.sqlLiteral(r.model ?? '')},
+${this.sqlLiteral(r.engine ?? '')},
+${this.sqlLiteral(r.channelType ?? '')},
+${this.sqlLiteral(r.channelTarget ?? '')},
+${Number.isFinite(r.turns) ? String(Math.floor(r.turns)) : '0'},
+${Number.isFinite(r.totalTokens) ? String(Math.floor(r.totalTokens)) : '0'},
+${this.sqlBool(Boolean(r.disconnectCapable))},
+${u}
+)`;
+            }).join(',\n');
+            // Upsert semantics:
+            // - refresh updates runtime fields (status/times/tokens/etc)
+            // - preserves user-edited card_title if it exists (non-empty)
+            // - initializes card_title from incoming card_title, else task_title.
+            const sql = `
+INSERT INTO ${FLEET_SESSIONS_TABLE} (
+	source,
+	session_id,
+	agent_id,
+	status,
+	started_at,
+	ended_at,
+	card_title,
+	task_title,
+	model,
+	engine,
+	channel_type,
+	channel_target,
+	turns,
+	total_tokens,
+	disconnect_capable,
+	updated_at
+) VALUES
+${values}
+ON CONFLICT (source, session_id) DO UPDATE SET
+	agent_id = excluded.agent_id,
+	status = excluded.status,
+	started_at = excluded.started_at,
+	ended_at = excluded.ended_at,
+	card_title = COALESCE(
+		NULLIF(${FLEET_SESSIONS_TABLE}.card_title, ''),
+		NULLIF(excluded.card_title, ''),
+		NULLIF(excluded.task_title, '')
+	),
+	task_title = excluded.task_title,
+	model = excluded.model,
+	engine = excluded.engine,
+	channel_type = excluded.channel_type,
+	channel_target = excluded.channel_target,
+	turns = excluded.turns,
+	total_tokens = excluded.total_tokens,
+	disconnect_capable = excluded.disconnect_capable,
+	updated_at = excluded.updated_at;
+`;
+            await this.runDuckDBExecForFleetWithLockRetry(sql, { maxWaitMs: 2000 });
+        }
+    }
+    async updateFleetCardTitle(sourceId, sessionId, cardTitle) {
+        await this.ensureFleetSchema();
+        const safeSessionId = String(sessionId ?? '').trim();
+        if (!safeSessionId) {
+            return;
+        }
+        const title = cardTitle ?? '';
+        const safeSourceId = String(sourceId ?? '').trim() || 'local';
+        // Lock contention happens during background indexing; retry writes briefly.
+        const sql = `
+BEGIN;
+UPDATE ${FLEET_SESSIONS_TABLE}
+SET card_title = ${this.sqlLiteral(title)},
+	updated_at = current_timestamp
+WHERE source = ${this.sqlLiteral(safeSourceId)}
+	AND session_id = ${this.sqlLiteral(safeSessionId)};
+
+INSERT INTO ${FLEET_SESSIONS_TABLE} (
+	source,
+	session_id,
+	card_title,
+	updated_at
+) SELECT
+	${this.sqlLiteral(safeSourceId)},
+	${this.sqlLiteral(safeSessionId)},
+	${this.sqlLiteral(title)},
+	current_timestamp
+WHERE NOT EXISTS (
+	SELECT 1 FROM ${FLEET_SESSIONS_TABLE}
+	WHERE source = ${this.sqlLiteral(safeSourceId)}
+		AND session_id = ${this.sqlLiteral(safeSessionId)}
+);
+COMMIT;
+`;
+        await this.runDuckDBExecForFleetWithLockRetry(sql, { maxWaitMs: 2000 });
+    }
+    async readFleetCardTitles(sessionIds) {
+        const ids = Array.from(new Set(sessionIds.filter(s => typeof s === 'string' && s.trim() !== '')));
+        if (ids.length === 0) {
+            return {};
+        }
+        await this.ensureFleetSchema();
+        const out = {};
+        const chunkSize = 200;
+        for (let i = 0; i < ids.length; i += chunkSize) {
+            const chunk = ids.slice(i, i + chunkSize);
+            const sql = `
+SELECT
+	session_id as sessionId,
+	arg_max(card_title, updated_at) as cardTitle
+FROM ${FLEET_SESSIONS_TABLE}
+WHERE session_id IN (${chunk.map(s => this.sqlLiteral(String(s))).join(', ')})
+GROUP BY session_id`;
+            const rows = await this.runDuckDB(sql);
+            for (const row of rows) {
+                if (!row.sessionId) {
+                    continue;
+                }
+                out[row.sessionId] = row.cardTitle === null ? '' : String(row.cardTitle);
+            }
+        }
+        return out;
+    }
+    dispose() {
+        this.cache.clear();
+        this.activeDuckDbQueries = 0;
+        while (this.duckDbQueryWaiters.length > 0) {
+            const waiter = this.duckDbQueryWaiters.shift();
+            waiter?.();
+        }
+    }
+}
+exports.QueryRunnerImpl = QueryRunnerImpl;