npm - @hongmaple0820/scale-engine - Versions diffs - 0.50.1 → 0.50.2 - Mend

@hongmaple0820/scale-engine 0.50.1 → 0.50.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (50) hide show

package/README.en.md +2 -2
package/README.md +2 -2
package/dist/api/http.js +3 -1
package/dist/api/http.js.map +1 -1
package/dist/cli/cortexCommands.d.ts +16 -0
package/dist/cli/cortexCommands.js +47 -4
package/dist/cli/cortexCommands.js.map +1 -1
package/dist/cortex/InstinctStore.d.ts +13 -1
package/dist/cortex/InstinctStore.js +90 -11
package/dist/cortex/InstinctStore.js.map +1 -1
package/dist/cortex/SessionInjector.js +39 -2
package/dist/cortex/SessionInjector.js.map +1 -1
package/dist/dashboard/DashboardServer.d.ts +158 -0
package/dist/dashboard/DashboardServer.js +753 -13
package/dist/dashboard/DashboardServer.js.map +1 -1
package/dist/dashboard/spa/assets/index-VYBCLBje.js +11 -0
package/dist/dashboard/spa/assets/index-VhwY_ac1.css +1 -0
package/dist/dashboard/spa/assets/naive-ui-BQy2AJkt.js +3340 -0
package/dist/dashboard/spa/assets/vendor-BPU6aOYA.js +3 -0
package/dist/dashboard/spa/assets/vue-CQQMb5Wi.js +17 -0
package/dist/dashboard/spa/index.html +15 -462
package/dist/memory/MemoryFabric.d.ts +13 -1
package/dist/memory/MemoryFabric.js +60 -0
package/dist/memory/MemoryFabric.js.map +1 -1
package/dist/version.d.ts +1 -1
package/dist/version.js +1 -1
package/docs/workflow/ASSESSMENT_INDEX.md +326 -0
package/docs/workflow/COMPARATIVE_ANALYSIS.md +422 -0
package/docs/workflow/EXECUTIVE_SUMMARY.md +310 -0
package/docs/workflow/IMPROVEMENT_CHECKLIST.md +518 -0
package/docs/workflow/IMPROVEMENT_ROADMAP.md +707 -0
package/docs/workflow/README.md +8 -0
package/package.json +6 -2
package/dist/dashboard/spa/app.js +0 -515
package/dist/dashboard/spa/components/DataTable.js +0 -53
package/dist/dashboard/spa/components/EventStream.js +0 -66
package/dist/dashboard/spa/components/LoadingState.js +0 -39
package/dist/dashboard/spa/components/MetricCard.js +0 -30
package/dist/dashboard/spa/components/Panel.js +0 -27
package/dist/dashboard/spa/components/StatusBadge.js +0 -51
package/dist/dashboard/spa/i18n.js +0 -767
package/dist/dashboard/spa/pages/costs.js +0 -522
package/dist/dashboard/spa/pages/documents.js +0 -540
package/dist/dashboard/spa/pages/knowledge.js +0 -457
package/dist/dashboard/spa/pages/monitoring.js +0 -361
package/dist/dashboard/spa/pages/overview.js +0 -301
package/dist/dashboard/spa/pages/topology-renderers.js +0 -251
package/dist/dashboard/spa/pages/topology.js +0 -370
package/dist/dashboard/spa/pages/workflow-renderers.js +0 -239
package/dist/dashboard/spa/pages/workflow.js +0 -217

package/dist/dashboard/DashboardServer.js CHANGED Viewed

@@ -8,6 +8,7 @@ import { streamSSE } from 'hono/streaming';
 import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs';
 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';
@@ -17,6 +18,9 @@ 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 ─────────────────────────────────────────────────────
@@ -54,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',
@@ -67,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';
@@ -80,9 +91,20 @@ 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' },
@@ -125,6 +147,8 @@ export class DashboardServer {
             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
@@ -181,6 +205,34 @@ export class DashboardServer {
             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)
@@ -536,6 +588,179 @@ export class DashboardServer {
             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({
@@ -594,6 +819,13 @@ export class DashboardServer {
     }
     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;
@@ -612,8 +844,13 @@ export class DashboardServer {
         // Scan common doc locations
         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');
-        return 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')
@@ -688,7 +925,283 @@ export class DashboardServer {
             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');
@@ -764,11 +1277,188 @@ 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) {
@@ -780,4 +1470,54 @@ function countBy(items, selector) {
 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