jfl 0.4.4 → 0.6.0

package/dist/commands/context-hub.js

@@ -25,6 +25,9 @@ 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";
@@ -152,7 +155,11 @@ function readKnowledgeDocs(projectRoot) {
         "NARRATIVE.md",
         "THESIS.md",
         "BRAND_DECISIONS.md",
-        "TASKS.md"
+        "TASKS.md",
+        "ARCHITECTURE.md",
+        "SERVICE_SPEC.md",
+        "DEPLOYMENT.md",
+        "RUNBOOK.md",
     ];
     for (const filename of priorityFiles) {
         const filePath = path.join(knowledgeDir, filename);
@@ -163,7 +170,7 @@ function readKnowledgeDocs(projectRoot) {
                 source: "knowledge",
                 type: "doc",
                 title,
-                content: content.slice(0, 2000), // Truncate for context
+                content: content.slice(0, 2000),
                 path: filePath
             });
         }
@@ -409,7 +416,7 @@ function getUnifiedContext(projectRoot, query, taskType) {
             journal: journalItems.length > 0,
             knowledge: knowledgeItems.length > 0,
             code: codeItems.length > 0,
-            memory: false
+            memory: fs.existsSync(path.join(projectRoot, ".jfl", "memory.db")),
         },
         query,
         taskType
@@ -540,6 +547,20 @@ function createServer(projectRoot, port, eventBus, flowEngine) {
             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 }) => {
@@ -766,6 +787,107 @@ function createServer(projectRoot, port, eventBus, flowEngine) {
             }
             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 = "";
@@ -778,7 +900,17 @@ function createServer(projectRoot, port, eventBus, flowEngine) {
                         res.end(JSON.stringify({ error: "query required" }));
                         return;
                     }
-                    const results = await searchMemories(query, { type, maxItems, since });
+                    const raw = await searchMemories(query, { type, maxItems, since });
+                    const results = raw.map(r => ({
+                        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,
+                    }));
                     res.writeHead(200, { "Content-Type": "application/json" });
                     res.end(JSON.stringify({ results }));
                 }
@@ -851,6 +983,23 @@ function createServer(projectRoot, port, eventBus, flowEngine) {
             }
             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 {
@@ -1076,6 +1225,116 @@ function createServer(projectRoot, port, eventBus, flowEngine) {
             }
             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;
+        }
         // Flow definitions
         if (url.pathname === "/api/flows" && req.method === "GET") {
             if (!flowEngine) {
@@ -1160,6 +1419,348 @@ function createServer(projectRoot, port, eventBus, flowEngine) {
             });
             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);
@@ -1198,6 +1799,359 @@ function createServer(projectRoot, port, eventBus, flowEngine) {
             });
             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
+        if (url.pathname === "/api/session/init" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => body += chunk);
+            req.on("end", async () => {
+                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
+                    let currentBranch = "";
+                    try {
+                        currentBranch = execSync("git branch --show-current", { cwd: projectRoot, stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+                    }
+                    catch { }
+                    let sessionBranch = currentBranch;
+                    if (!currentBranch.startsWith("session-")) {
+                        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);
+                        sessionBranch = `session-${user}-${dateStr}-${timeStr}-${randomId}`;
+                        try {
+                            execSync(`git checkout -b "${sessionBranch}"`, { cwd: projectRoot, stdio: ["pipe", "pipe", "pipe"] });
+                        }
+                        catch {
+                            sessionBranch = currentBranch || "main";
+                            warnings.push("Could not create session branch");
+                        }
+                    }
+                    // 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 }));
+                }
+            });
+            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/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;
+        }
         // 404
         res.writeHead(404, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ error: "Not found" }));
@@ -1284,47 +2238,19 @@ function getTrackedProjects() {
         .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) {
-        try {
-            const response = await fetch(`http://localhost:${port}/health`, {
-                signal: AbortSignal.timeout(2000)
-            });
-            if (response.ok) {
-                return { status: "running", message: `Already running (PID: ${status.pid})` };
-            }
-        }
-        catch {
-            // Process exists but not responding, fall through
-        }
+        return { status: "running", message: `Already running (PID: ${status.pid})` };
     }
     const portInUse = await isPortInUse(port);
     if (portInUse) {
-        try {
-            const response = await fetch(`http://localhost:${port}/health`, {
-                signal: AbortSignal.timeout(2000)
-            });
-            if (response.ok) {
-                return { status: "running", message: "Running (PID file missing but healthy)" };
-            }
-        }
-        catch {
-            // Not responding
-        }
-        try {
-            const lsofOutput = execSync(`lsof -ti :${port}`, { encoding: 'utf-8' }).trim();
-            if (lsofOutput) {
-                const orphanedPid = parseInt(lsofOutput.split('\n')[0], 10);
-                if (!status.pid || orphanedPid !== status.pid) {
-                    process.kill(orphanedPid, 'SIGTERM');
-                    await new Promise(resolve => setTimeout(resolve, 500));
-                }
-            }
-        }
-        catch {
-            // lsof failed or process already gone
-        }
+        // 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 };
@@ -1378,7 +2304,7 @@ async function startDaemon(projectRoot, port) {
     }
     // 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)], {
+    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")],
@@ -1563,7 +2489,7 @@ export async function ensureDaemonInstalled(opts) {
 // ============================================================================
 export async function contextHubCommand(action, options = {}) {
     const isGlobal = options.global || false;
-    const projectRoot = isGlobal ? homedir() : process.cwd();
+    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"];
@@ -1766,6 +2692,32 @@ export async function contextHubCommand(action, options = {}) {
             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");
@@ -1779,6 +2731,77 @@ export async function contextHubCommand(action, options = {}) {
             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,