@agenthippo-ai/agenthippo 0.1.0

package/out/analytics/dashboard/provider.js

@@ -0,0 +1,3885 @@
+"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.AnalyticsDashboardProvider = exports.shouldRunScriptsOnNavigation = void 0;
+const vscode = __importStar(require("vscode"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const pythonRunner_1 = require("../../utils/pythonRunner");
+const toolPath_1 = require("../../utils/toolPath");
+const index_1 = require("../../utils/index");
+const fleetOrchestrator_1 = require("./fleetOrchestrator");
+const fleetDisplayUtils_1 = require("./fleetDisplayUtils");
+const fleetRowDefaults_1 = require("./fleetRowDefaults");
+const fleetTypes_1 = require("./fleetTypes");
+const viewsConfigMerge_1 = require("./viewsConfigMerge");
+const teamViewDiscovery_1 = require("./teamViewDiscovery");
+const pathSafety_1 = require("../../utils/pathSafety");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+var viewsConfigMerge_2 = require("./viewsConfigMerge");
+Object.defineProperty(exports, "shouldRunScriptsOnNavigation", { enumerable: true, get: function () { return viewsConfigMerge_2.shouldRunScriptsOnNavigation; } });
+function postToWebview(webview, message) {
+    if (!webview) {
+        return;
+    }
+    void webview.postMessage(message);
+}
+// -----------------------------------------------------------------------------
+// Constants
+// -----------------------------------------------------------------------------
+const FILTER_AUTOGEN_DEBOUNCE_MS = 700;
+const FILTER_AUTOGEN_COOLDOWN_MS = 12_000;
+const MAX_FILTER_AUTOGEN_HISTORY = 100;
+const DEFAULT_SEED_REGISTRY_FILENAME = 'default-seed-scripts.json';
+// Fleet widget excluded so Global/Workspace default scripts stay distinct; Fleet view has scripts: ['agent-fleet-widget.js'] only.
+const FALLBACK_DEFAULT_SEED_SCRIPT_NAMES = [
+    'generate-default-charts.py',
+    'duckdbLocator.js',
+    'wow-model-widget.js',
+    'session-timeline-widget.js',
+    'session-comparison-widget.js',
+    'hotspot-analysis-widget.js',
+    'token-cost-flamegraph-widget.js',
+];
+const USER_SCRIPT_MAX_CONCURRENCY = 2;
+const WIDGET_RUN_LOG_RETENTION_COUNT = 20;
+/** Debounce views.yaml watcher reloads (global + workspace). */
+const VIEWS_CONFIG_DEBOUNCE_MS = 400;
+// -----------------------------------------------------------------------------
+// Provider Implementation
+// -----------------------------------------------------------------------------
+class AnalyticsDashboardProvider {
+    extensionContext;
+    queryRunner;
+    artifactManager;
+    outputChannel;
+    getIndexingService;
+    viewIdSuffix;
+    static viewType = 'agentide.analyticsView';
+    webviewView;
+    artifactWatcher;
+    viewsConfigWatcher;
+    viewsConfigDebounceTimeout;
+    generationAbortController;
+    isBatchingArtifactUpdates = false;
+    pendingArtifactRefresh = false;
+    artifactRefreshQueue = Promise.resolve();
+    pendingFilterAutoGenerateTimer;
+    isRefreshInProgress = false;
+    hasPendingRefreshRequest = false;
+    activeDuckDbScriptCount = 0;
+    duckDbScriptWaiters = [];
+    duckDbHeavyScriptNames = new Set([
+        'generate-default-charts.py',
+        'wow-model-widget.js',
+        'session-timeline-widget.js',
+        'session-comparison-widget.js',
+        'agent-fleet-widget.js',
+    ]);
+    static FLEET_EXPORT_FILENAME = 'fleet.json';
+    /** @deprecated Legacy export name; read fallback only. */
+    static LEGACY_FLEET_EXPORT_FILENAME = 'agent-fleet.json';
+    static DEFAULT_GALLERY_IGNORE = ['.json', '.csv'];
+    fleetRefreshVersion = 0;
+    autoGenerationAttemptByFilter = new Map();
+    htmlPreviewPanels = new Map();
+    viewsConfig = this.createDefaultViewsConfig();
+    agentFilterId;
+    disposables = [];
+    /** Serializes create/duplicate/delete view so rapid UI clicks cannot race views.yaml. */
+    viewConfigMutationQueue = Promise.resolve();
+    constructor(extensionContext, queryRunner, artifactManager, outputChannel, getIndexingService, 
+    /** When 'team', uses a separate views config and defaults to Fleet view (for Agent Team sidebar). */
+    viewIdSuffix) {
+        this.extensionContext = extensionContext;
+        this.queryRunner = queryRunner;
+        this.artifactManager = artifactManager;
+        this.outputChannel = outputChannel;
+        this.getIndexingService = getIndexingService;
+        this.viewIdSuffix = viewIdSuffix;
+    }
+    indexingService() {
+        return this.getIndexingService?.();
+    }
+    // -------------------------------------------------------------------------
+    // WebviewViewProvider Implementation
+    // -------------------------------------------------------------------------
+    resolveWebviewView(webviewView, _context, _token) {
+        this.webviewView = webviewView;
+        // Configure webview options
+        this.syncArtifactContext();
+        webviewView.webview.options = {
+            enableScripts: true,
+            localResourceRoots: [
+                this.extensionContext.extensionUri,
+                // Workspace-local and home-global analytics roots (store-installed global views).
+                vscode.Uri.file(this.artifactManager.getAnalyticsRoot()),
+                vscode.Uri.file(this.artifactManager.getGlobalAnalyticsRoot()),
+            ],
+        };
+        // Set HTML content
+        webviewView.webview.html = this.getHtmlContent(webviewView.webview);
+        // Handle messages from webview
+        this.disposables.push(webviewView.webview.onDidReceiveMessage(this.handleMessage.bind(this)));
+        // Start watching artifacts for live updates (always read gallery ignore patterns from disabled-charts.yaml)
+        this.artifactWatcher = this.artifactManager.watchForChanges((artifacts) => {
+            if (this.isBatchingArtifactUpdates) {
+                this.pendingArtifactRefresh = true;
+                return;
+            }
+            this.loadDisabledChartsConfig().then((disabledConfig) => {
+                this.sendArtifactsToWebview(artifacts, disabledConfig.galleryIgnore);
+            });
+        });
+        this.disposables.push(this.artifactWatcher);
+        // Watch views config (global home + workspace) so store installs and edits appear immediately.
+        const scheduleViewsConfigReload = () => {
+            if (this.viewsConfigDebounceTimeout) {
+                clearTimeout(this.viewsConfigDebounceTimeout);
+            }
+            this.viewsConfigDebounceTimeout = setTimeout(() => {
+                void this.handleViewsConfigChanged();
+            }, VIEWS_CONFIG_DEBOUNCE_MS);
+        };
+        for (const configPath of this.getViewsConfigPathsToWatch()) {
+            const watcher = vscode.workspace.createFileSystemWatcher(new vscode.RelativePattern(path.dirname(configPath), path.basename(configPath)));
+            this.disposables.push(watcher, watcher.onDidChange(scheduleViewsConfigReload), watcher.onDidCreate(scheduleViewsConfigReload), watcher.onDidDelete(scheduleViewsConfigReload));
+        }
+        // Cleanup old artifacts
+        const retentionDays = vscode.workspace.getConfiguration('agentide.analytics')
+            .get('artifactRetentionDays', 30);
+        this.artifactManager.cleanup(retentionDays).then(result => {
+            if (result.deletedCount > 0) {
+                this.outputChannel.appendLine(`[Dashboard] Cleaned up ${result.deletedCount} old artifacts (${(result.freedBytes / 1024).toFixed(1)} KB)`);
+            }
+        });
+        // Handle visibility changes
+        this.disposables.push(webviewView.onDidChangeVisibility(() => {
+            if (webviewView.visible) {
+                this.onPanelBecameVisible();
+            }
+        }));
+        // Initial load
+        this.onPanelBecameVisible();
+    }
+    // -------------------------------------------------------------------------
+    // Panel Lifecycle
+    // -------------------------------------------------------------------------
+    resolveWorkspaceRootPath() {
+        const activeEditorUri = vscode.window.activeTextEditor?.document.uri;
+        const activeFolder = activeEditorUri
+            ? vscode.workspace.getWorkspaceFolder(activeEditorUri)
+            : undefined;
+        const folder = activeFolder ?? vscode.workspace.workspaceFolders?.[0];
+        return folder?.uri.fsPath;
+    }
+    resolveWorkspaceProjectId() {
+        const folderPath = this.resolveWorkspaceRootPath();
+        if (folderPath) {
+            const projectId = path.basename(folderPath).trim();
+            if (projectId) {
+                return projectId;
+            }
+        }
+        const activeEditorUri = vscode.window.activeTextEditor?.document.uri;
+        const activeFolder = activeEditorUri ? vscode.workspace.getWorkspaceFolder(activeEditorUri) : undefined;
+        const folder = activeFolder ?? vscode.workspace.workspaceFolders?.[0];
+        if (folder?.uri.fsPath) {
+            const projectId = path.basename(folder.uri.fsPath).trim();
+            if (projectId) {
+                return projectId;
+            }
+        }
+        const workspaceName = vscode.workspace.name?.trim();
+        return workspaceName || undefined;
+    }
+    syncArtifactContext() {
+        this.artifactManager.setWorkspaceRoot(this.resolveWorkspaceRootPath());
+        const filters = this.getActiveFilters();
+        this.artifactManager.setViewContext({
+            scope: filters.scope === 'workspace' ? 'workspace' : 'global',
+            projectId: filters.projectId,
+            agentId: filters.agentId,
+            viewId: this.getActiveViewId(),
+        });
+    }
+    async withArtifactViewContext(view, fn) {
+        this.artifactManager.setWorkspaceRoot(this.resolveWorkspaceRootPath());
+        const activeView = this.getActiveView();
+        const previousContext = this.getViewContext(activeView);
+        this.artifactManager.setViewContext(this.getViewContext(view));
+        try {
+            return await fn();
+        }
+        finally {
+            this.artifactManager.setViewContext(previousContext);
+        }
+    }
+    runViewConfigMutation(fn) {
+        const run = this.viewConfigMutationQueue.then(fn, fn);
+        this.viewConfigMutationQueue = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    /** Fleet HTML widget; only the Fleet view should run it by default. */
+    static FLEET_WIDGET_BASENAME = 'agent-fleet-widget.js';
+    stripFleetWidgetFromGlobalWorkspace(viewId, scripts) {
+        const id = this.normalizeViewId(viewId);
+        if (id !== 'global' && id !== 'workspace') {
+            return scripts;
+        }
+        return scripts.filter(s => this.normalizeBasename(s) !== AnalyticsDashboardProvider.FLEET_WIDGET_BASENAME);
+    }
+    normalizeViewId(raw, fallback = 'global') {
+        return (0, viewsConfigMerge_1.normalizeDashboardViewId)(raw, fallback);
+    }
+    getViewsConfigFilename() {
+        return this.viewIdSuffix ? `views-${this.viewIdSuffix}.yaml` : 'views.yaml';
+    }
+    getGlobalViewsConfigPath() {
+        return path.join(this.artifactManager.getGlobalAnalyticsRoot(), 'panel', this.getViewsConfigFilename());
+    }
+    getWorkspaceViewsConfigPath() {
+        const workspaceRoot = this.resolveWorkspaceRootPath();
+        if (!workspaceRoot) {
+            return undefined;
+        }
+        return path.join(workspaceRoot, '.agent-hippo', 'analytics', 'panel', this.getViewsConfigFilename());
+    }
+    async readPanelConfigLayers(configFilename = this.getViewsConfigFilename()) {
+        const globalPath = path.join(this.artifactManager.getGlobalAnalyticsRoot(), 'panel', configFilename);
+        const workspaceRoot = this.resolveWorkspaceRootPath();
+        const workspacePath = workspaceRoot
+            ? path.join(workspaceRoot, '.agent-hippo', 'analytics', 'panel', configFilename)
+            : undefined;
+        return Promise.all([
+            this.readViewsConfigFile(globalPath),
+            workspacePath ? this.readViewsConfigFile(workspacePath) : Promise.resolve(undefined),
+        ]);
+    }
+    getViewsConfigPathsToWatch() {
+        const paths = [this.getGlobalViewsConfigPath()];
+        const workspacePath = this.getWorkspaceViewsConfigPath();
+        if (workspacePath && workspacePath !== paths[0]) {
+            paths.push(workspacePath);
+        }
+        return paths;
+    }
+    /** Workspace and home analytics roots (store-installed global views live under home). */
+    getAllowedAnalyticsRoots() {
+        const roots = [
+            path.resolve(this.artifactManager.getGlobalAnalyticsRoot()),
+            path.resolve(this.artifactManager.getAnalyticsRoot()),
+        ];
+        return [...new Set(roots)];
+    }
+    isPathWithinAllowedAnalyticsRoots(filePath) {
+        return (0, pathSafety_1.isPathUnderAnyRoot)(this.getAllowedAnalyticsRoots(), filePath);
+    }
+    isTeamSurface() {
+        return this.viewIdSuffix === 'team';
+    }
+    getSurfaceMode() {
+        return this.isTeamSurface() ? 'team' : 'spotlight';
+    }
+    async hydrateView(view, policy) {
+        const panelPolicy = policy ?? view;
+        const metadata = await this.readViewMetadata(view.id, view.scope);
+        let resolved;
+        if (metadata) {
+            const id = this.normalizeViewId(metadata.id, view.id);
+            let scripts = this.dedupeBasenames(metadata.scripts.length ? metadata.scripts : view.scripts);
+            scripts = id === 'fleet'
+                ? [AnalyticsDashboardProvider.FLEET_WIDGET_BASENAME]
+                : this.stripFleetWidgetFromGlobalWorkspace(id, scripts);
+            resolved = {
+                id,
+                name: metadata.name,
+                scope: metadata.scope,
+                scripts,
+                system: view.system === true || metadata.system === true,
+            };
+        }
+        else {
+            const base = view.id === 'fleet'
+                ? { ...view, scripts: [AnalyticsDashboardProvider.FLEET_WIDGET_BASENAME] }
+                : view;
+            resolved = {
+                ...base,
+                scripts: this.stripFleetWidgetFromGlobalWorkspace(base.id, base.scripts),
+            };
+        }
+        return {
+            ...resolved,
+            refreshOnNavigate: panelPolicy.refreshOnNavigate,
+            layout: panelPolicy.layout,
+            preserveFleetIframe: panelPolicy.preserveFleetIframe,
+        };
+    }
+    /** Agent Team: built-in Fleet plus views tagged `team` or `fleet` in view.yaml. */
+    async buildTeamViewsConfig(preferredActiveId, spotlightPanel) {
+        const policyById = new Map(spotlightPanel.views.map(view => [view.id, view]));
+        const discovered = await (0, teamViewDiscovery_1.discoverTeamTaggedViews)(this.getAllowedAnalyticsRoots());
+        const views = [
+            {
+                id: 'fleet',
+                name: 'Fleet',
+                scope: 'global',
+                scripts: [AnalyticsDashboardProvider.FLEET_WIDGET_BASENAME],
+                system: true,
+            },
+            // Workflows is a built-in team view (like Fleet): adding it here keeps it
+            // stable across reloads, unlike a postViewsState injection which flaps on
+            // this surface because buildTeamViewsConfig rebuilds the list each time.
+            (0, viewsConfigMerge_1.createDefaultWorkflowsView)(),
+        ];
+        for (const record of discovered) {
+            const policy = policyById.get(record.id);
+            views.push(await this.hydrateView({
+                id: record.id,
+                name: record.name,
+                scope: record.scope,
+                scripts: policy?.scripts ?? [],
+                system: false,
+            }, policy));
+        }
+        return this.finalizeTeamViewsConfig(views, preferredActiveId);
+    }
+    async loadTeamViewsConfig() {
+        const [[globalLoaded, workspaceLoaded], [spotlightGlobal, spotlightWorkspace]] = await Promise.all([
+            this.readPanelConfigLayers(),
+            this.readPanelConfigLayers('views.yaml'),
+        ]);
+        const spotlightPanel = this.mergeViewsConfigs(spotlightGlobal, spotlightWorkspace);
+        const preferredActiveId = this.normalizeViewId(workspaceLoaded?.activeViewId ?? globalLoaded?.activeViewId, 'fleet');
+        return this.buildTeamViewsConfig(preferredActiveId, spotlightPanel);
+    }
+    /** Agent Team picker: fleet plus discovered views only (no Spotlight global/workspace stubs). */
+    finalizeTeamViewsConfig(views, preferredActiveId) {
+        const normalizedViews = views.map(view => ({
+            ...view,
+            id: this.normalizeViewId(view.id, 'fleet'),
+            scripts: view.id === 'fleet'
+                ? [AnalyticsDashboardProvider.FLEET_WIDGET_BASENAME]
+                : this.stripFleetWidgetFromGlobalWorkspace(view.id, this.dedupeBasenames(view.scripts)),
+        }));
+        if (!normalizedViews.some(view => view.id === 'fleet')) {
+            normalizedViews.unshift({
+                id: 'fleet',
+                name: 'Fleet',
+                scope: 'global',
+                scripts: [AnalyticsDashboardProvider.FLEET_WIDGET_BASENAME],
+                system: true,
+            });
+        }
+        return {
+            version: 1,
+            activeViewId: this.resolvePersistedActiveId(normalizedViews, preferredActiveId, 'fleet'),
+            views: normalizedViews,
+        };
+    }
+    getViewMetadataPath(viewId, scope) {
+        const context = {
+            scope,
+            projectId: this.resolveWorkspaceProjectId(),
+            agentId: this.agentFilterId,
+            viewId,
+        };
+        return path.join(this.artifactManager.resolveViewRoot(context), 'view.yaml');
+    }
+    async readViewMetadata(viewId, scope) {
+        const metadataPath = this.getViewMetadataPath(viewId, scope);
+        try {
+            const raw = await fs_1.promises.readFile(metadataPath, 'utf-8');
+            const yaml = require('js-yaml');
+            const parsed = yaml.load(raw);
+            if (!parsed || typeof parsed !== 'object') {
+                return undefined;
+            }
+            const now = new Date().toISOString();
+            const versionField = parsed.version;
+            const version = typeof versionField === 'string' && versionField.trim()
+                ? versionField.trim()
+                : typeof versionField === 'number'
+                    ? versionField
+                    : 1;
+            return {
+                version,
+                id: this.normalizeViewId(typeof parsed.id === 'string' ? parsed.id : viewId, viewId),
+                name: typeof parsed.name === 'string' && parsed.name.trim() ? parsed.name.trim() : viewId,
+                scope: parsed.scope === 'workspace' ? 'workspace' : 'global',
+                projectId: typeof parsed.projectId === 'string' ? parsed.projectId : '',
+                agentId: typeof parsed.agentId === 'string' ? parsed.agentId : '',
+                createdAt: typeof parsed.createdAt === 'string' && parsed.createdAt.trim() ? parsed.createdAt : now,
+                updatedAt: typeof parsed.updatedAt === 'string' && parsed.updatedAt.trim() ? parsed.updatedAt : now,
+                scripts: this.dedupeBasenames(this.parseStringArray(parsed.scripts)),
+                system: parsed.system === true,
+                description: typeof parsed.description === 'string' ? parsed.description.trim() : undefined,
+                author: typeof parsed.author === 'string' ? parsed.author.trim() : undefined,
+                tags: Array.isArray(parsed.tags)
+                    ? parsed.tags.filter((tag) => typeof tag === 'string')
+                    : undefined,
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async writeViewMetadata(view, createdAt) {
+        const metadataPath = this.getViewMetadataPath(view.id, view.scope);
+        await fs_1.promises.mkdir(path.dirname(metadataPath), { recursive: true });
+        const now = new Date().toISOString();
+        const existing = await this.readViewMetadata(view.id, view.scope);
+        // Agent Team / Fleet view: persist only agent-fleet-widget.js by default.
+        const scripts = view.id === 'fleet' ? ['agent-fleet-widget.js'] : this.dedupeBasenames(view.scripts);
+        const payload = {
+            version: existing?.version ?? '1.0.0',
+            id: view.id,
+            name: view.name,
+            scope: view.scope,
+            projectId: this.resolveWorkspaceProjectId() ?? '',
+            agentId: this.agentFilterId ?? '',
+            createdAt: createdAt ?? existing?.createdAt ?? now,
+            updatedAt: now,
+            scripts,
+            system: view.system === true,
+            ...(existing?.description ? { description: existing.description } : {}),
+            ...(existing?.author ? { author: existing.author } : {}),
+            ...(existing?.tags?.length ? { tags: existing.tags } : {}),
+        };
+        const yaml = require('js-yaml');
+        const content = yaml.dump(payload, { lineWidth: 120, noRefs: true });
+        await fs_1.promises.writeFile(metadataPath, content, 'utf-8');
+    }
+    getViewContext(view) {
+        return {
+            scope: view.scope,
+            projectId: this.resolveWorkspaceProjectId(),
+            agentId: this.agentFilterId,
+            viewId: view.id,
+        };
+    }
+    getViewScriptsDir(view) {
+        return path.join(this.artifactManager.resolveViewRoot(this.getViewContext(view)), 'scripts');
+    }
+    async ensureViewOwnedScripts(view) {
+        // Seed the run scripts plus any declared sidecars (e.g. the Workflows collector/daemon
+        // the widget spawns) — driven by view config, not the view id.
+        const expectedScripts = this.dedupeBasenames([...view.scripts, ...(view.bundledScripts ?? [])]);
+        if (expectedScripts.length === 0) {
+            return;
+        }
+        const scriptsDir = this.getViewScriptsDir(view);
+        await fs_1.promises.mkdir(scriptsDir, { recursive: true });
+        for (const scriptName of expectedScripts) {
+            const destination = path.join(scriptsDir, scriptName);
+            try {
+                await fs_1.promises.access(destination);
+                continue;
+            }
+            catch {
+                // Missing destination; seed below when a bundled script exists.
+            }
+            const source = await this.findBundledAnalyticsScript(scriptName);
+            if (!source) {
+                this.outputChannel.appendLine(`[Dashboard] Could not seed script "${scriptName}" for view "${view.id}" (bundled script not found)`);
+                continue;
+            }
+            try {
+                await fs_1.promises.copyFile(source, destination);
+                this.outputChannel.appendLine(`[Dashboard] Seeded missing view script "${scriptName}" for view "${view.id}"`);
+            }
+            catch (err) {
+                this.outputChannel.appendLine(`[Dashboard] Failed seeding script "${scriptName}" for view "${view.id}": ${err}`);
+            }
+        }
+    }
+    async ensureViewOwnedDirectories(view) {
+        const viewRoot = this.artifactManager.resolveViewRoot(this.getViewContext(view));
+        for (const dir of [
+            path.join(viewRoot, 'scripts'),
+            path.join(viewRoot, 'charts'),
+            path.join(viewRoot, 'reports'),
+            path.join(viewRoot, 'exports'),
+            path.join(viewRoot, 'images'),
+            path.join(viewRoot, 'assets'),
+        ]) {
+            await fs_1.promises.mkdir(dir, { recursive: true });
+        }
+    }
+    async ensureViewsFilesystemState() {
+        for (const view of this.viewsConfig.views) {
+            await this.ensureViewOwnedDirectories(view);
+            await this.ensureViewOwnedScripts(view);
+            await this.writeViewMetadata(view);
+        }
+    }
+    async copyViewFiles(sourceView, targetView, folders) {
+        const sourceRoot = this.artifactManager.resolveViewRoot({
+            scope: sourceView.scope,
+            projectId: this.resolveWorkspaceProjectId(),
+            agentId: this.agentFilterId,
+            viewId: sourceView.id,
+        });
+        const destinationRoot = this.artifactManager.resolveViewRoot({
+            scope: targetView.scope,
+            projectId: this.resolveWorkspaceProjectId(),
+            agentId: this.agentFilterId,
+            viewId: targetView.id,
+        });
+        for (const folder of folders) {
+            const sourceDir = path.join(sourceRoot, folder);
+            const destinationDir = path.join(destinationRoot, folder);
+            await fs_1.promises.mkdir(destinationDir, { recursive: true });
+            let entries = [];
+            try {
+                entries = await fs_1.promises.readdir(sourceDir);
+            }
+            catch {
+                continue;
+            }
+            for (const entry of entries) {
+                const sourcePath = path.join(sourceDir, entry);
+                const destinationPath = path.join(destinationDir, entry);
+                try {
+                    const stat = await fs_1.promises.stat(sourcePath);
+                    if (!stat.isFile()) {
+                        continue;
+                    }
+                    await fs_1.promises.copyFile(sourcePath, destinationPath);
+                }
+                catch {
+                    // Best effort copy.
+                }
+            }
+        }
+    }
+    createDefaultViewsConfig() {
+        const defaultActiveViewId = this.viewIdSuffix === 'team' ? 'fleet' : 'global';
+        return {
+            version: 1,
+            activeViewId: defaultActiveViewId,
+            views: [
+                { id: 'global', name: 'Global', scope: 'global', scripts: [], system: true },
+                { id: 'workspace', name: 'Workspace', scope: 'workspace', scripts: [], system: true },
+                { id: 'fleet', name: 'Fleet', scope: 'global', scripts: ['agent-fleet-widget.js'], system: true },
+                (0, viewsConfigMerge_1.createDefaultWorkflowsView)(),
+            ],
+        };
+    }
+    normalizeViewsConfig(raw, options) {
+        const parsed = raw && typeof raw === 'object' ? raw : {};
+        const rawViews = Array.isArray(parsed.views) ? parsed.views : [];
+        const views = [];
+        const seen = new Set();
+        for (const item of rawViews) {
+            if (!item || typeof item !== 'object') {
+                continue;
+            }
+            const candidate = item;
+            const id = this.normalizeViewId(typeof candidate.id === 'string' ? candidate.id : undefined, 'view');
+            if (!id || seen.has(id)) {
+                continue;
+            }
+            seen.add(id);
+            const scope = candidate.scope === 'workspace' ? 'workspace' : 'global';
+            const name = typeof candidate.name === 'string' && candidate.name.trim() ? candidate.name.trim() : id;
+            const scripts = this.stripFleetWidgetFromGlobalWorkspace(id, this.dedupeBasenames(this.parseStringArray(candidate.scripts)));
+            const bundledScripts = this.dedupeBasenames(this.parseStringArray(candidate.bundledScripts));
+            const system = candidate.system === true;
+            const refreshOnNavigate = candidate.refreshOnNavigate === 'always' || candidate.refreshOnNavigate === 'when-empty'
+                ? candidate.refreshOnNavigate
+                : undefined;
+            const layout = candidate.layout === 'fleet-dashboard' || candidate.layout === 'gallery'
+                ? candidate.layout
+                : undefined;
+            const preserveFleetIframe = candidate.preserveFleetIframe === true
+                ? true
+                : candidate.preserveFleetIframe === false
+                    ? false
+                    : undefined;
+            views.push({
+                id, name, scope, scripts,
+                bundledScripts: bundledScripts.length ? bundledScripts : undefined,
+                system, refreshOnNavigate, layout, preserveFleetIframe,
+            });
+        }
+        if (!views.some(view => view.id === 'global')) {
+            views.unshift({ id: 'global', name: 'Global', scope: 'global', scripts: [], system: true });
+        }
+        if (!views.some(view => view.id === 'workspace')) {
+            views.push({ id: 'workspace', name: 'Workspace', scope: 'workspace', scripts: [], system: true });
+        }
+        if (!views.some(view => view.id === 'fleet')) {
+            views.push({ id: 'fleet', name: 'Fleet', scope: 'global', scripts: ['agent-fleet-widget.js'], system: true });
+        }
+        if (!views.some(view => view.id === viewsConfigMerge_1.WORKFLOWS_VIEW_ID)) {
+            views.push((0, viewsConfigMerge_1.createDefaultWorkflowsView)());
+        }
+        const defaultConfig = this.createDefaultViewsConfig();
+        const rawActive = typeof parsed.activeViewId === 'string' ? parsed.activeViewId : defaultConfig.activeViewId;
+        const activeViewId = this.normalizeViewId(rawActive, defaultConfig.activeViewId);
+        const hasActive = views.some(view => view.id === activeViewId);
+        return {
+            version: 1,
+            activeViewId: hasActive || options?.allowOrphanActiveId ? activeViewId : defaultConfig.activeViewId,
+            views,
+        };
+    }
+    async readViewsConfigFile(configPath) {
+        try {
+            const raw = await fs_1.promises.readFile(configPath, 'utf-8');
+            const yaml = require('js-yaml');
+            return this.normalizeViewsConfig(yaml.load(raw), { allowOrphanActiveId: true });
+        }
+        catch {
+            return undefined;
+        }
+    }
+    mergeViewsConfigs(globalConfig, workspaceConfig) {
+        const defaults = this.createDefaultViewsConfig();
+        const merged = (0, viewsConfigMerge_1.mergeDashboardViewsConfigs)(globalConfig, workspaceConfig, defaults);
+        return this.normalizeViewsConfig({
+            version: 1,
+            activeViewId: merged.activeViewId,
+            views: merged.views,
+        });
+    }
+    async handleViewsConfigChanged() {
+        const previousActiveViewId = this.getActiveViewId();
+        await this.loadViewsConfig();
+        if (!this.webviewView?.visible) {
+            return;
+        }
+        await this.postViewsState();
+        await this.postPanelState('default');
+        if (this.getActiveViewId() !== previousActiveViewId) {
+            await this.refreshAfterViewChange();
+            await this.refreshChartsForActiveViewAfterSwitch();
+        }
+    }
+    async loadViewsConfig() {
+        if (this.isTeamSurface()) {
+            const teamConfigPath = this.getGlobalViewsConfigPath();
+            let needsPersist = false;
+            try {
+                await fs_1.promises.access(teamConfigPath);
+            }
+            catch {
+                needsPersist = true;
+            }
+            this.viewsConfig = await this.loadTeamViewsConfig();
+            if (needsPersist) {
+                await this.saveViewsConfig(this.viewsConfig);
+            }
+            return this.viewsConfig;
+        }
+        const workspacePath = this.getWorkspaceViewsConfigPath();
+        const [globalLoaded, workspaceLoaded] = await this.readPanelConfigLayers();
+        let usedFallback = !globalLoaded && !workspaceLoaded;
+        let loaded = this.mergeViewsConfigs(globalLoaded, workspaceLoaded);
+        if (usedFallback) {
+            const fallback = this.createDefaultViewsConfig();
+            const allScripts = await this.artifactManager.listScripts({ disabledScripts: [] });
+            const allScriptNames = this.dedupeBasenames(allScripts.map(script => script.filename));
+            const fleetOnly = AnalyticsDashboardProvider.FLEET_WIDGET_BASENAME;
+            loaded = {
+                ...fallback,
+                views: fallback.views.map(view => ({
+                    ...view,
+                    scripts: view.scripts.length
+                        ? view.scripts
+                        : allScriptNames.filter((name) => view.id === 'fleet'
+                            ? this.normalizeBasename(name) === fleetOnly
+                            : this.normalizeBasename(name) !== fleetOnly),
+                })),
+            };
+        }
+        const hydratedViews = [];
+        for (const view of loaded.views) {
+            hydratedViews.push(await this.hydrateView(view));
+        }
+        const normalized = this.normalizeViewsConfig({
+            version: 1,
+            activeViewId: loaded.activeViewId,
+            views: hydratedViews,
+        });
+        this.viewsConfig = normalized;
+        const shouldPersist = usedFallback
+            || this.shouldHealWorkspaceActiveViewId(workspaceLoaded, workspacePath, loaded.activeViewId);
+        if (shouldPersist) {
+            await this.saveViewsConfig(this.viewsConfig);
+        }
+        return this.viewsConfig;
+    }
+    resolvePersistedActiveId(views, preferredId, fallbackId) {
+        const normalized = this.normalizeViewId(preferredId, fallbackId);
+        return views.some(view => view.id === normalized) ? normalized : fallbackId;
+    }
+    /** Rewrite workspace views.yaml when merge healed an orphan workspace activeViewId. */
+    shouldHealWorkspaceActiveViewId(workspaceLoaded, workspacePath, resolvedActiveViewId) {
+        if (!workspacePath || !workspaceLoaded) {
+            return false;
+        }
+        const stored = this.normalizeViewId(workspaceLoaded.activeViewId, '');
+        const resolved = this.normalizeViewId(resolvedActiveViewId, '');
+        return stored.length > 0 && stored !== resolved;
+    }
+    async saveViewsConfig(config) {
+        const normalized = this.normalizeViewsConfig(config);
+        const yaml = require('js-yaml');
+        if (this.isTeamSurface()) {
+            const defaultActive = 'fleet';
+            const activeViewId = this.resolvePersistedActiveId(normalized.views, normalized.activeViewId, defaultActive);
+            const teamPersist = {
+                version: 1,
+                activeViewId,
+                views: [{
+                        id: 'fleet',
+                        name: 'Fleet',
+                        scope: 'global',
+                        scripts: [AnalyticsDashboardProvider.FLEET_WIDGET_BASENAME],
+                        system: true,
+                    }],
+            };
+            const globalPath = this.getGlobalViewsConfigPath();
+            await fs_1.promises.mkdir(path.dirname(globalPath), { recursive: true });
+            await fs_1.promises.writeFile(globalPath, yaml.dump(teamPersist, { lineWidth: 120, noRefs: true }), 'utf-8');
+            const workspacePath = this.getWorkspaceViewsConfigPath();
+            if (workspacePath) {
+                await fs_1.promises.mkdir(path.dirname(workspacePath), { recursive: true });
+                await fs_1.promises.writeFile(workspacePath, yaml.dump({ version: 1, activeViewId, views: [] }, { lineWidth: 120, noRefs: true }), 'utf-8');
+            }
+            this.viewsConfig = normalized;
+            await this.ensureViewsFilesystemState();
+            return;
+        }
+        const globalViews = normalized.views.filter(view => view.scope !== 'workspace');
+        const workspaceViews = normalized.views.filter(view => view.scope === 'workspace');
+        const defaultActive = 'global';
+        const unifiedActive = this.normalizeViewId(normalized.activeViewId, defaultActive);
+        const activeViewId = normalized.views.some(view => view.id === unifiedActive)
+            ? unifiedActive
+            : defaultActive;
+        const globalPath = this.getGlobalViewsConfigPath();
+        const workspacePath = this.getWorkspaceViewsConfigPath();
+        const [existingGlobal] = await Promise.all([
+            this.readViewsConfigFile(globalPath),
+            workspacePath ? this.readViewsConfigFile(workspacePath) : Promise.resolve(undefined),
+        ]);
+        // Per-repo selection lives in workspace views.yaml when a folder is open; global activeViewId is home-only.
+        const globalActiveId = workspacePath
+            ? this.resolvePersistedActiveId(globalViews, existingGlobal?.activeViewId ?? defaultActive, defaultActive)
+            : activeViewId;
+        const globalConfig = {
+            version: 1,
+            activeViewId: globalActiveId,
+            views: globalViews,
+        };
+        await fs_1.promises.mkdir(path.dirname(globalPath), { recursive: true });
+        await fs_1.promises.writeFile(globalPath, yaml.dump(globalConfig, { lineWidth: 120, noRefs: true }), 'utf-8');
+        if (workspacePath) {
+            const workspaceConfig = {
+                version: 1,
+                activeViewId,
+                views: workspaceViews,
+            };
+            await fs_1.promises.mkdir(path.dirname(workspacePath), { recursive: true });
+            await fs_1.promises.writeFile(workspacePath, yaml.dump(workspaceConfig, { lineWidth: 120, noRefs: true }), 'utf-8');
+        }
+        this.viewsConfig = normalized;
+        await this.ensureViewsFilesystemState();
+    }
+    getActiveViewId() {
+        const fallback = this.isTeamSurface() ? 'fleet' : 'global';
+        const activeId = this.normalizeViewId(this.viewsConfig.activeViewId, fallback);
+        if (this.viewsConfig.views.some(view => view.id === activeId)) {
+            return activeId;
+        }
+        return fallback;
+    }
+    getActiveView() {
+        const activeId = this.getActiveViewId();
+        return this.viewsConfig.views.find(view => view.id === activeId) ?? this.createDefaultViewsConfig().views[0];
+    }
+    findViewById(viewId) {
+        const normalized = this.normalizeViewId(viewId);
+        return this.viewsConfig.views.find(view => view.id === normalized);
+    }
+    async postViewsState() {
+        if (!this.viewsConfig.views.some(v => v.id === 'fleet')) {
+            const fleetView = { id: 'fleet', name: 'Fleet', scope: 'global', scripts: ['agent-fleet-widget.js'], system: true };
+            this.viewsConfig = {
+                ...this.viewsConfig,
+                views: [...this.viewsConfig.views, fleetView],
+            };
+            await this.ensureViewOwnedDirectories(fleetView);
+            await this.writeViewMetadata(fleetView);
+            await this.saveViewsConfig(this.viewsConfig);
+        }
+        // Spotlight-only safety net. The team surface already owns Workflows as a built-in
+        // in buildTeamViewsConfig; injecting it here too would flap the picker (it rebuilds
+        // the list each reload) and pollute the shared team config on disk.
+        if (!this.isTeamSurface() && !this.viewsConfig.views.some(v => v.id === viewsConfigMerge_1.WORKFLOWS_VIEW_ID)) {
+            const workflowsView = (0, viewsConfigMerge_1.createDefaultWorkflowsView)();
+            this.viewsConfig = {
+                ...this.viewsConfig,
+                views: [...this.viewsConfig.views, workflowsView],
+            };
+            await this.ensureViewOwnedDirectories(workflowsView);
+            await this.ensureViewOwnedScripts(workflowsView);
+            await this.writeViewMetadata(workflowsView);
+            await this.saveViewsConfig(this.viewsConfig);
+        }
+        const activeViewId = this.getActiveViewId();
+        const views = this.viewsConfig.views.map(view => ({
+            id: view.id,
+            name: view.name,
+            scope: view.scope,
+            system: view.system === true,
+            layout: (0, viewsConfigMerge_1.resolveGalleryLayout)(view),
+            refreshOnNavigate: (0, viewsConfigMerge_1.resolveRefreshOnNavigate)(view),
+            preserveFleetIframe: (0, viewsConfigMerge_1.resolvePreserveFleetIframe)(view),
+        }));
+        postToWebview(this.webviewView?.webview, {
+            type: 'viewsLoaded',
+            activeViewId,
+            views,
+            surfaceMode: this.getSurfaceMode(),
+        });
+    }
+    async loadAndPostViewsState() {
+        this.viewsConfig = await this.loadViewsConfig();
+        await this.postViewsState();
+    }
+    /** Reload views.yaml from disk (global + workspace) and refresh the webview dropdown. */
+    async refreshViewsFromDisk() {
+        await this.loadAndPostViewsState();
+    }
+    async setActiveView(viewId) {
+        const normalized = this.normalizeViewId(viewId);
+        if (!this.viewsConfig.views.some(view => view.id === normalized)) {
+            return false;
+        }
+        if (this.viewsConfig.activeViewId === normalized) {
+            return true;
+        }
+        this.viewsConfig = {
+            ...this.viewsConfig,
+            activeViewId: normalized,
+        };
+        await this.saveViewsConfig(this.viewsConfig);
+        return true;
+    }
+    /**
+     * Switch the dashboard to the given view and persist. Caller should focus the panel after.
+     * Used by "Open Agent Fleet" to open the dashboard with the Fleet view active.
+     */
+    async openWithView(viewId) {
+        await this.loadViewsConfig();
+        const switched = await this.setActiveView(viewId);
+        if (!this.webviewView?.visible) {
+            return;
+        }
+        await this.postViewsState();
+        if (switched) {
+            this.syncArtifactContext();
+            await this.refreshAfterViewChange();
+            await this.refreshChartsForActiveViewAfterSwitch();
+        }
+    }
+    allocateViewId(name, fallback = 'view') {
+        const baseId = this.normalizeViewId(name, fallback);
+        let candidateId = baseId;
+        let suffix = 2;
+        while (this.viewsConfig.views.some(view => view.id === candidateId)) {
+            candidateId = `${baseId}-${suffix++}`;
+        }
+        return candidateId;
+    }
+    async createView(name) {
+        const trimmed = name.trim();
+        if (!trimmed) {
+            return undefined;
+        }
+        const candidateId = this.allocateViewId(trimmed, 'view');
+        const sourceView = this.getActiveView();
+        const newView = {
+            id: candidateId,
+            name: trimmed,
+            scope: sourceView.scope,
+            scripts: [],
+            system: false,
+        };
+        await this.ensureViewOwnedDirectories(newView);
+        await this.copyViewFiles(sourceView, newView, ['assets', 'images']);
+        this.viewsConfig = {
+            ...this.viewsConfig,
+            activeViewId: newView.id,
+            views: [...this.viewsConfig.views, newView],
+        };
+        await this.saveViewsConfig(this.viewsConfig);
+        return newView;
+    }
+    async renameView(viewId, name) {
+        const target = this.findViewById(viewId);
+        if (!target || target.system) {
+            return false;
+        }
+        const trimmed = name.trim();
+        if (!trimmed) {
+            return false;
+        }
+        this.viewsConfig = {
+            ...this.viewsConfig,
+            views: this.viewsConfig.views.map(view => view.id === target.id ? { ...view, name: trimmed } : view),
+        };
+        await this.saveViewsConfig(this.viewsConfig);
+        return true;
+    }
+    async duplicateView(viewId) {
+        const source = this.findViewById(viewId);
+        if (!source) {
+            return undefined;
+        }
+        const copyBaseName = `${source.name} Copy`;
+        const candidateId = this.allocateViewId(copyBaseName, 'view');
+        const copyDisplayName = (0, viewsConfigMerge_1.formatDisplayNameForAllocatedViewId)(copyBaseName, candidateId, (raw, fallback) => this.normalizeViewId(raw, fallback));
+        const scripts = await this.resolveScriptBasenamesForDuplicate(source);
+        const duplicate = {
+            id: candidateId,
+            name: copyDisplayName,
+            scope: source.scope,
+            scripts,
+            system: false,
+        };
+        await this.ensureViewOwnedDirectories(duplicate);
+        await this.copyViewFiles(source, duplicate, ['scripts', 'assets', 'images', 'charts', 'reports', 'exports']);
+        this.viewsConfig = {
+            ...this.viewsConfig,
+            activeViewId: duplicate.id,
+            views: [...this.viewsConfig.views, duplicate],
+        };
+        await this.saveViewsConfig(this.viewsConfig);
+        return duplicate;
+    }
+    async deleteView(viewId) {
+        const target = this.findViewById(viewId);
+        if (!target || target.system) {
+            return false;
+        }
+        const nextActiveViewId = this.getActiveViewId() === target.id ? 'global' : this.getActiveViewId();
+        this.viewsConfig = {
+            ...this.viewsConfig,
+            activeViewId: nextActiveViewId,
+            views: this.viewsConfig.views.filter(view => view.id !== target.id),
+        };
+        const viewRoot = this.artifactManager.resolveViewRoot({
+            scope: target.scope,
+            projectId: this.resolveWorkspaceProjectId(),
+            agentId: this.agentFilterId,
+            viewId: target.id,
+        });
+        await fs_1.promises.rm(viewRoot, { recursive: true, force: true }).catch(() => undefined);
+        const panelStatePath = path.join(this.artifactManager.getAnalyticsRoot(), 'panel-state', `default--${target.id}.json`);
+        await fs_1.promises.rm(panelStatePath, { force: true }).catch(() => undefined);
+        await this.saveViewsConfig(this.viewsConfig);
+        return true;
+    }
+    async editViewScripts(viewId) {
+        const view = viewId ? this.findViewById(viewId) : this.getActiveView();
+        if (!view) {
+            return false;
+        }
+        const scriptRoot = path.join(this.artifactManager.resolveViewRoot({
+            scope: view.scope,
+            projectId: this.resolveWorkspaceProjectId(),
+            agentId: this.agentFilterId,
+            viewId: view.id,
+        }), 'scripts');
+        await fs_1.promises.mkdir(scriptRoot, { recursive: true });
+        await vscode.commands.executeCommand('revealInExplorer', vscode.Uri.file(scriptRoot));
+        return true;
+    }
+    async refreshAllViews() {
+        // Spotlight "refresh" should never change the user's currently-selected view.
+        // Refresh only the active view to avoid temporarily switching through other
+        // system views (notably `fleet`) during the refresh cycle.
+        const activeViewId = this.getActiveViewId();
+        await this.refreshCharts({ viewId: activeViewId });
+    }
+    getRefreshContext(options) {
+        const requestedViewId = options?.viewId ? this.normalizeViewId(options.viewId) : this.getActiveViewId();
+        const view = this.viewsConfig.views.find(item => item.id === requestedViewId) ?? this.getActiveView();
+        return {
+            viewId: view.id,
+            viewName: view.name,
+        };
+    }
+    postRefreshStatus(type, options) {
+        const refreshContext = this.getRefreshContext(options);
+        postToWebview(this.webviewView?.webview, {
+            type,
+            viewId: refreshContext.viewId,
+            viewName: refreshContext.viewName,
+        });
+    }
+    async getScriptsForView(options) {
+        const viewId = options?.viewId ? this.normalizeViewId(options.viewId) : this.getActiveViewId();
+        const view = this.viewsConfig.views.find(item => item.id === viewId) ?? this.getActiveView();
+        await this.ensureViewOwnedScripts(view);
+        return this.withArtifactViewContext(view, async () => {
+            const allScripts = await this.artifactManager.listScripts({ disabledScripts: [] });
+            return this.resolveScriptsForView(view, allScripts);
+        });
+    }
+    resolveScriptsForView(view, allScripts) {
+        if (!view.scripts.length) {
+            // System views (e.g. Global, Workspace) with no scripts → use all scripts except the Fleet-only widget.
+            // Fleet view with no scripts → only agent-fleet-widget.js. User-created "Add view" → empty canvas.
+            if (!view.system) {
+                return { view, scripts: [] };
+            }
+            if (view.id === 'fleet') {
+                return {
+                    view,
+                    scripts: allScripts.filter(s => this.normalizeBasename(s.filename) === AnalyticsDashboardProvider.FLEET_WIDGET_BASENAME),
+                };
+            }
+            return {
+                view,
+                scripts: allScripts.filter(s => this.normalizeBasename(s.filename) !== AnalyticsDashboardProvider.FLEET_WIDGET_BASENAME),
+            };
+        }
+        const selectedBasenames = new Set(view.scripts.map(name => this.normalizeBasename(name)));
+        return {
+            view,
+            scripts: allScripts.filter(script => selectedBasenames.has(this.normalizeBasename(script.filename))),
+        };
+    }
+    async resolveScriptBasenamesForDuplicate(source) {
+        if (source.scripts.length > 0) {
+            return this.dedupeBasenames(source.scripts);
+        }
+        const selection = await this.withArtifactViewContext(source, async () => {
+            const allScripts = await this.artifactManager.listScripts({ disabledScripts: [] });
+            return this.resolveScriptsForView(source, allScripts);
+        });
+        return this.dedupeBasenames(selection.scripts.map(script => script.filename));
+    }
+    getScopedPanelId(panelId) {
+        const normalizedPanelId = this.normalizePanelStateId(panelId);
+        const viewId = this.getActiveViewId();
+        return `${normalizedPanelId}--${viewId}`;
+    }
+    async refreshDashboardData() {
+        this.queryRunner.invalidateCache();
+        void this.fetchDashboardBootstrapData().then(bootstrap => {
+            void this.postFilterState(bootstrap?.agentIds);
+            this.triggerSummaryCardsUpdate(bootstrap?.summary);
+        });
+        const refreshedBootstrap = await this.fetchDashboardBootstrapData();
+        await this.postFilterState(refreshedBootstrap?.agentIds);
+        this.triggerSummaryCardsUpdate(refreshedBootstrap?.summary);
+        await this.updateDataFreshnessHint(refreshedBootstrap
+            ? { hasData: refreshedBootstrap.hasData, dataHash: refreshedBootstrap.dataHash }
+            : undefined);
+    }
+    /**
+     * Reload gallery and summary after the active view or filters change.
+     * Policy: artifact-first — always load from disk here; script execution is gated separately
+     * (see PLAN/spotlight-refresh-policy.md and maybeRefreshChartsAfterViewSwitch).
+     */
+    async refreshAfterViewChange() {
+        this.queryRunner.invalidateCache();
+        const bootstrapPromise = this.fetchDashboardBootstrapData();
+        await this.loadAndSendArtifacts();
+        this.scheduleAutoGenerateForCurrentFilter();
+        const bootstrap = await bootstrapPromise;
+        await this.postFilterState(bootstrap?.agentIds);
+        this.triggerSummaryCardsUpdate(bootstrap?.summary);
+        await this.updateDataFreshnessHint(bootstrap ? { hasData: bootstrap.hasData, dataHash: bootstrap.dataHash } : undefined);
+    }
+    /**
+     * Whether navigation should run widget scripts (view switch after load).
+     * Fleet always runs; otherwise run only when the view has no chart artifacts.
+     */
+    async shouldRunScriptsOnNavigation() {
+        this.syncArtifactContext();
+        const artifacts = await this.artifactManager.listArtifacts();
+        return (0, viewsConfigMerge_1.shouldRunScriptsOnNavigation)(this.getActiveView(), artifacts.map(artifact => artifact.type));
+    }
+    /**
+     * Run widget scripts after view switch when policy allows (compute when empty; fleet always).
+     */
+    async refreshChartsForActiveViewAfterSwitch() {
+        try {
+            if (!(await this.shouldRunScriptsOnNavigation())) {
+                this.outputChannel.appendLine('[Dashboard] View switch: load only (chart artifacts present; use Refresh to re-run scripts)');
+                return;
+            }
+            await this.refreshCharts({ viewId: this.getActiveViewId() });
+        }
+        catch (err) {
+            this.outputChannel.appendLine(`[Dashboard] View-switch chart refresh failed: ${err}`);
+        }
+    }
+    getActiveFilters() {
+        const activeView = this.getActiveView();
+        return {
+            scope: activeView.scope,
+            projectId: this.resolveWorkspaceProjectId(),
+            agentId: this.agentFilterId,
+        };
+    }
+    async fetchDashboardBootstrapData() {
+        try {
+            return await this.queryRunner.getDashboardBootstrap(this.getActiveFilters());
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.outputChannel.appendLine(`[Dashboard] Could not load dashboard bootstrap data: ${message}`);
+            if (message.toLowerCase().includes('indexed analytics db')) {
+                this.webviewView?.webview.postMessage({
+                    type: 'notifyIndexing',
+                    message: 'Spotlight index unavailable. Re-index traces (Setup Spotlight) and refresh.',
+                });
+            }
+            return undefined;
+        }
+    }
+    triggerSummaryCardsUpdate(summaryOverride) {
+        void this.sendSummaryCards(summaryOverride);
+    }
+    async postFilterState(availableAgentIdsOverride) {
+        const filters = this.getActiveFilters();
+        let availableAgentIds = [];
+        if (availableAgentIdsOverride) {
+            availableAgentIds = [...availableAgentIdsOverride];
+        }
+        else {
+            try {
+                availableAgentIds = await this.queryRunner.getAgentIds({
+                    scope: filters.scope,
+                    projectId: filters.projectId,
+                });
+            }
+            catch (err) {
+                this.outputChannel.appendLine(`[Dashboard] Could not load agent filters: ${err}`);
+            }
+        }
+        if (this.agentFilterId && !availableAgentIds.includes(this.agentFilterId)) {
+            this.agentFilterId = undefined;
+        }
+        postToWebview(this.webviewView?.webview, {
+            type: 'filtersUpdated',
+            scope: filters.scope,
+            projectId: filters.projectId ?? '',
+            agentId: this.agentFilterId ?? '',
+            agentIds: availableAgentIds,
+            activeViewId: this.getActiveViewId(),
+        });
+    }
+    resolveIndexScriptPathForScripts() {
+        const candidate = path.resolve(__dirname, '../../scripts/analytics/index-traces.py');
+        return (0, fs_1.existsSync)(candidate) ? candidate : '';
+    }
+    buildScriptEnvironment(outputDir, disabledCharts = []) {
+        this.syncArtifactContext();
+        const filters = this.getActiveFilters();
+        const projectIdForScope = filters.scope === 'workspace' ? (filters.projectId ?? '') : '';
+        const workspaceRoot = this.resolveWorkspaceRootPath() ?? '';
+        const tracesDir = path.join((0, index_1.getAgentideHome)(), 'analytics', 'traces');
+        const indexingService = this.indexingService();
+        const indexedPath = indexingService?.getIndexPath().trim() ?? '';
+        const indexDbPath = indexedPath || path.join(tracesDir, 'analytics.duckdb');
+        const isIndexed = indexedPath.length > 0;
+        const indexScriptPath = this.resolveIndexScriptPathForScripts();
+        const analyticsConfig = vscode.workspace.getConfiguration('agentide.analytics');
+        const duckdbMemoryLimitMb = Math.max(64, analyticsConfig.get('duckdb.memoryLimitMb', 1024) ?? 1024);
+        const duckdbThreads = Math.max(1, analyticsConfig.get('duckdb.threads', 2) ?? 2);
+        const duckdbQueryTimeoutSeconds = Math.max(5, analyticsConfig.get('duckdb.queryTimeoutSeconds', 30) ?? 30);
+        const duckdbMaxResultRows = Math.max(100, analyticsConfig.get('duckdb.maxResultRows', 5000) ?? 5000);
+        const duckdbTempDirectory = (analyticsConfig.get('duckdb.tempDirectory', '') ?? '').trim();
+        return {
+            ...process.env,
+            // Augment PATH so uv/python/pip are found even when VS Code is
+            // launched from the Dock (which inherits a minimal PATH).
+            PATH: (0, toolPath_1.augmentPathForTools)(process.env.PATH ?? ''),
+            AGENTIDE_TRACES_DIR: tracesDir,
+            AGENTIDE_CHART_DIR: this.artifactManager.getChartDir(),
+            AGENTIDE_REPORT_DIR: this.artifactManager.getReportDir(),
+            AGENTIDE_EXPORT_DIR: this.artifactManager.getExportDir(),
+            AGENTIDE_IMAGE_DIR: this.artifactManager.getImageDir(),
+            AGENTIDE_ASSET_DIR: this.artifactManager.getAssetDir(),
+            AGENTIDE_VIEW_ROOT: this.artifactManager.getViewRoot(),
+            AGENTIDE_VIEW_ID: this.getActiveViewId(),
+            AGENTIDE_OUTPUT_DIR: outputDir,
+            AGENTIDE_ANALYTICS_SCOPE: filters.scope ?? 'global',
+            AGENTIDE_ANALYTICS_PROJECT_ID: projectIdForScope,
+            AGENTIDE_ANALYTICS_AGENT_ID: filters.agentId ?? '',
+            AGENTIDE_WORKSPACE_ROOT: workspaceRoot,
+            AGENTIDE_DISABLED_CHARTS: disabledCharts.join(','),
+            // Pass indexing status to Python script for fallback logic
+            AGENTIDE_INDEX_DB_PATH: indexDbPath,
+            AGENTIDE_USE_DUCKDB: isIndexed ? 'true' : 'false',
+            AGENTIDE_INDEX_SCRIPT_PATH: indexScriptPath,
+            AGENTIDE_DUCKDB_MEMORY_LIMIT_MB: String(duckdbMemoryLimitMb),
+            AGENTIDE_DUCKDB_THREADS: String(duckdbThreads),
+            AGENTIDE_DUCKDB_QUERY_TIMEOUT_SECONDS: String(duckdbQueryTimeoutSeconds),
+            AGENTIDE_DUCKDB_MAX_RESULT_ROWS: String(duckdbMaxResultRows),
+            AGENTIDE_DUCKDB_TEMP_DIRECTORY: duckdbTempDirectory,
+        };
+    }
+    parseStringArray(raw) {
+        if (!Array.isArray(raw)) {
+            return [];
+        }
+        return raw
+            .filter((entry) => typeof entry === 'string')
+            .map(entry => entry.trim())
+            .filter(entry => entry.length > 0);
+    }
+    normalizeBasename(value) {
+        return path.basename(value.trim()).toLowerCase();
+    }
+    dedupeBasenames(values) {
+        const seen = new Set();
+        const deduped = [];
+        for (const value of values) {
+            const trimmed = value.trim();
+            if (!trimmed) {
+                continue;
+            }
+            const basename = path.basename(trimmed);
+            const key = basename.toLowerCase();
+            if (!key || seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            deduped.push(basename);
+        }
+        return deduped;
+    }
+    dedupeCaseInsensitive(values) {
+        const seen = new Set();
+        const deduped = [];
+        for (const value of values) {
+            const trimmed = value.trim();
+            if (!trimmed) {
+                continue;
+            }
+            const key = trimmed.toLowerCase();
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            deduped.push(trimmed);
+        }
+        return deduped;
+    }
+    parseDisabledScriptsByView(raw) {
+        if (Array.isArray(raw)) {
+            const allScripts = this.dedupeBasenames(this.parseStringArray(raw));
+            return allScripts.length > 0 ? { all: allScripts } : {};
+        }
+        if (!raw || typeof raw !== 'object') {
+            return {};
+        }
+        const scriptsByView = {};
+        for (const [rawViewId, rawScripts] of Object.entries(raw)) {
+            const normalizedViewId = this.normalizeViewId(rawViewId, 'all');
+            const scripts = this.dedupeBasenames(this.parseStringArray(rawScripts));
+            if (scripts.length > 0) {
+                scriptsByView[normalizedViewId] = scripts;
+            }
+        }
+        return scriptsByView;
+    }
+    mergeDisabledScriptsByView(primary, fallback) {
+        const merged = {};
+        for (const [viewId, scripts] of Object.entries(fallback)) {
+            merged[viewId] = this.dedupeBasenames(scripts);
+        }
+        for (const [viewId, scripts] of Object.entries(primary)) {
+            merged[viewId] = this.dedupeBasenames([...(merged[viewId] ?? []), ...scripts]);
+        }
+        return merged;
+    }
+    getDisabledScriptsForView(config, viewId) {
+        const normalizedViewId = this.normalizeViewId(viewId, 'global');
+        return this.dedupeBasenames([
+            ...(config.scriptsByView.all ?? []),
+            ...(config.scriptsByView[normalizedViewId] ?? []),
+        ]);
+    }
+    async loadDisabledChartsConfig() {
+        const configPath = this.getDisabledChartsConfigPath();
+        try {
+            const raw = await fs_1.promises.readFile(configPath, 'utf-8');
+            const yaml = require('js-yaml');
+            const parsed = yaml.load(raw);
+            const disabled = parsed?.disabled && typeof parsed.disabled === 'object'
+                ? parsed.disabled
+                : {};
+            const scriptsByView = this.mergeDisabledScriptsByView(this.parseDisabledScriptsByView(parsed?.scripts), this.parseDisabledScriptsByView(disabled.scripts));
+            const hasGalleryIgnoreSetting = Boolean((parsed && (Object.prototype.hasOwnProperty.call(parsed, 'galleryIgnore') || Object.prototype.hasOwnProperty.call(parsed, 'gallery_ignore')))
+                || (Object.prototype.hasOwnProperty.call(disabled, 'galleryIgnore') || Object.prototype.hasOwnProperty.call(disabled, 'gallery_ignore')));
+            const galleryIgnore = this.dedupeCaseInsensitive([
+                ...this.parseStringArray(parsed?.galleryIgnore),
+                ...this.parseStringArray(parsed?.gallery_ignore),
+                ...this.parseStringArray(disabled.galleryIgnore),
+                ...this.parseStringArray(disabled.gallery_ignore),
+            ]);
+            return {
+                scriptsByView,
+                charts: this.dedupeBasenames([
+                    ...this.parseStringArray(parsed?.charts),
+                    ...this.parseStringArray(disabled.charts),
+                ]),
+                galleryIgnore: hasGalleryIgnoreSetting
+                    ? galleryIgnore
+                    : [...AnalyticsDashboardProvider.DEFAULT_GALLERY_IGNORE],
+            };
+        }
+        catch {
+            return {
+                scriptsByView: {},
+                charts: [],
+                galleryIgnore: [...AnalyticsDashboardProvider.DEFAULT_GALLERY_IGNORE],
+            };
+        }
+    }
+    async postDisabledChartsState(disabledConfig) {
+        const resolvedConfig = disabledConfig ?? await this.loadDisabledChartsConfig();
+        this.webviewView?.webview.postMessage({
+            type: 'disabledChartsUpdated',
+            charts: resolvedConfig.charts,
+        });
+    }
+    async saveDisabledChartsConfig(config) {
+        const configPath = this.getDisabledChartsConfigPath();
+        await fs_1.promises.mkdir(path.dirname(configPath), { recursive: true });
+        const scriptsByView = {};
+        for (const [rawViewId, rawScripts] of Object.entries(config.scriptsByView)) {
+            const viewId = this.normalizeViewId(rawViewId, 'all');
+            const scripts = this.dedupeBasenames(rawScripts);
+            if (scripts.length > 0) {
+                scriptsByView[viewId] = scripts;
+            }
+        }
+        const yaml = require('js-yaml');
+        const content = yaml.dump({
+            scripts: scriptsByView,
+            charts: this.dedupeBasenames(config.charts),
+            galleryIgnore: this.dedupeCaseInsensitive(config.galleryIgnore),
+        }, { lineWidth: 120, noRefs: true });
+        await fs_1.promises.writeFile(configPath, content, 'utf-8');
+    }
+    isPathWithinDir(pathValue, dirPath) {
+        return (0, pathSafety_1.isPathUnderRoot)(dirPath, pathValue);
+    }
+    async disableChartByFilename(filename) {
+        const normalizedFilename = path.basename(filename.trim());
+        if (!normalizedFilename) {
+            return;
+        }
+        const disabledConfig = await this.loadDisabledChartsConfig();
+        const existing = new Set(disabledConfig.charts.map(name => this.normalizeBasename(name)));
+        const key = this.normalizeBasename(normalizedFilename);
+        if (!key || existing.has(key)) {
+            return;
+        }
+        await this.saveDisabledChartsConfig({
+            scriptsByView: disabledConfig.scriptsByView,
+            charts: [...disabledConfig.charts, normalizedFilename],
+            galleryIgnore: disabledConfig.galleryIgnore,
+        });
+        await this.postDisabledChartsState();
+    }
+    normalizePanelStateId(panelId) {
+        const normalized = (panelId ?? 'default')
+            .trim()
+            .toLowerCase()
+            .replace(/[^a-z0-9._-]+/g, '_')
+            .replace(/^_+|_+$/g, '');
+        return normalized || 'default';
+    }
+    getPanelStatePath(panelId) {
+        const scopedPanelId = this.getScopedPanelId(panelId);
+        return path.join(this.artifactManager.getAnalyticsRoot(), 'panel-state', `${scopedPanelId}.json`);
+    }
+    async loadPanelState(panelId) {
+        const statePath = this.getPanelStatePath(panelId);
+        try {
+            const raw = await fs_1.promises.readFile(statePath, 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch {
+            return {};
+        }
+    }
+    async savePanelState(panelId, state) {
+        const statePath = this.getPanelStatePath(panelId);
+        await fs_1.promises.mkdir(path.dirname(statePath), { recursive: true });
+        const payload = state && typeof state === 'object' ? state : {};
+        await fs_1.promises.writeFile(statePath, `${JSON.stringify(payload, null, 2)}\n`, 'utf-8');
+    }
+    async postPanelState(panelId) {
+        const normalizedPanelId = this.normalizePanelStateId(panelId);
+        const state = await this.loadPanelState(panelId);
+        const fleetInterval = Math.max(0, vscode.workspace.getConfiguration('agentide.analytics').get('fleetAutoRefreshIntervalSeconds', 0));
+        this.webviewView?.webview.postMessage({
+            type: 'panelStateLoaded',
+            panelId: normalizedPanelId,
+            state,
+            fleetAutoRefreshIntervalSeconds: fleetInterval,
+            surfaceMode: this.getSurfaceMode(),
+        });
+    }
+    async updateDataFreshnessHint(dataHint) {
+        const filters = this.getActiveFilters();
+        const hasData = dataHint?.hasData ?? await this.queryRunner.hasData(filters);
+        if (!hasData) {
+            this.webviewView?.webview.postMessage({ type: 'dataFresh' });
+            return;
+        }
+        const manifest = await this.artifactManager.getManifest();
+        const currentHash = dataHint?.dataHash ?? await this.queryRunner.getDataHash(filters);
+        if (!manifest) {
+            // No manifest yet; don't show stale hint until first generation.
+            this.webviewView?.webview.postMessage({ type: 'dataFresh' });
+            return;
+        }
+        if (manifest.dataHash !== currentHash) {
+            this.webviewView?.webview.postMessage({
+                type: 'dataStale',
+                generatedAt: manifest.generatedAt,
+            });
+        }
+        else {
+            this.webviewView?.webview.postMessage({ type: 'dataFresh' });
+        }
+    }
+    /** Panel visible: load artifacts, then apply refresh policy (see PLAN/spotlight-refresh-policy.md). */
+    async onPanelBecameVisible() {
+        await this.loadAndPostViewsState();
+        this.syncArtifactContext();
+        await this.postPanelState('default');
+        await this.seedWorkspaceScripts();
+        const bootstrapPromise = this.fetchDashboardBootstrapData();
+        // Load existing artifacts immediately; don't block chart refresh on summary queries.
+        await this.loadAndSendArtifacts();
+        await this.postPanelState('default');
+        await this.ensureChartsForCurrentFilterIfNeeded({ trigger: 'panel-open' });
+        await this.autoRefreshDefaultCharts();
+        const bootstrap = await bootstrapPromise;
+        await this.postFilterState(bootstrap?.agentIds);
+        this.triggerSummaryCardsUpdate(bootstrap?.summary);
+        await this.updateDataFreshnessHint(bootstrap ? { hasData: bootstrap.hasData, dataHash: bootstrap.dataHash } : undefined);
+    }
+    getFilterCacheKey(filters = this.getActiveFilters()) {
+        const scope = filters.scope === 'workspace' ? 'workspace' : 'global';
+        const projectId = filters.scope === 'workspace' ? (filters.projectId ?? '') : '';
+        const agentId = filters.agentId ?? '';
+        return `${scope}::${projectId}::${agentId}`;
+    }
+    pruneAutoGenerationHistory() {
+        if (this.autoGenerationAttemptByFilter.size <= MAX_FILTER_AUTOGEN_HISTORY) {
+            return;
+        }
+        const entries = [...this.autoGenerationAttemptByFilter.entries()]
+            .sort((a, b) => a[1] - b[1]);
+        const removeCount = this.autoGenerationAttemptByFilter.size - MAX_FILTER_AUTOGEN_HISTORY;
+        for (let i = 0; i < removeCount; i++) {
+            this.autoGenerationAttemptByFilter.delete(entries[i][0]);
+        }
+    }
+    scheduleAutoGenerateForCurrentFilter() {
+        if (this.pendingFilterAutoGenerateTimer) {
+            clearTimeout(this.pendingFilterAutoGenerateTimer);
+        }
+        const scheduledFilterKey = this.getFilterCacheKey();
+        this.pendingFilterAutoGenerateTimer = setTimeout(() => {
+            void this.ensureChartsForCurrentFilterIfNeeded({
+                trigger: 'filter-switch',
+                expectedFilterKey: scheduledFilterKey,
+                respectCooldown: true,
+            });
+        }, FILTER_AUTOGEN_DEBOUNCE_MS);
+    }
+    async ensureChartsForCurrentFilterIfNeeded(options) {
+        this.syncArtifactContext();
+        const filters = this.getActiveFilters();
+        const filterKey = this.getFilterCacheKey(filters);
+        if (options?.expectedFilterKey && options.expectedFilterKey !== filterKey) {
+            return;
+        }
+        if (this.isRefreshInProgress) {
+            return;
+        }
+        if (options?.respectCooldown) {
+            const lastAttempt = this.autoGenerationAttemptByFilter.get(filterKey) ?? 0;
+            if (Date.now() - lastAttempt < FILTER_AUTOGEN_COOLDOWN_MS) {
+                this.outputChannel.appendLine('[Dashboard] Auto-generation skipped (cooldown active)');
+                return;
+            }
+        }
+        const artifacts = await this.artifactManager.listArtifacts();
+        const hasCharts = artifacts.some(artifact => artifact.type === 'chart');
+        if (hasCharts) {
+            return;
+        }
+        const hasData = options?.hasDataHint ?? await this.queryRunner.hasData(filters);
+        if (!hasData) {
+            return;
+        }
+        this.autoGenerationAttemptByFilter.set(filterKey, Date.now());
+        this.pruneAutoGenerationHistory();
+        this.outputChannel.appendLine('[Dashboard] No cached charts for selected filters; auto-generating');
+        await this.refreshCharts();
+    }
+    /**
+     * Panel-open chart bootstrap: compute when empty; hint when stale (no silent regen).
+     * Aligns with PLAN/spotlight-refresh-policy.md — no manifest → refreshCharts;
+     * stale hash → dataStale; fresh → dataFresh.
+     */
+    async autoRefreshDefaultCharts(options) {
+        const config = vscode.workspace.getConfiguration('agentide.analytics');
+        const autoGenerate = config.get('autoGenerateDefaults', true);
+        if (!autoGenerate) {
+            return;
+        }
+        const filters = this.getActiveFilters();
+        const hasData = options?.hasDataHint ?? await this.queryRunner.hasData(filters);
+        if (!hasData) {
+            return;
+        }
+        const manifest = await this.artifactManager.getManifest();
+        const currentHash = options?.dataHashHint ?? await this.queryRunner.getDataHash(filters);
+        if (!manifest) {
+            // No manifest = first time; run the full script set (seeds + runs all
+            // widget scripts, not just generate-default-charts.py).
+            await this.refreshCharts();
+        }
+        else if (manifest.dataHash !== currentHash) {
+            // Data changed since last generation - notify user, don't auto-regenerate
+            this.webviewView?.webview.postMessage({
+                type: 'dataStale',
+                generatedAt: manifest.generatedAt,
+            });
+        }
+        else {
+            this.webviewView?.webview.postMessage({ type: 'dataFresh' });
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Default Chart Generation (script-based)
+    // -------------------------------------------------------------------------
+    /**
+     * Run the bundled Python script to generate default dashboard charts.
+     * This is fast and reliable - no agent/LLM needed.
+     */
+    async runDefaultChartScript(options) {
+        this.syncArtifactContext();
+        const preserveExistingContent = options?.preserveExistingContent ?? false;
+        let refreshOutcome = 'finished';
+        let refreshError = '';
+        // Cancel any in-flight chart generation before starting a new one.
+        // This sends SIGTERM to the Python/DuckDB subprocess via the AbortSignal,
+        // preventing stale processes from piling up when users click refresh rapidly.
+        this.generationAbortController?.abort();
+        this.generationAbortController = new AbortController();
+        // Notify if indexing is in progress
+        const indexingService = this.indexingService();
+        if (indexingService && indexingService.isIndexing()) {
+            this.outputChannel.appendLine('[Dashboard] Background DuckDB indexing in progress; using JSONL fallback for charts');
+            if (!preserveExistingContent) {
+                this.webviewView?.webview.postMessage({
+                    type: 'notifyIndexing',
+                    message: 'DuckDB index is being built in background. Charts will use JSONL for now (slower).',
+                });
+            }
+        }
+        if (preserveExistingContent) {
+            this.startSmoothRefresh({ batchArtifactUpdates: true });
+        }
+        else {
+            this.webviewView?.webview.postMessage({ type: 'generatingStarted' });
+        }
+        try {
+            const tracesDir = path.join((0, index_1.getAgentideHome)(), 'analytics', 'traces');
+            const outputDir = (await this.artifactManager.ensureArtifactDir()).fsPath;
+            const disabledConfig = await this.loadDisabledChartsConfig();
+            const scriptEnv = this.buildScriptEnvironment(outputDir, disabledConfig.charts);
+            // Find the chart generation script
+            const scriptPath = await this.findChartScript();
+            if (!scriptPath) {
+                throw new Error('Chart generation script not found');
+            }
+            this.outputChannel.appendLine(`[Dashboard] Running default chart script: ${scriptPath}`);
+            this.outputChannel.appendLine(`[Dashboard] Traces: ${tracesDir}, Output: ${outputDir}`);
+            // Run with dependency management via shared Python runner.
+            const deps = await this.readPythonDeps();
+            let result;
+            try {
+                const runResult = await (0, pythonRunner_1.runPythonWithDeps)({
+                    scriptPath,
+                    args: [tracesDir, outputDir],
+                    deps,
+                    analyticsRoot: this.artifactManager.getAnalyticsRoot(),
+                    requirementsPath: path.join(this.artifactManager.getScriptDir(), 'requirements.txt'),
+                    execOptions: {
+                        timeout: 60_000,
+                        maxBuffer: 5 * 1024 * 1024,
+                        env: scriptEnv,
+                        signal: this.generationAbortController?.signal,
+                    },
+                    log: (message) => this.outputChannel.appendLine(message),
+                });
+                result = { stdout: runResult.stdout, stderr: runResult.stderr };
+            }
+            catch (err) {
+                // generate-default-charts.py uses exit code 2 for "no data" but still
+                // prints JSON to stdout. Recover that stdout so we can handle no_data cleanly.
+                const stdout = err.stdout;
+                const stderr = err.stderr;
+                if (typeof stdout === 'string' && stdout.trim().startsWith('{')) {
+                    result = {
+                        stdout,
+                        stderr: typeof stderr === 'string' ? stderr : '',
+                    };
+                }
+                else {
+                    throw err;
+                }
+            }
+            if (result.stderr) {
+                this.outputChannel.appendLine(`[Dashboard] Chart script stderr: ${result.stderr}`);
+            }
+            // Parse result JSON
+            let scriptResult;
+            try {
+                scriptResult = JSON.parse(result.stdout);
+            }
+            catch {
+                throw new Error(`Script output not valid JSON: ${result.stdout.slice(0, 200)}`);
+            }
+            if (scriptResult.status === 'no_data') {
+                this.outputChannel.appendLine('[Dashboard] No trace data available');
+                if (!preserveExistingContent) {
+                    this.webviewView?.webview.postMessage({ type: 'generatingCancelled' });
+                }
+                else {
+                    refreshOutcome = 'noData';
+                }
+                return;
+            }
+            if (scriptResult.status !== 'ok') {
+                throw new Error(scriptResult.error || 'Chart generation failed');
+            }
+            // Build and save manifest
+            const dataHash = await this.queryRunner.getDataHash(this.getActiveFilters());
+            const manifestEntries = (scriptResult.charts ?? []).map(c => ({
+                filename: path.basename(c.file),
+                path: path.relative(outputDir, c.file),
+                type: 'chart',
+                source: 'default',
+                title: c.title,
+                createdAt: new Date().toISOString(),
+                generator: 'generate-default-charts.py',
+            }));
+            const manifest = {
+                version: 1,
+                generatedAt: scriptResult.generated_at || new Date().toISOString(),
+                dataHash,
+                prompt: 'auto-generated',
+                artifacts: manifestEntries,
+            };
+            await this.artifactManager.saveManifest(manifest);
+            await this.writeFleetExportForCurrentView();
+            this.outputChannel.appendLine(`[Dashboard] Generated ${manifestEntries.length} default charts`);
+            // Reload artifacts in panel
+            await this.loadAndSendArtifacts();
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === 'AbortError') {
+                if (!preserveExistingContent) {
+                    this.webviewView?.webview.postMessage({ type: 'generatingCancelled' });
+                }
+                else {
+                    refreshOutcome = 'failed';
+                    refreshError = 'Refresh cancelled';
+                }
+            }
+            else {
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                this.outputChannel.appendLine(`[Dashboard] Chart generation failed: ${errorMessage}`);
+                if (preserveExistingContent) {
+                    refreshOutcome = 'failed';
+                    refreshError = errorMessage;
+                }
+                else {
+                    this.webviewView?.webview.postMessage({
+                        type: 'generatingFailed',
+                        error: errorMessage,
+                    });
+                }
+            }
+        }
+        finally {
+            if (preserveExistingContent) {
+                try {
+                    await this.finishSmoothRefresh({ notifyFinished: false });
+                }
+                catch (finishErr) {
+                    this.outputChannel.appendLine(`[Dashboard] Failed finishing default-refresh state: ${finishErr}`);
+                    this.webviewView?.webview.postMessage({ type: 'refreshFinished' });
+                }
+                if (refreshOutcome === 'finished') {
+                    this.webviewView?.webview.postMessage({ type: 'refreshFinished' });
+                }
+                else if (refreshOutcome === 'noData') {
+                    this.webviewView?.webview.postMessage({ type: 'refreshNoData' });
+                }
+                else {
+                    this.webviewView?.webview.postMessage({
+                        type: 'refreshFailed',
+                        error: refreshError || 'Refresh failed',
+                    });
+                }
+            }
+            this.generationAbortController = undefined;
+        }
+    }
+    /**
+     * Find the chart generation script in bundled or dev locations.
+     */
+    async findChartScript() {
+        const candidates = this.getBundledAnalyticsScriptCandidates('generate-default-charts.py');
+        for (const candidate of candidates) {
+            try {
+                await fs_1.promises.access(candidate);
+                return candidate;
+            }
+            catch {
+                // Try next
+            }
+        }
+        return null;
+    }
+    async findBundledAnalyticsScript(filename) {
+        const candidates = this.getBundledAnalyticsScriptCandidates(filename);
+        for (const candidate of candidates) {
+            try {
+                await fs_1.promises.access(candidate);
+                return candidate;
+            }
+            catch {
+                // Try next.
+            }
+        }
+        return null;
+    }
+    getBundledAnalyticsScriptCandidates(filename) {
+        const extensionPath = this.extensionContext.extensionPath;
+        const runtimeRelativeCandidates = [
+            path.resolve(__dirname, '../../scripts', 'analytics', filename),
+            path.resolve(__dirname, '../../../scripts', 'analytics', filename),
+            path.resolve(__dirname, '../../../../extensions', 'agentide', 'scripts', 'analytics', filename),
+        ];
+        const extensionRelativeCandidates = [
+            path.join(extensionPath, 'out', 'scripts', 'analytics', filename),
+            path.join(extensionPath, 'scripts', 'analytics', filename),
+            path.join(extensionPath, '..', 'scripts', 'analytics', filename),
+            path.join(extensionPath, '..', '..', 'scripts', 'analytics', filename),
+            path.join(extensionPath, '..', '..', '..', 'extensions', 'agentide', 'scripts', 'analytics', filename),
+        ];
+        return [...new Set([...runtimeRelativeCandidates, ...extensionRelativeCandidates])];
+    }
+    async loadBundledDefaultSeedScriptNames() {
+        const fallbackScriptNames = [...FALLBACK_DEFAULT_SEED_SCRIPT_NAMES];
+        const registryPath = await this.findBundledAnalyticsScript(DEFAULT_SEED_REGISTRY_FILENAME);
+        if (!registryPath) {
+            this.outputChannel.appendLine(`[Dashboard] Missing default seed registry: ${DEFAULT_SEED_REGISTRY_FILENAME}. Using built-in defaults.`);
+            return fallbackScriptNames;
+        }
+        try {
+            const raw = await fs_1.promises.readFile(registryPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            const registryScriptNames = this.parseStringArray(parsed.seedScripts)
+                .map(entry => path.basename(entry))
+                .filter(Boolean);
+            if (registryScriptNames.length === 0) {
+                this.outputChannel.appendLine(`[Dashboard] Seed registry ${registryPath} had no scripts. Using built-in defaults.`);
+            }
+            return this.dedupeBasenames([...registryScriptNames, ...fallbackScriptNames]);
+        }
+        catch (err) {
+            this.outputChannel.appendLine(`[Dashboard] Failed reading seed registry ${registryPath}: ${err}`);
+            return fallbackScriptNames;
+        }
+    }
+    getDisabledChartsConfigPath() {
+        return path.join(this.artifactManager.getAnalyticsRoot(), 'disabled-charts.yaml');
+    }
+    hasDuplicateShebangMarkers(content) {
+        const shebangMatches = content.match(/^#!/gm);
+        return (shebangMatches?.length ?? 0) > 1;
+    }
+    hasStaleDuckDbLookup(filename, content) {
+        const targetScripts = new Set(['session-timeline-widget.js', 'session-comparison-widget.js', 'wow-model-widget.js']);
+        if (!targetScripts.has(filename)) {
+            return false;
+        }
+        const usesSharedLocator = content.includes(`require('./duckdbLocator')`);
+        const hasLegacyInlineFinder = content.includes('function findDuckdb()')
+            && content.includes("path.join(home, '.agent-hippo', 'bin', 'duckdb')");
+        const hasWindowsCandidate = content.includes('duckdb.exe');
+        const hasLegacyHomeLookup = content.includes("const home = process.env.HOME || ''");
+        // Repair stale seeded scripts that still use legacy inline lookup and miss
+        // current Windows-safe logic and shared helper import.
+        return !usesSharedLocator && (hasLegacyInlineFinder || hasLegacyHomeLookup || !hasWindowsCandidate);
+    }
+    async repairCorruptedBundledDefaultScripts(defaultScriptNames) {
+        const scriptsDir = this.artifactManager.getScriptDir();
+        let repairedCount = 0;
+        for (const rawFilename of defaultScriptNames) {
+            const filename = path.basename(rawFilename);
+            if (!filename) {
+                continue;
+            }
+            const destinationPath = path.join(scriptsDir, filename);
+            let content;
+            try {
+                content = await fs_1.promises.readFile(destinationPath, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            const needsShebangRepair = this.hasDuplicateShebangMarkers(content);
+            const needsDuckdbRepair = this.hasStaleDuckDbLookup(filename, content);
+            if (!needsShebangRepair && !needsDuckdbRepair) {
+                continue;
+            }
+            const sourcePath = await this.findBundledAnalyticsScript(filename);
+            if (!sourcePath) {
+                this.outputChannel.appendLine(`[Dashboard] Could not repair script ${filename}: source not found`);
+                continue;
+            }
+            if (path.resolve(sourcePath) === path.resolve(destinationPath)) {
+                continue;
+            }
+            try {
+                await fs_1.promises.copyFile(sourcePath, destinationPath);
+                repairedCount += 1;
+                const reason = needsShebangRepair ? 'duplicate shebang markers' : 'stale DuckDB lookup';
+                this.outputChannel.appendLine(`[Dashboard] Repaired default script ${filename} (${reason})`);
+            }
+            catch (err) {
+                this.outputChannel.appendLine(`[Dashboard] Failed repairing default script ${filename}: ${err}`);
+            }
+        }
+        return repairedCount;
+    }
+    /**
+     * Bundled DuckDB/chart scripts belong on Workspace-style views, not custom views
+     * (e.g. live-fleet-2) that declare their own script list.
+     */
+    viewNeedsBundledDefaultScripts(view, defaultScriptNames) {
+        if (view.scripts.length === 0) {
+            // System views with no scripts (Workspace) run every script on disk except Fleet widget.
+            return view.system === true && view.id !== 'fleet';
+        }
+        const defaultBasenames = new Set(defaultScriptNames.map(name => path.basename(name).toLowerCase()));
+        return this.dedupeBasenames(view.scripts).some(script => defaultBasenames.has(script.toLowerCase()));
+    }
+    async ensureBundledDefaultScriptsPresent() {
+        const defaultScriptNames = await this.loadBundledDefaultSeedScriptNames();
+        if (defaultScriptNames.length === 0) {
+            this.outputChannel.appendLine('[Dashboard] No default scripts listed in seed registry');
+            return;
+        }
+        const activeView = this.getActiveView();
+        if (!this.viewNeedsBundledDefaultScripts(activeView, defaultScriptNames)) {
+            return;
+        }
+        const existingScripts = await this.artifactManager.listScripts();
+        const existingByBasename = new Set(existingScripts.map(script => path.basename(script.filename).toLowerCase()));
+        const seedCandidates = [];
+        for (const filename of defaultScriptNames) {
+            if (existingByBasename.has(path.basename(filename).toLowerCase())) {
+                continue;
+            }
+            const sourcePath = await this.findBundledAnalyticsScript(filename);
+            if (sourcePath) {
+                seedCandidates.push({ sourcePath, filename });
+            }
+        }
+        if (seedCandidates.length > 0) {
+            await this.artifactManager.ensureSeedScripts(seedCandidates);
+            this.outputChannel.appendLine(`[Dashboard] Seeded ${seedCandidates.length} missing default script(s)`);
+        }
+        else {
+            this.outputChannel.appendLine(`[Dashboard] No missing default scripts were resolvable from extension path: ${this.extensionContext.extensionPath}`);
+        }
+        const repairedCount = await this.repairCorruptedBundledDefaultScripts(defaultScriptNames);
+        if (repairedCount > 0) {
+            this.outputChannel.appendLine(`[Dashboard] Repaired ${repairedCount} default script(s)`);
+        }
+    }
+    async seedWorkspaceScripts() {
+        // Seed requirements.txt for Python script dependencies
+        await this.seedRequirements();
+        // Seed disabled-charts config for script/chart opt-out.
+        await this.seedDisabledChartsConfig();
+        // Ensure all bundled default scripts exist; never overwrite user edits.
+        await this.ensureBundledDefaultScriptsPresent();
+        // Ensure widget log folder exists even before first refresh so users can
+        // verify where per-run JSONL logs will appear.
+        try {
+            await fs_1.promises.mkdir(this.getWidgetRunLogsDir(), { recursive: true });
+        }
+        catch (err) {
+            this.outputChannel.appendLine(`[Dashboard] Failed creating widget log directory: ${err}`);
+        }
+        // Seed panel files (panel.js, panel.css, panel.html) into .agent-hippo/analytics/panel/
+        await this.seedPanelFiles();
+    }
+    async seedDisabledChartsConfig() {
+        const configPath = this.getDisabledChartsConfigPath();
+        try {
+            await fs_1.promises.access(configPath);
+            return;
+        }
+        catch {
+            // Missing file; seed default template.
+        }
+        const template = [
+            '# Disable script execution or chart outputs without deleting files.',
+            '# scripts: per-view script filenames in analytics/views/<viewId>/scripts to skip running.',
+            '# Use "all" to apply to every view id.',
+            'scripts:',
+            '  all: []',
+            '  # all:',
+            '  #   - wow-model-widget.js',
+            '  # fleet:',
+            '  #   - agent-fleet-widget.js',
+            '# charts: output filenames in analytics/views/.../charts to disable/hide.',
+            'charts:',
+            '  # Hotspot analysis is opt-in by default; remove this entry to enable it.',
+            '  - hotspot-analysis-widget.html',
+            '# galleryIgnore: suffixes or exact filenames hidden from gallery cards.',
+            'galleryIgnore:',
+            `  - ${AnalyticsDashboardProvider.DEFAULT_GALLERY_IGNORE[0]}`,
+            `  - ${AnalyticsDashboardProvider.DEFAULT_GALLERY_IGNORE[1]}`,
+            '',
+        ].join('\n');
+        try {
+            await fs_1.promises.writeFile(configPath, template, 'utf-8');
+        }
+        catch (err) {
+            this.outputChannel.appendLine(`[Dashboard] Failed seeding disabled-charts.yaml: ${err}`);
+        }
+    }
+    /**
+     * Seed a default requirements.txt in the scripts directory.
+     * Users and agents can edit this file to add/remove Python dependencies.
+     * Non-destructive: never overwrites an existing file.
+     */
+    async seedRequirements() {
+        const scriptsDir = this.artifactManager.getScriptDir();
+        await fs_1.promises.mkdir(scriptsDir, { recursive: true });
+        const reqPath = path.join(scriptsDir, 'requirements.txt');
+        try {
+            await fs_1.promises.access(reqPath);
+            return; // Already exists, respect user edits.
+        }
+        catch {
+            // Missing, seed it.
+        }
+        try {
+            await fs_1.promises.writeFile(reqPath, [
+                '# Python dependencies for analytics scripts.',
+                '# Add packages here - they are auto-installed when scripts run.',
+                'matplotlib',
+                'duckdb',
+                '',
+            ].join('\n'), 'utf-8');
+        }
+        catch (err) {
+            this.outputChannel.appendLine(`[Dashboard] Failed seeding requirements.txt: ${err}`);
+        }
+    }
+    /**
+     * Seed default panel files from bundled webview assets into
+     * the user's analytics panel directory (.agent-hippo/analytics/panel/).
+     * Non-destructive: existing files are never overwritten.
+     */
+    async seedPanelFiles() {
+        const panelDir = this.getPanelDir();
+        await fs_1.promises.mkdir(panelDir, { recursive: true });
+        const webviewBasePath = this.getWebviewPath();
+        const bundledDir = path.join(this.extensionContext.extensionPath, webviewBasePath);
+        // Bundled source → user destination filename
+        const seedMap = [
+            { bundled: 'panel.js', userFile: 'panel.js' },
+            { bundled: 'styles.css', userFile: 'panel.css' },
+            { bundled: 'analytics-panel.html', userFile: 'panel.html' },
+        ];
+        for (const { bundled, userFile } of seedMap) {
+            const dest = path.join(panelDir, userFile);
+            try {
+                await fs_1.promises.access(dest);
+                continue; // Already exists, respect user modifications.
+            }
+            catch {
+                // Missing, seed it.
+            }
+            const source = path.join(bundledDir, bundled);
+            try {
+                await fs_1.promises.copyFile(source, dest);
+            }
+            catch (err) {
+                this.outputChannel.appendLine(`[Dashboard] Failed seeding panel file ${userFile}: ${err}`);
+            }
+        }
+        await this.patchUserPanelHtmlOnDisk();
+    }
+    /**
+     * Get the user's panel directory under the analytics root.
+     */
+    getPanelDir() {
+        return this.artifactManager.getPanelDir();
+    }
+    // -------------------------------------------------------------------------
+    // Refresh: re-run widget scripts (manual, Fleet, or "compute when empty")
+    // Policy: PLAN/spotlight-refresh-policy.md — manual + Fleet always enter here;
+    // navigation should gate before calling refreshCharts on view switch.
+    // -------------------------------------------------------------------------
+    /**
+     * Run assigned widget scripts for the active view (or requested view when provided).
+     * Writes artifacts and updates manifest.dataHash.
+     */
+    async refreshCharts(options) {
+        if (options?.viewId) {
+            const switched = await this.setActiveView(options.viewId);
+            if (!switched) {
+                this.outputChannel.appendLine(`[Dashboard] Ignoring refresh for unknown view: ${options.viewId}`);
+                return;
+            }
+        }
+        this.syncArtifactContext();
+        if (this.isRefreshInProgress) {
+            this.hasPendingRefreshRequest = true;
+            this.outputChannel.appendLine('[Dashboard] Refresh already running; queued one follow-up refresh');
+            return;
+        }
+        const refreshContext = this.getRefreshContext(options);
+        this.isRefreshInProgress = true;
+        let rerunRequested = false;
+        let logContext;
+        let refreshOutcome = 'ok';
+        let refreshOutcomeError = '';
+        try {
+            try {
+                logContext = await this.startWidgetRunLog();
+            }
+            catch (logErr) {
+                this.outputChannel.appendLine(`[Dashboard] Failed to initialize widget run log: ${logErr}`);
+            }
+            await this.ensureBundledDefaultScriptsPresent();
+            const disabledConfig = await this.loadDisabledChartsConfig();
+            const scriptSelection = await this.getScriptsForView(options);
+            const disabledScriptNames = new Set(this.getDisabledScriptsForView(disabledConfig, scriptSelection.view.id)
+                .map(name => this.normalizeBasename(name)));
+            const userScripts = scriptSelection.scripts.filter(script => !disabledScriptNames.has(this.normalizeBasename(script.filename)));
+            if (userScripts.length === 0) {
+                this.outputChannel.appendLine(`[Dashboard] No scripts assigned to view "${scriptSelection.view.name}"`);
+                await this.finishSmoothRefresh({ notifyFinished: false, refresh: options });
+                postToWebview(this.webviewView?.webview, { type: 'refreshNoData', viewId: refreshContext.viewId });
+                return;
+            }
+            this.startSmoothRefresh({ batchArtifactUpdates: false, refresh: options });
+            let refreshError = null;
+            let widgetRunResult = { totalScripts: 0, failedScripts: 0 };
+            try {
+                const hasFleetScript = userScripts.some(s => this.normalizeBasename(s.filename) === 'agent-fleet-widget.js');
+                if (hasFleetScript) {
+                    // Use latest DuckDB data (avoid 30s cache) and request a quick re-index so next refresh is fresher
+                    this.queryRunner.invalidateCache();
+                    this.indexingService()?.scheduleIndexing(true, { debounceMs: 500 });
+                    const activeView = this.getActiveView();
+                    await this.ensureViewOwnedDirectories(activeView);
+                    await this.writeFleetExportForCurrentView();
+                }
+                this.outputChannel.appendLine(`[Dashboard] Refreshing view "${scriptSelection.view.name}" via ${userScripts.length} script(s)`);
+                widgetRunResult = await this.runUserScripts(userScripts, disabledConfig.charts, logContext);
+                if (widgetRunResult.failedScripts > 0 && refreshOutcome === 'ok') {
+                    refreshOutcome = 'failed';
+                    refreshOutcomeError = `${widgetRunResult.failedScripts}/${widgetRunResult.totalScripts} widget scripts failed`;
+                }
+                const dataHash = await this.queryRunner.getDataHash(this.getActiveFilters());
+                const manifest = await this.artifactManager.getManifest() ?? {
+                    version: 1,
+                    generatedAt: new Date().toISOString(),
+                    dataHash,
+                    prompt: '',
+                    artifacts: [],
+                };
+                manifest.generatedAt = new Date().toISOString();
+                manifest.dataHash = dataHash;
+                await this.artifactManager.saveManifest(manifest);
+                if (this.shouldUpdateFleetExportAfterRefresh(hasFleetScript)) {
+                    await this.writeFleetExportForCurrentView();
+                }
+                await this.enqueueArtifactRefresh();
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                this.outputChannel.appendLine(`[Dashboard] Refresh failed: ${errorMessage}`);
+                refreshError = errorMessage;
+                refreshOutcome = errorMessage.toLowerCase().includes('cancel') ? 'cancelled' : 'failed';
+                refreshOutcomeError = errorMessage;
+            }
+            finally {
+                try {
+                    await this.finishSmoothRefresh({ notifyFinished: true, refresh: options });
+                }
+                catch (finishErr) {
+                    this.outputChannel.appendLine(`[Dashboard] Failed finishing refresh state: ${finishErr}`);
+                    this.postRefreshStatus('refreshFinished', options);
+                }
+                if (refreshError !== null) {
+                    postToWebview(this.webviewView?.webview, {
+                        type: 'refreshFailed',
+                        viewId: refreshContext.viewId,
+                        error: refreshError,
+                    });
+                }
+            }
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            this.outputChannel.appendLine(`[Dashboard] Refresh failed: ${errorMessage}`);
+            postToWebview(this.webviewView?.webview, {
+                type: 'refreshFailed',
+                viewId: refreshContext.viewId,
+                error: errorMessage,
+            });
+            this.postRefreshStatus('refreshFinished', options);
+            refreshOutcome = errorMessage.toLowerCase().includes('cancel') ? 'cancelled' : 'failed';
+            refreshOutcomeError = errorMessage;
+        }
+        finally {
+            try {
+                await this.finishWidgetRunLog(logContext, refreshOutcome, refreshOutcomeError);
+            }
+            catch (logErr) {
+                this.outputChannel.appendLine(`[Dashboard] Failed finalizing widget run log: ${logErr}`);
+            }
+            rerunRequested = this.hasPendingRefreshRequest;
+            this.hasPendingRefreshRequest = false;
+            this.isRefreshInProgress = false;
+        }
+        if (rerunRequested) {
+            this.outputChannel.appendLine('[Dashboard] Running queued follow-up refresh');
+            await this.refreshCharts({ viewId: this.getActiveViewId() });
+        }
+    }
+    async refreshWidgetScriptsOnly(requestedScripts) {
+        const normalizedRequested = Array.from(new Set(requestedScripts
+            .map(script => this.normalizeBasename(script))
+            .filter(script => !!script)));
+        if (normalizedRequested.length === 0) {
+            return;
+        }
+        const refreshContext = {
+            viewId: this.getActiveViewId(),
+            viewName: this.getActiveView().name,
+        };
+        this.startSmoothRefresh({
+            batchArtifactUpdates: true,
+            refresh: refreshContext,
+        });
+        try {
+            this.syncArtifactContext();
+            await this.ensureBundledDefaultScriptsPresent();
+            const requestedSet = new Set(normalizedRequested);
+            const isFleetWidgetRefresh = requestedSet.has('agent-fleet-widget.js') && this.getActiveViewId() === 'fleet';
+            if (isFleetWidgetRefresh) {
+                const activeView = this.getActiveView();
+                await this.ensureViewOwnedDirectories(activeView);
+                await this.writeFleetExportForCurrentView();
+            }
+            const scriptSelection = await this.getScriptsForView({ viewId: this.getActiveViewId() });
+            const disabledConfig = await this.loadDisabledChartsConfig();
+            const disabledScriptNames = new Set(this.getDisabledScriptsForView(disabledConfig, scriptSelection.view.id)
+                .map(name => this.normalizeBasename(name)));
+            const scriptsToRun = scriptSelection.scripts.filter(script => requestedSet.has(this.normalizeBasename(script.filename))
+                && !disabledScriptNames.has(this.normalizeBasename(script.filename)));
+            if (scriptsToRun.length === 0) {
+                await this.enqueueArtifactRefresh();
+                await this.postViewExportSnapshot({ respondWhenMissing: true });
+                return;
+            }
+            await this.runUserScripts(scriptsToRun, disabledConfig.charts);
+            if (isFleetWidgetRefresh) {
+                // Bump version so non-preserveFleetIframe paths reload the iframe. preserveFleetIframe
+                // views (the default for fleet-dashboard layout) ignore this and rely on the
+                // viewExportSnapshot postMessage from postViewExportSnapshot below — the widget's
+                // DOM-diff renderer applies updates in-place without flicker.
+                this.fleetRefreshVersion += 1;
+            }
+            await this.enqueueArtifactRefresh();
+            await this.postViewExportSnapshot({ respondWhenMissing: true });
+        }
+        finally {
+            await this.finishSmoothRefresh({
+                notifyFinished: true,
+                refresh: refreshContext,
+            });
+        }
+    }
+    /**
+     * Run user-created scripts from <workspace>/.agent-hippo/analytics/views/<viewId>/scripts/.
+     * Each script receives env vars for traces dir and output dirs.
+     */
+    isDuckDbHeavyScript(script) {
+        return this.duckDbHeavyScriptNames.has(path.basename(script.filename).toLowerCase());
+    }
+    getWidgetRunLogsDir() {
+        return path.join(this.artifactManager.getAnalyticsRoot(), 'logs', 'widgets');
+    }
+    createWidgetRunId() {
+        const now = new Date();
+        const ts = now.toISOString().replace(/[:.]/g, '-');
+        const nonce = Math.random().toString(36).slice(2, 8);
+        return `refresh-${ts}-${nonce}`;
+    }
+    async appendWidgetRunLogLine(logPath, payload) {
+        const serialized = `${JSON.stringify(payload)}\n`;
+        await fs_1.promises.appendFile(logPath, serialized, 'utf-8');
+    }
+    /** Fleet export is only needed for the Fleet view or views that run agent-fleet-widget.js. */
+    shouldUpdateFleetExportAfterRefresh(hasFleetScript) {
+        return this.getActiveViewId() === 'fleet' || hasFleetScript;
+    }
+    async writeFleetExportForCurrentView() {
+        const filters = this.getActiveFilters();
+        const exportPath = path.join(this.artifactManager.getExportDir(), AnalyticsDashboardProvider.FLEET_EXPORT_FILENAME);
+        const normalizeSessionsForCompare = (sessions) => {
+            if (!Array.isArray(sessions)) {
+                return [];
+            }
+            return sessions
+                .map((s) => (s && typeof s === 'object' ? s : null))
+                .filter((s) => Boolean(s))
+                .slice()
+                .sort((a, b) => {
+                const rankDiff = (0, fleetTypes_1.rankFleetStatus)(a.status) - (0, fleetTypes_1.rankFleetStatus)(b.status);
+                if (rankDiff !== 0) {
+                    return rankDiff;
+                }
+                const aStarted = Date.parse(String(a.startedAt ?? ''));
+                const bStarted = Date.parse(String(b.startedAt ?? ''));
+                if (Number.isFinite(aStarted) && Number.isFinite(bStarted) && aStarted !== bStarted) {
+                    return bStarted - aStarted;
+                }
+                return String(a.sessionId ?? '').localeCompare(String(b.sessionId ?? ''));
+            });
+        };
+        const comparableFromPayload = (payload) => ({
+            scope: payload.scope ?? 'global',
+            projectId: payload.projectId ?? '',
+            agentId: payload.agentId ?? '',
+            totals: payload.totals ?? {},
+            sessions: normalizeSessionsForCompare(payload.sessions),
+        });
+        const readComparable = async () => {
+            try {
+                const raw = await fs_1.promises.readFile(exportPath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                return JSON.stringify(comparableFromPayload(parsed));
+            }
+            catch {
+                return null;
+            }
+        };
+        const previousComparable = await readComparable();
+        try {
+            const result = await (0, fleetOrchestrator_1.runFleetRefresh)({ scope: filters.scope ?? 'global', projectId: filters.projectId, agentId: filters.agentId }, {
+                queryRunner: this.queryRunner,
+                exportPath,
+                onError: (sourceId, err) => {
+                    this.outputChannel.appendLine(`[Dashboard] Fleet source "${sourceId}" failed: ${String(err)}`);
+                },
+            });
+            if (!result.success) {
+                this.outputChannel.appendLine(`[Dashboard] Fleet refresh completed with source errors (failed: ${result.failedSources.join(', ') || 'none'}).`);
+            }
+        }
+        catch (err) {
+            this.outputChannel.appendLine(`[Dashboard] Fleet refresh failed: ${err}`);
+            return;
+        }
+        const nextComparable = await readComparable();
+        const meaningfulChange = previousComparable === null || nextComparable !== previousComparable;
+        if (meaningfulChange && this.getActiveViewId() === 'fleet') {
+            this.fleetRefreshVersion += 1;
+            // Regenerate agent-fleet.html from the updated JSON so gallery mtime and iframe content stay in sync.
+            await this.refreshFleetWidgetFromCurrentExport();
+            // During refreshCharts, the outer flow calls enqueueArtifactRefresh after scripts; skip mid-refresh to avoid flicker.
+            if (!this.isRefreshInProgress) {
+                await this.enqueueArtifactRefresh();
+            }
+        }
+    }
+    async handleFleetCardTitleUpdate(sourceId, sessionIdValue, cardTitleValue) {
+        const sessionId = String(sessionIdValue ?? '').trim();
+        if (!sessionId) {
+            return;
+        }
+        const cardTitle = String(cardTitleValue ?? '').trim();
+        const fleetTitleLogPaths = Array.from(new Set([
+            path.join((0, index_1.getAgentideHome)(), 'analytics', 'fleet-title-updates.log'),
+            path.join(this.artifactManager.getAnalyticsRoot(), 'fleet-title-updates.log'),
+        ]));
+        const logLine = async (status, err) => {
+            const message = `${new Date().toISOString()}\tsessionId=${sessionId}\tcardTitle=${JSON.stringify(cardTitle)}\t${status}`;
+            const extra = err !== undefined ? `\terror=${String(err)}` : '';
+            await Promise.all(fleetTitleLogPaths.map(async (p) => {
+                await fs_1.promises.mkdir(path.dirname(p), { recursive: true });
+                await fs_1.promises.appendFile(p, `${message}${extra}\n`, 'utf-8').catch(() => undefined);
+            }));
+        };
+        await logLine('requested');
+        try {
+            await this.queryRunner.updateFleetCardTitle(sourceId, sessionId, cardTitle);
+            // Ensure widget export/html reflect the persisted title (writeFleetExport regenerates HTML when Fleet is active).
+            await this.writeFleetExportForCurrentView();
+            await logLine('persisted');
+            this.outputChannel.appendLine(`[Dashboard] Fleet title edit persisted for session=${sessionId}`);
+        }
+        catch (err) {
+            await logLine('failed', err);
+            this.outputChannel.appendLine(`[Dashboard] Fleet title edit failed for session=${sessionId}: ${err}`);
+        }
+    }
+    async refreshFleetWidgetFromCurrentExport() {
+        const activeViewId = this.getActiveViewId();
+        if (activeViewId !== 'fleet') {
+            return;
+        }
+        const activeView = this.getActiveView();
+        if (!activeView) {
+            return;
+        }
+        this.syncArtifactContext();
+        await this.ensureBundledDefaultScriptsPresent();
+        await this.ensureViewOwnedDirectories(activeView);
+        const scriptSelection = await this.getScriptsForView({ viewId: activeViewId });
+        const disabledConfig = await this.loadDisabledChartsConfig();
+        const disabledScriptNames = new Set(this.getDisabledScriptsForView(disabledConfig, scriptSelection.view.id)
+            .map(name => this.normalizeBasename(name)));
+        const scriptsToRun = scriptSelection.scripts.filter(script => {
+            const basename = this.normalizeBasename(script.filename);
+            return basename === 'agent-fleet-widget.js' && !disabledScriptNames.has(basename);
+        });
+        await this.runUserScripts(scriptsToRun, disabledConfig.charts);
+    }
+    buildFleetDisconnectPrompt(sessionId, channelType, channelTarget) {
+        const safeSessionId = sessionId.trim();
+        const safeChannelType = (channelType ?? '').trim() || 'unknown';
+        const safeChannelTarget = (channelTarget ?? '').trim();
+        return [
+            'Disconnect this Agent Anywhere channel session.',
+            `Session ID: ${safeSessionId}`,
+            `Channel Type: ${safeChannelType}`,
+            safeChannelTarget ? `Channel Target: ${safeChannelTarget}` : '',
+            'If direct disconnect tooling is unavailable, provide the exact command/workflow to disconnect safely.',
+        ].filter(Boolean).join('\n');
+    }
+    async handleFleetDisconnectRequest(sessionIdValue, channelType, channelTarget) {
+        const sessionId = sessionIdValue.trim();
+        if (!sessionId) {
+            return;
+        }
+        const choice = await vscode.window.showWarningMessage(`Disconnect channel for session ${sessionId}?`, { modal: true }, 'Disconnect');
+        if (choice !== 'Disconnect') {
+            return;
+        }
+        await this.openVsCodeChat({
+            prompt: this.buildFleetDisconnectPrompt(sessionId, channelType, channelTarget),
+        });
+    }
+    /**
+     * Builds the VS Code chat session resource URI for a local session id.
+     * Matches workbench LocalChatSessionUri: vscode-chat-session://local/{base64url(sessionId)}
+     */
+    buildLocalChatSessionResource(sessionId) {
+        const base64url = Buffer.from(sessionId, 'utf-8')
+            .toString('base64')
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=+$/, '');
+        return `vscode-chat-session://local/${base64url}`;
+    }
+    async resolveFleetSessionOpenPreferences(sessionId, model, engine, agentId, taskTitle) {
+        const row = (0, fleetRowDefaults_1.buildFleetSessionRow)('local', {
+            sessionId,
+            agentId,
+            status: 'in_progress',
+            startedAt: new Date().toISOString(),
+            endedAt: '',
+            taskTitle: String(taskTitle ?? '').trim() || sessionId,
+            model: String(model ?? '').trim() || 'unknown',
+            engine: String(engine ?? '').trim(),
+            channelType: 'none',
+            channelTarget: '',
+            turns: 0,
+            totalTokens: 0,
+        });
+        if (!taskTitle?.trim()) {
+            try {
+                const titleMap = await vscode.commands.executeCommand('agentide.resolveFleetSessionTitles', [sessionId]);
+                const resolved = typeof titleMap?.[sessionId] === 'string' ? titleMap[sessionId].trim() : '';
+                if (resolved) {
+                    row.taskTitle = resolved;
+                    row.cardTitle = row.cardTitle ?? resolved;
+                }
+            }
+            catch {
+                // Workbench command unavailable outside AgentHippo builds.
+            }
+        }
+        (0, fleetDisplayUtils_1.enrichFleetRowMetadata)(row);
+        return {
+            model: row.model,
+            engine: row.engine,
+            modeName: (0, fleetDisplayUtils_1.fleetEngineIdToChatModeName)(row.engine),
+        };
+    }
+    /**
+     * Opens the actual chat session by id in this workspace when it exists;
+     * otherwise opens chat with a prompt to investigate the session.
+     */
+    async openSpotlightForSession(sessionIdValue, channelType, channelTarget, model, engine, agentId) {
+        let sessionId = sessionIdValue.trim();
+        if (!sessionId) {
+            return;
+        }
+        // Fleet schedule cards use sessionId schedule:<id>; channelTarget stores the chat session id.
+        if (sessionId.startsWith('schedule:')) {
+            const linked = String(channelTarget ?? '').trim();
+            if (linked) {
+                sessionId = linked;
+            }
+        }
+        const sessionResource = this.buildLocalChatSessionResource(sessionId);
+        const resolved = await this.resolveFleetSessionOpenPreferences(sessionId, model, engine, agentId);
+        const preferredModel = resolved.model;
+        const preferredEngine = resolved.engine;
+        const packId = String(agentId ?? '').trim() || 'default';
+        const fallbackPrompt = [
+            'Show the session investigation for this agent session.',
+            `Session ID: ${sessionId}`,
+            channelType ? `Channel: ${channelType}` : '',
+            channelTarget ? `Target: ${channelTarget}` : '',
+            'Include: the live chat transcript, a chronological feed of the agent\'s actions/logs, and the exact prompt or payload that initiated the task.',
+        ].filter(Boolean).join('\n');
+        try {
+            await vscode.commands.executeCommand('workbench.action.chat.open', {
+                sessionResource,
+                mode: resolved.modeName ?? 'agent',
+            });
+            // Restore engine/model from fleet card (scheduled jobs often have no DuckDB token rows).
+            for (let attempt = 0; attempt < 5; attempt += 1) {
+                await new Promise(resolve => setTimeout(resolve, attempt === 0 ? 150 : 100));
+                const chatState = await vscode.commands.executeCommand('agentide.getChatState');
+                const activeSessionId = chatState?.sessionId?.trim() ?? '';
+                if (activeSessionId !== sessionId) {
+                    continue;
+                }
+                await this.applyFleetSessionChatPreferences(packId, preferredEngine, preferredModel);
+                return;
+            }
+            await this.applyFleetSessionChatPreferences(packId, preferredEngine, preferredModel);
+            // workbench.action.chat.open may silently fall back to current session when sessionResource is unknown.
+            // Verify active session and use prompt fallback if we didn't land on the requested id.
+            const chatState = await vscode.commands.executeCommand('agentide.getChatState');
+            const activeSessionId = chatState?.sessionId?.trim() ?? '';
+            if (activeSessionId === sessionId) {
+                return;
+            }
+            this.outputChannel.appendLine(`[Dashboard] Could not open session ${sessionId} directly (active=${activeSessionId || 'unknown'}); falling back to investigation prompt`);
+            await this.openVsCodeChat({ prompt: fallbackPrompt });
+        }
+        catch {
+            // Session may not exist in this workspace; fall back to opening chat with investigation prompt.
+            await this.openVsCodeChat({ prompt: fallbackPrompt });
+        }
+    }
+    async applyFleetSessionChatPreferences(packId, preferredEngine, preferredModel) {
+        if (!preferredEngine && !preferredModel) {
+            return;
+        }
+        try {
+            await vscode.commands.executeCommand('agentide.applyPackPreferences', {
+                packId,
+                preferredEngine: preferredEngine || undefined,
+                preferredModel: preferredModel || undefined,
+                silent: true,
+            });
+        }
+        catch (err) {
+            this.outputChannel.appendLine(`[Dashboard] Could not restore fleet session engine/model: ${err}`);
+        }
+    }
+    async startWidgetRunLog() {
+        const logsDir = this.getWidgetRunLogsDir();
+        await fs_1.promises.mkdir(logsDir, { recursive: true });
+        await this.trimOldWidgetRunLogs();
+        const runId = this.createWidgetRunId();
+        const logPath = path.join(logsDir, `${runId}.jsonl`);
+        const startedAt = new Date().toISOString();
+        const filters = this.getActiveFilters();
+        await this.appendWidgetRunLogLine(logPath, {
+            type: 'refresh_started',
+            runId,
+            startedAt,
+            scope: filters.scope,
+            projectId: filters.projectId ?? '',
+            agentId: filters.agentId ?? '',
+        });
+        this.outputChannel.appendLine(`[Dashboard] Widget refresh log: ${logPath}`);
+        return { runId, logPath, startedAt };
+    }
+    async trimOldWidgetRunLogs() {
+        const logsDir = this.getWidgetRunLogsDir();
+        let entries = [];
+        try {
+            const dirEntries = await fs_1.promises.readdir(logsDir, { withFileTypes: true });
+            entries = await Promise.all(dirEntries
+                .filter(entry => entry.isFile() && entry.name.endsWith('.jsonl'))
+                .map(async (entry) => {
+                const fullPath = path.join(logsDir, entry.name);
+                const stat = await fs_1.promises.stat(fullPath);
+                return { name: entry.name, fullPath, mtimeMs: stat.mtimeMs };
+            }));
+        }
+        catch {
+            return;
+        }
+        if (entries.length <= WIDGET_RUN_LOG_RETENTION_COUNT) {
+            return;
+        }
+        entries.sort((a, b) => b.mtimeMs - a.mtimeMs);
+        const stale = entries.slice(WIDGET_RUN_LOG_RETENTION_COUNT);
+        await Promise.all(stale.map(entry => fs_1.promises.unlink(entry.fullPath).catch(() => undefined)));
+    }
+    async finishWidgetRunLog(context, status, error) {
+        if (!context) {
+            return;
+        }
+        await this.appendWidgetRunLogLine(context.logPath, {
+            type: 'refresh_finished',
+            runId: context.runId,
+            status,
+            endedAt: new Date().toISOString(),
+            error: error ?? '',
+        });
+    }
+    async acquireDuckDbScriptSlot(script) {
+        if (!this.isDuckDbHeavyScript(script)) {
+            return;
+        }
+        while (this.activeDuckDbScriptCount >= 1) {
+            await new Promise(resolve => this.duckDbScriptWaiters.push(resolve));
+        }
+        this.activeDuckDbScriptCount += 1;
+        this.outputChannel.appendLine(`[Dashboard] DuckDB gate acquired: ${script.filename}`);
+    }
+    releaseDuckDbScriptSlot(script) {
+        if (!this.isDuckDbHeavyScript(script)) {
+            return;
+        }
+        this.activeDuckDbScriptCount = Math.max(0, this.activeDuckDbScriptCount - 1);
+        this.outputChannel.appendLine(`[Dashboard] DuckDB gate released: ${script.filename}`);
+        const next = this.duckDbScriptWaiters.shift();
+        next?.();
+    }
+    async runUserScripts(scripts, disabledCharts, logContext) {
+        this.syncArtifactContext();
+        const outputDir = (await this.artifactManager.ensureArtifactDir()).fsPath;
+        if (scripts.length === 0) {
+            this.outputChannel.appendLine('[Dashboard] All scripts disabled; nothing to run');
+            return { totalScripts: 0, failedScripts: 0 };
+        }
+        // Seed requirements.txt only when this run includes Python widgets.
+        if (scripts.some(script => script.filename.toLowerCase().endsWith('.py'))) {
+            await this.seedRequirements();
+        }
+        const env = this.buildScriptEnvironment(outputDir, disabledCharts);
+        const maxConcurrency = Math.max(1, Math.min(USER_SCRIPT_MAX_CONCURRENCY, scripts.length));
+        const failures = [];
+        let nextScriptIndex = 0;
+        const worker = async () => {
+            while (true) {
+                const currentIndex = nextScriptIndex++;
+                if (currentIndex >= scripts.length) {
+                    return;
+                }
+                const script = scripts[currentIndex];
+                const scriptStartedAtMs = Date.now();
+                let acquiredDuckDbSlot = false;
+                let duckDbGateWaitMs = 0;
+                let scriptStatus = 'ok';
+                let scriptError = '';
+                let scriptStdout = '';
+                let scriptStderr = '';
+                try {
+                    const gateWaitStartedAtMs = Date.now();
+                    await this.acquireDuckDbScriptSlot(script);
+                    duckDbGateWaitMs = Date.now() - gateWaitStartedAtMs;
+                    acquiredDuckDbSlot = true;
+                    const executionResult = await this.executeUserScript(script, env);
+                    scriptStdout = executionResult.stdout;
+                    scriptStderr = executionResult.stderr;
+                }
+                catch (error) {
+                    scriptStatus = 'failed';
+                    scriptError = error instanceof Error ? error.message : String(error);
+                    failures.push({ script, error });
+                }
+                finally {
+                    if (acquiredDuckDbSlot) {
+                        this.releaseDuckDbScriptSlot(script);
+                    }
+                    if (logContext) {
+                        try {
+                            const finishedAt = new Date().toISOString();
+                            const durationMs = Date.now() - scriptStartedAtMs;
+                            const filters = this.getActiveFilters();
+                            await this.appendWidgetRunLogLine(logContext.logPath, {
+                                type: 'script_run',
+                                runId: logContext.runId,
+                                script: script.filename,
+                                language: script.language,
+                                status: scriptStatus,
+                                error: scriptError,
+                                stdout: scriptStdout,
+                                stderr: scriptStderr,
+                                durationMs,
+                                duckDbGateWaitMs,
+                                finishedAt,
+                                scope: filters.scope,
+                                projectId: filters.projectId ?? '',
+                                agentId: filters.agentId ?? '',
+                            });
+                        }
+                        catch (logErr) {
+                            this.outputChannel.appendLine(`[Dashboard] Failed writing script run log: ${logErr}`);
+                        }
+                    }
+                    // Queue artifact refresh after each script; during smooth refresh
+                    // this is batched and emitted once at the end to avoid HTML flicker.
+                    await this.enqueueArtifactRefresh();
+                }
+            }
+        };
+        await Promise.all(Array.from({ length: maxConcurrency }, () => worker()));
+        if (failures.length === scripts.length) {
+            throw new Error('All refresh scripts failed. Check output logs for details.');
+        }
+        if (failures.length > 0) {
+            this.outputChannel.appendLine(`[Dashboard] Refresh completed with ${failures.length} script failure(s)`);
+            for (const failure of failures) {
+                const message = failure.error instanceof Error ? failure.error.message : String(failure.error);
+                this.outputChannel.appendLine(`[Dashboard] Script failed: ${failure.script.filename}: ${message}`);
+            }
+        }
+        return { totalScripts: scripts.length, failedScripts: failures.length };
+    }
+    isJavascriptEsmScopeError(error) {
+        const stderr = typeof error.stderr === 'string'
+            ? error.stderr
+            : '';
+        const message = error instanceof Error ? error.message : String(error);
+        const haystack = [message, stderr].join('\n').toLowerCase();
+        return haystack.includes('require is not defined in es module scope')
+            || haystack.includes('module is not defined in es module scope')
+            || haystack.includes('exports is not defined in es module scope');
+    }
+    async runJavascriptWithCommonJsRetry(scriptPath, execOpts) {
+        try {
+            return await execFileAsync('node', [scriptPath], execOpts);
+        }
+        catch (err) {
+            const extension = path.extname(scriptPath).toLowerCase();
+            if (extension !== '.js' || !this.isJavascriptEsmScopeError(err)) {
+                throw err;
+            }
+            const parsed = path.parse(scriptPath);
+            this.outputChannel.appendLine(`[Dashboard] Retrying JavaScript script as CommonJS: ${parsed.base}`);
+            const sandboxRoot = await fs_1.promises.mkdtemp(path.join(os.tmpdir(), `agentide-cjs-run-${parsed.name}-`));
+            const sandboxScriptsDir = path.join(sandboxRoot, 'scripts');
+            const sandboxScriptPath = path.join(sandboxScriptsDir, parsed.base);
+            try {
+                // Copy the whole script directory into a sandbox and force CommonJS mode there.
+                // This keeps relative requires (e.g. ./duckdbLocator) working on both Unix and Windows.
+                await fs_1.promises.cp(parsed.dir, sandboxScriptsDir, { recursive: true });
+                await fs_1.promises.writeFile(path.join(sandboxScriptsDir, 'package.json'), JSON.stringify({ type: 'commonjs' }), 'utf-8');
+                return await execFileAsync('node', [sandboxScriptPath], execOpts);
+            }
+            finally {
+                await fs_1.promises.rm(sandboxRoot, { recursive: true, force: true }).catch(() => undefined);
+            }
+        }
+    }
+    async executeUserScript(script, env) {
+        const scriptPath = script.uri.fsPath;
+        this.outputChannel.appendLine(`[Dashboard] Running user script: ${script.filename}`);
+        const execOpts = { timeout: 60_000, maxBuffer: 5 * 1024 * 1024, env };
+        let result;
+        switch (script.language) {
+            case 'python':
+                {
+                    const deps = await this.readPythonDeps();
+                    const runResult = await (0, pythonRunner_1.runPythonWithDeps)({
+                        scriptPath,
+                        args: [],
+                        deps,
+                        analyticsRoot: this.artifactManager.getAnalyticsRoot(),
+                        requirementsPath: path.join(this.artifactManager.getScriptDir(), 'requirements.txt'),
+                        execOptions: execOpts,
+                        log: (message) => this.outputChannel.appendLine(message),
+                    });
+                    result = { stdout: runResult.stdout, stderr: runResult.stderr };
+                }
+                break;
+            case 'javascript':
+                result = await this.runJavascriptWithCommonJsRetry(scriptPath, execOpts);
+                break;
+            case 'shell':
+                result = await execFileAsync('bash', [scriptPath], execOpts);
+                break;
+            default:
+                throw new Error(`Unsupported script language: ${script.language}`);
+        }
+        if (result.stderr) {
+            this.outputChannel.appendLine(`[Dashboard] ${script.filename} stderr: ${result.stderr.slice(0, 500)}`);
+        }
+        if (result.stdout) {
+            this.outputChannel.appendLine(`[Dashboard] ${script.filename} output: ${result.stdout.slice(0, 300)}`);
+        }
+        return result;
+    }
+    // -------------------------------------------------------------------------
+    // Python Dependency Management
+    // -------------------------------------------------------------------------
+    /**
+     * Run a Python script with automatic dependency resolution.
+     * Chain: uv run --with <deps> → pip install --user + python3 → actionable error.
+     */
+    /**
+     * Read Python dependencies from .agent-hippo/analytics/views/<viewId>/scripts/requirements.txt.
+     * Returns an empty array if the file doesn't exist.
+     */
+    async readPythonDeps() {
+        const reqFile = path.join(this.artifactManager.getScriptDir(), 'requirements.txt');
+        try {
+            const content = await fs_1.promises.readFile(reqFile, 'utf-8');
+            return content
+                .split('\n')
+                .map(line => line.replace(/#.*$/, '').trim()) // strip comments
+                .filter(line => line.length > 0);
+        }
+        catch {
+            return []; // no requirements.txt
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Summary Cards
+    // -------------------------------------------------------------------------
+    async sendSummaryCards(summaryOverride) {
+        try {
+            const summary = summaryOverride ?? await this.queryRunner.getCostSummary(this.getActiveFilters());
+            const cards = [
+                { label: 'Total Cost', value: `$${summary.totalCost.toFixed(2)}`, icon: '\u{1F4B0}' },
+                { label: 'Requests', value: summary.totalRequests.toLocaleString(), icon: '\u{1F4CA}' },
+                { label: 'Avg Latency', value: `${Math.round(summary.avgDurationMs)}ms`, icon: '\u26A1' },
+                { label: 'Top Model', value: this.formatModelName(summary.topModel), icon: '\u{1F916}' },
+            ];
+            this.webviewView?.webview.postMessage({
+                type: 'summaryCards',
+                cards,
+            });
+        }
+        catch (err) {
+            // Keep the previous summary cards on errors (for example during scope
+            // transitions) instead of replacing with a misleading zeroed snapshot.
+            this.outputChannel.appendLine(`[Dashboard] Could not load summary: ${err}`);
+        }
+    }
+    formatModelName(model) {
+        if (!model || model === 'unknown') {
+            return '-';
+        }
+        // Shorten model names for display
+        return model
+            .replace('claude-', '')
+            .replace('gpt-', '')
+            .replace('-20', '')
+            .slice(0, 12);
+    }
+    // -------------------------------------------------------------------------
+    // Artifact Management
+    // -------------------------------------------------------------------------
+    /**
+     * Fleet widget outputs `agent-fleet.html` / `agent-fleet.csv` in the active view charts dir.
+     * Global and Workspace should not show those cards (Fleet view only), including stale files
+     * left from older configs that ran the fleet script on every view.
+     */
+    filterFleetGalleryArtifactsForActiveView(artifacts) {
+        const id = this.getActiveViewId();
+        if (id !== 'global' && id !== 'workspace') {
+            return artifacts;
+        }
+        return artifacts.filter((a) => {
+            const n = a.filename.trim().toLowerCase();
+            return n !== 'agent-fleet.html' && n !== 'agent-fleet.csv';
+        });
+    }
+    async loadAndSendArtifacts() {
+        this.syncArtifactContext();
+        const [rawArtifacts, disabledConfig] = await Promise.all([
+            this.artifactManager.listArtifacts(),
+            this.loadDisabledChartsConfig(),
+        ]);
+        const artifacts = this.filterFleetGalleryArtifactsForActiveView(rawArtifacts);
+        this.sendArtifactsToWebview(artifacts, disabledConfig.galleryIgnore);
+        await this.postDisabledChartsState(disabledConfig);
+        // Also send manifest
+        const manifest = await this.artifactManager.getManifest();
+        if (manifest) {
+            this.webviewView?.webview.postMessage({
+                type: 'manifestUpdated',
+                manifest,
+            });
+        }
+        // Refresh any open HTML preview panels so they show the latest artifact content
+        // (e.g. Fleet in editor preview stays in sync when user clicks Manual Refresh in panel)
+        // Run after manifest so a failure here cannot block the main panel update.
+        try {
+            const artifactPaths = new Set(rawArtifacts.filter(a => a?.uri).map(a => path.resolve(a.uri.fsPath)));
+            for (const [normalizedPath, panel] of this.htmlPreviewPanels.entries()) {
+                if (artifactPaths.has(normalizedPath)) {
+                    this.setPreviewPanelHtml(panel, normalizedPath).catch(err => {
+                        this.outputChannel.appendLine(`[Dashboard] Failed refreshing preview for ${normalizedPath}: ${err}`);
+                    });
+                }
+            }
+        }
+        catch (err) {
+            this.outputChannel.appendLine(`[Dashboard] Error refreshing open preview panels: ${err}`);
+        }
+    }
+    /** Path convention for view-owned snapshot exports: exports/<viewId>.json (built-in fleet: fleet.json). */
+    getViewExportSnapshotPath(viewId) {
+        const id = (viewId ?? this.getActiveViewId()).trim();
+        if (!id) {
+            return undefined;
+        }
+        const exportDir = this.artifactManager.getExportDir();
+        const view = id === this.getActiveViewId()
+            ? this.getActiveView()
+            : this.viewsConfig.views.find(entry => entry.id === id);
+        if (id === 'fleet' || (view && (0, viewsConfigMerge_1.viewRunsFleetWidget)(view))) {
+            return path.join(exportDir, AnalyticsDashboardProvider.FLEET_EXPORT_FILENAME);
+        }
+        return path.join(exportDir, `${id}.json`);
+    }
+    /** Resolve fleet export JSON for read (prefers fleet.json, falls back to legacy agent-fleet.json). */
+    resolveFleetExportReadPath() {
+        const exportDir = this.artifactManager.getExportDir();
+        const primary = path.join(exportDir, AnalyticsDashboardProvider.FLEET_EXPORT_FILENAME);
+        if ((0, fs_1.existsSync)(primary)) {
+            return primary;
+        }
+        const legacy = path.join(exportDir, AnalyticsDashboardProvider.LEGACY_FLEET_EXPORT_FILENAME);
+        return (0, fs_1.existsSync)(legacy) ? legacy : primary;
+    }
+    /** Active view opts into iframe live updates via exports/<viewId>.json snapshots. */
+    activeViewPushesExportSnapshot() {
+        return (0, viewsConfigMerge_1.shouldPreserveFleetIframe)(this.getActiveView());
+    }
+    /**
+     * Push export JSON to the panel when the active view has preserveFleetIframe.
+     * Forwards the full parsed exports/<viewId>.json (generic passthrough); widgets normalize shape.
+     * Large session[] arrays are chunked for iframe delivery.
+     */
+    async postViewExportSnapshot(options) {
+        if (!this.webviewView) {
+            return;
+        }
+        const allowSnapshot = this.activeViewPushesExportSnapshot()
+            || options?.respondWhenMissing === true;
+        if (!allowSnapshot) {
+            return;
+        }
+        const exportPath = this.getViewExportSnapshotPath();
+        if (!exportPath) {
+            return;
+        }
+        const readPath = exportPath.endsWith(AnalyticsDashboardProvider.FLEET_EXPORT_FILENAME)
+            ? this.resolveFleetExportReadPath()
+            : exportPath;
+        if (!options?.respondWhenMissing && !(0, fs_1.existsSync)(readPath)) {
+            return;
+        }
+        try {
+            const raw = await fs_1.promises.readFile(readPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            const messages = (0, viewsConfigMerge_1.buildViewExportSnapshotMessages)(parsed);
+            for (const message of messages) {
+                this.webviewView.webview.postMessage({
+                    type: viewsConfigMerge_1.VIEW_EXPORT_SNAPSHOT_MESSAGE,
+                    payload: message.payload,
+                    meta: message.meta,
+                });
+            }
+        }
+        catch (err) {
+            const isEnoent = err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT';
+            if (!options?.respondWhenMissing && isEnoent) {
+                return;
+            }
+            this.webviewView.webview.postMessage({
+                type: viewsConfigMerge_1.VIEW_EXPORT_SNAPSHOT_MESSAGE,
+                payload: {
+                    generatedAt: '',
+                    totals: {},
+                },
+                meta: {
+                    ok: isEnoent,
+                    sessionCount: 0,
+                    error: err instanceof Error ? err.message : String(err),
+                    cliActive: false,
+                    daemonHint: false,
+                },
+            });
+        }
+    }
+    sendArtifactsToWebview(artifacts, galleryIgnorePatterns) {
+        if (!this.webviewView) {
+            return;
+        }
+        const webviewArtifacts = artifacts.map(a => ({
+            // Per-artifact cache bust using modifiedAt so only changed images reload;
+            // unchanged charts keep their cached URL and don't flicker.
+            webviewUri: this.webviewView.webview.asWebviewUri(a.uri).toString() + `?v=${a.modifiedAt.getTime()}`,
+            localPath: a.uri.fsPath,
+            filename: a.filename,
+            size: a.size,
+            modifiedAt: a.modifiedAt.toISOString(),
+            type: a.type,
+            format: a.format,
+            generator: a.generator,
+        }));
+        const activeViewId = this.getActiveViewId();
+        this.webviewView.webview.postMessage({
+            type: 'artifactsUpdated',
+            artifacts: webviewArtifacts,
+            activeViewId,
+            fleetRefreshVersion: activeViewId === 'fleet' ? this.fleetRefreshVersion : undefined,
+            galleryIgnorePatterns,
+        });
+        void this.postViewExportSnapshot();
+    }
+    async postArtifactContent(pathValue, format) {
+        const targetPath = pathValue?.trim();
+        if (!targetPath || !this.webviewView) {
+            return;
+        }
+        const normalizedTarget = path.resolve(targetPath);
+        if (!this.isPathWithinAllowedAnalyticsRoots(normalizedTarget)) {
+            this.webviewView.webview.postMessage({
+                type: 'artifactContent',
+                path: targetPath,
+                format: format ?? 'html',
+                error: 'Access denied for preview path.',
+            });
+            return;
+        }
+        try {
+            const stat = await fs_1.promises.stat(normalizedTarget);
+            if (!stat.isFile()) {
+                throw new Error('Preview target is not a file.');
+            }
+            if (stat.size > 2 * 1024 * 1024) {
+                throw new Error('Preview file is too large (>2MB).');
+            }
+            const content = await fs_1.promises.readFile(normalizedTarget, 'utf-8');
+            this.webviewView.webview.postMessage({
+                type: 'artifactContent',
+                path: targetPath,
+                format: format ?? 'html',
+                content,
+            });
+        }
+        catch (err) {
+            this.outputChannel.appendLine(`[Dashboard] Failed loading artifact preview for ${normalizedTarget}: ${err}`);
+            this.webviewView.webview.postMessage({
+                type: 'artifactContent',
+                path: targetPath,
+                format: format ?? 'html',
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    async openHtmlArtifactPreview(pathValue) {
+        const targetPath = pathValue?.trim();
+        if (!targetPath) {
+            return;
+        }
+        const normalizedTarget = path.resolve(targetPath);
+        let panel = this.htmlPreviewPanels.get(normalizedTarget);
+        if (!panel) {
+            panel = vscode.window.createWebviewPanel('agentide.analyticsHtmlPreview', `Preview: ${path.basename(normalizedTarget)}`, vscode.ViewColumn.Active, {
+                enableScripts: true,
+                retainContextWhenHidden: true,
+                localResourceRoots: [
+                    vscode.Uri.file(path.dirname(normalizedTarget)),
+                ],
+            });
+            this.htmlPreviewPanels.set(normalizedTarget, panel);
+            panel.onDidDispose(() => {
+                this.htmlPreviewPanels.delete(normalizedTarget);
+            });
+            // Forward widget messages (e.g. openSpotlightForSession) from preview to extension
+            panel.webview.onDidReceiveMessage(this.handleMessage.bind(this));
+        }
+        else {
+            panel.reveal(vscode.ViewColumn.Active);
+        }
+        await this.setPreviewPanelHtml(panel, normalizedTarget);
+    }
+    /** Load artifact HTML from disk and set it on the preview panel (used for open and for refresh). */
+    async setPreviewPanelHtml(panel, normalizedTarget) {
+        const nonce = getNonce();
+        try {
+            const rawHtml = await fs_1.promises.readFile(normalizedTarget, 'utf-8');
+            const withNonce = rawHtml.replace(/<script(?![^>]*\bnonce=)([^>]*)>/gi, `<script nonce="${nonce}"$1>`);
+            const csp = `<meta http-equiv="Content-Security-Policy" content="
+				default-src 'none';
+				style-src ${panel.webview.cspSource} 'unsafe-inline';
+				script-src 'nonce-${nonce}' 'unsafe-inline';
+				img-src ${panel.webview.cspSource} data: https: http:;
+				font-src ${panel.webview.cspSource};
+			">`;
+            // Bridge: when widget runs in preview (no iframe), it posts to window.parent (=== window).
+            // This script forwards those messages to the extension so card click → openSpotlightForSession works.
+            const previewBridge = `<script nonce="${nonce}">(function(){try{var api=typeof acquireVsCodeApi==="function"?acquireVsCodeApi():null;if(!api)return;window.addEventListener("message",function(e){var d=e.data;if(!d||typeof d!=="object")return;if(d.type==="openSpotlightForSession"&&typeof d.sessionId==="string")api.postMessage({type:"openSpotlightForSession",sessionId:d.sessionId,channelType:d.channelType||"",channelTarget:d.channelTarget||"",model:d.model||"",engine:d.engine||"",agentId:d.agentId||""});if(d.type==="refreshView")api.postMessage({type:"refreshView"});if(d.type==="refreshWidget"){var msg={type:"refreshWidget"};if(typeof d.script==="string")msg.script=d.script;if(Array.isArray(d.scripts))msg.scripts=d.scripts;api.postMessage(msg);}if(d.type==="refreshFleetWidget")api.postMessage({type:"refreshFleetWidget"});if(d.type==="disconnectFleetChannel"&&typeof d.sessionId==="string")api.postMessage({type:"disconnectFleetChannel",sessionId:d.sessionId,channelType:d.channelType||"",channelTarget:d.channelTarget||""});if(d.type==="copySessionId"&&typeof d.sessionId==="string")api.postMessage({type:"copySessionId",sessionId:d.sessionId});if(d.type==="requestClipboardText"&&typeof d.requestId==="string")api.postMessage({type:"requestClipboardText",requestId:d.requestId});if(d.type==="writeClipboardText"&&typeof d.text==="string")api.postMessage({type:"writeClipboardText",text:d.text});});}catch(err){}})();</script>`;
+            let html = /<head[^>]*>/i.test(withNonce)
+                ? withNonce.replace(/<head([^>]*)>/i, `<head$1>\n\t${csp}`)
+                : `<!DOCTYPE html><html><head>${csp}<meta charset="UTF-8"></head><body>${withNonce}</body></html>`;
+            html = html.replace(/<body(\s[^>]*)?>/i, (_m, bodyAttrs) => `<body${bodyAttrs ?? ''}>${previewBridge}`);
+            panel.title = `Preview: ${path.basename(normalizedTarget)}`;
+            panel.webview.html = html;
+        }
+        catch (err) {
+            this.outputChannel.appendLine(`[Dashboard] Failed setting html preview for ${normalizedTarget}: ${err}`);
+            panel.webview.html = `<!DOCTYPE html>
+<html>
+<body style="font-family: sans-serif; padding: 16px;">
+	<h3>Unable to preview HTML artifact</h3>
+	<p>${err instanceof Error ? err.message : String(err)}</p>
+</body>
+</html>`;
+        }
+    }
+    enqueueArtifactRefresh() {
+        if (this.isBatchingArtifactUpdates) {
+            this.pendingArtifactRefresh = true;
+            return this.artifactRefreshQueue;
+        }
+        this.artifactRefreshQueue = this.artifactRefreshQueue
+            .then(() => this.loadAndSendArtifacts())
+            .catch(err => {
+            this.outputChannel.appendLine(`[Dashboard] Incremental artifact refresh failed: ${err}`);
+        });
+        return this.artifactRefreshQueue;
+    }
+    startSmoothRefresh(options) {
+        this.isBatchingArtifactUpdates = options?.batchArtifactUpdates ?? true;
+        this.pendingArtifactRefresh = false;
+        postToWebview(this.webviewView?.webview, { type: 'dataFresh' });
+        this.postRefreshStatus('refreshStarted', options?.refresh);
+    }
+    async finishSmoothRefresh(options) {
+        const notifyFinished = options?.notifyFinished ?? true;
+        this.isBatchingArtifactUpdates = false;
+        if (this.pendingArtifactRefresh) {
+            this.pendingArtifactRefresh = false;
+            await this.loadAndSendArtifacts();
+        }
+        if (notifyFinished) {
+            this.postRefreshStatus('refreshFinished', options?.refresh);
+        }
+    }
+    async resizeSpotlightSidebar(direction) {
+        const sizeCommand = direction === 'expand'
+            ? 'workbench.action.increaseViewSize'
+            : 'workbench.action.decreaseViewSize';
+        const widthCommand = direction === 'expand'
+            ? 'workbench.action.increaseViewWidth'
+            : 'workbench.action.decreaseViewWidth';
+        const delayForFocus = async (ms = 50) => new Promise(resolve => setTimeout(resolve, ms));
+        try {
+            await vscode.commands.executeCommand('agentide.analyticsView.focus');
+            await delayForFocus();
+            await vscode.commands.executeCommand(sizeCommand);
+            return;
+        }
+        catch (err) {
+            this.outputChannel.appendLine(`[Dashboard] Spotlight resize primary path failed (${direction}): ${err}`);
+        }
+        try {
+            await vscode.commands.executeCommand('agentide.analyticsView.focus');
+            await delayForFocus();
+            await vscode.commands.executeCommand(widthCommand);
+            return;
+        }
+        catch (err) {
+            this.outputChannel.appendLine(`[Dashboard] Spotlight resize width fallback failed (${direction}): ${err}`);
+        }
+        await vscode.commands.executeCommand('workbench.action.focusSideBar');
+        await delayForFocus();
+        await vscode.commands.executeCommand(sizeCommand);
+    }
+    // -------------------------------------------------------------------------
+    // Message Handling
+    // -------------------------------------------------------------------------
+    async handleMessage(message) {
+        switch (message.type) {
+            case 'requestArtifacts':
+                await this.loadAndSendArtifacts();
+                break;
+            case 'requestSummary':
+                await this.sendSummaryCards();
+                break;
+            case 'requestFilters':
+                await this.postFilterState();
+                break;
+            case 'requestViews':
+                // Re-read views.yaml so external edits appear without requiring window reload.
+                await this.loadAndPostViewsState();
+                await this.postPanelState('default');
+                break;
+            case 'setActiveView': {
+                const switched = await this.setActiveView(message.viewId);
+                // Always update the webview with the correct view, even if the switch failed.
+                // This prevents the dropdown and provider state from being out of sync.
+                await this.postViewsState();
+                if (!switched) {
+                    break;
+                }
+                this.syncArtifactContext();
+                await this.postPanelState('default');
+                await this.refreshAfterViewChange();
+                await this.refreshChartsForActiveViewAfterSwitch();
+                break;
+            }
+            case 'createView': {
+                const created = await this.runViewConfigMutation(() => this.createView(message.name));
+                if (!created) {
+                    break;
+                }
+                await this.postViewsState();
+                await this.postPanelState('default');
+                await this.refreshAfterViewChange();
+                await this.refreshChartsForActiveViewAfterSwitch();
+                break;
+            }
+            case 'duplicateView': {
+                const duplicated = await this.runViewConfigMutation(() => this.duplicateView(message.viewId));
+                if (!duplicated) {
+                    break;
+                }
+                await this.setActiveView(duplicated.id);
+                await this.postViewsState();
+                await this.postPanelState('default');
+                await this.refreshAfterViewChange();
+                await this.refreshChartsForActiveViewAfterSwitch();
+                break;
+            }
+            case 'renameView': {
+                const renamed = await this.renameView(message.viewId, message.name);
+                if (!renamed) {
+                    break;
+                }
+                await this.postViewsState();
+                break;
+            }
+            case 'deleteView': {
+                const removed = await this.runViewConfigMutation(() => this.deleteView(message.viewId));
+                if (!removed) {
+                    break;
+                }
+                await this.postViewsState();
+                await this.postPanelState('default');
+                await this.refreshAfterViewChange();
+                await this.refreshChartsForActiveViewAfterSwitch();
+                break;
+            }
+            case 'requestRenameView': {
+                const viewId = message.viewId ?? this.getActiveViewId();
+                const view = viewId ? this.findViewById(viewId) : undefined;
+                if (!view || view.system) {
+                    break;
+                }
+                const name = await vscode.window.showInputBox({
+                    title: 'Rename view',
+                    value: view.name,
+                    prompt: 'Enter the new view name',
+                    validateInput: (value) => {
+                        const t = value?.trim();
+                        if (!t) {
+                            return 'Name cannot be empty';
+                        }
+                        return null;
+                    },
+                });
+                if (name !== undefined && name.trim()) {
+                    const renamed = await this.renameView(view.id, name.trim());
+                    if (renamed) {
+                        await this.postViewsState();
+                    }
+                }
+                break;
+            }
+            case 'requestDeleteView': {
+                const viewId = message.viewId ?? this.getActiveViewId();
+                const view = viewId ? this.findViewById(viewId) : undefined;
+                if (!view || view.system) {
+                    break;
+                }
+                const action = await vscode.window.showWarningMessage(`Delete view "${view.name}"?`, { modal: true }, 'Delete', 'Cancel');
+                if (action === 'Delete') {
+                    const removed = await this.deleteView(view.id);
+                    if (removed) {
+                        await this.postViewsState();
+                        await this.postPanelState('default');
+                        await this.refreshAfterViewChange();
+                        await this.refreshChartsForActiveViewAfterSwitch();
+                    }
+                }
+                break;
+            }
+            case 'editViewScripts':
+                await this.editViewScripts(message.viewId);
+                break;
+            case 'refreshAllViews':
+                await this.refreshAllViews();
+                break;
+            case 'refreshView':
+                await this.refreshDashboardData();
+                await this.refreshCharts({ viewId: this.getActiveViewId() });
+                break;
+            case 'refreshWidget': {
+                const normalizedScripts = [
+                    typeof message.script === 'string' ? message.script : '',
+                    ...(Array.isArray(message.scripts) ? message.scripts.filter((s) => typeof s === 'string') : []),
+                ]
+                    .map(s => s.trim())
+                    .filter(Boolean);
+                await this.refreshWidgetScriptsOnly(normalizedScripts);
+                break;
+            }
+            case 'refreshFleetWidget':
+                await this.refreshWidgetScriptsOnly(['agent-fleet-widget.js']);
+                break;
+            case 'shareView': {
+                const viewId = message.viewId?.trim() ?? '';
+                const view = viewId ? this.findViewById(viewId) : undefined;
+                if (!viewId || !view || view.system) {
+                    void vscode.window.showInformationMessage('Built-in Spotlight views cannot be shared. Duplicate the view or create a custom view first.');
+                    break;
+                }
+                const bundle = message.bundle === 'scripts-only' ? 'scripts-only' : 'full';
+                await vscode.commands.executeCommand('agentide.spotlight.publish', viewId, { bundle });
+                break;
+            }
+            case 'installView':
+                await vscode.commands.executeCommand('agentide.store.find', { typeFilter: 'view' });
+                break;
+            case 'expandSidebar': {
+                await this.resizeSpotlightSidebar('expand');
+                break;
+            }
+            case 'shrinkSidebar': {
+                await this.resizeSpotlightSidebar('shrink');
+                break;
+            }
+            case 'requestPanelState':
+                await this.postPanelState(message.panelId);
+                break;
+            case 'savePanelState':
+                await this.savePanelState(message.panelId, message.state);
+                break;
+            case 'requestArtifactContent':
+                await this.postArtifactContent(message.path, message.format);
+                break;
+            case 'requestViewExportSnapshot':
+                await this.postViewExportSnapshot({ respondWhenMissing: true });
+                break;
+            case 'openChat':
+                await this.openVsCodeChat();
+                break;
+            case 'openChatWithPrompt':
+                await this.openVsCodeChat({ prompt: message.prompt });
+                break;
+            case 'copySessionId': {
+                const sessionId = message.sessionId?.trim() ?? '';
+                if (!sessionId) {
+                    break;
+                }
+                await vscode.env.clipboard.writeText(sessionId);
+                this.webviewView?.webview.postMessage({
+                    type: 'sessionCopied',
+                    sessionId,
+                });
+                break;
+            }
+            case 'requestClipboardText': {
+                const requestId = message.requestId?.trim() ?? '';
+                if (!requestId) {
+                    break;
+                }
+                const text = await vscode.env.clipboard.readText();
+                const responsePayload = {
+                    type: 'clipboardText',
+                    requestId,
+                    text,
+                };
+                this.webviewView?.webview.postMessage(responsePayload);
+                for (const panel of this.htmlPreviewPanels.values()) {
+                    void panel.webview.postMessage(responsePayload);
+                }
+                break;
+            }
+            case 'writeClipboardText': {
+                const text = typeof message.text === 'string' ? message.text : '';
+                await vscode.env.clipboard.writeText(text);
+                break;
+            }
+            case 'updateFleetCardTitle':
+                await this.handleFleetCardTitleUpdate(message.sourceId, message.sessionId, message.cardTitle);
+                break;
+            case 'disconnectFleetChannel':
+                await this.handleFleetDisconnectRequest(message.sessionId, message.channelType, message.channelTarget);
+                break;
+            case 'openSpotlightForSession':
+                await this.openSpotlightForSession(message.sessionId, message.channelType, message.channelTarget, message.model, message.engine, message.agentId);
+                break;
+            case 'openArtifact': {
+                const targetPath = message.path?.trim() ?? '';
+                if (!targetPath) {
+                    break;
+                }
+                const normalizedTarget = path.resolve(targetPath);
+                if (normalizedTarget.toLowerCase().endsWith('.html')) {
+                    await this.openHtmlArtifactPreview(normalizedTarget);
+                    break;
+                }
+                await vscode.commands.executeCommand('vscode.open', vscode.Uri.file(normalizedTarget));
+                break;
+            }
+            case 'deleteArtifact':
+                try {
+                    const artifactPath = message.path.trim();
+                    if (artifactPath &&
+                        this.isPathWithinDir(artifactPath, this.artifactManager.getChartDir())) {
+                        await this.disableChartByFilename(path.basename(artifactPath));
+                    }
+                    await vscode.workspace.fs.delete(vscode.Uri.file(message.path));
+                    this.webviewView?.webview.postMessage({
+                        type: 'artifactDeleted',
+                        path: message.path,
+                    });
+                }
+                catch (err) {
+                    this.outputChannel.appendLine(`[Dashboard] Failed to delete artifact: ${err}`);
+                }
+                break;
+            case 'cancelGeneration':
+                this.generationAbortController?.abort();
+                break;
+            case 'retryGeneration':
+                await this.refreshCharts();
+                break;
+            case 'refreshDefaults':
+            case 'refreshCharts':
+                await this.refreshDashboardData();
+                await this.refreshCharts({ viewId: this.getActiveViewId() });
+                break;
+            case 'updateFilters':
+                this.agentFilterId = message.agentId?.trim() || undefined;
+                await this.refreshAfterViewChange();
+                break;
+            case 'resetChartsHome':
+                await this.resetChartsAndScripts('home');
+                break;
+            case 'resetChartsWorkspace':
+                await this.resetChartsAndScripts('workspace');
+                break;
+            case 'reenableAllCharts':
+                await this.reenableAllDisabledCharts();
+                break;
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Reset & Re-enable Operations
+    // -------------------------------------------------------------------------
+    /**
+     * Reset charts and scripts for either the home analytics folder or the
+     * current workspace. This deletes generated charts, user scripts, manifest,
+     * panel state, and disabled-charts config, then regenerates defaults.
+     */
+    async resetChartsAndScripts(target) {
+        const analyticsRoot = this.artifactManager.getAnalyticsRoot();
+        this.outputChannel.appendLine(`[Dashboard] Reset requested for: ${target}`);
+        try {
+            // Determine which directories to clear
+            const dirsToDelete = [];
+            if (target === 'home') {
+                // Home = global analytics root (under ~/.agent-hippo/analytics)
+                // Clear: panel/, views/, panel-state/, disabled-charts.yaml.
+                dirsToDelete.push(path.join(analyticsRoot, 'panel'), path.join(analyticsRoot, 'views'), path.join(analyticsRoot, 'panel-state'));
+            }
+            else {
+                // Workspace reset = current view root only (views/<viewId>/)
+                const viewRoot = this.getViewRoot();
+                dirsToDelete.push(path.join(viewRoot, 'charts'), path.join(viewRoot, 'reports'), path.join(viewRoot, 'exports'));
+                // Also delete the manifest for this view
+                const manifestPath = path.join(viewRoot, 'manifest.json');
+                try {
+                    await fs_1.promises.unlink(manifestPath);
+                }
+                catch { /* ok if missing */ }
+            }
+            // Delete directories recursively
+            for (const dir of dirsToDelete) {
+                try {
+                    await fs_1.promises.rm(dir, { recursive: true, force: true });
+                    this.outputChannel.appendLine(`[Dashboard] Deleted: ${dir}`);
+                }
+                catch (err) {
+                    this.outputChannel.appendLine(`[Dashboard] Could not delete ${dir}: ${err}`);
+                }
+            }
+            // For home reset, also delete the disabled-charts.yaml config
+            if (target === 'home') {
+                const configPath = this.getDisabledChartsConfigPath();
+                try {
+                    await fs_1.promises.unlink(configPath);
+                }
+                catch { /* ok if missing */ }
+            }
+            // Re-seed workspace scripts and regenerate defaults
+            await this.seedWorkspaceScripts();
+            await this.artifactManager.ensureArtifactDir();
+            // Refresh the webview
+            this.queryRunner.invalidateCache();
+            const bootstrapPromise = this.fetchDashboardBootstrapData();
+            await this.loadAndSendArtifacts();
+            const bootstrap = await bootstrapPromise;
+            await this.postFilterState(bootstrap?.agentIds);
+            this.triggerSummaryCardsUpdate(bootstrap?.summary);
+            // Run the full script set so all widgets are generated after reset
+            await this.refreshCharts();
+            vscode.window.showInformationMessage(target === 'home'
+                ? 'Analytics reset complete (home folder)'
+                : 'Analytics reset complete (workspace)');
+        }
+        catch (err) {
+            this.outputChannel.appendLine(`[Dashboard] Reset failed: ${err}`);
+            vscode.window.showErrorMessage(`Reset failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /**
+     * Get the current view root directory path (e.g. .../analytics/views/fleet).
+     */
+    getViewRoot() {
+        return this.artifactManager.resolveViewRoot({
+            scope: this.getActiveView()?.scope ?? 'global',
+            projectId: this.resolveWorkspaceProjectId(),
+            agentId: this.agentFilterId,
+            viewId: this.getActiveViewId(),
+        });
+    }
+    /**
+     * Re-enable all disabled charts/scripts by clearing those lists in disabled-charts.yaml.
+     * Also clears any hidden state in the panel-state.
+     */
+    async reenableAllDisabledCharts() {
+        this.outputChannel.appendLine('[Dashboard] Re-enabling all disabled charts');
+        try {
+            // Clear disabled script/chart blocks while preserving galleryIgnore patterns.
+            const disabledConfig = await this.loadDisabledChartsConfig();
+            await this.saveDisabledChartsConfig({
+                scriptsByView: {},
+                charts: [],
+                galleryIgnore: disabledConfig.galleryIgnore,
+            });
+            await this.postDisabledChartsState({
+                ...disabledConfig,
+                scriptsByView: {},
+                charts: [],
+            });
+            // Also clear hidden state in panel state for the default panel
+            const statePath = this.getPanelStatePath('default');
+            try {
+                const raw = await fs_1.promises.readFile(statePath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                if (parsed.charts && typeof parsed.charts === 'object') {
+                    // Set all hidden flags to false
+                    let changed = false;
+                    for (const key of Object.keys(parsed.charts)) {
+                        if (parsed.charts[key]?.hidden === true) {
+                            parsed.charts[key].hidden = false;
+                            changed = true;
+                        }
+                    }
+                    if (changed) {
+                        await fs_1.promises.writeFile(statePath, `${JSON.stringify(parsed, null, 2)}\n`, 'utf-8');
+                        await this.postPanelState('default');
+                    }
+                }
+            }
+            catch { /* ok if missing or malformed */ }
+            // Refresh the gallery
+            await this.loadAndSendArtifacts();
+            vscode.window.showInformationMessage('All hidden charts have been re-enabled');
+        }
+        catch (err) {
+            this.outputChannel.appendLine(`[Dashboard] Re-enable charts failed: ${err}`);
+            vscode.window.showErrorMessage(`Failed to re-enable charts: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // VS Code Chat Integration
+    // -------------------------------------------------------------------------
+    buildAnalyticsPrimer(userPrompt) {
+        return `Use spotlight skills as needed. ${userPrompt?.trim() || ''}`;
+    }
+    async openVsCodeChat(options) {
+        this.syncArtifactContext();
+        // Ensure artifact directories exist before opening chat
+        await this.artifactManager.ensureArtifactDir();
+        // Set environment variables so agent knows where to save charts and scripts
+        process.env.AGENTIDE_CHART_DIR = this.artifactManager.getChartDir();
+        process.env.AGENTIDE_REPORT_DIR = this.artifactManager.getReportDir();
+        process.env.AGENTIDE_EXPORT_DIR = this.artifactManager.getExportDir();
+        process.env.AGENTIDE_IMAGE_DIR = this.artifactManager.getImageDir();
+        process.env.AGENTIDE_ASSET_DIR = this.artifactManager.getAssetDir();
+        process.env.AGENTIDE_VIEW_ROOT = this.artifactManager.getViewRoot();
+        process.env.AGENTIDE_VIEW_ID = this.getActiveViewId();
+        process.env.AGENTIDE_SCRIPT_DIR = this.artifactManager.getScriptDir();
+        process.env.AGENTIDE_TRACES_DIR = path.join((0, index_1.getAgentideHome)(), 'analytics', 'traces');
+        const filters = this.getActiveFilters();
+        process.env.AGENTIDE_ANALYTICS_SCOPE = filters.scope ?? 'global';
+        process.env.AGENTIDE_ANALYTICS_PROJECT_ID = filters.scope === 'workspace'
+            ? (filters.projectId ?? '')
+            : '';
+        process.env.AGENTIDE_ANALYTICS_AGENT_ID = filters.agentId ?? '';
+        // Always open a dedicated session for analytics flows.
+        await vscode.commands.executeCommand('workbench.action.chat.newChat', {
+            agentMode: true,
+        });
+        const fullPrompt = this.buildAnalyticsPrimer(options?.prompt);
+        const sendImmediately = options?.sendImmediately ?? false;
+        // Open chat without participant mention and prefill by default.
+        // NOTE: the open command does not currently expose a direct title field,
+        // so we lead with "Agent Analytics" in the prompt and use a fresh session.
+        await vscode.commands.executeCommand('workbench.action.chat.open', {
+            mode: 'agent',
+            query: fullPrompt,
+            isPartialQuery: !sendImmediately,
+        });
+    }
+    // -------------------------------------------------------------------------
+    // HTML Content
+    // -------------------------------------------------------------------------
+    getWebviewPath() {
+        // Prefer out/ (used after full compile); fall back to src/ when only tsc watch was run so panel.js and bridge load
+        const outPath = path.join(this.extensionContext.extensionPath, 'out', 'analytics', 'dashboard', 'webview', 'panel.js');
+        return (0, fs_1.existsSync)(outPath) ? 'out/analytics/dashboard/webview' : 'src/analytics/dashboard/webview';
+    }
+    /** Share toolbar control; injected when user's panel.html lacks it (e.g. old seeded copy). */
+    getShareViewButtonFragment() {
+        return `
+				<button id="share-view-btn" class="toolbar-btn icon-only" title="Publish current view to store (full bundle)" aria-label="Publish current view to store (full bundle)">
+					<span class="btn-icon" aria-hidden="true">&#8593;</span>
+				</button>`;
+    }
+    /** Install toolbar control; injected when user's panel.html lacks it (e.g. old seeded copy). */
+    getInstallViewButtonFragment() {
+        return `
+				<button id="install-view-btn" class="toolbar-btn icon-only" title="Install Spotlight view from store" aria-label="Install Spotlight view from store">
+					<span class="btn-icon" aria-hidden="true">&#8595;</span>
+				</button>`;
+    }
+    getShareScriptsOnlyMenuFragment() {
+        return `
+				<button id="share-scripts-only-menu-item" class="dropdown-item" role="menuitem" data-action="share-scripts-only">
+					<span class="dropdown-icon">&#8593;</span>
+					Share scripts only to store
+				</button>`;
+    }
+    patchPanelHtmlForShareButton(panelHtml) {
+        let html = panelHtml;
+        if (!html.includes('id="share-scripts-only-menu-item')) {
+            const editScriptsMatch = html.match(/<button class="dropdown-item"[^>]*data-action="edit-view-scripts"[^>]*>[\s\S]*?<\/button>/);
+            if (editScriptsMatch && editScriptsMatch.index !== undefined) {
+                const insertAt = editScriptsMatch.index + editScriptsMatch[0].length;
+                html = `${html.slice(0, insertAt)}${this.getShareScriptsOnlyMenuFragment()}${html.slice(insertAt)}`;
+            }
+        }
+        if (!html.includes('id="share-view-btn"')) {
+            const refreshMatch = html.match(/<button[^>]*id="refresh-charts-btn"[^>]*>[\s\S]*?<\/button>/);
+            if (refreshMatch && refreshMatch.index !== undefined) {
+                const insertAt = refreshMatch.index + refreshMatch[0].length;
+                html = `${html.slice(0, insertAt)}${this.getShareViewButtonFragment()}${html.slice(insertAt)}`;
+            }
+        }
+        if (!html.includes('id="install-view-btn"')) {
+            const shareMatch = html.match(/<button[^>]*id="share-view-btn"[^>]*>[\s\S]*?<\/button>/);
+            if (shareMatch && shareMatch.index !== undefined) {
+                const insertAt = shareMatch.index + shareMatch[0].length;
+                html = `${html.slice(0, insertAt)}${this.getInstallViewButtonFragment()}${html.slice(insertAt)}`;
+            }
+        }
+        // Normalize share icon and keep share to the right of refresh.
+        html = html.replace(/(<button[^>]*id="share-view-btn"[^>]*>)\s*<span class="btn-icon"[^>]*>[\s\S]*?<\/span>/, '$1<span class="btn-icon" aria-hidden="true">&#8593;</span>');
+        html = html.replace(/(<button[^>]*id="install-view-btn"[^>]*>)\s*<span class="btn-icon"[^>]*>[\s\S]*?<\/span>/, '$1<span class="btn-icon" aria-hidden="true">&#8595;</span>');
+        const shareBeforeRefresh = /<button[^>]*id="share-view-btn"[^>]*>[\s\S]*?<\/button>\s*<button[^>]*id="refresh-charts-btn"/.test(html);
+        if (shareBeforeRefresh) {
+            html = html.replace(/(<button[^>]*id="share-view-btn"[^>]*>[\s\S]*?<\/button>)\s*(<button[^>]*id="refresh-charts-btn"[^>]*>[\s\S]*?<\/button>)/, '$2$1');
+        }
+        return html;
+    }
+    async patchUserPanelHtmlOnDisk() {
+        const userPanelHtml = path.join(this.getPanelDir(), 'panel.html');
+        if (!(0, fs_1.existsSync)(userPanelHtml)) {
+            return;
+        }
+        try {
+            const current = (0, fs_1.readFileSync)(userPanelHtml, 'utf-8');
+            const patched = this.patchPanelHtmlForShareButton(current);
+            if (patched !== current) {
+                await fs_1.promises.writeFile(userPanelHtml, patched, 'utf-8');
+            }
+        }
+        catch (err) {
+            this.outputChannel.appendLine(`[Dashboard] Failed patching panel.html for share button: ${err}`);
+        }
+    }
+    /** Modal HTML for "New view name"; injected when user's panel.html lacks it (e.g. old seeded copy). */
+    getNewViewModalFragment() {
+        return `
+	<!-- New view name modal (injected so Add view works without window.prompt) -->
+	<div id="new-view-modal" class="modal-overlay" role="dialog" aria-labelledby="new-view-modal-title" aria-modal="true" aria-hidden="true" style="display: none;">
+		<div class="modal-content">
+			<h2 id="new-view-modal-title" class="modal-title">New view name</h2>
+			<input type="text" id="new-view-name-input" class="modal-input" placeholder="View name" autocomplete="off" />
+			<div class="modal-actions">
+				<button type="button" id="new-view-modal-cancel" class="modal-btn modal-btn-secondary">Cancel</button>
+				<button type="button" id="new-view-modal-ok" class="modal-btn modal-btn-primary">OK</button>
+			</div>
+		</div>
+	</div>`;
+    }
+    getHtmlContent(webview) {
+        const nonce = getNonce();
+        const webviewBasePath = this.getWebviewPath();
+        // Runtime bridge - always loaded from the extension bundle
+        const bridgeUri = webview.asWebviewUri(vscode.Uri.joinPath(this.extensionContext.extensionUri, webviewBasePath, 'runtime-bridge.js'));
+        // Panel files - prefer user panel dir for HTML/CSS; always use bundled panel.js so refresh/expand/shrink and message handling are up to date
+        const panelDir = this.getPanelDir();
+        const userPanelCss = path.join(panelDir, 'panel.css');
+        const userPanelHtml = path.join(panelDir, 'panel.html');
+        const panelJsUri = webview.asWebviewUri(vscode.Uri.joinPath(this.extensionContext.extensionUri, webviewBasePath, 'panel.js'));
+        const panelCssUri = (0, fs_1.existsSync)(userPanelCss)
+            ? webview.asWebviewUri(vscode.Uri.file(userPanelCss))
+            : webview.asWebviewUri(vscode.Uri.joinPath(this.extensionContext.extensionUri, webviewBasePath, 'styles.css'));
+        // Read panel HTML body: user override → bundled default → empty
+        let panelHtml = '';
+        if ((0, fs_1.existsSync)(userPanelHtml)) {
+            try {
+                panelHtml = (0, fs_1.readFileSync)(userPanelHtml, 'utf-8');
+            }
+            catch { /* fall through */ }
+        }
+        if (!panelHtml) {
+            const bundledHtmlPath = path.join(this.extensionContext.extensionPath, webviewBasePath, 'analytics-panel.html');
+            try {
+                panelHtml = (0, fs_1.readFileSync)(bundledHtmlPath, 'utf-8');
+            }
+            catch { /* panel.js will build DOM itself */ }
+        }
+        panelHtml = this.patchPanelHtmlForShareButton(panelHtml);
+        // Ensure "Add view" modal is present (user may have old seeded panel.html without it)
+        const newViewModalFragment = this.getNewViewModalFragment();
+        if (newViewModalFragment && !panelHtml.includes('id="new-view-modal"')) {
+            // Append before closing </div> of #app so modal is inside #app
+            const appClose = panelHtml.lastIndexOf('</div>');
+            if (appClose !== -1) {
+                panelHtml = panelHtml.slice(0, appClose) + newViewModalFragment + '\n\t' + panelHtml.slice(appClose);
+            }
+            else {
+                panelHtml = panelHtml + newViewModalFragment;
+            }
+        }
+        const bodyClass = this.isTeamSurface() ? ' class="spotlight-surface-team"' : '';
+        return `<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<meta http-equiv="Content-Security-Policy" content="
+		default-src 'none';
+		style-src ${webview.cspSource} 'unsafe-inline';
+		script-src 'nonce-${nonce}';
+		img-src ${webview.cspSource} data:;
+		frame-src ${webview.cspSource};
+		font-src ${webview.cspSource};
+	">
+	<link href="${panelCssUri}" rel="stylesheet">
+	<title>Spotlight Dashboard</title>
+	<style nonce="${nonce}">.modal-overlay{position:fixed;inset:0;background:rgba(0,0,0,0.4);display:flex;align-items:center;justify-content:center;z-index:1000}.modal-content{background:var(--vscode-editor-background);border:1px solid var(--vscode-panel-border);border-radius:8px;padding:16px;min-width:280px;box-shadow:0 4px 24px rgba(0,0,0,0.25)}.modal-title{font-size:1em;font-weight:600;margin:0 0 12px 0;color:var(--vscode-foreground)}.modal-input{width:100%;padding:8px 10px;margin-bottom:14px;font-family:var(--vscode-font-family);font-size:var(--vscode-font-size);color:var(--vscode-input-foreground);background:var(--vscode-input-background);border:1px solid var(--vscode-input-border);border-radius:4px;box-sizing:border-box}.modal-input:focus{outline:none;border-color:var(--vscode-focusBorder)}.modal-actions{display:flex;justify-content:flex-end;gap:8px}.modal-btn{padding:6px 14px;font-size:0.9em;border-radius:4px;cursor:pointer;border:none}.modal-btn-primary{background:var(--vscode-button-background);color:var(--vscode-button-foreground)}.modal-btn-primary:hover{background:var(--vscode-button-hoverBackground)}.modal-btn-secondary{background:var(--vscode-button-secondaryBackground);color:var(--vscode-button-secondaryForeground)}.modal-btn-secondary:hover{background:var(--vscode-button-secondaryHoverBackground)}</style>
+</head>
+<body${bodyClass}>
+	${panelHtml}
+	<script nonce="${nonce}" src="${bridgeUri}"></script>
+	<script nonce="${nonce}" src="${panelJsUri}"></script>
+	<script nonce="${nonce}">
+	(function(){
+		var api = typeof window.panelApi !== 'undefined' ? window.panelApi : null;
+		if (!api) return;
+		var overlay = document.getElementById('new-view-modal');
+		var input = overlay && document.getElementById('new-view-name-input');
+		var okBtn = overlay && document.getElementById('new-view-modal-ok');
+		var cancelBtn = overlay && document.getElementById('new-view-modal-cancel');
+		if (!overlay || !input || !okBtn || !cancelBtn) return;
+		function showNewViewModal(onResetSelect) {
+			if (typeof onResetSelect === 'function') onResetSelect();
+			input.value = '';
+			overlay.style.display = 'flex';
+			overlay.setAttribute('aria-hidden', 'false');
+			input.focus();
+			function hide() {
+				overlay.style.display = 'none';
+				overlay.setAttribute('aria-hidden', 'true');
+				overlay.removeEventListener('click', handleOverlayClick);
+				document.removeEventListener('keydown', handleKeydown);
+			}
+			function submit() {
+				var trimmed = input.value.trim();
+				hide();
+				if (trimmed) api.postMessage({ type: 'createView', name: trimmed });
+			}
+			function handleOverlayClick(e) { if (e.target === overlay) hide(); }
+			function handleKeydown(e) {
+				if (e.key === 'Escape') { hide(); e.preventDefault(); }
+				else if (e.key === 'Enter') { submit(); e.preventDefault(); }
+			}
+			overlay.addEventListener('click', handleOverlayClick);
+			document.addEventListener('keydown', handleKeydown);
+			okBtn.onclick = submit;
+			cancelBtn.onclick = hide;
+		}
+		window.showNewViewModal = showNewViewModal;
+		window.promptCreateView = function() { showNewViewModal(); };
+		// Rename/Delete: use host dialogs so they work when webview prompt/confirm are unavailable (e.g. old panel.js)
+		document.querySelectorAll('[data-action="rename-view"], [data-action="delete-view"]').forEach(function(el) {
+			el.addEventListener('click', function(e) {
+				var action = this.getAttribute('data-action');
+				if (action === 'rename-view') { api.postMessage({ type: 'requestRenameView' }); e.stopImmediatePropagation(); e.preventDefault(); }
+				if (action === 'delete-view') { api.postMessage({ type: 'requestDeleteView' }); e.stopImmediatePropagation(); e.preventDefault(); }
+			}, true);
+		});
+	})();
+	</script>
+</body>
+</html>`;
+    }
+    // -------------------------------------------------------------------------
+    // Disposal
+    // -------------------------------------------------------------------------
+    dispose() {
+        this.artifactWatcher?.dispose();
+        this.viewsConfigWatcher?.dispose();
+        if (this.viewsConfigDebounceTimeout) {
+            clearTimeout(this.viewsConfigDebounceTimeout);
+        }
+        for (const panel of this.htmlPreviewPanels.values()) {
+            panel.dispose();
+        }
+        this.htmlPreviewPanels.clear();
+        if (this.pendingFilterAutoGenerateTimer) {
+            clearTimeout(this.pendingFilterAutoGenerateTimer);
+        }
+        this.disposables.forEach(d => d.dispose());
+    }
+}
+exports.AnalyticsDashboardProvider = AnalyticsDashboardProvider;
+// -----------------------------------------------------------------------------
+// Utilities
+// -----------------------------------------------------------------------------
+function getNonce() {
+    let text = '';
+    const possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    for (let i = 0; i < 32; i++) {
+        text += possible.charAt(Math.floor(Math.random() * possible.length));
+    }
+    return text;
+}