@10et/cli 1.0.0

package/dist/commands/context-hub.js

@@ -0,0 +1,3505 @@
+/**
+ * jfl context-hub - Unified context layer for AI agents
+ *
+ * Provides context from journal, knowledge docs, and code to any AI.
+ * Works locally (CLI) and hosted (platform).
+ *
+ * @purpose CLI command for Context Hub daemon management
+ */
+import chalk from "chalk";
+import ora from "ora";
+import { execSync, spawn } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import * as http from "http";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+import { initializeDatabase, getMemoryStats, insertMemory, getLinksFrom, getLinksTo, getMemoriesByIds, addLink, } from "../lib/memory-db.js";
+import { searchMemories } from "../lib/memory-search.js";
+import { indexJournalEntries, startPeriodicIndexing, backfillEmbeddings, indexCodeHeaders } from "../lib/memory-indexer.js";
+import { getProjectPort } from "../utils/context-hub-port.js";
+import { getConfigValue, setConfig } from "../utils/jfl-config.js";
+import Conf from "conf";
+import { MAPEventBus } from "../lib/map-event-bus.js";
+import { FlowEngine } from "../lib/flow-engine.js";
+import { WebSocketServer } from "ws";
+import { telemetry } from "../lib/telemetry.js";
+import { transformHookPayload } from "../lib/hook-transformer.js";
+import { loadAllAgentConfigs } from "../lib/agent-config.js";
+import { TrainingBuffer } from "../lib/training-buffer.js";
+import { FindingsEngine } from "../lib/findings-engine.js";
+const PID_FILE = ".jfl/context-hub.pid";
+const LOG_FILE = ".jfl/logs/context-hub.log";
+const TOKEN_FILE = ".jfl/context-hub.token";
+// ============================================================================
+// Security
+// ============================================================================
+function generateToken() {
+    return Array.from({ length: 32 }, () => Math.floor(Math.random() * 16).toString(16)).join('');
+}
+function getTokenFile(projectRoot) {
+    return path.join(projectRoot, TOKEN_FILE);
+}
+function getOrCreateToken(projectRoot) {
+    const tokenFile = getTokenFile(projectRoot);
+    if (fs.existsSync(tokenFile)) {
+        return fs.readFileSync(tokenFile, 'utf-8').trim();
+    }
+    const token = generateToken();
+    fs.writeFileSync(tokenFile, token, { mode: 0o600 }); // Owner read/write only
+    return token;
+}
+function validateAuth(req, projectRoot, url) {
+    const tokenFile = getTokenFile(projectRoot);
+    // If no token file exists, allow access (backwards compatibility during migration)
+    if (!fs.existsSync(tokenFile)) {
+        return true;
+    }
+    const expectedToken = fs.readFileSync(tokenFile, 'utf-8').trim();
+    // Check Authorization header first
+    const authHeader = req.headers['authorization'];
+    if (authHeader) {
+        const providedToken = authHeader.startsWith('Bearer ')
+            ? authHeader.slice(7)
+            : authHeader;
+        if (providedToken === expectedToken)
+            return true;
+    }
+    // Fall back to ?token= query param (needed for SSE/EventSource which can't set headers)
+    if (url) {
+        const queryToken = url.searchParams.get('token');
+        if (queryToken && queryToken === expectedToken)
+            return true;
+    }
+    return false;
+}
+function isPortInUse(port) {
+    return new Promise((resolve) => {
+        const server = http.createServer();
+        server.once('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                resolve(true);
+            }
+            else {
+                resolve(false);
+            }
+        });
+        server.once('listening', () => {
+            server.close();
+            resolve(false);
+        });
+        server.listen(port);
+    });
+}
+// ============================================================================
+// Journal Reader
+// ============================================================================
+function readJournalEntries(projectRoot, limit = 50) {
+    const journalDir = path.join(projectRoot, ".jfl", "journal");
+    const items = [];
+    if (!fs.existsSync(journalDir)) {
+        return items;
+    }
+    // Sort by modification time (newest first) so recent entries aren't buried
+    const files = fs.readdirSync(journalDir)
+        .filter(f => f.endsWith(".jsonl"))
+        .map(f => ({
+        name: f,
+        mtime: fs.statSync(path.join(journalDir, f)).mtimeMs
+    }))
+        .sort((a, b) => b.mtime - a.mtime)
+        .map(f => f.name);
+    // Read all entries from all files, then sort globally by timestamp
+    const allEntries = [];
+    for (const file of files) {
+        const filePath = path.join(journalDir, file);
+        const content = fs.readFileSync(filePath, "utf-8");
+        const lines = content.trim().split("\n").filter(l => l.trim());
+        for (const line of lines) {
+            try {
+                const entry = JSON.parse(line);
+                allEntries.push({
+                    source: "journal",
+                    type: entry.type || "entry",
+                    title: entry.title || "Untitled",
+                    content: entry.summary || entry.detail || "",
+                    timestamp: entry.ts,
+                    path: filePath
+                });
+            }
+            catch {
+                // Skip malformed lines
+            }
+        }
+    }
+    // Sort all entries by timestamp descending, then take the limit
+    allEntries.sort((a, b) => {
+        const ta = a.timestamp || "";
+        const tb = b.timestamp || "";
+        return tb.localeCompare(ta);
+    });
+    return allEntries.slice(0, limit);
+}
+// ============================================================================
+// Knowledge Reader
+// ============================================================================
+function readKnowledgeDocs(projectRoot) {
+    const knowledgeDir = path.join(projectRoot, "knowledge");
+    const items = [];
+    if (!fs.existsSync(knowledgeDir)) {
+        return items;
+    }
+    const priorityFiles = [
+        "VISION.md",
+        "ROADMAP.md",
+        "NARRATIVE.md",
+        "THESIS.md",
+        "BRAND_DECISIONS.md",
+        "TASKS.md",
+        "ARCHITECTURE.md",
+        "SERVICE_SPEC.md",
+        "DEPLOYMENT.md",
+        "RUNBOOK.md",
+    ];
+    for (const filename of priorityFiles) {
+        const filePath = path.join(knowledgeDir, filename);
+        if (fs.existsSync(filePath)) {
+            const content = fs.readFileSync(filePath, "utf-8");
+            const title = filename.replace(".md", "").replace(/_/g, " ");
+            items.push({
+                source: "knowledge",
+                type: "doc",
+                title,
+                content: content.slice(0, 2000),
+                path: filePath
+            });
+        }
+    }
+    return items;
+}
+function discoverServices(projectRoot) {
+    const services = {};
+    // Look for .jfl/services.json in current project and parent directories
+    // Also search sibling GTM directories
+    const searchPaths = [
+        projectRoot,
+        path.join(projectRoot, ".."),
+        path.join(projectRoot, "../.."),
+    ];
+    // Add sibling directories (e.g., if in jfl-cli, check ../JFL-GTM)
+    const parentDir = path.join(projectRoot, "..");
+    if (fs.existsSync(parentDir)) {
+        try {
+            const siblings = fs.readdirSync(parentDir, { withFileTypes: true });
+            for (const sibling of siblings) {
+                if (sibling.isDirectory() && (sibling.name.includes("GTM") || sibling.name.includes("gtm"))) {
+                    searchPaths.push(path.join(parentDir, sibling.name));
+                }
+            }
+        }
+        catch {
+            // Ignore read errors
+        }
+    }
+    for (const searchPath of searchPaths) {
+        if (!fs.existsSync(searchPath))
+            continue;
+        const servicesFile = path.join(searchPath, ".jfl/services.json");
+        if (fs.existsSync(servicesFile)) {
+            try {
+                const servicesData = JSON.parse(fs.readFileSync(servicesFile, "utf-8"));
+                for (const [serviceName, serviceData] of Object.entries(servicesData)) {
+                    const data = serviceData;
+                    // Check if service has service.json with MCP info
+                    let mcpInfo;
+                    const serviceJsonPath = path.join(data.path, "service.json");
+                    if (fs.existsSync(serviceJsonPath)) {
+                        try {
+                            const serviceJson = JSON.parse(fs.readFileSync(serviceJsonPath, "utf-8"));
+                            if (serviceJson.mcp) {
+                                mcpInfo = {
+                                    enabled: serviceJson.mcp.enabled || false,
+                                    transport: serviceJson.mcp.transport || "stdio"
+                                };
+                            }
+                        }
+                        catch {
+                            // Ignore parse errors
+                        }
+                    }
+                    // Determine service status (basic check - could be enhanced)
+                    let status = "unknown";
+                    if (data.port) {
+                        // Could check if port is in use
+                        status = "stopped";
+                    }
+                    services[serviceName] = {
+                        name: serviceName,
+                        type: data.type || "unknown",
+                        description: data.description || "",
+                        path: data.path,
+                        status,
+                        mcp: mcpInfo,
+                        commands: data.commands,
+                        healthcheck: data.healthcheck,
+                        port: data.port,
+                        dependencies: data.dependencies
+                    };
+                }
+            }
+            catch (err) {
+                console.error(`Failed to read services from ${servicesFile}:`, err);
+            }
+        }
+    }
+    return services;
+}
+// ============================================================================
+// Code Context Reader
+// ============================================================================
+function extractPurpose(content) {
+    const match = content.match(/@purpose\s+(.+?)(?:\n|\*)/i);
+    return match ? match[1].trim() : null;
+}
+function readCodeContext(projectRoot, limit = 30) {
+    const items = [];
+    // Look for files with @purpose in common locations
+    const searchDirs = [
+        path.join(projectRoot, "src"),
+        path.join(projectRoot, "app"),
+        path.join(projectRoot, "lib"),
+        path.join(projectRoot, "components"),
+        path.join(projectRoot, "product", "src"),
+        path.join(projectRoot, "product", "packages")
+    ];
+    const extensions = [".ts", ".tsx", ".js", ".jsx"];
+    function scanDir(dir, depth = 0) {
+        if (depth > 4 || items.length >= limit)
+            return;
+        if (!fs.existsSync(dir))
+            return;
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (items.length >= limit)
+                    break;
+                if (entry.name.startsWith(".") || entry.name === "node_modules")
+                    continue;
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    scanDir(fullPath, depth + 1);
+                }
+                else if (extensions.some(ext => entry.name.endsWith(ext))) {
+                    try {
+                        const content = fs.readFileSync(fullPath, "utf-8");
+                        const purpose = extractPurpose(content);
+                        if (purpose) {
+                            items.push({
+                                source: "code",
+                                type: "file",
+                                title: entry.name,
+                                content: purpose,
+                                path: fullPath
+                            });
+                        }
+                    }
+                    catch {
+                        // Skip unreadable files
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip unreadable directories
+        }
+    }
+    for (const dir of searchDirs) {
+        scanDir(dir);
+    }
+    return items;
+}
+/**
+ * Read GTM content artifacts — drafts, specs, content, scripts.
+ * Used instead of code indexing for GTM-type projects.
+ */
+function readGtmContent(projectRoot, limit = 40) {
+    const items = [];
+    const gtmDirs = [
+        { dir: "content", type: "content" },
+        { dir: "drafts", type: "draft" },
+        { dir: "specs", type: "spec" },
+        { dir: "scripts", type: "script" },
+    ];
+    const mdExtensions = [".md", ".txt"];
+    const scriptExtensions = [".sh", ".py", ".mjs", ".js"];
+    for (const { dir, type } of gtmDirs) {
+        const fullDir = path.join(projectRoot, dir);
+        if (!fs.existsSync(fullDir))
+            continue;
+        function scanDir(d, depth = 0) {
+            if (depth > 3 || items.length >= limit)
+                return;
+            try {
+                const entries = fs.readdirSync(d, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (items.length >= limit)
+                        break;
+                    if (entry.name.startsWith(".") || entry.name === "node_modules")
+                        continue;
+                    const fullPath = path.join(d, entry.name);
+                    if (entry.isDirectory()) {
+                        scanDir(fullPath, depth + 1);
+                    }
+                    else {
+                        const isMarkdown = mdExtensions.some(ext => entry.name.endsWith(ext));
+                        const isScript = type === "script" && scriptExtensions.some(ext => entry.name.endsWith(ext));
+                        if (isMarkdown || isScript) {
+                            try {
+                                const raw = fs.readFileSync(fullPath, "utf-8");
+                                // Extract first heading + first paragraph as summary
+                                const lines = raw.split("\n").filter(l => l.trim());
+                                const heading = lines.find(l => l.startsWith("#"))?.replace(/^#+\s*/, "") || entry.name;
+                                const bodyLines = lines.filter(l => !l.startsWith("#") && !l.startsWith("---"));
+                                const summary = bodyLines.slice(0, 5).join(" ").slice(0, 500);
+                                if (summary.length > 20) {
+                                    items.push({
+                                        source: "content",
+                                        type,
+                                        title: heading,
+                                        content: summary,
+                                        path: fullPath
+                                    });
+                                }
+                            }
+                            catch {
+                                // Skip unreadable files
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // Skip unreadable directories
+            }
+        }
+        scanDir(fullDir);
+    }
+    return items;
+}
+// ============================================================================
+// Search & Scoring (TF-IDF style)
+// ============================================================================
+function tokenize(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\w\s]/g, " ")
+        .split(/\s+/)
+        .filter(t => t.length > 2);
+}
+function computeTF(tokens) {
+    const tf = new Map();
+    for (const token of tokens) {
+        tf.set(token, (tf.get(token) || 0) + 1);
+    }
+    // Normalize by document length
+    for (const [term, count] of tf) {
+        tf.set(term, count / tokens.length);
+    }
+    return tf;
+}
+function computeIDF(documents) {
+    const idf = new Map();
+    const N = documents.length;
+    // Count documents containing each term
+    const docCount = new Map();
+    for (const doc of documents) {
+        const uniqueTerms = new Set(doc);
+        for (const term of uniqueTerms) {
+            docCount.set(term, (docCount.get(term) || 0) + 1);
+        }
+    }
+    // Compute IDF
+    for (const [term, count] of docCount) {
+        idf.set(term, Math.log((N + 1) / (count + 1)) + 1);
+    }
+    return idf;
+}
+function scoreItem(item, queryTokens, idf) {
+    const text = `${item.title} ${item.content}`;
+    const tokens = tokenize(text);
+    const tf = computeTF(tokens);
+    let score = 0;
+    for (const queryTerm of queryTokens) {
+        const termTF = tf.get(queryTerm) || 0;
+        const termIDF = idf.get(queryTerm) || 1;
+        score += termTF * termIDF;
+    }
+    // Boost title matches
+    const titleTokens = new Set(tokenize(item.title));
+    for (const queryTerm of queryTokens) {
+        if (titleTokens.has(queryTerm)) {
+            score *= 1.5;
+        }
+    }
+    // Boost recent items (journal)
+    if (item.source === "journal" && item.timestamp) {
+        const age = Date.now() - new Date(item.timestamp).getTime();
+        const daysSinceUpdate = age / (1000 * 60 * 60 * 24);
+        if (daysSinceUpdate < 7) {
+            score *= 1.3; // Boost recent entries
+        }
+    }
+    return score;
+}
+function semanticSearch(items, query) {
+    const queryTokens = tokenize(query);
+    if (queryTokens.length === 0)
+        return items;
+    // Build corpus for IDF
+    const documents = items.map(item => tokenize(`${item.title} ${item.content}`));
+    const idf = computeIDF(documents);
+    // Score and sort
+    for (const item of items) {
+        item.relevance = scoreItem(item, queryTokens, idf);
+    }
+    return items
+        .filter(item => (item.relevance || 0) > 0)
+        .sort((a, b) => (b.relevance || 0) - (a.relevance || 0));
+}
+// ============================================================================
+// Orchestrator
+// ============================================================================
+function getProjectType(projectRoot) {
+    const configPath = path.join(projectRoot, ".jfl", "config.json");
+    if (fs.existsSync(configPath)) {
+        try {
+            const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            return config.type || "standalone";
+        }
+        catch { }
+    }
+    return "standalone";
+}
+function getUnifiedContext(projectRoot, query, taskType) {
+    const journalItems = readJournalEntries(projectRoot);
+    const knowledgeItems = readKnowledgeDocs(projectRoot);
+    const projectType = getProjectType(projectRoot);
+    const codeItems = readCodeContext(projectRoot);
+    const contentItems = projectType === "gtm" ? readGtmContent(projectRoot) : [];
+    let items = [...journalItems, ...knowledgeItems, ...codeItems, ...contentItems];
+    // Apply semantic search if query provided
+    if (query) {
+        items = semanticSearch(items, query);
+    }
+    return {
+        items,
+        sources: {
+            journal: journalItems.length > 0,
+            knowledge: knowledgeItems.length > 0,
+            code: codeItems.length > 0,
+            content: contentItems.length > 0,
+            memory: fs.existsSync(path.join(projectRoot, ".jfl", "memory.db")),
+        },
+        query,
+        taskType
+    };
+}
+function getChildHubs(projectRoot) {
+    const configPath = path.join(projectRoot, ".jfl", "config.json");
+    if (!fs.existsSync(configPath))
+        return [];
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        if (config.type !== "portfolio")
+            return [];
+        const children = [];
+        for (const service of config.registered_services || []) {
+            if (service.type === "gtm" && service.path) {
+                const childPort = getProjectPort(service.path);
+                const tokenPath = path.join(service.path, ".jfl", "context-hub.token");
+                const token = fs.existsSync(tokenPath)
+                    ? fs.readFileSync(tokenPath, "utf-8").trim()
+                    : undefined;
+                children.push({ name: service.name, path: service.path, port: childPort, token });
+            }
+        }
+        return children;
+    }
+    catch {
+        return [];
+    }
+}
+async function fetchChildContext(child, endpoint, body) {
+    try {
+        const headers = { "Content-Type": "application/json" };
+        if (child.token)
+            headers["Authorization"] = `Bearer ${child.token}`;
+        const response = await fetch(`http://localhost:${child.port}${endpoint}`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok)
+            return [];
+        const data = (await response.json());
+        return (data.items || []).map((item) => ({
+            ...item,
+            title: `[${child.name}] ${item.title}`,
+        }));
+    }
+    catch {
+        return readJournalEntries(child.path, 10).map((item) => ({
+            ...item,
+            title: `[${child.name}] ${item.title}`,
+        }));
+    }
+}
+async function getPortfolioContext(projectRoot, query, taskType, maxItems) {
+    const local = getUnifiedContext(projectRoot, query, taskType);
+    const children = getChildHubs(projectRoot);
+    if (children.length === 0) {
+        if (maxItems)
+            local.items = local.items.slice(0, maxItems);
+        return local;
+    }
+    const endpoint = query ? "/api/context/search" : "/api/context";
+    const body = { maxItems: maxItems || 20 };
+    if (query)
+        body.query = query;
+    if (taskType)
+        body.taskType = taskType;
+    const childResults = await Promise.all(children.map((child) => fetchChildContext(child, endpoint, body)));
+    let merged = [...local.items, ...childResults.flat()];
+    if (query) {
+        merged = semanticSearch(merged, query);
+    }
+    return {
+        items: maxItems ? merged.slice(0, maxItems) : merged,
+        sources: {
+            ...local.sources,
+            journal: true,
+            knowledge: true,
+        },
+        query,
+        taskType,
+    };
+}
+// ============================================================================
+// HTTP Server
+// ============================================================================
+function createServer(projectRoot, port, eventBus, flowEngine) {
+    const server = http.createServer(async (req, res) => {
+        const requestStart = Date.now();
+        const pathname = new URL(req.url || "/", `http://localhost:${port}`).pathname;
+        // Intercept writeHead to capture status code for telemetry
+        let capturedStatus = 200;
+        const originalWriteHead = res.writeHead.bind(res);
+        res.writeHead = function (statusCode, ...args) {
+            capturedStatus = statusCode;
+            return originalWriteHead(statusCode, ...args);
+        };
+        // Track request on response finish (skip health/OPTIONS/dashboard)
+        const shouldTrack = req.method !== "OPTIONS"
+            && pathname !== "/health"
+            && !pathname.startsWith("/dashboard");
+        if (shouldTrack) {
+            res.on('finish', () => {
+                telemetry.track({
+                    category: 'context_hub',
+                    event: 'context_hub:request',
+                    endpoint: pathname,
+                    method: req.method,
+                    status_code: capturedStatus,
+                    duration_ms: Date.now() - requestStart,
+                    hub_port: port,
+                });
+            });
+        }
+        // CORS - include Authorization header
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+        if (req.method === "OPTIONS") {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        const url = new URL(req.url || "/", `http://localhost:${port}`);
+        // Health check - no auth required (for monitoring)
+        if (url.pathname === "/health" && req.method === "GET") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ status: "ok", port }));
+            return;
+        }
+        // Setup report — serves .jfl/setup-report.json for dashboard consumption
+        if (url.pathname === "/api/setup-report" && req.method === "GET") {
+            const reportPath = path.join(projectRoot, ".jfl", "setup-report.json");
+            if (fs.existsSync(reportPath)) {
+                const report = fs.readFileSync(reportPath, "utf-8");
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(report);
+            }
+            else {
+                res.writeHead(404, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "No setup report. Run: jfl setup" }));
+            }
+            return;
+        }
+        // Dashboard - served without API auth (has its own token flow in JS)
+        if (url.pathname.startsWith("/dashboard")) {
+            import("../dashboard/index.js").then(({ handleDashboardRoutes }) => {
+                if (!handleDashboardRoutes(req, res, projectRoot, port)) {
+                    res.writeHead(404, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Not found" }));
+                }
+            }).catch(() => {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Dashboard module failed to load" }));
+            });
+            return;
+        }
+        // Hook ingestion (Claude Code HTTP hooks)
+        // No auth required — localhost-only. Always returns 200.
+        if (url.pathname === "/api/hooks" && req.method === "POST") {
+            const remoteAddr = req.socket.remoteAddress || "";
+            const isLocalhost = remoteAddr === "127.0.0.1" || remoteAddr === "::1" || remoteAddr === "::ffff:127.0.0.1";
+            if (!isLocalhost) {
+                res.writeHead(403, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "localhost only" }));
+                return;
+            }
+            let body = "";
+            let bodySize = 0;
+            const MAX_BODY = 64 * 1024;
+            req.on("data", (chunk) => {
+                bodySize += typeof chunk === "string" ? chunk.length : chunk.byteLength;
+                if (bodySize <= MAX_BODY) {
+                    body += chunk;
+                }
+            });
+            req.on("end", () => {
+                try {
+                    if (bodySize > MAX_BODY) {
+                        console.warn(`[hooks] Dropped oversized payload: ${bodySize} bytes`);
+                        res.writeHead(200, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ ok: true, dropped: true }));
+                        return;
+                    }
+                    const payload = JSON.parse(body);
+                    const partial = transformHookPayload(payload);
+                    if (eventBus) {
+                        eventBus.emit(partial);
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: true }));
+                }
+                catch (err) {
+                    console.warn(`[hooks] Parse error: ${err.message}`);
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: true, parse_error: true }));
+                }
+            });
+            return;
+        }
+        // All other endpoints require auth
+        if (!validateAuth(req, projectRoot, url)) {
+            telemetry.track({
+                category: 'context_hub',
+                event: 'context_hub:auth_failed',
+                endpoint: pathname,
+            });
+            res.writeHead(401, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                error: "Unauthorized",
+                message: "Provide token via Authorization header: Bearer <token>",
+                tokenFile: ".jfl/context-hub.token"
+            }));
+            return;
+        }
+        // Status (includes child hub health for portfolio)
+        if (url.pathname === "/api/context/status" && req.method === "GET") {
+            const context = getUnifiedContext(projectRoot);
+            const children = getChildHubs(projectRoot);
+            // Read actual workspace type from config
+            let workspaceType = "standalone";
+            let workspaceConfig = {};
+            const configPath = path.join(projectRoot, ".jfl", "config.json");
+            if (fs.existsSync(configPath)) {
+                try {
+                    const cfg = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+                    if (cfg.type === "portfolio" || cfg.type === "gtm" || cfg.type === "service") {
+                        workspaceType = cfg.type;
+                    }
+                    workspaceConfig = {
+                        name: cfg.name,
+                        type: cfg.type,
+                        description: cfg.description,
+                        scope: cfg.context_scope || null,
+                        registered_services: (cfg.registered_services || []).map((s) => ({
+                            name: s.name,
+                            path: s.path,
+                            type: s.type,
+                            status: s.status,
+                            context_scope: s.context_scope || null,
+                        })),
+                        openclaw_agents: (cfg.openclaw_agents || []).map((a) => ({
+                            id: a.id,
+                            runtime: a.runtime,
+                            registered_at: a.registered_at,
+                        })),
+                        gtm_parent: cfg.gtm_parent || null,
+                        portfolio_parent: cfg.portfolio_parent || null,
+                    };
+                }
+                catch { }
+            }
+            const childStatus = await Promise.all(children.map(async (child) => {
+                try {
+                    const resp = await fetch(`http://localhost:${child.port}/health`, {
+                        signal: AbortSignal.timeout(2000),
+                    });
+                    return { name: child.name, port: child.port, status: resp.ok ? "ok" : "error" };
+                }
+                catch {
+                    return { name: child.name, port: child.port, status: "down" };
+                }
+            }));
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                status: "running",
+                port,
+                type: workspaceType,
+                config: workspaceConfig,
+                sources: context.sources,
+                itemCount: context.items.length,
+                ...(children.length > 0 ? { children: childStatus } : {}),
+            }));
+            return;
+        }
+        // Get context (portfolio-aware: fans out to child hubs)
+        if (url.pathname === "/api/context" && req.method === "POST") {
+            let body = "";
+            req.on("data", chunk => body += chunk);
+            req.on("end", async () => {
+                try {
+                    const { query, taskType, maxItems } = JSON.parse(body || "{}");
+                    const context = await getPortfolioContext(projectRoot, query, taskType, maxItems);
+                    telemetry.track({
+                        category: 'context_hub',
+                        event: 'context_hub:context_loaded',
+                        item_count: context.items.length,
+                        journal_count: context.items.filter(i => i.source === 'journal').length,
+                        knowledge_count: context.items.filter(i => i.source === 'knowledge').length,
+                        code_count: context.items.filter(i => i.source === 'code').length,
+                        content_count: context.items.filter(i => i.source === 'content').length,
+                        query_length: query ? query.length : 0,
+                    });
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify(context));
+                }
+                catch (err) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        // Search (portfolio-aware: fans out to child hubs)
+        if (url.pathname === "/api/context/search" && req.method === "POST") {
+            let body = "";
+            req.on("data", chunk => body += chunk);
+            req.on("end", async () => {
+                try {
+                    const { query, maxItems = 20 } = JSON.parse(body || "{}");
+                    if (!query) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "query required" }));
+                        return;
+                    }
+                    const searchStart = Date.now();
+                    const context = await getPortfolioContext(projectRoot, query, undefined, maxItems);
+                    context.items = context.items
+                        .filter(item => item.relevance && item.relevance > 0)
+                        .slice(0, maxItems);
+                    telemetry.track({
+                        category: 'context_hub',
+                        event: 'context_hub:search',
+                        result_count: context.items.length,
+                        duration_ms: Date.now() - searchStart,
+                        has_query: true,
+                        query_length: query.length,
+                    });
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify(context));
+                }
+                catch (err) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        // Services registry
+        if (url.pathname === "/api/services" && req.method === "GET") {
+            try {
+                const services = discoverServices(projectRoot);
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(services));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // Get specific service
+        if (url.pathname.startsWith("/api/services/") && req.method === "GET") {
+            try {
+                const serviceName = url.pathname.replace("/api/services/", "");
+                const services = discoverServices(projectRoot);
+                const service = services[serviceName];
+                if (!service) {
+                    res.writeHead(404, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Service not found" }));
+                    return;
+                }
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(service));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // RAG Chat — search context + memory, then stream LLM response
+        if (url.pathname === "/api/chat" && req.method === "POST") {
+            let body = "";
+            req.on("data", chunk => body += chunk);
+            req.on("end", async () => {
+                try {
+                    const { message, history = [] } = JSON.parse(body || "{}");
+                    if (!message) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "message required" }));
+                        return;
+                    }
+                    const [memRaw, ctxResult] = await Promise.allSettled([
+                        searchMemories(message, { maxItems: 5 }),
+                        getPortfolioContext(projectRoot, message, undefined, 5),
+                    ]);
+                    const memResults = memRaw.status === "fulfilled"
+                        ? memRaw.value.map(r => ({ title: r.memory.title, content: r.memory.content, type: r.memory.type, relevance: r.relevance }))
+                        : [];
+                    const ctxResults = ctxResult.status === "fulfilled"
+                        ? (ctxResult.value.items || []).slice(0, 5).map((i) => ({ title: i.title || i.path, content: i.content?.slice(0, 500), type: i.type }))
+                        : [];
+                    const sources = [...memResults, ...ctxResults];
+                    let contextBlock = "";
+                    if (sources.length > 0) {
+                        contextBlock = "Here is relevant context from the project:\n\n" +
+                            sources.map((s, i) => `[${i + 1}] ${s.title} (${s.type})\n${s.content}`).join("\n\n") +
+                            "\n\n---\n\n";
+                    }
+                    // Load .env from project root for API keys
+                    const envPath = path.join(projectRoot, ".env");
+                    if (fs.existsSync(envPath)) {
+                        for (const line of fs.readFileSync(envPath, "utf-8").split("\n")) {
+                            const match = line.match(/^([A-Z_]+)=(.+)$/);
+                            if (match && !process.env[match[1]])
+                                process.env[match[1]] = match[2].trim();
+                        }
+                    }
+                    const apiKey = process.env.STRATUS_API_KEY || process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY;
+                    if (!apiKey) {
+                        res.writeHead(200, {
+                            "Content-Type": "text/event-stream",
+                            "Cache-Control": "no-cache",
+                            "Connection": "keep-alive",
+                        });
+                        const fallback = sources.length > 0
+                            ? "I found relevant context but no LLM API key is configured. Set STRATUS_API_KEY, OPENAI_API_KEY, or ANTHROPIC_API_KEY in your .env.\n\n**Sources found:**\n" +
+                                sources.map((s, i) => `${i + 1}. **${s.title}** \`${s.type}\`\n   ${s.content?.slice(0, 150)}`).join("\n")
+                            : "No API key configured and no relevant context found.";
+                        res.write(`data: ${JSON.stringify({ sources })}\n\n`);
+                        res.write(`data: ${JSON.stringify({ delta: fallback })}\n\n`);
+                        res.write("data: [DONE]\n\n");
+                        res.end();
+                        return;
+                    }
+                    const useStratus = apiKey === process.env.STRATUS_API_KEY;
+                    const baseURL = useStratus ? "https://api.stratus.run/v1" : undefined;
+                    const model = useStratus ? "stratus-x1ac-huge-claude-sonnet-4-6" : "gpt-4o-mini";
+                    const OpenAI = (await import("openai")).default;
+                    const client = new OpenAI({ apiKey, baseURL });
+                    const messages = [
+                        {
+                            role: "system",
+                            content: `You are JFL Assistant, helping the user understand their project context. Answer questions based on the provided context from journal entries, knowledge docs, and code files. Be concise and direct. If the context doesn't contain enough information, say so. Reference specific sources when possible.\n\n${contextBlock}`
+                        },
+                        ...history.slice(-6).map((m) => ({ role: m.role, content: m.content })),
+                        { role: "user", content: message },
+                    ];
+                    res.writeHead(200, {
+                        "Content-Type": "text/event-stream",
+                        "Cache-Control": "no-cache",
+                        "Connection": "keep-alive",
+                    });
+                    res.write(`data: ${JSON.stringify({ sources })}\n\n`);
+                    try {
+                        const stream = await client.chat.completions.create({
+                            model,
+                            messages,
+                            stream: true,
+                            max_tokens: 1024,
+                        });
+                        for await (const chunk of stream) {
+                            const delta = chunk.choices?.[0]?.delta?.content;
+                            if (delta) {
+                                res.write(`data: ${JSON.stringify({ delta })}\n\n`);
+                            }
+                        }
+                    }
+                    catch (llmErr) {
+                        res.write(`data: ${JSON.stringify({ delta: `\n\nLLM error: ${llmErr.message}` })}\n\n`);
+                    }
+                    res.write("data: [DONE]\n\n");
+                    res.end();
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        // Memory search
+        if (url.pathname === "/api/memory/search" && req.method === "POST") {
+            let body = "";
+            req.on("data", chunk => body += chunk);
+            req.on("end", async () => {
+                try {
+                    const { query, type, maxItems = 10, since } = JSON.parse(body || "{}");
+                    if (!query) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "query required" }));
+                        return;
+                    }
+                    const raw = await searchMemories(query, { type, maxItems, since });
+                    const results = raw.map(r => ({
+                        id: r.memory.id,
+                        title: r.memory.title,
+                        content: r.memory.content,
+                        summary: r.memory.summary,
+                        type: r.memory.type,
+                        source: r.memory.source,
+                        ts: r.memory.created_at,
+                        score: r.score,
+                        relevance: r.relevance,
+                    }));
+                    // Surface linked memories (teacup ↔ insight connections)
+                    const linkedResults = [];
+                    for (const r of results) {
+                        if (r.id) {
+                            try {
+                                const linksFrom = await getLinksFrom(r.id);
+                                const linksTo = await getLinksTo(r.id);
+                                const linkedIds = [
+                                    ...linksFrom.map(l => l.to_memory_id),
+                                    ...linksTo.map(l => l.from_memory_id)
+                                ].filter(id => !results.some(existing => existing.id === id));
+                                for (const linkedId of linkedIds.slice(0, 3)) {
+                                    try {
+                                        const [linked] = await getMemoriesByIds([linkedId]);
+                                        if (linked) {
+                                            const linkType = linksFrom.find(l => l.to_memory_id === linkedId)?.link_type
+                                                || linksTo.find(l => l.from_memory_id === linkedId)?.link_type
+                                                || 'related_to';
+                                            linkedResults.push({
+                                                id: linked.id,
+                                                title: `🔗 ${linkType === 'leads_to' ? '🫖→' : '←🫖'} ${linked.title}`,
+                                                content: linked.content,
+                                                summary: linked.summary,
+                                                type: linked.type,
+                                                source: linked.source,
+                                                ts: linked.created_at,
+                                                score: r.score * 0.8,
+                                                relevance: 'medium',
+                                            });
+                                        }
+                                    }
+                                    catch { /* skip broken links */ }
+                                }
+                            }
+                            catch { /* links optional */ }
+                        }
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ results: [...results, ...linkedResults] }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        // Memory status
+        if (url.pathname === "/api/memory/status" && req.method === "GET") {
+            getMemoryStats()
+                .then(stats => {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(stats));
+            })
+                .catch((err) => {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            });
+            return;
+        }
+        // Memory add
+        if (url.pathname === "/api/memory/add" && req.method === "POST") {
+            let body = "";
+            req.on("data", chunk => body += chunk);
+            req.on("end", async () => {
+                try {
+                    const { title, content, tags, type, linked_to } = JSON.parse(body || "{}");
+                    if (!title || !content) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "title and content required" }));
+                        return;
+                    }
+                    const id = await insertMemory({
+                        source: 'manual',
+                        type: type || undefined,
+                        title,
+                        content,
+                        created_at: new Date().toISOString()
+                    });
+                    // If this teacup/insight links to another memory, create the link
+                    if (linked_to && typeof linked_to === 'number') {
+                        try {
+                            const linkType = type === 'teacup' ? 'leads_to' : 'related_to';
+                            await addLink(id, linked_to, linkType);
+                        }
+                        catch { /* link is optional, don't fail the add */ }
+                    }
+                    res.writeHead(201, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ id }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        // POST /api/memory/index — trigger journal→memory indexing + embedding backfill
+        if (url.pathname === "/api/memory/index" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => body += chunk);
+            req.on("end", async () => {
+                try {
+                    const { force, backfill } = JSON.parse(body || "{}");
+                    const stats = await indexJournalEntries(force ?? false);
+                    let embeddingStats = { updated: 0, errors: 0 };
+                    if (backfill !== false) {
+                        embeddingStats = await backfillEmbeddings();
+                    }
+                    const codeStats = await indexCodeHeaders();
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: true, ...stats, embeddings_backfilled: embeddingStats.updated, embedding_errors: embeddingStats.errors, code_headers_added: codeStats.added, code_headers_updated: codeStats.updated }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        // POST /api/memory/link — add a graph edge between two memories
+        if (url.pathname === "/api/memory/link" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => body += chunk);
+            req.on("end", async () => {
+                try {
+                    const { from, to, type } = JSON.parse(body || "{}");
+                    if (!from || !to || !type) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "from, to, and type are required" }));
+                        return;
+                    }
+                    const { addLink } = await import("../lib/memory-db.js");
+                    const id = await addLink(from, to, type);
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: true, id }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        // Eval trajectory
+        if (url.pathname === "/api/eval/trajectory" && req.method === "GET") {
+            try {
+                const { getTrajectory } = await import("../lib/eval-store.js");
+                const agent = url.searchParams.get("agent") || "";
+                const metric = url.searchParams.get("metric") || "composite";
+                if (!agent) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "agent query param required" }));
+                    return;
+                }
+                const points = getTrajectory(agent, metric, projectRoot);
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ agent, metric, points }));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // Eval entries (all raw entries for cycle display)
+        if (url.pathname === "/api/eval/entries" && req.method === "GET") {
+            try {
+                const { readEvals } = await import("../lib/eval-store.js");
+                const limit = parseInt(url.searchParams.get("limit") || "100", 10);
+                const entries = readEvals(projectRoot)
+                    .sort((a, b) => b.ts.localeCompare(a.ts))
+                    .slice(0, limit);
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ entries }));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // Eval leaderboard
+        if (url.pathname === "/api/eval/leaderboard" && req.method === "GET") {
+            try {
+                const { readEvals, listAgents, getLatestEval, getTrajectory } = await import("../lib/eval-store.js");
+                const agents = listAgents(projectRoot);
+                const leaderboard = agents.map(agent => {
+                    const latest = getLatestEval(agent, projectRoot);
+                    const trajectory = getTrajectory(agent, "composite", projectRoot);
+                    const prevPoint = trajectory.length >= 2 ? trajectory[trajectory.length - 2] : null;
+                    const delta = latest?.composite != null && prevPoint
+                        ? latest.composite - prevPoint.value
+                        : null;
+                    return {
+                        agent,
+                        composite: latest?.composite ?? null,
+                        metrics: latest?.metrics ?? {},
+                        delta,
+                        model_version: latest?.model_version ?? null,
+                        lastTs: latest?.ts ?? null,
+                        trajectory: trajectory.slice(-20).map(p => p.value),
+                    };
+                }).sort((a, b) => (b.composite ?? 0) - (a.composite ?? 0));
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(leaderboard));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // Synopsis (work summary)
+        if (url.pathname === "/api/synopsis" && req.method === "GET") {
+            try {
+                const hours = parseInt(url.searchParams.get("hours") || "24", 10);
+                const author = url.searchParams.get("author") || undefined;
+                const { generateSynopsis } = await import("./synopsis.js");
+                const synopsis = generateSynopsis(projectRoot, hours, author);
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(synopsis));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // Prediction accuracy (Stratus)
+        if (url.pathname === "/api/eval/predictions" && req.method === "GET") {
+            try {
+                const { Predictor } = await import("../lib/predictor.js");
+                const predictor = new Predictor({ projectRoot });
+                const accuracy = predictor.getAccuracy();
+                const recent = predictor.getHistory(20).reverse();
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ accuracy, recent }));
+            }
+            catch (err) {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ accuracy: { total: 0, resolved: 0, direction_accuracy: 0, mean_delta_error: 0, calibration: 0 }, recent: [] }));
+            }
+            return;
+        }
+        // Cross-project health
+        if (url.pathname === "/api/projects" && req.method === "GET") {
+            const tracked = getTrackedProjects();
+            Promise.all(tracked.map(async (p) => {
+                // Self-check: if this is our own port, we know we're OK
+                if (p.port === port) {
+                    return {
+                        name: p.path.split("/").pop() || p.path,
+                        path: p.path,
+                        port: p.port,
+                        status: "OK",
+                        pid: process.pid,
+                        message: "This instance",
+                    };
+                }
+                const result = await diagnoseProject(p.path, p.port);
+                return {
+                    name: p.path.split("/").pop() || p.path,
+                    path: p.path,
+                    port: p.port,
+                    status: result.status,
+                    pid: result.pid,
+                    message: result.message,
+                };
+            }))
+                .then((results) => {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(results));
+            })
+                .catch((err) => {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            });
+            return;
+        }
+        // Publish event
+        if (url.pathname === "/api/events" && req.method === "POST") {
+            if (!eventBus) {
+                res.writeHead(503, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Event bus not initialized" }));
+                return;
+            }
+            let body = "";
+            req.on("data", chunk => body += chunk);
+            req.on("end", () => {
+                try {
+                    const { type, source, target, session, data, ttl } = JSON.parse(body || "{}");
+                    if (!type || !source) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "type and source required" }));
+                        return;
+                    }
+                    const event = eventBus.emit({
+                        type: type,
+                        source,
+                        target,
+                        session,
+                        data: data || {},
+                        ttl,
+                    });
+                    res.writeHead(201, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify(event));
+                }
+                catch (err) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        // Get recent events
+        if (url.pathname === "/api/events" && req.method === "GET") {
+            if (!eventBus) {
+                res.writeHead(503, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Event bus not initialized" }));
+                return;
+            }
+            const since = url.searchParams.get("since") || undefined;
+            const pattern = url.searchParams.get("pattern") || undefined;
+            const limit = url.searchParams.get("limit") ? parseInt(url.searchParams.get("limit"), 10) : 50;
+            const events = eventBus.getEvents({ since, pattern, limit });
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ events, count: events.length }));
+            return;
+        }
+        // SSE event stream
+        if (url.pathname === "/api/events/stream" && req.method === "GET") {
+            if (!eventBus) {
+                res.writeHead(503, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Event bus not initialized" }));
+                return;
+            }
+            const patterns = (url.searchParams.get("patterns") || "*").split(",");
+            res.writeHead(200, {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                Connection: "keep-alive",
+                "Access-Control-Allow-Origin": "*",
+            });
+            res.write("retry: 3000\n\n");
+            const sub = eventBus.subscribe({
+                clientId: `sse-${Date.now()}`,
+                patterns,
+                transport: "sse",
+                callback: (event) => {
+                    res.write(`id: ${event.id}\nevent: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`);
+                },
+            });
+            req.on("close", () => {
+                eventBus.unsubscribe(sub.id);
+            });
+            return;
+        }
+        // Telemetry digest
+        if (url.pathname === "/api/telemetry/digest" && req.method === "GET") {
+            try {
+                const { loadLocalEvents, analyzeEvents } = await import("../lib/telemetry-digest.js");
+                const hours = parseInt(url.searchParams.get("hours") || "168", 10);
+                const events = loadLocalEvents();
+                const digest = analyzeEvents(events, hours);
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(digest));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // Telemetry agent status
+        if (url.pathname === "/api/telemetry/agent" && req.method === "GET") {
+            const agent = server.__telemetryAgent;
+            if (agent) {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(agent.getStatus()));
+            }
+            else {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ running: false, lastRun: '', runCount: 0, lastInsights: [] }));
+            }
+            return;
+        }
+        // Telemetry agent: trigger manual run
+        if (url.pathname === "/api/telemetry/agent/run" && req.method === "POST") {
+            const agent = server.__telemetryAgent;
+            if (agent) {
+                try {
+                    const insights = await agent.run();
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: true, insights }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            }
+            else {
+                res.writeHead(503, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Telemetry agent not running" }));
+            }
+            return;
+        }
+        // ── Autoresearch / Experiments API ──────────────────────────────
+        // Agent configs
+        if (url.pathname === "/api/v1/agents" && req.method === "GET") {
+            try {
+                const { listAgentConfigs, loadAgentConfig } = await import("../lib/agent-config.js");
+                const names = listAgentConfigs(projectRoot);
+                const agents = names.map(name => {
+                    try {
+                        return loadAgentConfig(projectRoot, name);
+                    }
+                    catch {
+                        return null;
+                    }
+                }).filter(Boolean);
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ agents }));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // Replay buffer (experiment history)
+        if (url.pathname === "/api/v1/experiments" && req.method === "GET") {
+            try {
+                const bufferPath = path.join(projectRoot, ".jfl", "replay-buffer.jsonl");
+                const trainingPath = path.join(projectRoot, ".jfl", "training-buffer.jsonl");
+                const experiments = [];
+                for (const p of [bufferPath, trainingPath]) {
+                    if (fs.existsSync(p)) {
+                        const lines = fs.readFileSync(p, "utf-8").trim().split("\n").filter(Boolean);
+                        for (const line of lines.slice(-100)) {
+                            try {
+                                experiments.push(JSON.parse(line));
+                            }
+                            catch { }
+                        }
+                    }
+                }
+                const agent = url.searchParams.get("agent");
+                const filtered = agent ? experiments.filter(e => e.agent === agent) : experiments;
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ experiments: filtered, total: filtered.length }));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // Session results
+        if (url.pathname === "/api/v1/sessions" && req.method === "GET") {
+            try {
+                const sessionsDir = path.join(projectRoot, ".jfl", "sessions");
+                const sessions = [];
+                if (fs.existsSync(sessionsDir)) {
+                    for (const dir of fs.readdirSync(sessionsDir)) {
+                        const resultsPath = path.join(sessionsDir, dir, "results.tsv");
+                        if (fs.existsSync(resultsPath)) {
+                            const content = fs.readFileSync(resultsPath, "utf-8").trim();
+                            const lines = content.split("\n").slice(1); // skip header
+                            const rounds = lines.filter(l => l.trim()).map(line => {
+                                const [round, task, baseline, metric, delta, kept, duration, error, timestamp] = line.split("\t");
+                                return { round: +round, task, baseline: +baseline, metric: +metric, delta: +delta, kept: kept === "1", duration_ms: +duration, error, timestamp };
+                            });
+                            if (rounds.length > 0) {
+                                sessions.push({ id: dir, rounds, agent: dir.replace(/-[a-f0-9]{8}-\d+$/, "") });
+                            }
+                        }
+                    }
+                }
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ sessions }));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // Product context
+        if (url.pathname === "/api/v1/product-context" && req.method === "GET") {
+            const contextPath = path.join(projectRoot, ".jfl", "product-context.md");
+            if (fs.existsSync(contextPath)) {
+                const content = fs.readFileSync(contextPath, "utf-8");
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ context: content, updatedAt: fs.statSync(contextPath).mtime.toISOString() }));
+            }
+            else {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ context: null, updatedAt: null }));
+            }
+            return;
+        }
+        // Product analysis (telemetry agent v2)
+        if (url.pathname === "/api/v1/product-analysis" && req.method === "GET") {
+            try {
+                const { TelemetryAgentV2 } = await import("../lib/telemetry-agent-v2.js");
+                const agent = new TelemetryAgentV2({ projectRoot });
+                const analysis = await agent.analyzeProduct();
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(analysis));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // Kanban board
+        // ── Kanban API (GitHub Issues-backed) ──────────────────────
+        if (url.pathname === "/api/kanban" && req.method === "GET") {
+            try {
+                const { GitHubKanban } = await import("../lib/kanban-github.js");
+                const scope = url.searchParams.get("scope") ?? undefined;
+                const source = url.searchParams.get("source") ?? undefined;
+                const filter = (scope || source) ? { scope, source } : undefined;
+                const kb = new GitHubKanban(projectRoot);
+                const board = await kb.getBoard(filter);
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(board));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        if (url.pathname === "/api/kanban/cards" && req.method === "GET") {
+            try {
+                const { GitHubKanban } = await import("../lib/kanban-github.js");
+                const scope = url.searchParams.get("scope") ?? undefined;
+                const source = url.searchParams.get("source") ?? undefined;
+                const filter = (scope || source) ? { scope, source } : undefined;
+                const kb = new GitHubKanban(projectRoot);
+                const cards = await kb.getCards(filter);
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(cards));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        if (url.pathname === "/api/kanban/scopes" && req.method === "GET") {
+            try {
+                const { GitHubKanban } = await import("../lib/kanban-github.js");
+                const kb = new GitHubKanban(projectRoot);
+                const workspace = kb.getWorkspaceInfo();
+                const services = kb.getRegisteredServices();
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ workspace, services }));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        if (url.pathname === "/api/kanban" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => { body += chunk; });
+            req.on("end", async () => {
+                try {
+                    const data = JSON.parse(body || "{}");
+                    const { GitHubKanban } = await import("../lib/kanban-github.js");
+                    const kb = new GitHubKanban(projectRoot);
+                    if (data.action === "create") {
+                        const number = kb.create({
+                            title: data.title,
+                            description: data.description,
+                            source: data.source ?? "human",
+                            priority: data.priority ?? 0,
+                            scope: data.scope,
+                            labels: data.labels,
+                        });
+                        res.writeHead(201, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ id: `#${number}`, number }));
+                    }
+                    else if (data.action === "move") {
+                        // Accept both #8 and 8 format
+                        const num = typeof data.id === "string" ? parseInt(data.id.replace("#", "")) : data.id;
+                        kb.move(num, data.column);
+                        res.writeHead(200, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ ok: true }));
+                    }
+                    else if (data.action === "pick") {
+                        const num = typeof data.id === "string" ? parseInt(data.id.replace("#", "")) : data.id;
+                        kb.pick(num, data.agent);
+                        res.writeHead(200, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ ok: true }));
+                    }
+                    else {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "Unknown action" }));
+                    }
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        // Flow definitions
+        if (url.pathname === "/api/flows" && req.method === "GET") {
+            if (!flowEngine) {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify([]));
+                return;
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(flowEngine.getFlows()));
+            return;
+        }
+        // Flow executions
+        if (url.pathname === "/api/flows/executions" && req.method === "GET") {
+            if (!flowEngine) {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ executions: [] }));
+                return;
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ executions: flowEngine.getExecutions() }));
+            return;
+        }
+        // Flow approval
+        if (url.pathname.match(/^\/api\/flows\/[^/]+\/approve$/) && req.method === "POST") {
+            if (!flowEngine) {
+                res.writeHead(503, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Flow engine not initialized" }));
+                return;
+            }
+            const flowName = decodeURIComponent(url.pathname.split("/")[3]);
+            let body = "";
+            req.on("data", chunk => body += chunk);
+            req.on("end", async () => {
+                try {
+                    const { trigger_event_id } = JSON.parse(body || "{}");
+                    if (!trigger_event_id) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "trigger_event_id required" }));
+                        return;
+                    }
+                    const result = await flowEngine.approveGated(flowName, trigger_event_id);
+                    if (!result) {
+                        res.writeHead(404, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "Gated execution not found" }));
+                        return;
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify(result));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        if (url.pathname.match(/^\/api\/flows\/[^/]+\/toggle$/) && req.method === "POST") {
+            if (!flowEngine) {
+                res.writeHead(503, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Flow engine not initialized" }));
+                return;
+            }
+            const flowName = decodeURIComponent(url.pathname.split("/")[3]);
+            let body = "";
+            req.on("data", chunk => body += chunk);
+            req.on("end", () => {
+                try {
+                    const { enabled } = JSON.parse(body || "{}");
+                    const result = flowEngine.toggleFlow(flowName, enabled);
+                    if (!result) {
+                        res.writeHead(404, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "Flow not found" }));
+                        return;
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: true, flow: flowName, enabled: result.enabled }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        // Topology — returns nodes/edges for agent topology visualization
+        if (url.pathname === "/api/v1/topology" && req.method === "GET") {
+            try {
+                const configPath = path.join(projectRoot, ".jfl", "config.json");
+                let registeredServices = [];
+                let workspaceType = "standalone";
+                let workspaceName = "workspace";
+                if (fs.existsSync(configPath)) {
+                    try {
+                        const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+                        registeredServices = config.registered_services || [];
+                        workspaceType = config.type || "standalone";
+                        workspaceName = config.name || "workspace";
+                    }
+                    catch { }
+                }
+                // Read event counts from map-events.jsonl
+                const mapEventsPath = path.join(projectRoot, ".jfl", "map-events.jsonl");
+                const eventCounts = {};
+                const edgeEventCounts = {}; // "source:target:eventType" -> count
+                const recentWindow = 24 * 60 * 60 * 1000; // 24 hours
+                if (fs.existsSync(mapEventsPath)) {
+                    try {
+                        const lines = fs.readFileSync(mapEventsPath, "utf-8").trim().split("\n");
+                        const now = Date.now();
+                        for (const line of lines.slice(-1000)) { // Last 1000 events
+                            if (!line)
+                                continue;
+                            try {
+                                const evt = JSON.parse(line);
+                                const ts = new Date(evt.ts).getTime();
+                                if (now - ts > recentWindow)
+                                    continue;
+                                // Count events by source
+                                if (evt.source) {
+                                    const srcId = evt.source.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+                                    eventCounts[srcId] = (eventCounts[srcId] || 0) + 1;
+                                }
+                                // Count events by type prefix (for edge matching)
+                                if (evt.type) {
+                                    const prefix = evt.type.split(":")[0];
+                                    eventCounts[prefix] = (eventCounts[prefix] || 0) + 1;
+                                }
+                            }
+                            catch { }
+                        }
+                    }
+                    catch { }
+                }
+                // System agents (always present in a JFL installation)
+                // Only Peter Parker is a real system agent — others come from .jfl/agents/*.toml configs
+                // Stratus, eval-engine, telemetry-agent are either external infra or RL agents now
+                const systemAgents = [
+                    { id: "peter-parker", label: "Peter Parker", type: "orchestrator", status: "running", produces: ["peter:task-completed", "peter:rollout-request", "peter:experiment-start"], consumes: ["telemetry:insight", "telemetry:metric-alert", "eval:scored", "sentinel:recommendation"] },
+                ];
+                const nodes = [
+                    ...systemAgents.map(a => ({
+                        id: a.id,
+                        label: a.label,
+                        type: a.type,
+                        status: a.status,
+                        eventCount: eventCounts[a.id] || eventCounts[a.id.split("-")[0]] || 0,
+                        produces: a.produces,
+                        consumes: a.consumes,
+                    })),
+                ];
+                // Add registered services as nodes
+                for (const service of registeredServices) {
+                    if (!nodes.find(n => n.id === service.name)) {
+                        const nodeType = service.type === "agent" ? "agent"
+                            : service.type === "eval" ? "eval"
+                                : service.type === "gtm" ? "gtm"
+                                    : "service";
+                        nodes.push({
+                            id: service.name,
+                            label: service.name.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" "),
+                            type: nodeType,
+                            status: service.status === "running" ? "running" : service.status === "idle" ? "idle" : "stopped",
+                            eventCount: eventCounts[service.name] || 0,
+                            produces: service.context_scope?.produces,
+                            consumes: service.context_scope?.consumes,
+                        });
+                    }
+                }
+                // Add RL agent nodes from .jfl/agents/*.toml configs
+                try {
+                    const rlAgentConfigs = loadAllAgentConfigs(projectRoot);
+                    const trainingBuffer = new TrainingBuffer(projectRoot);
+                    const trainingEntries = trainingBuffer.read();
+                    for (const config of rlAgentConfigs) {
+                        const nodeId = `rl-agent-${config.name}`;
+                        // Skip if node already exists (e.g., matches a registered service name)
+                        if (nodes.find(n => n.id === nodeId || n.id === config.name)) {
+                            continue;
+                        }
+                        // Check for recent training data (within last 24h)
+                        const now = Date.now();
+                        const recentWindow = 24 * 60 * 60 * 1000;
+                        const recentEntries = trainingEntries.filter(e => {
+                            if (e.agent !== config.name)
+                                return false;
+                            const ts = new Date(e.ts).getTime();
+                            return now - ts < recentWindow;
+                        });
+                        const status = recentEntries.length > 0 ? "running" : "idle";
+                        // Convert name to proper label (e.g., "cli-speed" -> "Cli Speed")
+                        const label = config.name
+                            .split("-")
+                            .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+                            .join(" ");
+                        nodes.push({
+                            id: nodeId,
+                            label,
+                            type: "agent",
+                            status,
+                            eventCount: recentEntries.length,
+                            produces: config.context_scope?.produces,
+                            consumes: config.context_scope?.consumes,
+                        });
+                    }
+                }
+                catch (err) {
+                    // Non-fatal: RL agents are optional
+                }
+                // For portfolio mode, fetch child GTM services and their registered services
+                const childHubs = getChildHubs(projectRoot);
+                const hierarchy = {
+                    gtms: [],
+                };
+                if (workspaceType === "portfolio" && childHubs.length > 0) {
+                    hierarchy.portfolio = workspaceName;
+                    for (const child of childHubs) {
+                        const gtmServices = [];
+                        // Try to read child's config for its registered services
+                        const childConfigPath = path.join(child.path, ".jfl", "config.json");
+                        if (fs.existsSync(childConfigPath)) {
+                            try {
+                                const childConfig = JSON.parse(fs.readFileSync(childConfigPath, "utf-8"));
+                                const childServices = childConfig.registered_services || [];
+                                for (const svc of childServices) {
+                                    const svcId = `${child.name}/${svc.name}`;
+                                    gtmServices.push(svc.name);
+                                    // Add child services as nodes (if not already present)
+                                    if (!nodes.find(n => n.id === svcId)) {
+                                        nodes.push({
+                                            id: svcId,
+                                            label: `${svc.name}`,
+                                            type: svc.type === "agent" ? "agent" : "service",
+                                            status: "idle", // We don't know remote status
+                                            eventCount: 0,
+                                            produces: svc.context_scope?.produces,
+                                            consumes: svc.context_scope?.consumes,
+                                            parent: child.name,
+                                        });
+                                    }
+                                }
+                            }
+                            catch { }
+                        }
+                        hierarchy.gtms.push({
+                            name: child.name,
+                            port: child.port,
+                            services: gtmServices,
+                        });
+                        // Add GTM node if not present
+                        if (!nodes.find(n => n.id === child.name)) {
+                            nodes.push({
+                                id: child.name,
+                                label: child.name.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" "),
+                                type: "gtm",
+                                status: "running",
+                                eventCount: 0,
+                                children: gtmServices,
+                            });
+                        }
+                    }
+                }
+                // Build edges from produces/consumes relationships
+                const edges = [];
+                let edgeId = 0;
+                // Create edges between services based on scope patterns
+                for (const producer of nodes) {
+                    if (!producer.produces)
+                        continue;
+                    for (const eventPattern of producer.produces) {
+                        for (const consumer of nodes) {
+                            if (producer.id === consumer.id || !consumer.consumes)
+                                continue;
+                            for (const consumePattern of consumer.consumes) {
+                                // Check if patterns match (simple glob matching)
+                                const patternMatches = (prod, cons) => {
+                                    if (cons.endsWith(":*")) {
+                                        return prod.startsWith(cons.slice(0, -1));
+                                    }
+                                    if (cons === "*")
+                                        return true;
+                                    return prod === cons || prod.startsWith(cons.split(":")[0] + ":");
+                                };
+                                if (patternMatches(eventPattern, consumePattern)) {
+                                    const existing = edges.find(e => e.source === producer.id && e.target === consumer.id && e.eventType === eventPattern);
+                                    if (!existing) {
+                                        const edgeKey = `${producer.id}:${consumer.id}:${eventPattern}`;
+                                        const prefix = eventPattern.split(":")[0];
+                                        edges.push({
+                                            id: `e${++edgeId}`,
+                                            source: producer.id,
+                                            target: consumer.id,
+                                            eventType: eventPattern,
+                                            category: eventPattern.includes("eval") || eventPattern.includes("scored") ? "success"
+                                                : eventPattern.includes("peter") || eventPattern.includes("rollout") ? "rl"
+                                                    : "data",
+                                            recentEvents: edgeEventCounts[edgeKey] || eventCounts[prefix] || 0,
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                // Add known system flow edges that might not be captured by scope
+                const systemEdges = [
+                    { source: "telemetry-agent", target: "peter-parker", eventType: "telemetry:insight", category: "data" },
+                    { source: "peter-parker", target: "eval-engine", eventType: "peter:task-completed", category: "rl" },
+                    { source: "eval-engine", target: "telemetry-agent", eventType: "eval:scored", category: "success" },
+                    { source: "peter-parker", target: "stratus", eventType: "peter:rollout-request", category: "rl" },
+                    { source: "stratus", target: "eval-engine", eventType: "stratus:prediction", category: "success" },
+                ];
+                for (const sysEdge of systemEdges) {
+                    const exists = edges.find(e => e.source === sysEdge.source && e.target === sysEdge.target);
+                    if (!exists && nodes.find(n => n.id === sysEdge.source) && nodes.find(n => n.id === sysEdge.target)) {
+                        const prefix = sysEdge.eventType.split(":")[0];
+                        edges.push({
+                            id: `e${++edgeId}`,
+                            ...sysEdge,
+                            recentEvents: eventCounts[prefix] || 0,
+                        });
+                    }
+                }
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({
+                    nodes,
+                    edges,
+                    hierarchy: workspaceType === "portfolio" ? hierarchy : undefined,
+                    workspaceType,
+                    workspaceName,
+                }));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // Autoresearch status — returns current autoresearch run state
+        if (url.pathname === "/api/v1/autoresearch/status" && req.method === "GET") {
+            try {
+                const status = {
+                    running: false,
+                    currentRound: 0,
+                    totalRounds: 0,
+                    baselineComposite: null,
+                    proposals: [],
+                    dimensions: {},
+                    history: [],
+                    lastUpdate: null,
+                };
+                // Try to read from log files
+                const logPaths = [
+                    path.join(projectRoot, ".jfl", "autoresearch-continuous.log"),
+                    path.join(projectRoot, ".jfl", "autoresearch-overnight.log"),
+                ];
+                let logContent = "";
+                let logPath = "";
+                for (const p of logPaths) {
+                    if (fs.existsSync(p)) {
+                        const stat = fs.statSync(p);
+                        // Use the most recently modified log
+                        if (!logPath || stat.mtimeMs > fs.statSync(logPath).mtimeMs) {
+                            logPath = p;
+                        }
+                    }
+                }
+                if (logPath) {
+                    logContent = fs.readFileSync(logPath, "utf-8");
+                    status.lastUpdate = fs.statSync(logPath).mtime.toISOString();
+                    // Parse total rounds from header
+                    const roundsMatch = logContent.match(/Autoresearch Mode \((\d+) rounds\)/);
+                    if (roundsMatch) {
+                        status.totalRounds = parseInt(roundsMatch[1], 10);
+                    }
+                    // Parse baseline
+                    const baselineMatch = logContent.match(/Baseline composite: ([\d.]+)/);
+                    if (baselineMatch) {
+                        status.baselineComposite = parseFloat(baselineMatch[1]);
+                    }
+                    // Parse latest round number
+                    const roundMatches = [...logContent.matchAll(/── Round (\d+)\/\d+ ──/g)];
+                    if (roundMatches.length > 0) {
+                        status.currentRound = parseInt(roundMatches[roundMatches.length - 1][1], 10);
+                    }
+                    // Parse policy head proposals (get the latest set)
+                    const proposalBlocks = [...logContent.matchAll(/Policy head re-ranked 3 proposals.*?\n([\s\S]*?)(?=\n\s*Task:|$)/g)];
+                    if (proposalBlocks.length > 0) {
+                        const latestBlock = proposalBlocks[proposalBlocks.length - 1][1];
+                        const proposalMatches = [...latestBlock.matchAll(/#(\d+) \[pred=([-\d.]+)\] ([^\n]+)/g)];
+                        status.proposals = proposalMatches.map(m => ({
+                            rank: parseInt(m[1], 10),
+                            predicted: parseFloat(m[2]),
+                            description: m[3].trim(),
+                        }));
+                    }
+                    // Parse dimensions from latest eval
+                    const dimMatches = [...logContent.matchAll(/Dimensions: (tests=[\d.]+ tsc=[\d.]+ lint=[\d.]+ telemetry=[\d.]+ newTests=[\d.]+)/g)];
+                    if (dimMatches.length > 0) {
+                        const latest = dimMatches[dimMatches.length - 1][1];
+                        for (const [, key, val] of latest.matchAll(/(tests|tsc|lint|telemetry|newTests)=([\d.]+)/g)) {
+                            status.dimensions[key] = parseFloat(val);
+                        }
+                    }
+                    // Parse round results for history
+                    const resultMatches = [...logContent.matchAll(/Round (\d+) result: ([\d.]+) \(([-=+][\d.]+)\)\s*\n\s*Tests: (\d+\/\d+)/g)];
+                    status.history = resultMatches.map(m => ({
+                        round: parseInt(m[1], 10),
+                        composite: parseFloat(m[2]),
+                        delta: m[3].startsWith("=") ? 0 : parseFloat(m[3]),
+                        tests: m[4],
+                    }));
+                    // Check if running (log modified in last 5 minutes and no completion message)
+                    const fiveMinAgo = Date.now() - 5 * 60 * 1000;
+                    const logMtime = fs.statSync(logPath).mtimeMs;
+                    const hasCompletionMsg = logContent.includes("All rounds complete") || logContent.includes("Autoresearch finished");
+                    status.running = logMtime > fiveMinAgo && !hasCompletionMsg && status.currentRound > 0;
+                }
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(status));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        if (url.pathname === "/api/actions/spawn" && req.method === "POST") {
+            let body = "";
+            req.on("data", chunk => body += chunk);
+            req.on("end", () => {
+                try {
+                    const { command, args, cwd, event_type, event_data } = JSON.parse(body || "{}");
+                    if (!command) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "command required" }));
+                        return;
+                    }
+                    const env = { ...process.env };
+                    delete env.ANTHROPIC_API_KEY;
+                    delete env.CLAUDE_CODE_ENTRYPOINT;
+                    const child = spawn(command, args || [], {
+                        cwd: cwd || projectRoot,
+                        detached: true,
+                        stdio: "ignore",
+                        env,
+                    });
+                    child.unref();
+                    if (event_type && eventBus) {
+                        eventBus.emit({
+                            type: event_type,
+                            source: "dashboard:action",
+                            data: event_data || { command, args, pid: child.pid },
+                        });
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: true, pid: child.pid }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        // ── Session Parity API ────────────────────────────────────────────
+        // These endpoints provide runtime-agnostic session lifecycle.
+        // Both Claude Code hooks and Pi extensions call these instead of
+        // duplicating logic. Single source of truth for session init/end.
+        // POST /api/session/init — sync repos, create branch, run doctor
+        //
+        // CONCURRENCY: Multiple Pi sessions can call this simultaneously.
+        // We use a file lock + serialization to prevent branch race conditions.
+        // The Hub creates the branch with `git branch` (no checkout) and returns
+        // the name. The Pi extension does the actual checkout in its own context.
+        if (url.pathname === "/api/session/init" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => body += chunk);
+            req.on("end", async () => {
+                // Serialize session init calls to prevent git race conditions
+                const lockFile = path.join(projectRoot, ".jfl", ".session-init.lock");
+                const maxWait = 15000;
+                const waitStart = Date.now();
+                // Wait for any concurrent session init to finish
+                while (fs.existsSync(lockFile) && Date.now() - waitStart < maxWait) {
+                    try {
+                        // Check if lock is stale (older than 30s)
+                        const lockStat = fs.statSync(lockFile);
+                        if (Date.now() - lockStat.mtimeMs > 30000) {
+                            fs.unlinkSync(lockFile);
+                            break;
+                        }
+                    }
+                    catch { }
+                    await new Promise(resolve => setTimeout(resolve, 200));
+                }
+                // Acquire lock
+                try {
+                    fs.mkdirSync(path.join(projectRoot, ".jfl"), { recursive: true });
+                    fs.writeFileSync(lockFile, `${process.pid}:${Date.now()}`);
+                }
+                catch { }
+                try {
+                    const { runtime } = JSON.parse(body || "{}");
+                    const warnings = [];
+                    const scriptDir = path.join(projectRoot, "scripts", "session");
+                    // Step 1: Sync repos
+                    const syncScript = path.join(scriptDir, "session-sync.sh");
+                    let syncOk = true;
+                    if (fs.existsSync(syncScript)) {
+                        try {
+                            execSync(`bash "${syncScript}"`, { cwd: projectRoot, timeout: 60000, stdio: ["pipe", "pipe", "pipe"] });
+                        }
+                        catch (err) {
+                            syncOk = false;
+                            warnings.push(`Sync warning: ${(err.message || "").split("\n")[0]}`);
+                        }
+                    }
+                    // Step 2: Doctor check
+                    const doctorScript = path.join(scriptDir, "jfl-doctor.sh");
+                    let doctorErrors = 0;
+                    let doctorWarnings = 0;
+                    if (fs.existsSync(doctorScript)) {
+                        try {
+                            const doctorOut = execSync(`bash "${doctorScript}"`, { cwd: projectRoot, timeout: 30000, stdio: ["pipe", "pipe", "pipe"] }).toString();
+                            const em = doctorOut.match(/(\d+) error\(s\)/);
+                            const wm = doctorOut.match(/(\d+) warning\(s\)/);
+                            doctorErrors = em ? parseInt(em[1]) : 0;
+                            doctorWarnings = wm ? parseInt(wm[1]) : 0;
+                            if (doctorErrors > 0)
+                                warnings.push(`Doctor: ${doctorErrors} errors`);
+                        }
+                        catch { }
+                    }
+                    // Step 3: Create session branch (always create a fresh one)
+                    let currentBranch = "";
+                    try {
+                        currentBranch = execSync("git branch --show-current", { cwd: projectRoot, stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+                    }
+                    catch { }
+                    // Generate session branch name first (needed regardless of path)
+                    const user = (() => {
+                        try {
+                            return execSync("git config user.name", { cwd: projectRoot, stdio: ["pipe", "pipe", "pipe"] })
+                                .toString().trim().replace(/\s+/g, "-").toLowerCase().replace(/[^a-z0-9-]/g, "").slice(0, 30) || "user";
+                        }
+                        catch {
+                            return "user";
+                        }
+                    })();
+                    const now = new Date();
+                    const dateStr = now.toISOString().slice(0, 10).replace(/-/g, "");
+                    const timeStr = now.toISOString().slice(11, 16).replace(":", "");
+                    const randomId = Math.random().toString(16).slice(2, 8);
+                    let sessionBranch = `session-${user}-${dateStr}-${timeStr}-${randomId}`;
+                    // Determine working branch from config or default to main
+                    let workingBranch = "main";
+                    const configPath = path.join(projectRoot, ".jfl", "config.json");
+                    if (fs.existsSync(configPath)) {
+                        try {
+                            const cfg = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+                            if (cfg.working_branch)
+                                workingBranch = cfg.working_branch;
+                        }
+                        catch { }
+                    }
+                    // Save any dirty state before branch operations — git add -A catches
+                    // both modified and untracked files. Without this, checkout fails on
+                    // dirty working trees (the #1 cause of "Could not create session branch").
+                    try {
+                        const status = execSync("git status --porcelain", { cwd: projectRoot, timeout: 5000, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+                        if (status) {
+                            execSync("git add -A && git commit -m 'auto: session-init save before branch switch' --no-verify", { cwd: projectRoot, timeout: 10000, stdio: ["pipe", "pipe", "pipe"] });
+                        }
+                    }
+                    catch (commitErr) {
+                        // If commit fails (e.g. nothing to commit after add), try stash as fallback
+                        try {
+                            execSync("git stash push -m 'jfl-session-init-stash' --include-untracked", { cwd: projectRoot, timeout: 10000, stdio: ["pipe", "pipe", "pipe"] });
+                            warnings.push("Stashed dirty state (commit failed)");
+                        }
+                        catch {
+                            // Last resort: force checkout will carry dirty files to new branch
+                        }
+                    }
+                    // If on a stale session branch, merge it first (prevent data loss)
+                    if (currentBranch.startsWith("session-")) {
+                        try {
+                            // Check for unique commits
+                            const uniqueCommits = execSync(`git log --oneline "${workingBranch}".."${currentBranch}" 2>/dev/null | wc -l`, { cwd: projectRoot, encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] }).trim();
+                            if (parseInt(uniqueCommits) > 0) {
+                                // Merge stale branch to working branch
+                                execSync(`git checkout "${workingBranch}"`, { cwd: projectRoot, timeout: 10000, stdio: ["pipe", "pipe", "pipe"] });
+                                try {
+                                    execSync(`git merge "${currentBranch}" --no-edit -X ours`, { cwd: projectRoot, timeout: 15000, stdio: ["pipe", "pipe", "pipe"] });
+                                    try {
+                                        execSync(`git branch -d "${currentBranch}"`, { cwd: projectRoot, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+                                    }
+                                    catch { }
+                                    warnings.push(`Merged stale session ${currentBranch} (${uniqueCommits} commits) → ${workingBranch}`);
+                                }
+                                catch {
+                                    try {
+                                        execSync("git merge --abort", { cwd: projectRoot, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+                                    }
+                                    catch { }
+                                    warnings.push(`Could not merge stale branch ${currentBranch} — preserved for manual merge`);
+                                }
+                            }
+                            else {
+                                execSync(`git checkout "${workingBranch}"`, { cwd: projectRoot, timeout: 10000, stdio: ["pipe", "pipe", "pipe"] });
+                            }
+                        }
+                        catch {
+                            warnings.push(`Could not switch from stale session branch ${currentBranch}`);
+                        }
+                    }
+                    // Ensure we're on working branch before creating session branch
+                    try {
+                        const nowBranch = execSync("git branch --show-current", { cwd: projectRoot, stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+                        if (nowBranch !== workingBranch) {
+                            execSync(`git checkout "${workingBranch}"`, { cwd: projectRoot, timeout: 10000, stdio: ["pipe", "pipe", "pipe"] });
+                        }
+                    }
+                    catch { }
+                    // Create the new session branch
+                    try {
+                        execSync(`git checkout -b "${sessionBranch}"`, { cwd: projectRoot, stdio: ["pipe", "pipe", "pipe"] });
+                    }
+                    catch {
+                        // If branch creation fails (name collision?), try with longer random
+                        const fallbackId = Math.random().toString(16).slice(2, 14);
+                        sessionBranch = `session-${user}-${dateStr}-${timeStr}-${fallbackId}`;
+                        try {
+                            execSync(`git checkout -b "${sessionBranch}"`, { cwd: projectRoot, stdio: ["pipe", "pipe", "pipe"] });
+                        }
+                        catch {
+                            sessionBranch = currentBranch || "main";
+                            warnings.push("Could not create session branch");
+                        }
+                    }
+                    // Pop stash if we stashed earlier
+                    try {
+                        const stashList = execSync("git stash list", { cwd: projectRoot, timeout: 5000, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+                        if (stashList.includes("jfl-session-init-stash")) {
+                            execSync("git stash pop", { cwd: projectRoot, timeout: 10000, stdio: ["pipe", "pipe", "pipe"] });
+                        }
+                    }
+                    catch { }
+                    // Step 4: Save session info
+                    const jflDir = path.join(projectRoot, ".jfl");
+                    fs.mkdirSync(path.join(jflDir, "logs"), { recursive: true });
+                    fs.mkdirSync(path.join(jflDir, "journal"), { recursive: true });
+                    fs.writeFileSync(path.join(jflDir, "current-session-branch.txt"), sessionBranch);
+                    fs.writeFileSync(path.join(jflDir, "current-worktree.txt"), "direct");
+                    // Emit session start event
+                    if (eventBus) {
+                        eventBus.emit({
+                            type: "session:started",
+                            source: `hub:${runtime || "unknown"}`,
+                            data: { branch: sessionBranch, runtime, warnings },
+                        });
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({
+                        ok: true,
+                        branch: sessionBranch,
+                        syncOk,
+                        doctor: { errors: doctorErrors, warnings: doctorWarnings },
+                        warnings,
+                    }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+                finally {
+                    // Release session init lock
+                    try {
+                        fs.unlinkSync(lockFile);
+                    }
+                    catch { }
+                }
+            });
+            return;
+        }
+        // POST /api/prompt — get system prompt injection (CLAUDE.md + context)
+        if (url.pathname === "/api/prompt" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => body += chunk);
+            req.on("end", async () => {
+                try {
+                    const { taskType, maxItems } = JSON.parse(body || "{}");
+                    const parts = [];
+                    // 1. Load CLAUDE.md
+                    const claudeMdPath = path.join(projectRoot, "CLAUDE.md");
+                    if (fs.existsSync(claudeMdPath)) {
+                        const content = fs.readFileSync(claudeMdPath, "utf-8");
+                        if (content.length > 50000) {
+                            const sections = content.split(/^## /m);
+                            const critical = sections.filter((s) => /CRITICAL|Session Sync|Journal Protocol|Immediate Decision|Working Mode|Core Architecture/i.test(s.slice(0, 100)));
+                            if (critical.length > 0) {
+                                parts.push("# Project Instructions (CLAUDE.md — critical sections)\n");
+                                parts.push("## " + critical.join("\n\n## "));
+                            }
+                            else {
+                                parts.push("# Project Instructions (CLAUDE.md — truncated)\n");
+                                parts.push(content.slice(0, 30000));
+                            }
+                        }
+                        else {
+                            parts.push("# Project Instructions (CLAUDE.md)\n");
+                            parts.push(content);
+                        }
+                    }
+                    // 2. Load recent context
+                    try {
+                        const contextItems = readJournalEntries(projectRoot, maxItems ?? 20);
+                        if (contextItems.length > 0) {
+                            parts.push("\n## Recent Project Context\n");
+                            parts.push(contextItems.map(item => {
+                                const prefix = item.source ? `[${item.source}] ` : "";
+                                return `${prefix}${item.content}`;
+                            }).join("\n\n"));
+                        }
+                    }
+                    catch { }
+                    // 3. Load knowledge docs summaries
+                    const knowledgeDir = path.join(projectRoot, "knowledge");
+                    if (fs.existsSync(knowledgeDir)) {
+                        const knowledgeDocs = ["VISION.md", "ROADMAP.md", "NARRATIVE.md", "THESIS.md"];
+                        const summaries = [];
+                        for (const doc of knowledgeDocs) {
+                            const docPath = path.join(knowledgeDir, doc);
+                            if (fs.existsSync(docPath)) {
+                                const content = fs.readFileSync(docPath, "utf-8");
+                                if (content.length > 100) {
+                                    summaries.push(`### ${doc}\n${content.slice(0, 500)}${content.length > 500 ? "\n..." : ""}`);
+                                }
+                            }
+                        }
+                        if (summaries.length > 0) {
+                            parts.push("\n## Knowledge Documents\n");
+                            parts.push(summaries.join("\n\n"));
+                        }
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({
+                        prompt: parts.join("\n"),
+                        claudeMdSize: fs.existsSync(path.join(projectRoot, "CLAUDE.md"))
+                            ? fs.statSync(path.join(projectRoot, "CLAUDE.md")).size : 0,
+                        taskType: taskType ?? "general",
+                    }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        // POST /api/session/pivot — checkpoint work without ending session
+        if (url.pathname === "/api/session/pivot" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => body += chunk);
+            req.on("end", async () => {
+                try {
+                    const { summary, push } = JSON.parse(body || "{}");
+                    const { pivotCommand } = await import("./pivot.js");
+                    const result = await pivotCommand({ summary, push, json: false });
+                    if (eventBus) {
+                        eventBus.emit({
+                            type: "session:pivoted",
+                            source: "hub:pivot",
+                            data: { branch: result.branch, pivotNumber: result.pivotNumber, summary: summary || "", filesChanged: result.filesChanged },
+                        });
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify(result));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        // POST /api/session/end — cleanup session (merge, commit, etc)
+        if (url.pathname === "/api/session/end" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => body += chunk);
+            req.on("end", async () => {
+                try {
+                    const { runtime, skipCleanup } = JSON.parse(body || "{}");
+                    // Check journal exists
+                    let hasJournal = false;
+                    try {
+                        const branch = execSync("git branch --show-current", { cwd: projectRoot, stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+                        const journalPath = path.join(projectRoot, ".jfl", "journal", `${branch}.jsonl`);
+                        hasJournal = fs.existsSync(journalPath) && fs.statSync(journalPath).size > 0;
+                    }
+                    catch { }
+                    let cleanupResult = "skipped";
+                    if (!skipCleanup) {
+                        const cleanupScript = path.join(projectRoot, "scripts", "session", "session-cleanup.sh");
+                        if (fs.existsSync(cleanupScript)) {
+                            try {
+                                execSync(`bash "${cleanupScript}"`, { cwd: projectRoot, timeout: 60000, stdio: ["pipe", "pipe", "pipe"] });
+                                cleanupResult = "ok";
+                            }
+                            catch (err) {
+                                cleanupResult = `error: ${(err.message || "").split("\n")[0]}`;
+                            }
+                        }
+                        else {
+                            cleanupResult = "no cleanup script";
+                        }
+                    }
+                    // Emit session end event
+                    if (eventBus) {
+                        eventBus.emit({
+                            type: "session:ended",
+                            source: `hub:${runtime || "unknown"}`,
+                            data: { hasJournal, cleanupResult, runtime },
+                        });
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({
+                        ok: true,
+                        hasJournal,
+                        cleanupResult,
+                        warnings: hasJournal ? [] : ["No journal entry for this session"],
+                    }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        // ── Findings API ──────────────────────────────────────────────────
+        // GET /api/v1/findings — list current findings
+        if (url.pathname === "/api/v1/findings" && req.method === "GET") {
+            try {
+                const engine = new FindingsEngine(projectRoot);
+                const refresh = url.searchParams.get("refresh") === "true";
+                let findings;
+                if (refresh) {
+                    findings = await engine.analyze();
+                }
+                else {
+                    findings = engine.getFindings();
+                    // Auto-analyze if no findings exist
+                    if (findings.length === 0) {
+                        findings = await engine.analyze();
+                    }
+                }
+                // Filter out dismissed unless ?include_dismissed=true
+                const includeDismissed = url.searchParams.get("include_dismissed") === "true";
+                if (!includeDismissed) {
+                    findings = findings.filter(f => !f.dismissed);
+                }
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ findings, total: findings.length }));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // POST /api/v1/findings/:id/dismiss — dismiss a finding
+        if (url.pathname.match(/^\/api\/v1\/findings\/[^/]+\/dismiss$/) && req.method === "POST") {
+            try {
+                const findingId = decodeURIComponent(url.pathname.split("/")[4]);
+                const engine = new FindingsEngine(projectRoot);
+                const success = engine.dismissFinding(findingId);
+                if (success) {
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: true, dismissed: findingId }));
+                }
+                else {
+                    res.writeHead(404, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Finding not found" }));
+                }
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // POST /api/v1/findings/:id/spawn — spawn an agent from a finding
+        if (url.pathname.match(/^\/api\/v1\/findings\/[^/]+\/spawn$/) && req.method === "POST") {
+            try {
+                const findingId = decodeURIComponent(url.pathname.split("/")[4]);
+                const engine = new FindingsEngine(projectRoot);
+                const findings = engine.getFindings();
+                const finding = findings.find(f => f.id === findingId);
+                if (!finding) {
+                    res.writeHead(404, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Finding not found" }));
+                    return;
+                }
+                if (!finding.agent_config) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Finding has no agent config" }));
+                    return;
+                }
+                // Spawn peter-parker to fix the issue
+                const env = { ...process.env };
+                delete env.ANTHROPIC_API_KEY;
+                delete env.CLAUDE_CODE_ENTRYPOINT;
+                const agentConfig = finding.agent_config;
+                const prompt = `Fix this issue: ${finding.title}\n\n${finding.description}\n\nTarget metric: ${agentConfig.metric} >= ${agentConfig.target}\nScope files: ${agentConfig.scope_files.join(", ")}`;
+                const child = spawn("jfl", ["peter", "run", "--prompt", prompt], {
+                    cwd: projectRoot,
+                    detached: true,
+                    stdio: "ignore",
+                    env,
+                });
+                child.unref();
+                // Emit event for tracking
+                if (eventBus) {
+                    eventBus.emit({
+                        type: "findings:agent-spawned",
+                        source: "findings-engine",
+                        data: {
+                            finding_id: findingId,
+                            finding_type: finding.type,
+                            finding_title: finding.title,
+                            pid: child.pid,
+                        },
+                    });
+                }
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({
+                    ok: true,
+                    pid: child.pid,
+                    finding_id: findingId,
+                    agent_config: agentConfig,
+                }));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // POST /api/v1/findings/analyze — force re-analyze
+        if (url.pathname === "/api/v1/findings/analyze" && req.method === "POST") {
+            try {
+                const engine = new FindingsEngine(projectRoot);
+                const findings = await engine.analyze();
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ findings, total: findings.length }));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // POST /api/webhooks/linear — handle Linear webhook events
+        if (url.pathname === "/api/webhooks/linear" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => { body += chunk; });
+            req.on("end", async () => {
+                try {
+                    const payload = JSON.parse(body || "{}");
+                    const { handleLinearWebhook } = await import("../lib/linear-webhook.js");
+                    const result = handleLinearWebhook(payload, projectRoot);
+                    if (result.handled && eventBus) {
+                        eventBus.emit({
+                            type: "linear:document-sync",
+                            source: "linear-webhook",
+                            data: {
+                                action: payload.action,
+                                documentTitle: payload.data?.title,
+                                journalFile: result.journalFile,
+                            },
+                        });
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify(result));
+                }
+                catch (err) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        // 404
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Not found" }));
+    });
+    // WebSocket upgrade for event streaming
+    if (eventBus) {
+        const wss = new WebSocketServer({ noServer: true });
+        server.on("upgrade", (request, socket, head) => {
+            const reqUrl = new URL(request.url || "/", `http://localhost:${port}`);
+            if (reqUrl.pathname !== "/ws/events") {
+                socket.destroy();
+                return;
+            }
+            if (!validateAuth(request, projectRoot, reqUrl)) {
+                socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+                socket.destroy();
+                return;
+            }
+            wss.handleUpgrade(request, socket, head, (ws) => {
+                const patterns = (reqUrl.searchParams.get("patterns") || "*").split(",");
+                const sub = eventBus.subscribe({
+                    clientId: `ws-${Date.now()}`,
+                    patterns,
+                    transport: "websocket",
+                    callback: (event) => {
+                        if (ws.readyState === ws.OPEN) {
+                            ws.send(JSON.stringify(event));
+                        }
+                    },
+                });
+                ws.on("close", () => {
+                    eventBus.unsubscribe(sub.id);
+                });
+                ws.on("error", () => {
+                    eventBus.unsubscribe(sub.id);
+                });
+            });
+        });
+    }
+    return server;
+}
+// ============================================================================
+// Daemon Management
+// ============================================================================
+function getPidFile(projectRoot) {
+    return path.join(projectRoot, PID_FILE);
+}
+function getLogFile(projectRoot) {
+    const logFile = path.join(projectRoot, LOG_FILE);
+    const logDir = path.dirname(logFile);
+    if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+    }
+    return logFile;
+}
+export function isRunning(projectRoot) {
+    const pidFile = getPidFile(projectRoot);
+    if (!fs.existsSync(pidFile)) {
+        return { running: false };
+    }
+    const pid = parseInt(fs.readFileSync(pidFile, "utf-8").trim(), 10);
+    try {
+        process.kill(pid, 0); // Check if process exists
+        return { running: true, pid };
+    }
+    catch {
+        // Process doesn't exist, clean up stale PID file
+        fs.unlinkSync(pidFile);
+        return { running: false };
+    }
+}
+// ============================================================================
+// Cross-Project Helpers
+// ============================================================================
+function getTrackedProjects() {
+    // Read from both config sources (Conf library + XDG config)
+    const confStore = new Conf({ projectName: "jfl" });
+    const confProjects = confStore.get("projects") || [];
+    const xdgProjects = getConfigValue("projects") || [];
+    // Deduplicate
+    const allPaths = [...new Set([...confProjects, ...xdgProjects])];
+    return allPaths
+        .filter(p => fs.existsSync(path.join(p, ".jfl")))
+        .map(p => ({ path: p, port: getProjectPort(p) }));
+}
+async function ensureForProject(projectRoot, port, quiet = false) {
+    // Rule: ensure ONLY starts hubs, NEVER kills them.
+    // If something is on the port, leave it alone.
+    const status = isRunning(projectRoot);
+    if (status.running) {
+        return { status: "running", message: `Already running (PID: ${status.pid})` };
+    }
+    const portInUse = await isPortInUse(port);
+    if (portInUse) {
+        // Something is on this port. Don't kill it — could be a healthy hub
+        // whose PID file was lost, or a hub started by another process.
+        return { status: "running", message: `Port ${port} in use (assuming healthy)` };
+    }
+    // Nothing running, nothing on port — safe to start
+    const result = await startDaemon(projectRoot, port);
+    if (result.success) {
+        return { status: "started", message: result.message };
+    }
+    return { status: "failed", message: result.message };
+}
+async function diagnoseProject(projectPath, port) {
+    if (!fs.existsSync(projectPath)) {
+        return { path: projectPath, port, status: "STALE", message: "Directory does not exist" };
+    }
+    const pidStatus = isRunning(projectPath);
+    if (!pidStatus.running) {
+        return { path: projectPath, port, status: "DOWN", pid: undefined };
+    }
+    try {
+        const response = await fetch(`http://localhost:${port}/health`, {
+            signal: AbortSignal.timeout(2000)
+        });
+        if (response.ok) {
+            return { path: projectPath, port, status: "OK", pid: pidStatus.pid };
+        }
+    }
+    catch {
+        // Not responding
+    }
+    return { path: projectPath, port, status: "ZOMBIE", pid: pidStatus.pid, message: "PID exists but not responding" };
+}
+async function startDaemon(projectRoot, port) {
+    const status = isRunning(projectRoot);
+    if (status.running) {
+        return { success: true, message: `Context Hub already running (PID: ${status.pid})` };
+    }
+    // Check if port is in use by another process
+    const portInUse = await isPortInUse(port);
+    if (portInUse) {
+        return { success: false, message: `Port ${port} is already in use by another process` };
+    }
+    const logFile = getLogFile(projectRoot);
+    const pidFile = getPidFile(projectRoot);
+    // Generate auth token before starting
+    const token = getOrCreateToken(projectRoot);
+    // Find jfl command (prefer global install)
+    let jflCmd = "jfl";
+    try {
+        // Try to find jfl in PATH
+        execSync("which jfl", { encoding: "utf-8" }).trim();
+    }
+    catch {
+        // Fall back to current process
+        jflCmd = process.argv[1];
+    }
+    // Start as detached process with CONTEXT_HUB_DAEMON=1 so the serve
+    // action knows to ignore SIGTERM during its startup grace period
+    const child = spawn(jflCmd, ["context-hub", "serve", "--port", String(port), "--project-root", projectRoot], {
+        cwd: projectRoot,
+        detached: true,
+        stdio: ["ignore", fs.openSync(logFile, "a"), fs.openSync(logFile, "a")],
+        env: { ...process.env, NODE_ENV: "production", CONTEXT_HUB_DAEMON: "1" }
+    });
+    child.unref();
+    // Wait a moment to ensure process started
+    await new Promise(resolve => setTimeout(resolve, 500));
+    // Write PID file EARLY to avoid race conditions
+    if (child.pid) {
+        // Write PID file immediately
+        fs.writeFileSync(pidFile, String(child.pid));
+        // Then verify process is still running
+        try {
+            process.kill(child.pid, 0);
+            // Give it a bit more time to be ready
+            await new Promise(resolve => setTimeout(resolve, 300));
+            return { success: true, message: `Started (PID: ${child.pid}). Token: ${token.slice(0, 8)}...` };
+        }
+        catch {
+            // Process died, clean up PID file
+            fs.unlinkSync(pidFile);
+            return { success: false, message: "Process started but immediately exited" };
+        }
+    }
+    return { success: false, message: "Failed to spawn daemon process" };
+}
+async function stopDaemon(projectRoot) {
+    const status = isRunning(projectRoot);
+    if (!status.running || !status.pid) {
+        return { success: true, message: "Context Hub is not running" };
+    }
+    const pidFile = getPidFile(projectRoot);
+    try {
+        // Send SIGTERM first (graceful)
+        process.kill(status.pid, "SIGTERM");
+        // Wait up to 3 seconds for graceful shutdown
+        let attempts = 0;
+        while (attempts < 6) {
+            await new Promise(resolve => setTimeout(resolve, 500));
+            try {
+                process.kill(status.pid, 0); // Check if still running
+                attempts++;
+            }
+            catch {
+                // Process is gone
+                break;
+            }
+        }
+        // If still running after 3 seconds, force kill
+        try {
+            process.kill(status.pid, 0);
+            process.kill(status.pid, "SIGKILL");
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        catch {
+            // Process is gone, that's fine
+        }
+        // Clean up PID file (preserve token for seamless restart)
+        if (fs.existsSync(pidFile)) {
+            fs.unlinkSync(pidFile);
+        }
+        return { success: true, message: "Context Hub stopped" };
+    }
+    catch (err) {
+        return { success: false, message: `Failed to stop daemon: ${err}` };
+    }
+}
+// ============================================================================
+// Auto-Install Daemon
+// ============================================================================
+export async function ensureDaemonInstalled(opts) {
+    const quiet = opts?.quiet ?? false;
+    if (process.platform !== "darwin") {
+        return false;
+    }
+    const plistLabel = "com.jfl.context-hub";
+    const plistDir = path.join(homedir(), "Library", "LaunchAgents");
+    const plistPath = path.join(plistDir, `${plistLabel}.plist`);
+    const logPath = path.join(homedir(), ".config", "jfl", "context-hub-agent.log");
+    // If plist exists, check if loaded
+    if (fs.existsSync(plistPath)) {
+        try {
+            const output = execSync("launchctl list", { encoding: "utf-8" });
+            if (output.includes(plistLabel)) {
+                return true;
+            }
+        }
+        catch {
+            // launchctl failed, try to reload
+        }
+        // Exists but not loaded — reload it
+        try {
+            execSync(`launchctl load "${plistPath}"`, { stdio: "ignore" });
+            if (!quiet) {
+                console.log(chalk.green(`\n  Daemon reloaded.`));
+                console.log(chalk.gray(`  Plist: ${plistPath}\n`));
+            }
+            return true;
+        }
+        catch {
+            // Fall through to full install
+        }
+    }
+    // Full install
+    let jflPath = "";
+    try {
+        jflPath = execSync("which jfl", { encoding: "utf-8" }).trim();
+    }
+    catch {
+        jflPath = process.argv[1] || "jfl";
+    }
+    const logDir = path.dirname(logPath);
+    if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+    }
+    const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${plistLabel}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${jflPath}</string>
+        <string>context-hub</string>
+        <string>ensure-all</string>
+        <string>--quiet</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>StartInterval</key>
+    <integer>300</integer>
+    <key>ProcessType</key>
+    <string>Background</string>
+    <key>LowPriorityIO</key>
+    <true/>
+    <key>Nice</key>
+    <integer>10</integer>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+    </dict>
+    <key>StandardOutPath</key>
+    <string>${logPath}</string>
+    <key>StandardErrorPath</key>
+    <string>${logPath}</string>
+</dict>
+</plist>
+`;
+    if (!fs.existsSync(plistDir)) {
+        fs.mkdirSync(plistDir, { recursive: true });
+    }
+    // Unload if partially loaded
+    try {
+        execSync(`launchctl unload "${plistPath}" 2>/dev/null`, { stdio: "ignore" });
+    }
+    catch {
+        // Not loaded, fine
+    }
+    fs.writeFileSync(plistPath, plistContent);
+    try {
+        execSync(`launchctl load "${plistPath}"`);
+        if (!quiet) {
+            console.log(chalk.green(`\n  Daemon installed and loaded.`));
+            console.log(chalk.gray(`  Plist: ${plistPath}`));
+            console.log(chalk.gray(`  Log:   ${logPath}`));
+            console.log(chalk.gray(`  Runs ensure-all every 5 minutes + on login.\n`));
+        }
+        return true;
+    }
+    catch {
+        if (!quiet) {
+            console.log(chalk.red(`\n  Failed to load daemon.\n`));
+        }
+        return false;
+    }
+}
+// ============================================================================
+// CLI Command
+// ============================================================================
+export async function contextHubCommand(action, options = {}) {
+    const isGlobal = options.global || false;
+    const projectRoot = options.projectRoot || (isGlobal ? homedir() : process.cwd());
+    const port = options.port || getProjectPort(projectRoot);
+    // Ensure directories exist (skip for actions that don't need local project root)
+    const globalActions = ["ensure-all", "doctor", "install-daemon", "uninstall-daemon"];
+    if (!globalActions.includes(action || "")) {
+        if (isGlobal) {
+            const { JFL_PATHS, ensureJflDirs } = await import("../utils/jfl-paths.js");
+            ensureJflDirs();
+        }
+        else {
+            const jflDir = path.join(projectRoot, ".jfl");
+            if (!fs.existsSync(jflDir)) {
+                fs.mkdirSync(jflDir, { recursive: true });
+            }
+        }
+    }
+    switch (action) {
+        case "start": {
+            const spinner = ora("Starting Context Hub...").start();
+            const result = await startDaemon(projectRoot, port);
+            if (result.success) {
+                // Check if it was already running
+                if (result.message.includes("already running")) {
+                    spinner.info(result.message);
+                }
+                else {
+                    // Wait for server to be ready
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                    const status = isRunning(projectRoot);
+                    spinner.succeed(`Context Hub started on port ${port} (PID: ${status.pid})`);
+                    console.log(chalk.gray(`  Token file: .jfl/context-hub.token`));
+                }
+            }
+            else {
+                spinner.fail(result.message);
+            }
+            break;
+        }
+        case "stop": {
+            const spinner = ora("Stopping Context Hub...").start();
+            const result = await stopDaemon(projectRoot);
+            if (result.success) {
+                spinner.succeed(result.message);
+            }
+            else {
+                spinner.fail(result.message);
+            }
+            break;
+        }
+        case "restart": {
+            await contextHubCommand("stop", options);
+            await new Promise(resolve => setTimeout(resolve, 500));
+            await contextHubCommand("start", options);
+            break;
+        }
+        case "status": {
+            const status = isRunning(projectRoot);
+            if (status.running) {
+                console.log(chalk.green(`\n  Context Hub is running`));
+                console.log(chalk.gray(`  PID: ${status.pid}`));
+                console.log(chalk.gray(`  Port: ${port}`));
+                // Try to get more info from the API
+                try {
+                    const response = await fetch(`http://localhost:${port}/api/context/status`);
+                    const data = await response.json();
+                    console.log(chalk.gray(`  Sources: ${Object.entries(data.sources).filter(([, v]) => v).map(([k]) => k).join(", ")}`));
+                    console.log(chalk.gray(`  Items: ${data.itemCount}`));
+                }
+                catch {
+                    // Server might not be responding yet
+                }
+                console.log();
+            }
+            else {
+                console.log(chalk.yellow("\n  Context Hub is not running"));
+                console.log(chalk.gray("  Run: jfl context-hub start\n"));
+            }
+            break;
+        }
+        case "ensure": {
+            await ensureForProject(projectRoot, port, true);
+            break;
+        }
+        case "ensure-all": {
+            const tracked = getTrackedProjects();
+            if (tracked.length === 0) {
+                if (!options.quiet) {
+                    console.log(chalk.yellow("\n  No tracked projects found.\n"));
+                }
+                break;
+            }
+            const results = [];
+            for (const project of tracked) {
+                const name = path.basename(project.path);
+                const result = await ensureForProject(project.path, project.port, true);
+                results.push({ name, result });
+            }
+            if (!options.quiet) {
+                console.log(chalk.bold("\n  Context Hub - ensure-all\n"));
+                for (const { name, result } of results) {
+                    const icon = result.status === "failed" ? chalk.red("✗") : chalk.green("✓");
+                    const label = result.status === "started" ? chalk.cyan("started") :
+                        result.status === "running" ? chalk.green("running") :
+                            chalk.red("failed");
+                    console.log(`  ${icon} ${chalk.bold(name)} — ${label}`);
+                }
+                const ok = results.filter(r => r.result.status !== "failed").length;
+                const fail = results.filter(r => r.result.status === "failed").length;
+                console.log(chalk.gray(`\n  ${ok} running, ${fail} failed\n`));
+            }
+            break;
+        }
+        case "doctor": {
+            const confStoreDoctor = new Conf({ projectName: "jfl" });
+            const confProjectsDoctor = confStoreDoctor.get("projects") || [];
+            const xdgProjectsDoctor = getConfigValue("projects") || [];
+            const allProjects = [...new Set([...confProjectsDoctor, ...xdgProjectsDoctor])];
+            if (allProjects.length === 0) {
+                console.log(chalk.yellow("\n  No tracked projects found.\n"));
+                break;
+            }
+            const cleanMode = process.argv.includes("--clean");
+            if (cleanMode) {
+                const before = allProjects.length;
+                const valid = allProjects.filter(p => fs.existsSync(p));
+                // Write cleaned list back to both stores
+                confStoreDoctor.set("projects", valid.filter(p => confProjectsDoctor.includes(p)));
+                setConfig("projects", valid.filter(p => xdgProjectsDoctor.includes(p)));
+                const removed = before - valid.length;
+                if (removed > 0) {
+                    console.log(chalk.green(`\n  Removed ${removed} stale project${removed > 1 ? "s" : ""} from tracker.\n`));
+                }
+                else {
+                    console.log(chalk.green("\n  No stale projects found.\n"));
+                }
+                break;
+            }
+            console.log(chalk.bold("\n  Context Hub - doctor\n"));
+            let staleCount = 0;
+            let downCount = 0;
+            let zombieCount = 0;
+            let okCount = 0;
+            for (const projectPath of allProjects) {
+                const projectPort = getProjectPort(projectPath);
+                const result = await diagnoseProject(projectPath, projectPort);
+                const name = path.basename(result.path);
+                switch (result.status) {
+                    case "OK":
+                        console.log(`  ${chalk.green("OK")}     ${chalk.bold(name)} — PID ${result.pid}, port ${result.port}`);
+                        okCount++;
+                        break;
+                    case "ZOMBIE":
+                        console.log(`  ${chalk.red("ZOMBIE")} ${chalk.bold(name)} — PID ${result.pid} not responding on port ${result.port}`);
+                        zombieCount++;
+                        break;
+                    case "DOWN":
+                        console.log(`  ${chalk.red("DOWN")}   ${chalk.bold(name)} — not running (port ${result.port})`);
+                        downCount++;
+                        break;
+                    case "STALE":
+                        console.log(`  ${chalk.yellow("STALE")}  ${chalk.gray(result.path)} — directory missing`);
+                        staleCount++;
+                        break;
+                }
+            }
+            console.log();
+            if (downCount > 0 || zombieCount > 0) {
+                console.log(chalk.gray(`  Hint: run ${chalk.cyan("jfl context-hub ensure-all")} to start all hubs`));
+            }
+            if (staleCount > 0) {
+                console.log(chalk.gray(`  Hint: run ${chalk.cyan("jfl context-hub doctor --clean")} to remove stale entries`));
+            }
+            if (okCount === allProjects.length) {
+                console.log(chalk.green("  All projects healthy."));
+            }
+            console.log();
+            break;
+        }
+        case "install-daemon": {
+            const result = await ensureDaemonInstalled({ quiet: false });
+            if (!result) {
+                console.log(chalk.yellow("\n  Daemon install skipped (non-macOS or failed).\n"));
+            }
+            break;
+        }
+        case "uninstall-daemon": {
+            const plistLabel = "com.jfl.context-hub";
+            const plistPath = path.join(homedir(), "Library", "LaunchAgents", `${plistLabel}.plist`);
+            if (!fs.existsSync(plistPath)) {
+                console.log(chalk.yellow("\n  Daemon not installed.\n"));
+                break;
+            }
+            try {
+                execSync(`launchctl unload "${plistPath}"`, { stdio: "ignore" });
+            }
+            catch {
+                // Already unloaded
+            }
+            fs.unlinkSync(plistPath);
+            console.log(chalk.green("\n  Daemon uninstalled.\n"));
+            break;
+        }
+        case "serve": {
+            // Load .env files for API keys (hub runs as detached process)
+            for (const envFile of [
+                path.join(projectRoot, ".env"),
+                path.join(projectRoot, ".env.local"),
+                path.join(process.env.HOME || "/tmp", ".env"),
+            ]) {
+                if (fs.existsSync(envFile)) {
+                    const envContent = fs.readFileSync(envFile, "utf-8");
+                    for (const line of envContent.split("\n")) {
+                        const trimmed = line.trim();
+                        if (!trimmed || trimmed.startsWith("#"))
+                            continue;
+                        const eqIdx = trimmed.indexOf("=");
+                        if (eqIdx === -1)
+                            continue;
+                        const key = trimmed.slice(0, eqIdx).trim();
+                        let val = trimmed.slice(eqIdx + 1).trim();
+                        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+                            val = val.slice(1, -1);
+                        }
+                        if (!process.env[key]) {
+                            process.env[key] = val;
+                        }
+                    }
+                }
+            }
+            // Run server in foreground (used by daemon)
+            const serviceEventsPath = path.join(projectRoot, ".jfl", "service-events.jsonl");
+            const mapPersistPath = path.join(projectRoot, ".jfl", "map-events.jsonl");
+            const journalDir = path.join(projectRoot, ".jfl", "journal");
+            const eventBus = new MAPEventBus({
+                maxSize: 1000,
+                persistPath: mapPersistPath,
+                serviceEventsPath,
+                journalDir: fs.existsSync(journalDir) ? journalDir : null,
+            });
+            const flowEngine = new FlowEngine(eventBus, projectRoot);
+            const server = createServer(projectRoot, port, eventBus, flowEngine);
+            let isListening = false;
+            // Cross-service scope impact detection (GTM/portfolio level)
+            // When eval:scored fires with improved=true, detect which other services
+            // are affected and emit scope:impact events for each
+            const configPath = path.join(projectRoot, ".jfl", "config.json");
+            const hubConfig = fs.existsSync(configPath) ? JSON.parse(fs.readFileSync(configPath, "utf-8")) : {};
+            if (hubConfig.type === "gtm" || hubConfig.type === "portfolio") {
+                eventBus.subscribe({
+                    clientId: "scope-detector",
+                    patterns: ["eval:scored"],
+                    transport: "poll",
+                    callback: (event) => {
+                        if (event.data?.improved !== "true" && event.data?.improved !== true)
+                            return;
+                        const serviceName = event.data?.service || event.source || "unknown";
+                        const registeredServices = hubConfig.registered_services || [];
+                        // Find source service's produces
+                        const sourceReg = registeredServices.find((s) => s.name === serviceName);
+                        if (!sourceReg?.path)
+                            return;
+                        try {
+                            const svcConfigPath = path.join(sourceReg.path, ".jfl", "config.json");
+                            if (!fs.existsSync(svcConfigPath))
+                                return;
+                            const svcConfig = JSON.parse(fs.readFileSync(svcConfigPath, "utf-8"));
+                            const produces = svcConfig.context_scope?.produces || [];
+                            if (produces.length === 0)
+                                return;
+                            // Check each other service for consuming matches
+                            for (const otherSvc of registeredServices) {
+                                if (otherSvc.name === serviceName || !otherSvc.path)
+                                    continue;
+                                const otherConfigPath = path.join(otherSvc.path, ".jfl", "config.json");
+                                if (!fs.existsSync(otherConfigPath))
+                                    continue;
+                                const otherConfig = JSON.parse(fs.readFileSync(otherConfigPath, "utf-8"));
+                                const consumes = otherConfig.context_scope?.consumes || [];
+                                // Match produces against consumes
+                                const matched = [];
+                                for (const p of produces) {
+                                    for (const c of consumes) {
+                                        if (c === "*" || p === c || (c.endsWith(":*") && p.startsWith(c.slice(0, -1))) || (c.endsWith("*") && p.startsWith(c.slice(0, -1)))) {
+                                            matched.push(`${p} → ${c}`);
+                                        }
+                                    }
+                                }
+                                if (matched.length > 0) {
+                                    const ts = new Date().toISOString();
+                                    console.log(`[${ts}] scope:impact — ${serviceName} → ${otherSvc.name} (${matched.length} patterns)`);
+                                    eventBus.emit({
+                                        type: "scope:impact",
+                                        source: "scope-detector",
+                                        data: {
+                                            source_service: serviceName,
+                                            affected_service: otherSvc.name,
+                                            affected_service_path: otherSvc.path,
+                                            scope_patterns: matched,
+                                            source_pr: event.data?.pr_number || "",
+                                            change_description: event.data?.branch || "eval improvement",
+                                            source_delta: event.data?.delta || "0",
+                                        },
+                                    });
+                                }
+                            }
+                        }
+                        catch (err) {
+                            console.error(`[scope-detector] Error checking impact for ${serviceName}:`, err.message);
+                        }
+                    },
+                });
+                console.log(`[scope-detector] Cross-service impact detection enabled for ${hubConfig.type} hub`);
+            }
+            // When spawned as daemon, ignore SIGTERM during startup grace period.
+            // The parent process (hook runner) may exit and send SIGTERM to the
+            // process group before we're fully detached. After grace period,
+            // re-enable normal shutdown handling.
+            const isDaemon = process.env.CONTEXT_HUB_DAEMON === "1";
+            let startupGrace = isDaemon;
+            if (isDaemon) {
+                setTimeout(() => {
+                    startupGrace = false;
+                }, 5000);
+            }
+            // Error handling - keep process alive
+            process.on("uncaughtException", (err) => {
+                console.error(`Uncaught exception: ${err.message}`);
+                console.error(err.stack);
+                telemetry.track({
+                    category: 'error',
+                    event: 'error:hub_crash',
+                    error_type: err.constructor.name,
+                    error_code: err.code || undefined,
+                    hub_port: port,
+                    hub_uptime_s: isListening ? Math.floor((Date.now() - hubStartTime) / 1000) : 0,
+                });
+            });
+            process.on("unhandledRejection", (reason, promise) => {
+                console.error(`Unhandled rejection at ${promise}: ${reason}`);
+                // Don't exit - log and continue
+            });
+            server.on("error", (err) => {
+                console.error(`Server error: ${err.message}`);
+                telemetry.track({
+                    category: 'error',
+                    event: 'error:hub_server',
+                    error_type: err.constructor.name,
+                    error_code: err.code || undefined,
+                    hub_port: port,
+                });
+                if (err.code === "EADDRINUSE") {
+                    console.error(`Port ${port} is already in use. Exiting.`);
+                    process.exit(1);
+                }
+            });
+            const hubStartTime = Date.now();
+            server.listen(port, async () => {
+                isListening = true;
+                const timestamp = new Date().toISOString();
+                console.log(`[${timestamp}] Context Hub listening on port ${port}`);
+                console.log(`[${timestamp}] PID: ${process.pid}`);
+                telemetry.track({
+                    category: 'context_hub',
+                    event: 'context_hub:started',
+                    hub_port: port,
+                    duration_ms: Date.now() - hubStartTime,
+                });
+                // Initialize memory system
+                try {
+                    await initializeDatabase();
+                    console.log(`[${timestamp}] Memory database initialized`);
+                    // Index existing journal entries
+                    const stats = await indexJournalEntries();
+                    if (stats.added > 0) {
+                        console.log(`[${timestamp}] Indexed ${stats.added} new journal entries`);
+                    }
+                    // Start periodic indexing (every 60 seconds)
+                    startPeriodicIndexing(60000);
+                    console.log(`[${timestamp}] Periodic memory indexing started`);
+                }
+                catch (err) {
+                    console.error(`[${timestamp}] Failed to initialize memory system:`, err.message);
+                    // Don't exit - memory is optional
+                }
+                // Start flow engine (with child hub connections for portfolio mode)
+                try {
+                    const children = getChildHubs(projectRoot);
+                    if (children.length > 0) {
+                        flowEngine.setChildren(children);
+                        console.log(`[${timestamp}] Portfolio mode: connecting to ${children.length} child hub(s)`);
+                    }
+                    const flowCount = await flowEngine.start();
+                    if (flowCount > 0) {
+                        console.log(`[${timestamp}] Flow engine started with ${flowCount} active flow(s)`);
+                    }
+                }
+                catch (err) {
+                    console.error(`[${timestamp}] Failed to start flow engine:`, err.message);
+                }
+                // Start telemetry agent (periodic pattern detection)
+                try {
+                    const { TelemetryAgent } = await import("../lib/telemetry-agent.js");
+                    const telemetryAgent = new TelemetryAgent({
+                        projectRoot,
+                        intervalMs: 30 * 60 * 1000,
+                        emitEvent: (type, data, source) => {
+                            eventBus.emit({ type: type, data, source: source || 'telemetry-agent' });
+                        },
+                    });
+                    telemetryAgent.start();
+                    server.__telemetryAgent = telemetryAgent;
+                    console.log(`[${timestamp}] Telemetry agent started (interval: 30m)`);
+                }
+                catch (err) {
+                    console.error(`[${timestamp}] Failed to start telemetry agent:`, err.message);
+                }
+                console.log(`[${timestamp}] MAP event bus initialized (buffer: 1000, subscribers: ${eventBus.getSubscriberCount()})`);
+                console.log(`[${timestamp}] Ready to serve requests`);
+            });
+            // Handle shutdown gracefully
+            const shutdown = (signal) => {
+                // During startup grace period (daemon mode), ignore SIGTERM from
+                // parent process cleanup. This prevents the hook runner from
+                // killing the hub before it's fully detached.
+                if (startupGrace && signal === "SIGTERM") {
+                    const ts = new Date().toISOString();
+                    console.log(`[${ts}] Ignoring ${signal} during startup grace period (PID: ${process.pid}, Parent: ${process.ppid})`);
+                    return;
+                }
+                if (!isListening) {
+                    // Server never started, just exit
+                    process.exit(0);
+                    return;
+                }
+                // Log who sent the signal for debugging
+                const timestamp = new Date().toISOString();
+                console.log(`[${timestamp}] Received ${signal}`);
+                console.log(`[${timestamp}] PID: ${process.pid}, Parent PID: ${process.ppid}`);
+                console.log(`[${timestamp}] Shutting down...`);
+                telemetry.track({
+                    category: 'context_hub',
+                    event: 'context_hub:stopped',
+                    hub_port: port,
+                    hub_uptime_s: Math.floor((Date.now() - hubStartTime) / 1000),
+                });
+                server.close(() => {
+                    eventBus.destroy();
+                    console.log(`[${new Date().toISOString()}] Server closed`);
+                    process.exit(0);
+                });
+                // Force exit after 5s if server doesn't close
+                setTimeout(() => {
+                    console.log(`[${new Date().toISOString()}] Force exit after timeout`);
+                    process.exit(1);
+                }, 5000);
+            };
+            process.on("SIGTERM", () => shutdown("SIGTERM"));
+            process.on("SIGINT", () => shutdown("SIGINT"));
+            // Keep process alive with heartbeat
+            const heartbeat = setInterval(() => {
+                // Heartbeat - ensures event loop stays active
+                // Also log periodically so we know it's alive
+                if (isListening && Date.now() % 300000 < 60000) { // Every 5 minutes
+                    const timestamp = new Date().toISOString();
+                    console.log(`[${timestamp}] Heartbeat: Still running (PID: ${process.pid})`);
+                }
+            }, 60000);
+            // Cleanup heartbeat on exit
+            process.on("exit", () => {
+                clearInterval(heartbeat);
+            });
+            break;
+        }
+        case "query": {
+            // Quick query for testing
+            const context = getUnifiedContext(projectRoot);
+            console.log(chalk.bold("\n  Context Hub Query\n"));
+            console.log(chalk.gray(`  Sources: ${Object.entries(context.sources).filter(([, v]) => v).map(([k]) => k).join(", ")}`));
+            console.log(chalk.gray(`  Items: ${context.items.length}\n`));
+            for (const item of context.items.slice(0, 10)) {
+                console.log(chalk.cyan(`  [${item.source}] ${item.title}`));
+                console.log(chalk.gray(`    ${item.content.slice(0, 100)}${item.content.length > 100 ? "..." : ""}`));
+            }
+            console.log();
+            break;
+        }
+        case "logs": {
+            // Launch TUI log viewer
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = path.dirname(__filename);
+            const logViewer = spawn(process.execPath, [
+                path.join(__dirname, "../ui/context-hub-logs.js")
+            ], {
+                stdio: "inherit",
+                cwd: projectRoot
+            });
+            logViewer.on("exit", (code) => {
+                process.exit(code || 0);
+            });
+            break;
+        }
+        case "dashboard": {
+            const token = getOrCreateToken(projectRoot);
+            const dashUrl = `http://localhost:${port}/dashboard?token=${token}`;
+            try {
+                execSync(`open "${dashUrl}"`);
+            }
+            catch {
+                // open not available — print URL instead
+            }
+            console.log(chalk.gray(`  Opening ${dashUrl}`));
+            break;
+        }
+        case "clear-logs": {
+            // Clear both global and local log files
+            const { JFL_FILES } = await import("../utils/jfl-paths.js");
+            const globalLogFile = path.join(JFL_FILES.servicesLogs, "context-hub.log");
+            const localLogFile = getLogFile(projectRoot);
+            let cleared = 0;
+            if (fs.existsSync(globalLogFile)) {
+                fs.writeFileSync(globalLogFile, '');
+                console.log(chalk.green('✓ Global Context Hub logs cleared'));
+                console.log(chalk.gray(`  File: ${globalLogFile}`));
+                cleared++;
+            }
+            if (fs.existsSync(localLogFile) && localLogFile !== globalLogFile) {
+                fs.writeFileSync(localLogFile, '');
+                console.log(chalk.green('✓ Local Context Hub logs cleared'));
+                console.log(chalk.gray(`  File: ${localLogFile}`));
+                cleared++;
+            }
+            if (cleared === 0) {
+                console.log(chalk.yellow('No log files found'));
+            }
+            break;
+        }
+        default: {
+            console.log(chalk.bold("\n  Context Hub - Unified context for AI agents\n"));
+            console.log(chalk.gray("  Commands:"));
+            console.log("    jfl context-hub start            Start the daemon");
+            console.log("    jfl context-hub stop             Stop the daemon");
+            console.log("    jfl context-hub restart          Restart the daemon");
+            console.log("    jfl context-hub status           Check if running");
+            console.log("    jfl context-hub ensure           Start if not running (for hooks)");
+            console.log("    jfl context-hub ensure-all       Ensure all tracked projects are running");
+            console.log("    jfl context-hub doctor           Diagnose all tracked projects");
+            console.log("    jfl context-hub doctor --clean   Remove stale project entries");
+            console.log("    jfl context-hub dashboard        Open web dashboard in browser");
+            console.log("    jfl context-hub install-daemon   Install macOS launchd keepalive");
+            console.log("    jfl context-hub uninstall-daemon Remove macOS launchd keepalive");
+            console.log("    jfl context-hub logs             Show real-time logs (TUI)");
+            console.log("    jfl context-hub clear-logs       Clear log file");
+            console.log("    jfl context-hub query            Quick context query");
+            console.log();
+            console.log(chalk.gray("  Options:"));
+            console.log("    --port <port>   Port to run on (default: per-project)");
+            console.log("    --quiet         Suppress output (for daemon use)");
+            console.log();
+        }
+    }
+}
+//# sourceMappingURL=context-hub.js.map