@agenthippo-ai/agenthippo 0.1.0

package/out/analytics/dashboard/indexingService.js

@@ -0,0 +1,422 @@
+"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.IndexingService = void 0;
+const vscode = __importStar(require("vscode"));
+const path = __importStar(require("path"));
+const fs_1 = require("fs");
+const pythonRunner_1 = require("../../utils/pythonRunner");
+const toolPath_1 = require("../../utils/toolPath");
+/**
+ * Manages background JSONL → DuckDB indexing.
+ *
+ * Key responsibilities:
+ * - Watch traces directory for new JSONL files
+ * - Debounce indexing triggers after file changes (default 15s)
+ * - Spawn background indexing subprocess with resource limits
+ * - Track indexing state and emit progress updates
+ * - Persist state to disk (.duckdb-index.json)
+ * - Gracefully handle errors and fall back to JSONL
+ */
+class IndexingService {
+    tracesDir;
+    outputChannel;
+    performanceMonitor;
+    static EXIT_CODE_ALREADY_RUNNING = 3;
+    watcher;
+    indexingProcess;
+    retryTimeout;
+    indexProgress = { status: 'idle', percent: 0 };
+    indexState = {
+        version: 1,
+        indexed: false,
+        lastMtime: 0,
+        duckdbPath: '',
+    };
+    progressChangeEmitter = new vscode.EventEmitter();
+    indexCompleteEmitter = new vscode.EventEmitter();
+    indexErrorEmitter = new vscode.EventEmitter();
+    disposables = [];
+    failureCount = 0;
+    static MAX_FAILURES = 3;
+    constructor(tracesDir, outputChannel, performanceMonitor) {
+        this.tracesDir = tracesDir;
+        this.outputChannel = outputChannel;
+        this.performanceMonitor = performanceMonitor;
+        this.indexState.duckdbPath = path.join(tracesDir, 'analytics.duckdb');
+        this.disposables.push(this.progressChangeEmitter, this.indexCompleteEmitter, this.indexErrorEmitter);
+    }
+    /**
+     * Initialize indexing service: load state, start file watcher, check if re-indexing needed.
+     */
+    async initialize() {
+        try {
+            // Load persisted state
+            await this.loadIndexState();
+            // Start watching traces directory
+            this.startFileWatcher();
+            // Check if indexing needed on startup
+            await this.checkAndScheduleIndexing();
+        }
+        catch (error) {
+            this.outputChannel.appendLine(`[Dashboard] Indexing initialization failed: ${error}`);
+        }
+    }
+    /**
+     * Load persisted indexing state from disk.
+     */
+    async loadIndexState() {
+        const stateFile = path.join(this.tracesDir, '.duckdb-index.json');
+        try {
+            const content = await fs_1.promises.readFile(stateFile, 'utf-8');
+            const saved = JSON.parse(content);
+            if (saved.version === 1) {
+                this.indexState = {
+                    version: 1,
+                    indexed: saved.indexed ?? false,
+                    lastMtime: saved.lastMtime ?? 0,
+                    duckdbPath: saved.duckdbPath || this.indexState.duckdbPath,
+                    indexedAt: saved.indexedAt,
+                };
+            }
+        }
+        catch {
+            // File doesn't exist or is invalid; use defaults
+        }
+    }
+    /**
+     * Save indexing state to disk.
+     */
+    async saveIndexState() {
+        const stateFile = path.join(this.tracesDir, '.duckdb-index.json');
+        try {
+            await fs_1.promises.writeFile(stateFile, JSON.stringify(this.indexState, null, 2), 'utf-8');
+        }
+        catch (error) {
+            this.outputChannel.appendLine(`[Dashboard] Failed to save indexing state: ${error}`);
+        }
+    }
+    /**
+     * Start watching traces directory for new JSONL files.
+     */
+    startFileWatcher() {
+        const tracesPattern = new vscode.RelativePattern(this.tracesDir, '*.jsonl');
+        this.watcher = vscode.workspace.createFileSystemWatcher(tracesPattern);
+        // Listen for file creates, changes, and deletes
+        this.watcher.onDidCreate(() => this.scheduleIndexing());
+        this.watcher.onDidChange(() => this.scheduleIndexing());
+        this.watcher.onDidDelete(() => this.scheduleIndexing());
+        this.disposables.push(this.watcher);
+    }
+    /**
+     * Check if re-indexing is needed by comparing file mtimes.
+     * Schedule indexing if needed.
+     */
+    async checkAndScheduleIndexing() {
+        try {
+            const currentMtime = await this.getLatestJSONLMtime();
+            if (currentMtime > this.indexState.lastMtime) {
+                this.scheduleIndexing();
+            }
+        }
+        catch {
+            // Best-effort; if we can't check, it's ok to skip
+        }
+    }
+    /**
+     * Get the maximum mtime of all JSONL files in traces directory.
+     * Used to detect if new traces have been added.
+     */
+    async getLatestJSONLMtime() {
+        try {
+            const entries = await fs_1.promises.readdir(this.tracesDir, { withFileTypes: true });
+            let maxMtime = 0;
+            for (const entry of entries) {
+                if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+                    const filePath = path.join(this.tracesDir, entry.name);
+                    const stats = await fs_1.promises.stat(filePath);
+                    maxMtime = Math.max(maxMtime, stats.mtimeMs);
+                }
+            }
+            return maxMtime;
+        }
+        catch {
+            return 0;
+        }
+    }
+    /**
+     * Schedule background indexing with debouncing.
+     * If already scheduled, this is a no-op unless force is true.
+     * @param overrides.debounceMs - Use a shorter debounce when Fleet view needs fresher data (e.g. 500).
+     */
+    scheduleIndexing(force = false, overrides) {
+        if (!force && this.indexingProcess) {
+            // Already scheduled; wait for debounce
+            return;
+        }
+        // Clear existing timer
+        if (this.indexingProcess) {
+            clearTimeout(this.indexingProcess);
+        }
+        const config = this.getIndexingConfig();
+        if (!config.enabled) {
+            this.outputChannel.appendLine('[Dashboard] Background indexing is disabled');
+            return;
+        }
+        const debounceMs = overrides?.debounceMs ?? config.debounceMs;
+        this.indexingProcess = setTimeout(() => {
+            this.indexingProcess = undefined;
+            void this.startIndexing();
+        }, debounceMs);
+    }
+    /**
+     * Get current indexing configuration from VS Code settings.
+     */
+    getIndexingConfig() {
+        const config = vscode.workspace.getConfiguration('agentide.analytics');
+        return {
+            enabled: config.get('backgroundIndexing', true),
+            debounceMs: config.get('indexingDebounceMs', 15000),
+            timeoutSeconds: config.get('indexingTimeoutSeconds', 300),
+        };
+    }
+    /**
+     * Start background indexing process.
+     */
+    async startIndexing() {
+        const config = this.getIndexingConfig();
+        // Update progress
+        this.setProgress({ status: 'indexing', percent: 0 });
+        this.performanceMonitor.logIndexingStarted(this.tracesDir);
+        try {
+            const startTime = Date.now();
+            // Get path to index-traces.py script
+            const scriptPath = this.resolveIndexScriptPath();
+            // Execute indexing subprocess with dependency management and timeout.
+            const result = await (0, pythonRunner_1.runPythonWithDeps)({
+                scriptPath,
+                args: [this.tracesDir],
+                deps: ['duckdb'],
+                analyticsRoot: path.dirname(this.tracesDir),
+                execOptions: {
+                    timeout: config.timeoutSeconds * 1000,
+                    env: {
+                        ...process.env,
+                        PATH: (0, toolPath_1.augmentPathForTools)(process.env.PATH ?? ''),
+                        AGENTIDE_TRACES_DIR: this.tracesDir,
+                        AGENTIDE_INDEX_DB_PATH: this.indexState.duckdbPath,
+                    },
+                },
+                log: (message) => this.outputChannel.appendLine(message),
+                preserveNonZeroExit: true,
+            });
+            const durationMs = Date.now() - startTime;
+            // Another process currently owns indexing lock; treat as a no-op, not failure.
+            if (result.code === IndexingService.EXIT_CODE_ALREADY_RUNNING) {
+                let message = 'Indexing already in progress';
+                try {
+                    const output = JSON.parse(result.stdout);
+                    if (typeof output.message === 'string' && output.message.trim().length > 0) {
+                        message = output.message;
+                    }
+                }
+                catch {
+                    // Best-effort parse only.
+                }
+                this.setProgress({ status: 'idle', percent: 0, message });
+                this.failureCount = 0;
+                return;
+            }
+            // Parse output
+            if (result.code === 0 || result.code === 2) {
+                // code 2 = already indexed / no data (idempotent)
+                if (!result.stdout || result.stdout.trim().length === 0) {
+                    // The indexer always emits a JSON line; empty stdout means the launcher
+                    // (e.g. uv) exited with a colliding code without running the script.
+                    throw new Error(`Indexing produced no output (exit ${result.code}). stderr: ${result.stderr || '(empty)'}`);
+                }
+                const output = JSON.parse(result.stdout);
+                const outputIndexed = output.indexed === true;
+                const hasAnyJsonl = (await this.getLatestJSONLMtime()) > 0;
+                if (outputIndexed) {
+                    this.indexState.indexed = true;
+                    this.indexState.lastMtime = await this.getLatestJSONLMtime();
+                    this.indexState.indexedAt = new Date().toISOString();
+                    await this.saveIndexState();
+                    this.setProgress({ status: 'complete', percent: 100 });
+                    this.performanceMonitor.logIndexingComplete(this.indexState.duckdbPath, durationMs);
+                    this.failureCount = 0; // Reset failure count on success
+                    this.indexCompleteEmitter.fire();
+                }
+                else if (!hasAnyJsonl) {
+                    // Empty traces dir is a valid no-op state; don't treat as failure.
+                    this.indexState.indexed = false;
+                    this.indexState.lastMtime = 0;
+                    await this.saveIndexState();
+                    this.setProgress({ status: 'idle', percent: 0, message: output.message ?? 'No trace files to index' });
+                    this.failureCount = 0;
+                }
+                else {
+                    throw new Error('Indexing returned success but indexed=false');
+                }
+            }
+            else {
+                throw new Error(`Indexing script failed: ${result.stderr}`);
+            }
+        }
+        catch (error) {
+            this.failureCount++;
+            this.performanceMonitor.logIndexingError(error, this.failureCount < IndexingService.MAX_FAILURES);
+            this.setProgress({
+                status: 'error',
+                percent: 0,
+                error: error,
+            });
+            this.indexErrorEmitter.fire(error);
+            // Auto-retry up to MAX_FAILURES times, then give up
+            if (this.failureCount < IndexingService.MAX_FAILURES) {
+                const retryDelayMs = 10000 * this.failureCount; // Exponential backoff
+                this.outputChannel.appendLine(`[Dashboard] Indexing will retry in ${retryDelayMs}ms (attempt ${this.failureCount}/${IndexingService.MAX_FAILURES})`);
+                this.retryTimeout = setTimeout(() => {
+                    void this.startIndexing();
+                }, retryDelayMs);
+            }
+            else {
+                this.outputChannel.appendLine('[Dashboard] Indexing disabled after multiple failures; will use JSONL fallback');
+                this.disableIndexing();
+            }
+        }
+    }
+    /**
+     * Disable indexing for the rest of the session.
+     */
+    disableIndexing() {
+        vscode.workspace
+            .getConfiguration('agentide.analytics')
+            .update('backgroundIndexing', false, vscode.ConfigurationTarget.WorkspaceFolder);
+    }
+    resolveIndexScriptPath() {
+        // Runtime locations:
+        // - dev: extensions/agentide/src/analytics/dashboard -> ../../scripts/analytics/index-traces.py
+        // - packaged out: extensions/agentide/out/analytics/dashboard -> ../../scripts/analytics/index-traces.py
+        return path.resolve(__dirname, '../../scripts/analytics/index-traces.py');
+    }
+    /**
+     * Update progress state and emit event.
+     */
+    setProgress(progress) {
+        this.indexProgress = progress;
+        this.progressChangeEmitter.fire(progress);
+    }
+    /**
+     * Check if indexing is currently in progress.
+     */
+    isIndexing() {
+        return this.indexProgress.status === 'indexing';
+    }
+    /**
+     * Check if database is indexed and ready to use.
+     */
+    async isIndexed() {
+        if (this.indexState.indexed) {
+            // Verify database file still exists
+            try {
+                await fs_1.promises.access(this.indexState.duckdbPath);
+                return true;
+            }
+            catch {
+                // Database was deleted; mark as not indexed
+                this.indexState.indexed = false;
+                await this.saveIndexState();
+                return false;
+            }
+        }
+        return false;
+    }
+    /**
+     * Get current progress state.
+     */
+    getProgress() {
+        return this.indexProgress;
+    }
+    /**
+     * Get path to indexed database (or empty string if not indexed).
+     */
+    getIndexPath() {
+        return this.indexState.indexed ? this.indexState.duckdbPath : '';
+    }
+    /**
+     * Event: indexing progress changed.
+     */
+    onProgressChange(listener) {
+        return this.progressChangeEmitter.event(listener);
+    }
+    /**
+     * Event: indexing completed successfully.
+     */
+    onIndexComplete(listener) {
+        return this.indexCompleteEmitter.event(listener);
+    }
+    /**
+     * Event: indexing failed with error.
+     */
+    onIndexError(listener) {
+        return this.indexErrorEmitter.event(listener);
+    }
+    /**
+     * Cancel any pending indexing operations.
+     */
+    cancelIndexing() {
+        if (this.indexingProcess) {
+            clearTimeout(this.indexingProcess);
+            this.indexingProcess = undefined;
+        }
+        if (this.retryTimeout) {
+            clearTimeout(this.retryTimeout);
+            this.retryTimeout = undefined;
+        }
+    }
+    /**
+     * Cleanup: stop watcher, cancel pending operations.
+     */
+    dispose() {
+        this.cancelIndexing();
+        vscode.Disposable.from(...this.disposables).dispose();
+    }
+}
+exports.IndexingService = IndexingService;

package/out/analytics/dashboard/localFleetAdapter.js

@@ -0,0 +1,222 @@
+"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.getScheduledFleetRequests = getScheduledFleetRequests;
+exports.createLocalFleetAdapter = createLocalFleetAdapter;
+const vscode = __importStar(require("vscode"));
+const fleetTypes_1 = require("./fleetTypes");
+const fleetDisplayUtils_1 = require("./fleetDisplayUtils");
+const fleetRowDefaults_1 = require("./fleetRowDefaults");
+const scheduledFleetStorage_1 = require("./scheduledFleetStorage");
+const LOCAL_SOURCE_ID = 'local';
+const FUTURE_START_SCHEDULED_MS = 60_000;
+const RECENT_END_IN_PROGRESS_MS = 90_000;
+/** Trace rows with no end time older than this are treated as done (avoids "Running for 2947m" ghosts). */
+const STALE_IN_PROGRESS_WITHOUT_END_MS = 15 * 60_000;
+function normalizeStatus(session) {
+    const now = Date.now();
+    const startedMs = Date.parse(session.startedAt);
+    const endedMs = Date.parse(session.endedAt);
+    if (Number.isFinite(startedMs) && startedMs > now + FUTURE_START_SCHEDULED_MS) {
+        return 'scheduled';
+    }
+    if (!Number.isFinite(endedMs) || endedMs <= 0 || (Number.isFinite(startedMs) && endedMs < startedMs)) {
+        if (Number.isFinite(startedMs) && startedMs < now - STALE_IN_PROGRESS_WITHOUT_END_MS) {
+            return 'done';
+        }
+        return 'in_progress';
+    }
+    if (endedMs > now - RECENT_END_IN_PROGRESS_MS) {
+        return 'in_progress';
+    }
+    return 'done';
+}
+function normalizeRowStatus(row) {
+    if (row.status !== 'in_progress') {
+        return;
+    }
+    const normalized = normalizeStatus({
+        sessionId: row.sessionId,
+        agentId: row.agentId,
+        startedAt: row.startedAt,
+        endedAt: row.endedAt,
+        turns: row.turns,
+        totalTokens: row.totalTokens,
+        model: row.model,
+        engine: row.engine,
+    });
+    if (normalized !== 'in_progress') {
+        row.status = normalized;
+    }
+}
+function toRow(sessionId, agentId, startedAt, endedAt, status, taskTitle, model, engine, turns, totalTokens) {
+    return (0, fleetRowDefaults_1.buildFleetSessionRow)(LOCAL_SOURCE_ID, {
+        sessionId,
+        agentId,
+        status,
+        startedAt,
+        endedAt,
+        taskTitle,
+        model,
+        engine,
+        channelType: 'none',
+        channelTarget: '',
+        turns,
+        totalTokens,
+        disconnectCapable: false,
+    });
+}
+/** Returns scheduled chat requests for fleet merge (used by orchestrator for formal local script). */
+async function getScheduledFleetRequests() {
+    return (0, scheduledFleetStorage_1.loadScheduledFleetRequests)();
+}
+/**
+ * Local fleet source adapter: trace-derived sessions + scheduled chat requests, merged and status-normalized.
+ */
+function createLocalFleetAdapter(queryRunner) {
+    return {
+        async fetch(filters) {
+            const dashboardFilters = { scope: filters.scope, projectId: filters.projectId, agentId: filters.agentId };
+            let sessions = [];
+            try {
+                sessions = await queryRunner.getFleetSessions(500, dashboardFilters);
+            }
+            catch {
+                // Trace DB may be missing; continue with scheduled only.
+            }
+            const scheduledRequests = await getScheduledFleetRequests();
+            const scheduleHintsByChatSessionId = (0, fleetDisplayUtils_1.buildScheduleHintsByChatSessionId)(await (0, scheduledFleetStorage_1.loadScheduledFleetEnrichmentHints)());
+            const sessionsById = new Map();
+            for (const session of sessions) {
+                const status = normalizeStatus(session);
+                sessionsById.set(session.sessionId, toRow(session.sessionId, session.agentId, session.startedAt, session.endedAt, status, session.agentPack ?? session.agentId ?? session.sessionId ?? 'Task', session.model ?? 'unknown', session.engine ?? '', session.turns ?? 0, session.totalTokens ?? 0));
+            }
+            for (const scheduled of scheduledRequests) {
+                if (filters.agentId && scheduled.agentId && scheduled.agentId !== filters.agentId) {
+                    continue;
+                }
+                const runAtIso = new Date(scheduled.runAt).toISOString();
+                const messagePreview = scheduled.messageText.length > 80
+                    ? `${scheduled.messageText.slice(0, 77)}...`
+                    : scheduled.messageText;
+                const scheduleRowKey = `schedule:${scheduled.id}`;
+                // Unique fleet PK per schedule; channelTarget holds the chat session id for Spotlight open.
+                const scheduleRow = (0, fleetRowDefaults_1.buildFleetSessionRow)(LOCAL_SOURCE_ID, {
+                    sessionId: scheduleRowKey,
+                    agentId: scheduled.agentId,
+                    status: 'scheduled',
+                    startedAt: runAtIso,
+                    endedAt: '',
+                    taskTitle: messagePreview || scheduled.agentId || scheduled.sessionId || 'Scheduled task',
+                    model: scheduled.model ?? 'scheduled',
+                    engine: scheduled.engine ?? (0, fleetDisplayUtils_1.inferFleetEngineId)(scheduled.model),
+                    channelType: 'none',
+                    channelTarget: scheduled.sessionId,
+                    turns: 0,
+                    totalTokens: 0,
+                    disconnectCapable: false,
+                });
+                sessionsById.set(scheduleRowKey, scheduleRow);
+            }
+            const sessionIdsForTitles = [...new Set(Array.from(sessionsById.values()).flatMap(row => {
+                    const ids = [];
+                    if (row.sessionId && !row.sessionId.startsWith('schedule:')) {
+                        ids.push(row.sessionId);
+                    }
+                    const linked = String(row.channelTarget ?? '').trim();
+                    if (linked) {
+                        ids.push(linked);
+                    }
+                    return ids;
+                }))];
+            if (sessionIdsForTitles.length > 0) {
+                try {
+                    const titleMap = await vscode.commands.executeCommand('agentide.resolveFleetSessionTitles', sessionIdsForTitles);
+                    if (titleMap && typeof titleMap === 'object') {
+                        for (const row of sessionsById.values()) {
+                            const linked = String(row.channelTarget ?? '').trim();
+                            const titleKeys = [row.sessionId, linked].filter(Boolean);
+                            for (const key of titleKeys) {
+                                const t = typeof titleMap[key] === 'string' ? titleMap[key].trim() : '';
+                                if (t
+                                    && (!row.taskTitle || row.taskTitle === row.sessionId || row.taskTitle === (row.agentId ?? ''))) {
+                                    row.taskTitle = t;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Command exists only in AgentHippo workbench builds.
+                }
+            }
+            const persistedCardTitleIds = Array.from(sessionsById.values())
+                .map(row => String(row.sessionId ?? '').trim())
+                .filter(id => id && !id.startsWith('schedule:'));
+            if (persistedCardTitleIds.length > 0) {
+                try {
+                    const cardTitleMap = await queryRunner.readFleetCardTitles(persistedCardTitleIds);
+                    for (const row of sessionsById.values()) {
+                        const saved = typeof cardTitleMap[row.sessionId] === 'string'
+                            ? cardTitleMap[row.sessionId].trim()
+                            : '';
+                        if (saved) {
+                            row.cardTitle = saved;
+                        }
+                    }
+                }
+                catch {
+                    // fleet_sessions may be unavailable during first refresh.
+                }
+            }
+            for (const row of sessionsById.values()) {
+                const linkedSessionId = row.sessionId.startsWith('schedule:')
+                    ? String(row.channelTarget ?? '').trim()
+                    : row.sessionId;
+                const scheduleHint = linkedSessionId
+                    ? scheduleHintsByChatSessionId.get(linkedSessionId)
+                    : undefined;
+                (0, fleetDisplayUtils_1.enrichFleetRowMetadata)(row, scheduleHint);
+                normalizeRowStatus(row);
+            }
+            const rows = Array.from(sessionsById.values()).sort(fleetTypes_1.compareFleetSessionsByStatusThenStart);
+            return rows;
+        },
+    };
+}