@theihtisham/agent-shadow-brain 6.0.2 → 6.2.0

package/dist/dashboard/server.d.ts

@@ -10,7 +10,26 @@ export declare class DashboardServer {
     private clients;
     private orchestrator;
     private options;
+    private brainBusUnsub;
+    private brainWatcher;
+    private brainDbPath;
+    private seenEntryIds;
+    private brainFileDebounce;
     constructor(orchestrator: Orchestrator, options?: DashboardOptions);
+    /** Forward every realtime brain-bus event straight to all WebSocket clients. */
+    private subscribeToBrainBus;
+    /**
+     * Cross-process realtime: an agent in another terminal writes to the shared
+     * ~/.shadow-brain/global.json. That write lands in a different process's
+     * GlobalBrain instance, so the in-process bus never sees it. We watch the
+     * file and republish any entry id we have not already broadcast. The bus
+     * dedups by composite id, so our own in-process memory-writes are ignored.
+     */
+    private startBrainFileWatcher;
+    private primeSeenEntryIds;
+    /** Re-read the on-disk brain and publish any entries we haven't seen. */
+    private scanBrainFile;
+    private toEpoch;
     private handleRequest;
     private handleV6Request;
     /** Aggregate recent activity from all v6 modules into a single unified stream. */
@@ -18,9 +37,14 @@ export declare class DashboardServer {
     private readJsonBody;
     private getModulesData;
     private getMemoryData;
+    private getRuntimeContext;
     private getToolsData;
     private getTimelineData;
     private getFirewallDemo;
+    private getDefaultWorkflowProjectDir;
+    private pathExists;
+    private getWorkflowAgentStatus;
+    private getWorkflowWarnings;
     private setupWebSocket;
     private subscribeToOrchestrator;
     private send;

package/dist/dashboard/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/dashboard/server.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAMxD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAwYD,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,GAAG,CAAkB;IAC7B,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,OAAO,CAA6B;gBAEhC,YAAY,EAAE,YAAY,EAAE,OAAO,GAAE,gBAAqB;IAiBtE,OAAO,CAAC,aAAa;YAmDP,eAAe;IAwgB7B,kFAAkF;YACpE,kBAAkB;YAoElB,YAAY;IAY1B,OAAO,CAAC,cAAc;IA+CtB,OAAO,CAAC,aAAa;IAgBrB,OAAO,CAAC,YAAY;IA0BpB,OAAO,CAAC,eAAe;IAcvB,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,cAAc;IAwCtB,OAAO,CAAC,uBAAuB;IA2C/B,OAAO,CAAC,IAAI;IAMZ,OAAO,CAAC,SAAS;IASX,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;IAUxB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAY3B,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/dashboard/server.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAQxD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAmYD,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,GAAG,CAAkB;IAC7B,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,aAAa,CAA6B;IAClD,OAAO,CAAC,YAAY,CAA0B;IAC9C,OAAO,CAAC,WAAW,CAAM;IACzB,OAAO,CAAC,YAAY,CAA0B;IAC9C,OAAO,CAAC,iBAAiB,CAA+B;gBAE5C,YAAY,EAAE,YAAY,EAAE,OAAO,GAAE,gBAAqB;IAmBtE,gFAAgF;IAChF,OAAO,CAAC,mBAAmB;IAM3B;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;IAoB7B,OAAO,CAAC,iBAAiB;IAQzB,yEAAyE;IACzE,OAAO,CAAC,aAAa;IAuDrB,OAAO,CAAC,OAAO;IAMf,OAAO,CAAC,aAAa;YAmDP,eAAe;IAuvB7B,kFAAkF;YACpE,kBAAkB;YAkFlB,YAAY;IAY1B,OAAO,CAAC,cAAc;IA+CtB,OAAO,CAAC,aAAa;IAgBrB,OAAO,CAAC,iBAAiB;IAkDzB,OAAO,CAAC,YAAY;IA0BpB,OAAO,CAAC,eAAe;IAcvB,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,4BAA4B;YAQtB,UAAU;YASV,sBAAsB;IAuCpC,OAAO,CAAC,mBAAmB;IAoB3B,OAAO,CAAC,cAAc;IA4CtB,OAAO,CAAC,uBAAuB;IA2C/B,OAAO,CAAC,IAAI;IAMZ,OAAO,CAAC,SAAS;IASX,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;IAUxB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAiB3B,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/dist/dashboard/server.js

@@ -2,9 +2,13 @@
 // v5.0.1 — Infinite Intelligence Edition
 // 8-panel layout: Health, Insights, AI Tools, Memory Tiers, Modules, Fixes, Controls, Activity
 import * as http from 'http';
+import * as fs from 'fs';
+import chokidar from 'chokidar';
 import { WebSocketServer, WebSocket } from 'ws';
 import { AgentFirewall } from '../brain/agent-firewall.js';
+import { analyzeMemoryQuality, generateContextResumePack } from '../brain/context-continuity.js';
 import { getGlobalBrain, GlobalBrain } from '../brain/global-brain.js';
+import { getBrainBus } from '../brain/brain-bus.js';
 import { V6_DASHBOARD_HTML } from './v6-dashboard-html.js';
 // ── Embedded HTML Client ──────────────────────────────────────────────────────
 const HTML_CLIENT = `<!DOCTYPE html>
@@ -212,11 +216,6 @@ function ts(){return new Date().toLocaleTimeString('en-US',{hour12:false})}
 function esc(s){return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;')}
 function sc(v){return v>=85?'var(--green)':v>=70?'var(--yellow)':v>=50?'var(--orange)':'var(--red)'}
 
-// Log to insights panel feedback via activity
-function logActivity(msg,type){
-  // We no longer have a dedicated log panel, so we use a minimal approach
-}
-
 function renderHealth(s){
   if(!s)return;
   const c=sc(s.overall);
@@ -398,6 +397,11 @@ connect();
 export class DashboardServer {
     constructor(orchestrator, options = {}) {
         this.clients = new Set();
+        this.brainBusUnsub = null;
+        this.brainWatcher = null;
+        this.brainDbPath = '';
+        this.seenEntryIds = new Set();
+        this.brainFileDebounce = null;
         this.orchestrator = orchestrator;
         this.options = {
             port: options.port ?? 7341,
@@ -410,6 +414,120 @@ export class DashboardServer {
         this.wss = new WebSocketServer({ server: this.server });
         this.setupWebSocket();
         this.subscribeToOrchestrator();
+        this.subscribeToBrainBus();
+        this.startBrainFileWatcher();
+    }
+    /** Forward every realtime brain-bus event straight to all WebSocket clients. */
+    subscribeToBrainBus() {
+        this.brainBusUnsub = getBrainBus().subscribe((event) => {
+            this.broadcast({ type: 'activity', event });
+        });
+    }
+    /**
+     * Cross-process realtime: an agent in another terminal writes to the shared
+     * ~/.shadow-brain/global.json. That write lands in a different process's
+     * GlobalBrain instance, so the in-process bus never sees it. We watch the
+     * file and republish any entry id we have not already broadcast. The bus
+     * dedups by composite id, so our own in-process memory-writes are ignored.
+     */
+    startBrainFileWatcher() {
+        try {
+            const brain = getGlobalBrain();
+            this.brainDbPath = brain.dbPath;
+            // Seed the seen-set with current contents so we never replay history.
+            this.primeSeenEntryIds();
+            this.brainWatcher = chokidar.watch(this.brainDbPath, {
+                persistent: true,
+                ignoreInitial: true,
+                awaitWriteFinish: { stabilityThreshold: 300, pollInterval: 100 },
+            });
+            const onChange = () => {
+                if (this.brainFileDebounce)
+                    clearTimeout(this.brainFileDebounce);
+                this.brainFileDebounce = setTimeout(() => this.scanBrainFile(), 400);
+            };
+            this.brainWatcher.on('add', onChange).on('change', onChange);
+        }
+        catch { /* watcher is best-effort; in-process events still flow */ }
+    }
+    primeSeenEntryIds() {
+        try {
+            const raw = fs.readFileSync(this.brainDbPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            for (const e of parsed.entries ?? [])
+                this.seenEntryIds.add(e.id);
+        }
+        catch { /* file may not exist yet */ }
+    }
+    /** Re-read the on-disk brain and publish any entries we haven't seen. */
+    scanBrainFile() {
+        let parsed;
+        let raw = '';
+        try {
+            raw = fs.readFileSync(this.brainDbPath, 'utf-8');
+        }
+        catch {
+            return;
+        }
+        // Very large stores: skip the per-entry diff, emit one generic pulse.
+        if (raw.length > 8000000) {
+            getBrainBus().publish({
+                id: `brain-updated:${Date.now()}`,
+                type: 'brain-updated',
+                source: 'global-brain',
+                detail: 'brain store updated (large store — details suppressed)',
+            });
+            return;
+        }
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        const entries = parsed.entries ?? [];
+        let fresh = 0;
+        for (const e of entries) {
+            const id = String(e.id ?? '');
+            if (!id || this.seenEntryIds.has(id))
+                continue;
+            this.seenEntryIds.add(id);
+            fresh++;
+            // Cap how many we replay in a single burst to avoid flooding the UI.
+            if (fresh > 100)
+                continue;
+            getBrainBus().publish({
+                id: `memory-write:${id}`,
+                ts: this.toEpoch(e.createdAt),
+                type: 'memory-write',
+                source: String(e.agentTool ?? 'agent'),
+                detail: `[${String(e.category ?? '')}] ${String(e.content ?? '').slice(0, 220)}`,
+                meta: {
+                    category: e.category,
+                    importance: e.importance,
+                    projectName: e.projectName,
+                    crossProcess: true,
+                },
+            });
+        }
+        if (fresh > 100) {
+            getBrainBus().publish({
+                id: `brain-updated:${Date.now()}`,
+                type: 'brain-updated',
+                source: 'global-brain',
+                detail: `${fresh} memories written (showing first 100)`,
+            });
+        }
+    }
+    toEpoch(v) {
+        if (typeof v === 'number')
+            return v;
+        if (typeof v === 'string') {
+            const t = Date.parse(v);
+            if (!Number.isNaN(t))
+                return t;
+        }
+        return Date.now();
     }
     handleRequest(req, res) {
         const url = req.url || '/';
@@ -508,9 +626,11 @@ export class DashboardServer {
                 const brain = getGlobalBrain();
                 await brain.init();
                 const tokenReport = await tokens.report();
+                const runtime = this.getRuntimeContext();
                 return send({
-                    version: '6.0.0',
+                    version: '6.0.3',
                     localFirst: true,
+                    runtime,
                     totalAgentsConnected: brain.getStats().totalAgents,
                     totalMemoriesStored: brain.getStats().totalEntries,
                     modules: {
@@ -526,6 +646,171 @@ export class DashboardServer {
                     generatedAt: new Date(),
                 });
             }
+            case '/api/v6/ww2br-ops': {
+                const projectDir = String(qs.get('projectDir') || body.projectDir || this.getDefaultWorkflowProjectDir());
+                const brain = getGlobalBrain();
+                await brain.init();
+                const stats = brain.getStats();
+                const projectId = GlobalBrain.projectIdFor(projectDir);
+                let timeline = brain.timeline({ projectId, limit: 18 });
+                let scoped = true;
+                if (!timeline.length) {
+                    scoped = false;
+                    timeline = brain.timeline({ limit: 18 });
+                }
+                const memoryEntries = brain.recall({
+                    projectId: scoped ? projectId : undefined,
+                    minImportance: 0,
+                    limit: 500,
+                });
+                const quality = analyzeMemoryQuality(memoryEntries);
+                const resumePack = generateContextResumePack({
+                    projectDir,
+                    projectName: projectDir.split(/[\\/]/).filter(Boolean).pop() ?? projectDir,
+                    projectId,
+                    entries: memoryEntries,
+                    maxMemories: 12,
+                });
+                const agents = await this.getWorkflowAgentStatus(projectDir);
+                const categories = {};
+                for (const event of timeline)
+                    categories[event.category] = (categories[event.category] ?? 0) + 1;
+                return send({
+                    projectDir,
+                    projectName: projectDir.split(/[\\/]/).filter(Boolean).pop() ?? projectDir,
+                    projectExists: await this.pathExists(projectDir),
+                    projectScoped: scoped,
+                    stats,
+                    agents,
+                    warnings: this.getWorkflowWarnings(projectDir, agents, timeline, scoped),
+                    recent: timeline,
+                    categories,
+                    quality,
+                    resumePack: {
+                        generatedAt: resumePack.generatedAt,
+                        stats: resumePack.stats,
+                        warnings: resumePack.warnings,
+                        suggestedRecallQueries: resumePack.suggestedRecallQueries,
+                        blockers: resumePack.blockers.slice(0, 5),
+                        topMemories: resumePack.topMemories.slice(0, 5),
+                    },
+                    generatedAt: new Date(),
+                });
+            }
+            case '/api/v6/ww2br-recall': {
+                const projectDir = String(qs.get('projectDir') || body.projectDir || this.getDefaultWorkflowProjectDir());
+                const query = String(qs.get('q') || qs.get('query') || (body.query ?? '')).trim();
+                const brain = getGlobalBrain();
+                await brain.init();
+                const projectId = GlobalBrain.projectIdFor(projectDir);
+                const common = {
+                    agentTool: qs.get('agent') || body.agent || undefined,
+                    category: qs.get('category') || body.category || undefined,
+                    keywords: query ? query.split(/\s+/).filter(Boolean) : undefined,
+                    minImportance: Number(qs.get('minImportance') ?? body.minImportance ?? 0),
+                    limit: Number(qs.get('limit') ?? body.limit ?? 12),
+                };
+                const projectResults = brain.recall({ projectId, ...common });
+                const results = projectResults.length ? projectResults : brain.recall(common);
+                return send({
+                    projectDir,
+                    projectScoped: projectResults.length > 0,
+                    query,
+                    results,
+                    generatedAt: new Date(),
+                });
+            }
+            case '/api/v6/resume-pack': {
+                const projectDir = String(qs.get('projectDir') || body.projectDir || this.getDefaultWorkflowProjectDir());
+                const format = String(qs.get('format') || body.format || 'json').toLowerCase();
+                const limit = Number(qs.get('limit') ?? body.limit ?? 12);
+                const brain = getGlobalBrain();
+                await brain.init();
+                const projectId = GlobalBrain.projectIdFor(projectDir);
+                let entries = brain.recall({ projectId, minImportance: 0, limit: 500 });
+                let projectScoped = true;
+                if (!entries.length) {
+                    projectScoped = false;
+                    entries = brain.recall({ minImportance: 0, limit: 500 });
+                }
+                const pack = generateContextResumePack({
+                    projectDir,
+                    projectName: projectDir.split(/[\\/]/).filter(Boolean).pop() ?? projectDir,
+                    projectId,
+                    entries,
+                    maxMemories: Number.isFinite(limit) ? Math.max(1, Math.min(30, limit)) : 12,
+                });
+                if (format === 'markdown' || format === 'md')
+                    return send(pack.markdown, 200, 'text/markdown; charset=utf-8');
+                return send({ ...pack, projectScoped });
+            }
+            case '/api/v6/live-brain': {
+                const { getLiveBrain } = await import('../brain/live-brain.js');
+                const projectDir = String(qs.get('projectDir') || body.projectDir || this.getDefaultWorkflowProjectDir());
+                const format = String(qs.get('format') || body.format || 'json').toLowerCase();
+                const queriesRaw = String(qs.get('queries') || body.queries || '').trim();
+                const queries = queriesRaw ? queriesRaw.split('|').map(q => q.trim()).filter(Boolean) : undefined;
+                const report = await getLiveBrain().report({
+                    projectDir,
+                    maxMemories: Number(qs.get('limit') ?? body.limit ?? 12),
+                    queries,
+                    globalFallback: body.globalFallback !== false && qs.get('globalFallback') !== 'false',
+                });
+                if (format === 'markdown' || format === 'md')
+                    return send(report.agentBriefing, 200, 'text/markdown; charset=utf-8');
+                return send(report);
+            }
+            case '/api/v6/seed-drafts': {
+                const { getMemorySeeder } = await import('../brain/memory-seeder.js');
+                const limit = Number(qs.get('limit') ?? body.limit ?? 30);
+                const seeder = getMemorySeeder();
+                await seeder.init();
+                return send(seeder.list(limit));
+            }
+            case '/api/v6/seed-draft': {
+                const { getMemorySeeder } = await import('../brain/memory-seeder.js');
+                const seeder = getMemorySeeder();
+                return send(await seeder.createDraft({
+                    topic: body.topic,
+                    objective: body.objective,
+                    projectDir: body.projectDir || this.getDefaultWorkflowProjectDir(),
+                    category: body.category,
+                    tags: body.tags,
+                    importance: body.importance,
+                    researchAgent: body.researchAgent,
+                    approverAgent: body.approverAgent,
+                    approvalMode: body.approvalMode,
+                    sources: body.sources,
+                    content: body.content,
+                }));
+            }
+            case '/api/v6/seed-approve': {
+                const { getMemorySeeder } = await import('../brain/memory-seeder.js');
+                return send(await getMemorySeeder().approve(body.id, body.approvedBy || 'user', body.note));
+            }
+            case '/api/v6/seed-reject': {
+                const { getMemorySeeder } = await import('../brain/memory-seeder.js');
+                return send(await getMemorySeeder().reject(body.id, body.rejectedBy || 'user', body.reason || 'Rejected from dashboard'));
+            }
+            case '/api/v6/seed-commit': {
+                const { getMemorySeeder } = await import('../brain/memory-seeder.js');
+                return send(await getMemorySeeder().seed(body.id, body.seededBy || 'user'));
+            }
+            case '/api/v6/agent-handoff': {
+                const { AgentHandoff } = await import('../brain/agent-handoff.js');
+                const projectDir = String(body.projectDir || qs.get('projectDir') || this.getDefaultWorkflowProjectDir());
+                const packet = await new AgentHandoff().generate({
+                    fromAgent: (body.fromAgent || 'user'),
+                    toAgent: (body.toAgent || 'claude-code'),
+                    projectDir,
+                    task: body.task,
+                    limit: body.limit ?? 12,
+                });
+                const format = String(body.format || qs.get('format') || 'json').toLowerCase();
+                if (format === 'markdown' || format === 'md')
+                    return send(packet.markdown, 200, 'text/markdown; charset=utf-8');
+                return send(packet);
+            }
             case '/api/v6/subagent-sliver': {
                 const { getSubAgentBridge } = await import('../brain/subagent-bridge.js');
                 const b = getSubAgentBridge();
@@ -620,7 +905,8 @@ export class DashboardServer {
             }
             case '/api/v6/tokens-report': {
                 const { getTokenEconomy } = await import('../brain/token-economy.js');
-                return send(await getTokenEconomy().report());
+                const report = await getTokenEconomy().report();
+                return send({ ...report, runtime: this.getRuntimeContext() });
             }
             case '/api/v6/forget-consolidate': {
                 const { getForgettingCurve } = await import('../brain/forgetting-curve.js');
@@ -968,6 +1254,75 @@ export class DashboardServer {
                     return send({});
                 }
             }
+            case '/api/v6/memory-intelligence': {
+                const brain = getGlobalBrain();
+                await brain.init();
+                const limit = Number(qs.get('limit') ?? body.limit ?? 500);
+                const events = brain.timeline({ limit: Number.isFinite(limit) ? Math.max(50, Math.min(2000, limit)) : 500 });
+                const now = Date.now();
+                const byCategory = {};
+                const byAgent = {};
+                const topTags = {};
+                let sourceBacked = 0;
+                let recent24h = 0;
+                let recent7d = 0;
+                let stale30d = 0;
+                let highImportance = 0;
+                for (const event of events) {
+                    const createdAt = new Date(event.createdAt).getTime();
+                    const ageMs = now - createdAt;
+                    byCategory[event.category] = (byCategory[event.category] ?? 0) + 1;
+                    byAgent[event.agentTool] = (byAgent[event.agentTool] ?? 0) + 1;
+                    if (event.importance >= 0.75)
+                        highImportance++;
+                    if (ageMs <= 24 * 60 * 60 * 1000)
+                        recent24h++;
+                    if (ageMs <= 7 * 24 * 60 * 60 * 1000)
+                        recent7d++;
+                    if (ageMs > 30 * 24 * 60 * 60 * 1000)
+                        stale30d++;
+                    const sources = Array.isArray(event.metadata?.sources) ? event.metadata.sources : [];
+                    if (sources.length > 0)
+                        sourceBacked++;
+                    const tags = Array.isArray(event.metadata?.tags) ? event.metadata.tags : [];
+                    for (const tag of tags) {
+                        const key = String(tag).trim();
+                        if (key)
+                            topTags[key] = (topTags[key] ?? 0) + 1;
+                    }
+                }
+                const sortRecord = (record) => Object.entries(record)
+                    .sort((a, b) => b[1] - a[1])
+                    .slice(0, 12)
+                    .map(([name, count]) => ({ name, count }));
+                let seedDrafts = [];
+                try {
+                    const { getMemorySeeder } = await import('../brain/memory-seeder.js');
+                    const seeder = getMemorySeeder();
+                    await seeder.init();
+                    seedDrafts = seeder.list(100);
+                }
+                catch {
+                    seedDrafts = [];
+                }
+                return send({
+                    totalEntries: brain.getStats().totalEntries,
+                    sampledEntries: events.length,
+                    sourceBacked,
+                    sourceCoverage: events.length ? sourceBacked / events.length : 0,
+                    recent24h,
+                    recent7d,
+                    stale30d,
+                    highImportance,
+                    byCategory: sortRecord(byCategory),
+                    byAgent: sortRecord(byAgent),
+                    topTags: sortRecord(topTags),
+                    openSeedDrafts: seedDrafts.filter(d => d.status === 'draft' || d.status === 'approved').length,
+                    pendingApprovals: seedDrafts.filter(d => d.status === 'draft').length,
+                    recent: events.slice(0, 12),
+                    generatedAt: new Date(),
+                });
+            }
             case '/api/v6/memory-browser': {
                 const brain = getGlobalBrain();
                 await brain.init();
@@ -990,6 +1345,21 @@ export class DashboardServer {
                     }));
                 return send(results);
             }
+            case '/api/v6/memory-graph': {
+                const { getMemoryGraph } = await import('../brain/memory-graph.js');
+                const projectDirRaw = String(qs.get('projectDir') || body.projectDir || '').trim();
+                const limit = Number(qs.get('limit') ?? body.limit ?? 400);
+                const maxNodes = Number(qs.get('maxNodes') ?? body.maxNodes ?? 180);
+                const minImportance = Number(qs.get('minImportance') ?? body.minImportance ?? 0);
+                const projectId = projectDirRaw ? GlobalBrain.projectIdFor(projectDirRaw) : undefined;
+                const snapshot = await getMemoryGraph().build({
+                    projectId,
+                    limit: Number.isFinite(limit) ? limit : 400,
+                    maxNodes: Number.isFinite(maxNodes) ? maxNodes : 180,
+                    minImportance: Number.isFinite(minImportance) ? minImportance : 0,
+                });
+                return send(snapshot);
+            }
             case '/api/v6/topology': {
                 // Assemble a real-time topology snapshot: agents + sub-agents + recent signal events
                 const projectDir = body.projectDir || process.cwd();
@@ -1082,6 +1452,20 @@ export class DashboardServer {
             }
         }
         catch { /* empty */ }
+        try {
+            const { getMemorySeeder } = await import('../brain/memory-seeder.js');
+            const seeder = getMemorySeeder();
+            await seeder.init();
+            for (const draft of seeder.list(30)) {
+                events.push({
+                    timestamp: new Date(draft.updatedAt || draft.createdAt),
+                    source: `seed:${draft.researchAgent}`,
+                    type: draft.status === 'seeded' ? 'memory-seeded' : 'seed-draft',
+                    detail: `[${draft.status}] ${draft.topic} | approval: ${draft.approvalMode}`,
+                });
+            }
+        }
+        catch { /* empty */ }
         try {
             const { getSubAgentBridge } = await import('../brain/subagent-bridge.js');
             const bridge = getSubAgentBridge();
@@ -1212,6 +1596,48 @@ export class DashboardServer {
             return { raw: 0, summary: 0, pattern: 0, principle: 0, turboCompression: 0 };
         }
     }
+    getRuntimeContext() {
+        const status = this.orchestrator.getStatus();
+        const agents = (status.agents || []).map(a => a.toLowerCase());
+        let currentAgentTool = null;
+        let source = 'orchestrator';
+        if (process.env.CODEX_SHELL || process.env.CODEX_THREAD_ID || process.env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE) {
+            currentAgentTool = 'codex';
+            source = 'environment';
+        }
+        else if (agents.some(a => a.includes('codex'))) {
+            currentAgentTool = 'codex';
+        }
+        else if (agents.some(a => a.includes('claude'))) {
+            currentAgentTool = 'claude-code';
+        }
+        else if (agents.some(a => a.includes('cursor'))) {
+            currentAgentTool = 'cursor';
+        }
+        const labels = {
+            codex: 'Codex',
+            'claude-code': 'Claude Code',
+            cursor: 'Cursor',
+            cline: 'Cline',
+            copilot: 'Copilot',
+            windsurf: 'Windsurf',
+            'kilo-code': 'Kilo Code',
+            'roo-code': 'Roo Code',
+            opencode: 'OpenCode',
+            aider: 'Aider',
+        };
+        const statusProvider = typeof status.provider === 'string' ? status.provider : '';
+        const provider = statusProvider || (process.env.OPENAI_BASE_URL ? 'openai-compatible' : 'ollama');
+        const model = typeof status.model === 'string' && status.model.trim() ? status.model : null;
+        return {
+            currentAgentTool,
+            currentAgentDisplay: currentAgentTool ? labels[currentAgentTool] ?? currentAgentTool : 'Unknown agent',
+            provider,
+            model,
+            source,
+            note: 'Current agent is runtime context. Token spend rows are historical records and may include other agents or models.',
+        };
+    }
     getToolsData() {
         try {
             const status = this.orchestrator.getStatus();
@@ -1262,6 +1688,80 @@ export class DashboardServer {
             return { allowed: true, findings: [], riskScore: 0, summary: 'Firewall unavailable' };
         }
     }
+    getDefaultWorkflowProjectDir() {
+        const status = this.orchestrator.getStatus();
+        const configured = String(status.projectDir || '').trim();
+        const ww2br = 'D:\\New Game';
+        if (configured)
+            return configured;
+        return ww2br;
+    }
+    async pathExists(pathToCheck) {
+        try {
+            const fs = await import('node:fs');
+            return fs.existsSync(pathToCheck);
+        }
+        catch {
+            return false;
+        }
+    }
+    async getWorkflowAgentStatus(projectDir) {
+        const knownAgents = [
+            { name: 'claude-code', displayName: 'Claude Code' },
+            { name: 'cursor', displayName: 'Cursor' },
+            { name: 'cline', displayName: 'Cline' },
+            { name: 'codex', displayName: 'Codex' },
+            { name: 'copilot', displayName: 'GitHub Copilot' },
+            { name: 'windsurf', displayName: 'Windsurf' },
+            { name: 'kilo-code', displayName: 'Kilo Code' },
+            { name: 'roo-code', displayName: 'Roo Code' },
+            { name: 'opencode', displayName: 'OpenCode' },
+            { name: 'aider', displayName: 'Aider' },
+        ];
+        let detected = [];
+        let hooks = [];
+        try {
+            const { detectRunningAgents } = await import('../adapters/index.js');
+            detected = await detectRunningAgents(projectDir);
+        }
+        catch {
+            detected = [];
+        }
+        try {
+            const { getHookInstaller } = await import('../brain/session-hooks.js');
+            hooks = await getHookInstaller().audit(projectDir);
+        }
+        catch {
+            hooks = [];
+        }
+        return knownAgents.map(agent => {
+            const det = detected.find((d) => d.name === agent.name);
+            const hook = hooks.find((h) => h.agent === agent.name);
+            return {
+                ...agent,
+                detected: !!det,
+                hookInstalled: !!hook,
+                hookPath: hook?.installPath,
+            };
+        });
+    }
+    getWorkflowWarnings(projectDir, agents, timeline, projectScoped) {
+        const warnings = [];
+        if (!projectDir)
+            warnings.push('No active project path is configured for the workflow view.');
+        if (!agents.some(a => a.detected || a.hookInstalled)) {
+            warnings.push('No agent integrations are detected or hooked for this project path.');
+        }
+        else if (!agents.some(a => a.hookInstalled)) {
+            warnings.push('Agent tools may be present, but Shadow Brain hooks are not installed for this project path.');
+        }
+        if (!projectScoped && timeline.length > 0) {
+            warnings.push('No project-scoped memories found; showing the latest global brain memories instead.');
+        }
+        if (!timeline.length)
+            warnings.push('No memories are available yet. Run agents with Shadow Brain attached to build the timeline.');
+        return warnings;
+    }
     setupWebSocket() {
         this.wss.on('connection', (ws) => {
             this.clients.add(ws);
@@ -1293,6 +1793,9 @@ export class DashboardServer {
                 evolutionGen: status.evolutionGeneration ?? 0,
                 swarmConv: status.swarmConvergence ?? 0,
             });
+            // Replay recent realtime activity so a late-connecting client's live
+            // feed is populated immediately instead of waiting for the next event.
+            this.send(ws, { type: 'activity-backlog', events: getBrainBus().recent(50) });
             ws.on('close', () => { this.clients.delete(ws); });
             ws.on('error', () => { this.clients.delete(ws); });
         });
@@ -1356,6 +1859,20 @@ export class DashboardServer {
     }
     async stop() {
         return new Promise((resolve) => {
+            try {
+                this.brainBusUnsub?.();
+            }
+            catch { /* ignore */ }
+            this.brainBusUnsub = null;
+            if (this.brainFileDebounce) {
+                clearTimeout(this.brainFileDebounce);
+                this.brainFileDebounce = null;
+            }
+            try {
+                this.brainWatcher?.close();
+            }
+            catch { /* ignore */ }
+            this.brainWatcher = null;
             for (const client of this.clients) {
                 try {
                     client.close();