@hongmaple0820/scale-engine 0.49.0 → 0.50.2

package/dist/dashboard/DashboardServer.js

@@ -6,15 +6,23 @@ import { Hono } from 'hono';
 import { cors } from 'hono/cors';
 import { streamSSE } from 'hono/streaming';
 import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs';
-import { join, dirname, extname } from 'node:path';
+import { basename, join, dirname, extname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import Database from 'better-sqlite3';
+import { MemoryBrain } from '../memory/MemoryBrain.js';
+import { inspectMemoryProviders, recallMemoryProviders, } from '../memory/MemoryProviders.js';
 import { dumpCodeGraphData } from '../codegraph/CodeIntelligence.js';
 import { classifyLayers } from '../topology/LayerClassifier.js';
 import { mapDomains } from '../topology/DomainMapper.js';
 import { generateTour } from '../topology/TourGenerator.js';
 import { aggregateGovernanceMetrics } from './MetricsAggregator.js';
 import { logger } from '../core/logger.js';
+import { RuntimeEvidenceLedger } from '../runtime/RuntimeEvidenceLedger.js';
+import { optimizeCodingPrompt, } from '../prompts/PromptOptimizer.js';
+import { PhasePromptRegistry } from '../prompts/PhasePromptRegistry.js';
+import { listVisualVibeTemplates } from '../prompts/VibeTemplateGallery.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
+const MEMORY_REVIEW_ACTIONS = ['approve', 'reject', 'stale', 'restore'];
 // ── Dashboard Server ─────────────────────────────────────────────────────
 export class DashboardServer {
     constructor(options = {}) {
@@ -27,8 +35,17 @@ export class DashboardServer {
         this.detectorTracker = options.detectorTracker ?? null;
         this.port = options.port ?? 3210;
         this.host = options.host ?? '0.0.0.0';
-        this.projectDir = options.projectDir ?? process.cwd();
-        this.scaleDir = options.scaleDir ?? join(this.projectDir, '.scale');
+        this.projectDir = resolve(options.projectDir ?? process.cwd());
+        this.scaleDir = resolve(options.scaleDir ?? join(this.projectDir, '.scale'));
+        this.currentProject = normalizeProjectSummary({
+            id: options.currentProjectId,
+            name: options.projectName,
+            projectDir: this.projectDir,
+            scaleDir: this.scaleDir,
+            url: options.projectUrl,
+            current: true,
+        });
+        this.projects = normalizeProjectList(options.projects, this.currentProject);
         this.setupMiddleware();
         this.setupSPA();
         this.setupAPI();
@@ -41,10 +58,11 @@ export class DashboardServer {
     }
     // ── SPA Serves ───────────────────────────────────────────────────────
     setupSPA() {
-        // Resolve SPA dir: try dist/spa first, fall back to src/spa
-        const distSpa = join(__dirname, 'spa');
-        const srcSpa = join(__dirname, '..', '..', 'src', 'dashboard', 'spa');
-        const spaDir = existsSync(distSpa) ? distSpa : srcSpa;
+        // Vue dashboard is the canonical UI and is served from the dashboard root.
+        const packagedVueSpa = join(__dirname, 'spa');
+        const projectVueSpa = join(__dirname, '..', '..', 'dist', 'dashboard', 'spa');
+        const hasVueDashboard = (dir) => existsSync(join(dir, 'index.html')) && existsSync(join(dir, 'assets'));
+        const vueSpaDir = hasVueDashboard(packagedVueSpa) ? packagedVueSpa : hasVueDashboard(projectVueSpa) ? projectVueSpa : '';
         const mimeTypes = {
             '.html': 'text/html; charset=utf-8',
             '.js': 'application/javascript; charset=utf-8',
@@ -54,12 +72,18 @@ export class DashboardServer {
             '.svg': 'image/svg+xml',
             '.ico': 'image/x-icon',
         };
-        // Serve SPA static files
-        this.app.get('/spa/*', async (c) => {
-            const path = c.req.path.replace('/spa/', '') || 'index.html';
-            const filePath = join(spaDir, path);
+        const serveStatic = (c, prefix, dir, fallbackToIndex = false) => {
+            const path = c.req.path.replace(prefix, '') || 'index.html';
+            const filePath = join(dir, path);
             if (!existsSync(filePath) || !statSync(filePath).isFile()) {
-                return c.notFound();
+                if (!fallbackToIndex)
+                    return c.notFound();
+                const indexPath = join(dir, 'index.html');
+                if (!existsSync(indexPath))
+                    return c.notFound();
+                return new Response(readFileSync(indexPath), {
+                    headers: { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-cache' },
+                });
             }
             const ext = extname(filePath);
             const contentType = mimeTypes[ext] ?? 'application/octet-stream';
@@ -67,9 +91,24 @@ export class DashboardServer {
             return new Response(content, {
                 headers: { 'Content-Type': contentType, 'Cache-Control': 'no-cache' },
             });
-        });
-        // Root redirect to SPA
-        this.app.get('/', (c) => c.redirect('/spa/'));
+        };
+        const serveVueSpa = (c) => {
+            if (existsSync(vueSpaDir))
+                return serveStatic(c, '/', vueSpaDir, true);
+            return c.html('<!doctype html><html><head><title>SCALE Engine Dashboard</title></head><body><main id="app">Run npm run build to generate the Vue dashboard.</main></body></html>', 503);
+        };
+        this.app.get('/assets/*', (c) => existsSync(vueSpaDir) ? serveStatic(c, '/', vueSpaDir) : c.notFound());
+        // Backward-compatible preview URLs from the migration period.
+        this.app.get('/spa', (c) => c.redirect('/'));
+        this.app.get('/spa/*', (c) => c.redirect('/'));
+        this.app.get('/vue', (c) => c.redirect('/'));
+        this.app.get('/vue/*', (c) => c.redirect('/'));
+        // Root Vue dashboard.
+        this.app.get('/', serveVueSpa);
+        this.app.get('/favicon.ico', () => new Response(null, {
+            status: 204,
+            headers: { 'Cache-Control': 'public, max-age=86400' },
+        }));
         // Legacy views (backward compat)
         const distViews = join(__dirname, 'views');
         const srcViews = join(__dirname, '..', '..', 'src', 'dashboard', 'views');
@@ -100,6 +139,16 @@ export class DashboardServer {
     }
     // ── API Routes ───────────────────────────────────────────────────────
     setupAPI() {
+        // Project metadata for multi-project dashboard launchers
+        this.app.get('/api/project', (c) => c.json(this.currentProject));
+        this.app.get('/api/projects', (c) => c.json(this.projects));
+        this.app.get('/api/projects/summary', (c) => {
+            const sinceDays = parsePositiveInt(c.req.query('days'), 7);
+            const limit = parsePositiveInt(c.req.query('limit'), 100);
+            return c.json(this.getProjectsSummary(sinceDays, limit));
+        });
+        this.app.get('/api/dashboard/capabilities', (c) => c.json(this.getDashboardCapabilityReport()));
+        this.app.get('/api/capabilities', (c) => c.json(this.getDashboardCapabilityReport()));
         // Full dashboard state
         this.app.get('/api/state', async (c) => c.json(await this.getDashboardState()));
         // Artifact tree
@@ -147,6 +196,43 @@ export class DashboardServer {
             const docPath = c.req.path.replace('/api/documents/', '');
             return this.serveDocument(docPath, c);
         });
+        // Memory/knowledge view. Provider recall is explicit to keep page load cheap.
+        this.app.get('/api/knowledge', async (c) => {
+            const query = (c.req.query('query') ?? '').trim();
+            const limit = parsePositiveInt(c.req.query('limit'), 20);
+            const includeProviders = c.req.query('providers') !== 'false';
+            const runRecall = c.req.query('recall') === '1' || c.req.query('recall') === 'true';
+            const provider = c.req.query('provider')?.trim() || undefined;
+            return c.json(await this.getKnowledgeReport({ query, limit, includeProviders, runRecall, provider }));
+        });
+        // Repo-native knowledge base: docs, SQLite knowledge, Graphify graph, and gbrain visualization.
+        this.app.get('/api/knowledge-base', (c) => c.json(this.getKnowledgeBaseReport()));
+        this.app.get('/api/prompts', (c) => c.json(this.getPromptStudioReport()));
+        this.app.post('/api/prompts/optimize', async (c) => {
+            const body = await c.req.json().catch(() => ({}));
+            const rawPrompt = String(body.rawPrompt ?? body.input ?? body.prompt ?? '').trim();
+            if (!rawPrompt)
+                return c.json({ error: 'Prompt input is required.' }, 400);
+            try {
+                const result = optimizeCodingPrompt({
+                    rawPrompt,
+                    title: typeof body.title === 'string' ? body.title : undefined,
+                    language: normalizeDashboardPromptLanguage(body.language),
+                    level: typeof body.level === 'string' ? body.level : undefined,
+                    files: toStringArray(body.files),
+                    services: toStringArray(body.services ?? body.service),
+                    successCriteria: toStringArray(body.successCriteria ?? body['success-criteria']),
+                });
+                return c.json({
+                    project: this.currentProject,
+                    generatedAt: Date.now(),
+                    result,
+                });
+            }
+            catch (e) {
+                return c.json({ error: e instanceof Error ? e.message : String(e) }, 400);
+            }
+        });
         // Available FSM actions for artifact
         this.app.get('/api/artifacts/:id/actions', async (c) => {
             if (!this.fsm)
@@ -294,8 +380,79 @@ export class DashboardServer {
                 return c.json({ error: e instanceof Error ? e.message : String(e) }, 500);
             }
         });
+        this.app.post('/api/knowledge/local/:id/review', async (c) => {
+            const id = c.req.param('id');
+            const body = await c.req.json().catch(() => ({}));
+            const action = normalizeMemoryReviewAction(body.action);
+            if (!action) {
+                return c.json({
+                    error: 'Invalid memory review action',
+                    allowedActions: MEMORY_REVIEW_ACTIONS,
+                }, 400);
+            }
+            let brain = null;
+            try {
+                brain = new MemoryBrain({ projectDir: this.projectDir, scaleDir: this.scaleDir });
+                const report = brain.review(id, action, {
+                    reason: body.reason ?? `Dashboard memory review: ${action}`,
+                    actor: 'dashboard',
+                });
+                if (!report.ok || !report.node) {
+                    return c.json({
+                        error: report.warnings[0] ?? 'Memory review transition blocked',
+                        warnings: report.warnings,
+                        action,
+                        previousStatus: report.previousStatus,
+                        node: report.node,
+                    }, report.node ? 422 : 404);
+                }
+                const evidence = this.recordMemoryReviewEvidence({
+                    action,
+                    node: report.node,
+                    previousStatus: report.previousStatus,
+                    reason: body.reason,
+                });
+                return c.json({
+                    success: true,
+                    action,
+                    previousStatus: report.previousStatus,
+                    node: report.node,
+                    warnings: report.warnings,
+                    evidence,
+                });
+            }
+            catch (e) {
+                return c.json({ error: e instanceof Error ? e.message : String(e) }, 500);
+            }
+            finally {
+                brain?.close();
+            }
+        });
     }
     // ── Data Collection ──────────────────────────────────────────────────
+    recordMemoryReviewEvidence(input) {
+        const ledger = new RuntimeEvidenceLedger({
+            projectDir: this.projectDir,
+            scaleDir: this.scaleDir,
+        });
+        return ledger.record({
+            taskId: 'dashboard-memory-review',
+            kind: 'manual',
+            status: 'passed',
+            title: `Dashboard memory review: ${input.action} ${input.node.id}`,
+            summary: `Memory node ${input.node.id} transitioned from ${input.previousStatus ?? 'unknown'} to ${input.node.status}.`,
+            artifacts: ['.scale/memory/brain.sqlite', ...input.node.evidencePaths],
+            metadata: {
+                action: input.action,
+                nodeId: input.node.id,
+                previousStatus: input.previousStatus,
+                nextStatus: input.node.status,
+                reason: input.reason,
+                source: 'dashboard',
+                resolutionKey: `memory-review:${input.node.id}`,
+            },
+        });
+    }
     async getDashboardState() {
         const [artifacts, evolutionMetrics, detectorStats, autoDefectStats, recentEvents] = await Promise.all([
             this.getArtifactTree(),
@@ -382,8 +539,293 @@ export class DashboardServer {
         const raw = dumpCodeGraphData({ projectDir: this.projectDir });
         return classifyLayers(raw);
     }
+    getProjectsSummary(sinceDays, limit) {
+        const projects = this.projects.slice(0, limit).map(project => this.getProjectOverview(project, sinceDays));
+        const warnings = projects.flatMap(project => project.warnings.map(warning => `${project.project.name}: ${warning}`));
+        return {
+            generatedAt: Date.now(),
+            sinceDays,
+            currentProjectId: this.currentProject.id,
+            totals: {
+                projects: projects.length,
+                readyProjects: projects.filter(project => project.health === 'ready').length,
+                warningProjects: projects.filter(project => project.health === 'warning').length,
+                missingProjects: projects.filter(project => project.health === 'missing').length,
+                documents: sum(projects, project => project.documents.total),
+                localMemoryNodes: sum(projects, project => project.knowledge.total),
+                activeMemoryNodes: sum(projects, project => project.knowledge.active),
+                commandRuns: sum(projects, project => project.metrics.commandRuns),
+                failedCommandRuns: sum(projects, project => project.metrics.failedCommandRuns),
+                gateFailures: sum(projects, project => project.metrics.gateFailures),
+            },
+            projects,
+            warnings,
+        };
+    }
+    getProjectOverview(project, sinceDays) {
+        const warnings = [];
+        const scaleDirExists = existsSync(project.scaleDir);
+        if (!scaleDirExists)
+            warnings.push('.scale directory is missing');
+        const documents = this.listDocumentsFor(project.projectDir, project.scaleDir);
+        const knowledge = this.getLocalKnowledgeSummary(project, warnings);
+        const metrics = this.getGovernanceMetricSummary(project, sinceDays, warnings);
+        const health = !scaleDirExists
+            ? 'missing'
+            : warnings.length > 0
+                ? 'warning'
+                : 'ready';
+        return {
+            project,
+            health,
+            scaleDirExists,
+            documents: {
+                total: documents.length,
+                byType: countBy(documents, document => document.type),
+            },
+            knowledge,
+            metrics,
+            warnings,
+        };
+    }
+    getDashboardCapabilityReport() {
+        const warnings = [];
+        let metrics = null;
+        try {
+            metrics = aggregateGovernanceMetrics({
+                projectDir: this.projectDir,
+                scaleDir: this.scaleDir,
+                sinceDays: 7,
+            });
+        }
+        catch (error) {
+            warnings.push(`metrics aggregation failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const scaleDirExists = existsSync(this.scaleDir);
+        const documents = this.listDocuments();
+        const memoryDb = join(this.scaleDir, 'memory', 'brain.sqlite');
+        const modelUsageFile = join(this.scaleDir, 'model-usage', 'usage.jsonl');
+        const runtimeEvidenceDir = join(this.scaleDir, 'evidence', 'runtime');
+        const commandRunsDir = join(this.scaleDir, 'evidence', 'command-runs');
+        const promptReport = this.getPromptStudioReport();
+        const knowledgeBaseReport = this.getKnowledgeBaseReport();
+        const runtimeEvidenceCount = countMatchingFiles(runtimeEvidenceDir, file => file.endsWith('.json'));
+        const commandRunCount = metrics?.commandRuns.total ?? countMatchingFiles(commandRunsDir, file => file.endsWith('.json'));
+        const modelUsageCount = metrics?.modelUsage.totalRecords ?? 0;
+        const memoryCount = this.getLocalKnowledgeSummary(this.currentProject, warnings).total;
+        const busAvailable = Boolean(this.bus);
+        const artifactTransitions = Boolean(this.fsm && this.store);
+        const dataSources = [
+            {
+                id: 'project-scale-dir',
+                title: 'Project .scale state',
+                description: 'Workspace governance state and local evidence root.',
+                status: scaleDirExists ? 'ready' : 'missing',
+                refreshMode: 'snapshot',
+                source: this.scaleDir,
+                count: scaleDirExists ? 1 : 0,
+                lastUpdated: latestMtime(this.scaleDir),
+                emptyReason: scaleDirExists ? undefined : 'The project has no .scale directory yet.',
+                action: scaleDirExists ? undefined : 'Run scale bootstrap or initialize the workflow in this project.',
+            },
+            {
+                id: 'runtime-evidence',
+                title: 'Runtime evidence ledger',
+                description: 'Pass/fail/resolved records produced by governed workflow runs.',
+                status: runtimeEvidenceCount > 0 ? 'ready' : 'missing',
+                refreshMode: 'polling',
+                source: runtimeEvidenceDir,
+                count: runtimeEvidenceCount,
+                lastUpdated: latestMtime(runtimeEvidenceDir),
+                emptyReason: runtimeEvidenceCount > 0 ? undefined : 'No runtime evidence JSON files were found.',
+                action: runtimeEvidenceCount > 0 ? undefined : 'Run a governed verify/preflight command that records runtime evidence.',
+            },
+            {
+                id: 'command-runs',
+                title: 'Command run evidence',
+                description: 'Recorded shell/tool executions, pass rate, and output compression savings.',
+                status: commandRunCount > 0 ? 'ready' : 'missing',
+                refreshMode: 'polling',
+                source: commandRunsDir,
+                count: commandRunCount,
+                lastUpdated: latestMtime(commandRunsDir),
+                emptyReason: commandRunCount > 0 ? undefined : 'No command-run evidence files were found.',
+                action: commandRunCount > 0 ? undefined : 'Run commands through the governed runtime or preflight pipeline.',
+            },
+            {
+                id: 'model-usage',
+                title: 'Model usage ledger',
+                description: 'Actual model token usage and cache savings from scale token record/report.',
+                status: modelUsageCount > 0 ? 'ready' : 'missing',
+                refreshMode: 'polling',
+                source: modelUsageFile,
+                count: modelUsageCount,
+                lastUpdated: latestMtime(modelUsageFile),
+                emptyReason: modelUsageCount > 0 ? undefined : 'No model usage ledger is present, so token/cost charts are empty.',
+                action: modelUsageCount > 0 ? undefined : 'Record provider usage with scale token record, then refresh the dashboard.',
+            },
+            {
+                id: 'memory-brain',
+                title: 'gbrain memory',
+                description: 'Local gbrain memory nodes used by the knowledge page.',
+                status: existsSync(memoryDb) ? (memoryCount > 0 ? 'ready' : 'partial') : 'missing',
+                refreshMode: 'polling',
+                source: memoryDb,
+                count: memoryCount,
+                lastUpdated: latestMtime(memoryDb),
+                emptyReason: existsSync(memoryDb) ? (memoryCount > 0 ? undefined : 'The memory database exists but has no nodes.') : 'No local gbrain database exists.',
+                action: memoryCount > 0 ? undefined : 'Capture or approve project memory through the memory workflow.',
+            },
+            {
+                id: 'knowledge-base',
+                title: 'Knowledge base',
+                description: 'Repo-native knowledge documents, SQLite knowledge entries, Karpathy guidance, and Graphify knowledge graph.',
+                status: knowledgeBaseReport.summary.documents + knowledgeBaseReport.summary.entries + knowledgeBaseReport.summary.graphNodes > 0 ? 'ready' : 'missing',
+                refreshMode: 'polling',
+                source: `${join(this.scaleDir, 'knowledge.db')} + ${join(this.projectDir, 'graphify-out')} + knowledge docs`,
+                count: knowledgeBaseReport.summary.documents + knowledgeBaseReport.summary.entries,
+                lastUpdated: latestMtimeForDocuments(knowledgeBaseReport.documents, this.projectDir, this.scaleDir)
+                    ?? latestMtime(join(this.scaleDir, 'knowledge.db'))
+                    ?? latestMtime(join(this.projectDir, 'graphify-out')),
+                emptyReason: knowledgeBaseReport.summary.documents + knowledgeBaseReport.summary.entries + knowledgeBaseReport.summary.graphNodes > 0
+                    ? undefined
+                    : 'No knowledge docs, knowledge.db entries, or Graphify graph were found.',
+                action: knowledgeBaseReport.summary.documents + knowledgeBaseReport.summary.entries + knowledgeBaseReport.summary.graphNodes > 0
+                    ? undefined
+                    : 'Add knowledge docs, run the knowledge ingestion flow, or generate graphify-out/graph.json.',
+            },
+            {
+                id: 'documents',
+                title: 'Documents and prototypes',
+                description: 'Markdown, JSON, and HTML artifacts available for preview, copy, and download.',
+                status: documents.length > 0 ? 'ready' : 'missing',
+                refreshMode: 'polling',
+                source: `${this.projectDir}/docs + ${this.scaleDir}/docs + ${this.scaleDir}/artifacts + knowledge graph entry docs`,
+                count: documents.length,
+                lastUpdated: latestMtimeForDocuments(documents, this.projectDir, this.scaleDir),
+                emptyReason: documents.length > 0 ? undefined : 'No previewable docs or HTML prototypes were found.',
+                action: documents.length > 0 ? undefined : 'Generate or add docs/artifacts under docs, .scale/docs, or .scale/artifacts.',
+            },
+            {
+                id: 'prompt-studio',
+                title: 'Prompt Studio',
+                description: 'Built-in vibe coding templates, prompt packs, and optimizer API.',
+                status: promptReport.summary.vibeTemplates + promptReport.summary.phasePrompts > 0 ? 'ready' : 'missing',
+                refreshMode: 'snapshot',
+                source: 'src/prompts + .scale/prompts',
+                count: promptReport.summary.vibeTemplates + promptReport.summary.phasePrompts + promptReport.summary.packs,
+                emptyReason: promptReport.summary.vibeTemplates + promptReport.summary.phasePrompts > 0 ? undefined : 'No prompt templates were discovered.',
+                action: promptReport.summary.vibeTemplates + promptReport.summary.phasePrompts > 0 ? undefined : 'Add project prompts under .scale/prompts or use built-in templates.',
+            },
+            {
+                id: 'event-stream',
+                title: 'Realtime event stream',
+                description: 'Server-sent events used to refresh live runtime changes.',
+                status: busAvailable ? 'ready' : 'partial',
+                refreshMode: busAvailable ? 'sse' : 'polling',
+                source: '/api/stream',
+                count: busAvailable ? 1 : 0,
+                emptyReason: busAvailable ? undefined : 'The dashboard server is running heartbeat-only SSE because no runtime EventBus was injected.',
+                action: busAvailable ? undefined : 'Start the dashboard from an embedded runtime or wire an EventBus into serve.',
+            },
+            {
+                id: 'artifact-fsm',
+                title: 'Workflow artifact transitions',
+                description: 'Dashboard write path for artifact actions and lesson review transitions.',
+                status: artifactTransitions ? 'ready' : 'partial',
+                refreshMode: 'manual',
+                source: '/api/artifacts/:id/actions + /api/artifacts/:id/transition',
+                count: artifactTransitions ? 1 : 0,
+                emptyReason: artifactTransitions ? undefined : 'The HTTP dashboard was started without artifact store/FSM injection.',
+                action: artifactTransitions ? undefined : 'Wire the serve entrypoint to an artifact store and FSM before enabling dashboard transitions.',
+            },
+        ];
+        const summary = summarizeDataSources(dataSources);
+        return {
+            project: this.currentProject,
+            generatedAt: Date.now(),
+            summary,
+            realtime: {
+                status: busAvailable ? 'ready' : 'partial',
+                mode: busAvailable ? 'event-bus' : 'heartbeat-only',
+                busAvailable,
+                heartbeatOnly: !busAvailable,
+                refreshIntervalMs: 30000,
+            },
+            writeOps: {
+                artifactTransitions,
+                memoryReview: existsSync(memoryDb),
+                promptOptimization: true,
+            },
+            dataSources,
+            warnings: [...warnings, ...promptReport.warnings, ...knowledgeBaseReport.warnings],
+        };
+    }
+    getGovernanceMetricSummary(project, sinceDays, warnings) {
+        try {
+            const metrics = aggregateGovernanceMetrics({
+                projectDir: project.projectDir,
+                scaleDir: project.scaleDir,
+                sinceDays,
+            });
+            const commandRuns = metrics.commandRuns.total;
+            return {
+                available: true,
+                commandRuns,
+                failedCommandRuns: metrics.commandRuns.failed,
+                commandPassRate: commandRuns > 0 ? metrics.commandRuns.passed / commandRuns : 0,
+                gateFailures: metrics.gateFailures.failed,
+                recentTasks: metrics.taskMetrics.recentTasks,
+                recentFirstPassRate: metrics.taskMetrics.recentFirstPassRate,
+            };
+        }
+        catch (error) {
+            warnings.push(`governance metrics failed: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                available: false,
+                commandRuns: 0,
+                failedCommandRuns: 0,
+                commandPassRate: 0,
+                gateFailures: 0,
+                recentTasks: 0,
+                recentFirstPassRate: 0,
+            };
+        }
+    }
+    getLocalKnowledgeSummary(project, warnings) {
+        const dbPath = join(project.scaleDir, 'memory', 'brain.sqlite');
+        if (!existsSync(dbPath))
+            return { available: false, total: 0, active: 0 };
+        let brain = null;
+        try {
+            brain = new MemoryBrain({ projectDir: project.projectDir, scaleDir: project.scaleDir });
+            const nodes = brain.list();
+            return {
+                available: true,
+                total: nodes.length,
+                active: nodes.filter(node => node.status === 'active').length,
+            };
+        }
+        catch (error) {
+            warnings.push(`local memory brain failed: ${error instanceof Error ? error.message : String(error)}`);
+            return { available: false, total: 0, active: 0 };
+        }
+        finally {
+            brain?.close();
+        }
+    }
     listDocuments() {
+        return this.listDocumentsFor(this.projectDir, this.scaleDir);
+    }
+    listDocumentsFor(projectDir, scaleDir) {
         const docs = [];
+        const addFile = (path) => {
+            const fullPath = join(projectDir, path);
+            if (!existsSync(fullPath) || !statSync(fullPath).isFile())
+                return;
+            const stat = statSync(fullPath);
+            docs.push({ name: basename(path), path, type: extname(path).slice(1), size: stat.size });
+        };
         const scanDir = (dir, prefix) => {
             if (!existsSync(dir))
                 return;
@@ -400,10 +842,15 @@ export class DashboardServer {
             }
         };
         // Scan common doc locations
-        scanDir(join(this.scaleDir, 'docs'), '.scale/docs');
-        scanDir(join(this.scaleDir, 'artifacts'), '.scale/artifacts');
-        scanDir(join(this.projectDir, 'docs'), 'docs');
-        return docs;
+        scanDir(join(scaleDir, 'docs'), '.scale/docs');
+        scanDir(join(scaleDir, 'artifacts'), '.scale/artifacts');
+        scanDir(join(scaleDir, 'knowledge'), '.scale/knowledge');
+        scanDir(join(scaleDir, 'graphify-knowledge', 'entries'), '.scale/graphify-knowledge/entries');
+        scanDir(join(projectDir, 'docs'), 'docs');
+        addFile('graphify-out/GRAPH_REPORT.md');
+        addFile('graphify-out/graph.json');
+        addFile('graphify-out/manifest.json');
+        return dedupeDocuments(docs);
     }
     serveDocument(docPath, c) {
         // docPath already includes prefix (e.g., 'docs/foo.md' or '.scale/docs/foo.md')
@@ -422,7 +869,339 @@ export class DashboardServer {
         }
         return c.json({ error: 'Document not found' }, 404);
     }
+    async getKnowledgeReport(options) {
+        const warnings = [];
+        const local = this.getLocalKnowledge(options.query, options.limit, warnings);
+        let providers;
+        let recall;
+        if (options.includeProviders) {
+            try {
+                providers = inspectMemoryProviders({ projectDir: this.projectDir, scaleDir: this.scaleDir });
+            }
+            catch (error) {
+                warnings.push(`memory provider status failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (options.runRecall && options.query.length > 0) {
+            try {
+                recall = await recallMemoryProviders({
+                    projectDir: this.projectDir,
+                    scaleDir: this.scaleDir,
+                    query: options.query,
+                    limit: options.limit,
+                    includeCandidates: true,
+                    provider: options.provider,
+                });
+            }
+            catch (error) {
+                warnings.push(`memory provider recall failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        return { project: this.currentProject, local, providers, recall, warnings };
+    }
+    getLocalKnowledge(query, limit, warnings) {
+        const dbPath = join(this.scaleDir, 'memory', 'brain.sqlite');
+        if (!existsSync(dbPath))
+            return { available: false, total: 0, byStatus: {}, nodes: [] };
+        let brain = null;
+        try {
+            brain = new MemoryBrain({ projectDir: this.projectDir, scaleDir: this.scaleDir });
+            const allNodes = brain.list();
+            const nodes = query
+                ? brain.query(query, { limit }).nodes
+                : allNodes.slice(0, limit);
+            return {
+                available: true,
+                total: allNodes.length,
+                byStatus: countBy(allNodes, node => node.status),
+                nodes,
+            };
+        }
+        catch (error) {
+            warnings.push(`local memory brain failed: ${error instanceof Error ? error.message : String(error)}`);
+            return { available: false, total: 0, byStatus: {}, nodes: [] };
+        }
+        finally {
+            brain?.close();
+        }
+    }
+    getKnowledgeBaseReport() {
+        const warnings = [];
+        const documents = this.listKnowledgeDocuments();
+        const entries = this.listKnowledgeEntries(warnings);
+        const graph = this.getGraphifyKnowledgeGraph();
+        const memoryGraph = this.getGbrainMemoryGraph(warnings);
+        if (graph.status === 'error' && graph.emptyReason)
+            warnings.push(graph.emptyReason);
+        if (memoryGraph.status === 'error' && memoryGraph.emptyReason)
+            warnings.push(memoryGraph.emptyReason);
+        return {
+            project: this.currentProject,
+            generatedAt: Date.now(),
+            summary: {
+                documents: documents.length,
+                entries: entries.length,
+                graphNodes: graph.nodeCount,
+                graphEdges: graph.edgeCount,
+                memoryNodes: memoryGraph.nodeCount,
+                memoryEdges: memoryGraph.edgeCount,
+            },
+            documents,
+            documentTree: buildDocumentTree(documents),
+            entries,
+            graph,
+            memoryGraph,
+            exports: {
+                report: '/api/knowledge-base',
+                documents: '/api/documents',
+                graph: graph.source,
+                memoryGraph: '/api/knowledge',
+            },
+            warnings,
+        };
+    }
+    listKnowledgeDocuments() {
+        const docs = this.listDocuments();
+        const specialPaths = [
+            'src/skills/karpathy-guidelines/SKILL.md',
+            'docs/CODE_INTELLIGENCE.md',
+            'docs/MEMORY_FABRIC.md',
+            'docs/MEMORY_BRAIN.md',
+            'docs/THIRD_PARTY_SKILLS.md',
+            'docs/EXTERNAL_REFERENCES.md',
+            '.scale/code-intelligence.json',
+            '.scale/graph/manifest.json',
+            'graphify-out/GRAPH_REPORT.md',
+            'graphify-out/graph.json',
+        ];
+        for (const path of specialPaths) {
+            const fullPath = join(this.projectDir, path);
+            if (!existsSync(fullPath) || !statSync(fullPath).isFile())
+                continue;
+            const stat = statSync(fullPath);
+            docs.push({
+                name: basename(path),
+                path,
+                type: extname(path).slice(1),
+                size: stat.size,
+            });
+        }
+        return dedupeDocuments(docs).filter(document => isKnowledgeDocument(document.path));
+    }
+    listKnowledgeEntries(warnings) {
+        const dbPath = join(this.scaleDir, 'knowledge.db');
+        if (!existsSync(dbPath))
+            return [];
+        let db = null;
+        try {
+            db = new Database(dbPath, { readonly: true, fileMustExist: true });
+            const rows = db.prepare(`
+        SELECT id, title, content, type, tags, score, createdAt, updatedAt, source
+        FROM knowledge_entries
+        ORDER BY updatedAt DESC
+        LIMIT 200
+      `).all();
+            return rows.map(row => ({
+                id: String(row.id),
+                title: String(row.title || row.id),
+                content: String(row.content || ''),
+                type: String(row.type || 'unknown'),
+                tags: parseStringList(row.tags),
+                score: Number(row.score || 0),
+                createdAt: Number(row.createdAt || 0),
+                updatedAt: Number(row.updatedAt || 0),
+                source: typeof row.source === 'string' ? row.source : undefined,
+            }));
+        }
+        catch (error) {
+            warnings.push(`knowledge.db read failed: ${error instanceof Error ? error.message : String(error)}`);
+            return [];
+        }
+        finally {
+            db?.close();
+        }
+    }
+    getGraphifyKnowledgeGraph() {
+        const graphPath = join(this.projectDir, 'graphify-out', 'graph.json');
+        const reportPath = join(this.projectDir, 'graphify-out', 'GRAPH_REPORT.md');
+        const manifestPath = join(this.scaleDir, 'graph', 'manifest.json');
+        const source = existsSync(graphPath) ? 'graphify-out/graph.json' : existsSync(manifestPath) ? '.scale/graph/manifest.json' : 'graphify-out/graph.json';
+        if (!existsSync(graphPath) && !existsSync(manifestPath)) {
+            return {
+                status: 'missing',
+                source,
+                reportPath: existsSync(reportPath) ? 'graphify-out/GRAPH_REPORT.md' : undefined,
+                nodeCount: 0,
+                edgeCount: 0,
+                nodes: [],
+                edges: [],
+                emptyReason: 'Graphify graph was not found.',
+            };
+        }
+        try {
+            const raw = JSON.parse(readFileSync(existsSync(graphPath) ? graphPath : manifestPath, 'utf-8'));
+            const rawNodes = extractGraphNodes(raw);
+            const rawEdges = extractGraphEdges(raw);
+            const nodes = rawNodes.slice(0, 160).map((node, index) => normalizeGraphNode(node, index, 'graphify'));
+            const nodeIds = new Set(nodes.map(node => node.id));
+            const edges = rawEdges
+                .map(edge => normalizeGraphEdge(edge))
+                .filter(edge => edge && nodeIds.has(edge.source) && nodeIds.has(edge.target))
+                .slice(0, 260);
+            return {
+                status: rawNodes.length > 0 ? 'ready' : 'partial',
+                source,
+                reportPath: existsSync(reportPath) ? 'graphify-out/GRAPH_REPORT.md' : undefined,
+                nodeCount: rawNodes.length,
+                edgeCount: rawEdges.length,
+                nodes,
+                edges,
+                emptyReason: rawNodes.length > 0 ? undefined : 'Graphify graph exists but has no readable nodes.',
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                source,
+                reportPath: existsSync(reportPath) ? 'graphify-out/GRAPH_REPORT.md' : undefined,
+                nodeCount: 0,
+                edgeCount: 0,
+                nodes: [],
+                edges: [],
+                emptyReason: `Graphify graph read failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    getGbrainMemoryGraph(warnings) {
+        const dbPath = join(this.scaleDir, 'memory', 'brain.sqlite');
+        if (!existsSync(dbPath)) {
+            return {
+                status: 'missing',
+                source: '.scale/memory/brain.sqlite',
+                nodeCount: 0,
+                edgeCount: 0,
+                nodes: [],
+                edges: [],
+                emptyReason: 'No local gbrain database exists.',
+            };
+        }
+        let brain = null;
+        try {
+            brain = new MemoryBrain({ projectDir: this.projectDir, scaleDir: this.scaleDir });
+            const memories = brain.list();
+            const nodes = [];
+            const edges = [];
+            for (const memory of memories.slice(0, 120)) {
+                const memoryId = `memory:${memory.id}`;
+                nodes.push({
+                    id: memoryId,
+                    label: memory.title || memory.id,
+                    kind: memory.type || 'memory',
+                    group: memory.layer || memory.status || 'memory',
+                    source: 'gbrain',
+                });
+                const layer = memory.layer || 'unknown-layer';
+                const layerId = `layer:${layer}`;
+                if (!nodes.some(node => node.id === layerId)) {
+                    nodes.push({
+                        id: layerId,
+                        label: layer,
+                        kind: 'layer',
+                        group: 'memory-layer',
+                        source: 'gbrain',
+                    });
+                }
+                edges.push({ source: memoryId, target: layerId, label: 'layer' });
+                for (const evidencePath of (memory.evidencePaths || []).slice(0, 4)) {
+                    const evidenceId = `evidence:${evidencePath}`;
+                    if (!nodes.some(node => node.id === evidenceId)) {
+                        nodes.push({
+                            id: evidenceId,
+                            label: basename(evidencePath),
+                            kind: 'evidence',
+                            group: 'evidence',
+                            source: 'gbrain',
+                            path: evidencePath,
+                        });
+                    }
+                    edges.push({ source: memoryId, target: evidenceId, label: 'evidence' });
+                }
+            }
+            return {
+                status: memories.length > 0 ? 'ready' : 'partial',
+                source: '.scale/memory/brain.sqlite',
+                nodeCount: nodes.length,
+                edgeCount: edges.length,
+                nodes,
+                edges: edges.slice(0, 240),
+                emptyReason: memories.length > 0 ? undefined : 'The gbrain database exists but has no memory nodes.',
+            };
+        }
+        catch (error) {
+            warnings.push(`gbrain graph failed: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                status: 'error',
+                source: '.scale/memory/brain.sqlite',
+                nodeCount: 0,
+                edgeCount: 0,
+                nodes: [],
+                edges: [],
+                emptyReason: `gbrain graph failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+        finally {
+            brain?.close();
+        }
+    }
     // ── Lifecycle ────────────────────────────────────────────────────────
+    getPromptStudioReport() {
+        const warnings = [];
+        let phasePrompts = [];
+        let packs = [];
+        try {
+            const registry = new PhasePromptRegistry(this.projectDir);
+            phasePrompts = registry.listPrompts().map(prompt => ({
+                ...prompt,
+                source: classifyPromptSource(prompt.id),
+                command: prompt.id.includes(':') ? undefined : `scale vibe --phase ${prompt.phase}`,
+            }));
+            packs = registry.listPacks().map(pack => ({
+                id: pack.id,
+                name: pack.name,
+                description: pack.description,
+                phases: pack.phases,
+                templateIds: pack.templates.map(template => template.id),
+                command: `scale vibe --pack ${pack.id}`,
+            }));
+        }
+        catch (error) {
+            warnings.push(`phase prompt registry failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const vibeTemplates = listVisualVibeTemplates().map(template => ({
+            ...template,
+            command: `scale vibe --template ${template.id}`,
+        }));
+        return {
+            project: this.currentProject,
+            generatedAt: Date.now(),
+            summary: {
+                vibeTemplates: vibeTemplates.length,
+                phasePrompts: phasePrompts.length,
+                packs: packs.length,
+                customPrompts: phasePrompts.filter(prompt => prompt.source !== 'builtin').length,
+            },
+            commands: {
+                vibeIndex: 'scale vibe-index',
+                vibeTemplate: 'scale vibe --template <template-id> --app "<project>"',
+                vibePack: 'scale vibe --pack <pack-id> --app "<project>"',
+                promptOptimize: 'scale prompt optimize --input "<raw prompt>" --json',
+            },
+            vibeTemplates,
+            phasePrompts,
+            packs,
+            warnings,
+        };
+    }
     async start() {
         try {
             const { serve } = await import('@hono/node-server');
@@ -456,4 +1235,289 @@ export class DashboardServer {
         return this.app;
     }
 }
+function normalizeProjectSummary(input) {
+    const projectDir = resolve(input.projectDir);
+    const scaleDir = resolve(input.scaleDir);
+    const name = input.name?.trim() || basename(projectDir) || 'project';
+    return {
+        id: input.id?.trim() || safeProjectId(name),
+        name,
+        projectDir,
+        scaleDir,
+        url: input.url,
+        current: input.current,
+    };
+}
+function normalizeProjectList(projects, currentProject) {
+    const input = projects && projects.length > 0 ? projects : [currentProject];
+    const seen = new Set();
+    const normalized = [];
+    for (const project of input) {
+        const item = normalizeProjectSummary({
+            ...project,
+            current: project.id === currentProject.id || project.projectDir === currentProject.projectDir,
+        });
+        let id = item.id;
+        let suffix = 2;
+        while (seen.has(id))
+            id = `${item.id}-${suffix++}`;
+        seen.add(id);
+        normalized.push({ ...item, id });
+    }
+    if (!normalized.some(project => project.current)) {
+        normalized.unshift(currentProject);
+    }
+    return normalized.map(project => ({ ...project, current: project.projectDir === currentProject.projectDir }));
+}
+function safeProjectId(name) {
+    const id = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+    return id || 'project';
+}
+function parsePositiveInt(value, fallback) {
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+function classifyPromptSource(id) {
+    if (id.startsWith('project:'))
+        return 'project';
+    if (id.startsWith('global:'))
+        return 'global';
+    return 'builtin';
+}
+function normalizeDashboardPromptLanguage(value) {
+    const normalized = String(value ?? 'auto').trim().toLowerCase();
+    return normalized === 'zh' || normalized === 'en' || normalized === 'auto' ? normalized : 'auto';
+}
+function toStringArray(value) {
+    if (Array.isArray(value))
+        return value.map(item => String(item).trim()).filter(Boolean);
+    if (typeof value === 'string')
+        return value.split(',').map(item => item.trim()).filter(Boolean);
+    return [];
+}
+function normalizeMemoryReviewAction(value) {
+    if (!value)
+        return null;
+    return MEMORY_REVIEW_ACTIONS.includes(value) ? value : null;
+}
+function dedupeDocuments(documents) {
+    const seen = new Map();
+    for (const document of documents) {
+        if (!seen.has(document.path))
+            seen.set(document.path, document);
+    }
+    return [...seen.values()].sort((left, right) => left.path.localeCompare(right.path));
+}
+function buildDocumentTree(documents) {
+    const roots = [];
+    const folderByPath = new Map();
+    const ensureFolder = (parts, depth) => {
+        if (depth >= parts.length)
+            return roots;
+        const path = parts.slice(0, depth + 1).join('/');
+        const parentChildren = depth === 0 ? roots : ensureFolder(parts, depth - 1);
+        let folder = folderByPath.get(path);
+        if (!folder) {
+            folder = { name: parts[depth] || path, path, type: 'folder', children: [] };
+            folderByPath.set(path, folder);
+            parentChildren.push(folder);
+        }
+        return folder.children ?? [];
+    };
+    for (const document of documents) {
+        const parts = document.path.split('/').filter(Boolean);
+        const folderParts = parts.slice(0, -1);
+        const children = folderParts.length > 0 ? ensureFolder(folderParts, folderParts.length - 1) : roots;
+        children.push({
+            name: document.name,
+            path: document.path,
+            type: 'document',
+            size: document.size,
+            docType: document.type,
+        });
+    }
+    const sortTree = (nodes) => {
+        nodes.sort((left, right) => {
+            if (left.type !== right.type)
+                return left.type === 'folder' ? -1 : 1;
+            return left.name.localeCompare(right.name);
+        });
+        for (const node of nodes)
+            sortTree(node.children ?? []);
+    };
+    sortTree(roots);
+    return roots;
+}
+function isKnowledgeDocument(path) {
+    const normalized = path.toLowerCase();
+    const keywords = [
+        'knowledge',
+        'memory',
+        'graph',
+        'code-intelligence',
+        'code_intelligence',
+        'karpathy',
+        'llm',
+        'context',
+        'skill',
+        'workflow',
+        'governance',
+    ];
+    return normalized.startsWith('.scale/knowledge/')
+        || normalized.startsWith('.scale/graphify-knowledge/')
+        || normalized.startsWith('graphify-out/')
+        || keywords.some(keyword => normalized.includes(keyword));
+}
+function parseStringList(value) {
+    if (Array.isArray(value))
+        return value.map(item => String(item).trim()).filter(Boolean);
+    if (typeof value !== 'string')
+        return [];
+    const trimmed = value.trim();
+    if (!trimmed)
+        return [];
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed))
+            return parsed.map(item => String(item).trim()).filter(Boolean);
+    }
+    catch {
+        // Fall back to comma-separated tags.
+    }
+    return trimmed.split(',').map(item => item.trim()).filter(Boolean);
+}
+function extractGraphNodes(raw) {
+    const record = asRecord(raw);
+    const candidates = [
+        record.nodes,
+        asRecord(record.graph).nodes,
+        asRecord(record.elements).nodes,
+        asRecord(record.data).nodes,
+    ];
+    for (const candidate of candidates) {
+        if (!Array.isArray(candidate))
+            continue;
+        return candidate
+            .map(item => asRecord(asRecord(item).data ?? item))
+            .filter(item => Object.keys(item).length > 0);
+    }
+    return [];
+}
+function extractGraphEdges(raw) {
+    const record = asRecord(raw);
+    const candidates = [
+        record.edges,
+        record.links,
+        asRecord(record.graph).edges,
+        asRecord(record.graph).links,
+        asRecord(record.elements).edges,
+        asRecord(record.data).edges,
+    ];
+    for (const candidate of candidates) {
+        if (!Array.isArray(candidate))
+            continue;
+        return candidate
+            .map(item => asRecord(asRecord(item).data ?? item))
+            .filter(item => Object.keys(item).length > 0);
+    }
+    return [];
+}
+function normalizeGraphNode(node, index, source) {
+    const id = firstString(node.id, node.key, node.name, node.path, node.label) || `${source}:node:${index}`;
+    const label = firstString(node.label, node.name, node.title, node.path, node.id) || id;
+    const kind = firstString(node.kind, node.type, node.category, node.nodeType) || 'node';
+    const group = firstString(node.group, node.layer, node.domain, node.package, node.kind, node.type) || kind;
+    return {
+        id,
+        label,
+        kind,
+        group,
+        source,
+        path: firstString(node.path, node.file, node.filePath),
+    };
+}
+function normalizeGraphEdge(edge) {
+    const source = firstString(edge.source, edge.from, edge.src, edge.start, edge.sourceId);
+    const target = firstString(edge.target, edge.to, edge.dst, edge.end, edge.targetId);
+    if (!source || !target)
+        return null;
+    return {
+        source,
+        target,
+        label: firstString(edge.label, edge.type, edge.kind, edge.relation),
+    };
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+        if (typeof value === 'number' && Number.isFinite(value))
+            return String(value);
+    }
+    return undefined;
+}
+function countBy(items, selector) {
+    const counts = {};
+    for (const item of items) {
+        const key = selector(item);
+        counts[key] = (counts[key] ?? 0) + 1;
+    }
+    return counts;
+}
+function sum(items, selector) {
+    return items.reduce((total, item) => total + selector(item), 0);
+}
+function summarizeDataSources(dataSources) {
+    return {
+        total: dataSources.length,
+        ready: dataSources.filter(source => source.status === 'ready').length,
+        partial: dataSources.filter(source => source.status === 'partial').length,
+        missing: dataSources.filter(source => source.status === 'missing').length,
+        error: dataSources.filter(source => source.status === 'error').length,
+    };
+}
+function countMatchingFiles(dir, predicate) {
+    if (!existsSync(dir))
+        return 0;
+    let count = 0;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const absolute = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            count += countMatchingFiles(absolute, predicate);
+            continue;
+        }
+        if (entry.isFile() && predicate(entry.name))
+            count += 1;
+    }
+    return count;
+}
+function latestMtime(path) {
+    if (!existsSync(path))
+        return undefined;
+    const stat = statSync(path);
+    if (stat.isFile())
+        return stat.mtimeMs;
+    let latest = stat.mtimeMs;
+    for (const entry of readdirSync(path, { withFileTypes: true })) {
+        const child = latestMtime(join(path, entry.name));
+        if (child && child > latest)
+            latest = child;
+    }
+    return latest;
+}
+function latestMtimeForDocuments(documents, projectDir, scaleDir) {
+    let latest;
+    for (const document of documents) {
+        const candidates = [join(projectDir, document.path), join(scaleDir, document.path)];
+        for (const candidate of candidates) {
+            const value = latestMtime(candidate);
+            if (value && (!latest || value > latest))
+                latest = value;
+        }
+    }
+    return latest;
+}
 //# sourceMappingURL=DashboardServer.js.map