archbyte 0.3.5 → 0.4.1

package/dist/server/src/index.js

@@ -14,6 +14,9 @@ const UI_DIST = path.resolve(__dirname, "../../../ui/dist");
 let config;
 let sseClients = new Set();
 let diagramWatcher = null;
+let isAnalyzing = false;
+const sessionChanges = [];
+const MAX_SESSION_CHANGES = 50;
 let currentArchitecture = null;
 // Process tracking for run-from-UI
 const runningWorkflows = new Map();
@@ -103,7 +106,7 @@ function createHttpServer() {
         const reqOrigin = req.headers.origin || "";
         const allowedOrigin = /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(reqOrigin) ? reqOrigin : `http://localhost:${config.port}`;
         res.setHeader("Access-Control-Allow-Origin", allowedOrigin);
-        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, OPTIONS");
         res.setHeader("Access-Control-Allow-Headers", "Content-Type");
         res.setHeader("X-Content-Type-Options", "nosniff");
         res.setHeader("X-Frame-Options", "SAMEORIGIN");
@@ -254,8 +257,81 @@ function createHttpServer() {
             }));
             return;
         }
-        // API: Validate
-        if (url === "/api/validate" && req.method === "GET") {
+        // API: Impact analysis — blast radius BFS from a node
+        if (url.startsWith("/api/impact/") && req.method === "GET") {
+            const arch = currentArchitecture || (await loadArchitecture());
+            if (!arch) {
+                res.writeHead(404, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "No architecture loaded" }));
+                return;
+            }
+            const urlParts = url.split("?");
+            const nodeId = decodeURIComponent(urlParts[0].replace("/api/impact/", ""));
+            const params = new URL(url, `http://localhost:${config.port}`).searchParams;
+            const depth = Math.min(Math.max(parseInt(params.get("depth") || "2", 10) || 2, 1), 5);
+            const direction = params.get("direction") || "both";
+            // Build adjacency lists
+            const forward = new Map();
+            const reverse = new Map();
+            for (const nd of arch.nodes) {
+                forward.set(nd.id, []);
+                reverse.set(nd.id, []);
+            }
+            for (const edge of arch.edges) {
+                forward.get(edge.source)?.push(edge.target);
+                reverse.get(edge.target)?.push(edge.source);
+            }
+            const nodeMap = new Map();
+            for (const nd of arch.nodes)
+                nodeMap.set(nd.id, nd);
+            // BFS helper
+            function bfs(startId, adj, maxDepth) {
+                const visited = new Map();
+                visited.set(startId, 0);
+                const queue = [{ id: startId, d: 0 }];
+                const result = [];
+                while (queue.length > 0) {
+                    const { id, d } = queue.shift();
+                    if (d >= maxDepth)
+                        continue;
+                    for (const neighbor of adj.get(id) || []) {
+                        if (!visited.has(neighbor)) {
+                            const nd = d + 1;
+                            visited.set(neighbor, nd);
+                            result.push({ id: neighbor, label: nodeMap.get(neighbor)?.label.split("\n")[0] || neighbor, depth: nd });
+                            queue.push({ id: neighbor, d: nd });
+                        }
+                    }
+                }
+                return result;
+            }
+            const upstream = (direction === "downstream") ? [] : bfs(nodeId, reverse, depth);
+            const downstream = (direction === "upstream") ? [] : bfs(nodeId, forward, depth);
+            // Collect all affected node IDs (including origin)
+            const affectedSet = new Set([nodeId]);
+            for (const n of upstream)
+                affectedSet.add(n.id);
+            for (const n of downstream)
+                affectedSet.add(n.id);
+            // Affected edges: edges between any two nodes in the affected set
+            const affectedEdges = [];
+            for (const edge of arch.edges) {
+                if (affectedSet.has(edge.source) && affectedSet.has(edge.target)) {
+                    affectedEdges.push(edge.id);
+                }
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                nodeId,
+                upstream,
+                downstream,
+                affectedEdges,
+                totalAffected: affectedSet.size - 1,
+            }));
+            return;
+        }
+        // API: Audit — unified validation + health endpoint
+        if ((url === "/api/audit" || url === "/api/validate") && req.method === "GET") {
             const arch = currentArchitecture || (await loadArchitecture());
             if (!arch) {
                 res.writeHead(404, { "Content-Type": "application/json" });
@@ -282,6 +358,7 @@ function createHttpServer() {
                         level: "error",
                         message: `"${src.label}" (${src.layer}) -> "${tgt.label}" (${tgt.layer})`,
                         nodeIds: [src.id, tgt.id],
+                        ruleType: "builtin",
                     });
                 }
             }
@@ -299,6 +376,7 @@ function createHttpServer() {
                         level: "warn",
                         message: `"${nd.label}" has ${count} connections (threshold: 6)`,
                         nodeIds: [nd.id],
+                        ruleType: "builtin",
                     });
                 }
             }
@@ -315,6 +393,7 @@ function createHttpServer() {
                         level: "warn",
                         message: `"${nd.label}" has no connections`,
                         nodeIds: [nd.id],
+                        ruleType: "builtin",
                     });
                 }
             }
@@ -356,19 +435,288 @@ function createHttpServer() {
                     level: "error",
                     message: `Cycle: ${cycle.map((id) => nodeMap.get(id)?.label || id).join(" -> ")}`,
                     nodeIds: cycle.filter((id, i, arr) => arr.indexOf(id) === i),
+                    ruleType: "builtin",
                 });
             }
+            // Custom rules from archbyte.yaml
+            try {
+                const yamlPath = path.join(config.workspaceRoot, ".archbyte/archbyte.yaml");
+                if (existsSync(yamlPath)) {
+                    const yamlContent = readFileSync(yamlPath, "utf-8");
+                    const rulesMatch = yamlContent.match(/^rules:\s*\n((?:\s+.*\n)*)/m);
+                    if (rulesMatch) {
+                        const rulesBlock = rulesMatch[1];
+                        const ruleRegex = /^\s+-\s+name:\s*"?([^"\n]+)"?\s*\n\s+from:\s*"?([^"\n]+)"?\s*\n\s+to:\s*"?([^"\n]+)"?\s*\n\s+level:\s*"?([^"\n]+)"?/gm;
+                        let m;
+                        const customRules = [];
+                        while ((m = ruleRegex.exec(rulesBlock)) !== null) {
+                            customRules.push({ name: m[1].trim(), from: m[2].trim(), to: m[3].trim(), level: m[4].trim() });
+                        }
+                        // Helper: check if a node matches a custom rule matcher (type:xxx, layer:xxx, or exact id)
+                        const matchesNode = (nd, matcher) => {
+                            if (matcher.startsWith("type:"))
+                                return nd.type === matcher.slice(5);
+                            if (matcher.startsWith("layer:"))
+                                return nd.layer === matcher.slice(6);
+                            return nd.id === matcher;
+                        };
+                        for (const rule of customRules) {
+                            for (const edge of arch.edges) {
+                                const src = nodeMap.get(edge.source);
+                                const tgt = nodeMap.get(edge.target);
+                                if (!src || !tgt)
+                                    continue;
+                                if (matchesNode(src, rule.from) && matchesNode(tgt, rule.to)) {
+                                    violations.push({
+                                        rule: rule.name,
+                                        level: rule.level === "error" ? "error" : "warn",
+                                        message: `"${src.label}" -> "${tgt.label}" violates custom rule "${rule.name}"`,
+                                        nodeIds: [src.id, tgt.id],
+                                        ruleType: "custom",
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch { /* ignore custom rule errors */ }
+            // === STRUCTURAL ISSUES ===
+            // Build degree maps for health metrics
+            const inDeg = new Map();
+            const outDeg = new Map();
+            const connCount = new Map();
+            const fwdAdj = new Map();
+            for (const nd of realNodes) {
+                inDeg.set(nd.id, 0);
+                outDeg.set(nd.id, 0);
+                connCount.set(nd.id, 0);
+                fwdAdj.set(nd.id, []);
+            }
+            for (const edge of arch.edges) {
+                outDeg.set(edge.source, (outDeg.get(edge.source) || 0) + 1);
+                inDeg.set(edge.target, (inDeg.get(edge.target) || 0) + 1);
+                connCount.set(edge.source, (connCount.get(edge.source) || 0) + 1);
+                connCount.set(edge.target, (connCount.get(edge.target) || 0) + 1);
+                fwdAdj.get(edge.source)?.push(edge.target);
+            }
+            // DFS cycle detection for metrics
+            const visitedH = new Set();
+            const inStackH = new Set();
+            const nodesInCycles = new Set();
+            let circularDependenciesCount = 0;
+            function dfsHealth(nodeId) {
+                visitedH.add(nodeId);
+                inStackH.add(nodeId);
+                for (const neighbor of fwdAdj.get(nodeId) || []) {
+                    if (!visitedH.has(neighbor)) {
+                        dfsHealth(neighbor);
+                    }
+                    else if (inStackH.has(neighbor)) {
+                        nodesInCycles.add(neighbor);
+                        nodesInCycles.add(nodeId);
+                        circularDependenciesCount++;
+                    }
+                }
+                inStackH.delete(nodeId);
+            }
+            for (const nd of realNodes) {
+                if (!visitedH.has(nd.id))
+                    dfsHealth(nd.id);
+            }
+            // Health nodes
+            const totalConnections = Array.from(connCount.values()).reduce((a, b) => a + b, 0);
+            const avgConn = realNodes.length > 0 ? totalConnections / realNodes.length : 0;
+            const maxConn = Math.max(...Array.from(connCount.values()), 1);
+            const healthNodes = realNodes.map((nd) => {
+                const cc = connCount.get(nd.id) || 0;
+                const isOrphan = cc === 0;
+                const isHub = cc > 6;
+                const inCycle = nodesInCycles.has(nd.id);
+                const normalizedFanInOutRatio = maxConn > 0 ? Math.round((cc / maxConn) * 10 * 10) / 10 : 0;
+                let modularityIndex = 100;
+                if (isOrphan)
+                    modularityIndex -= 30;
+                if (isHub)
+                    modularityIndex -= 20;
+                if (inCycle)
+                    modularityIndex -= 25;
+                if (avgConn > 0 && cc > avgConn * 1.5)
+                    modularityIndex -= Math.min(25, Math.round(((cc - avgConn) / avgConn) * 25));
+                modularityIndex = Math.max(0, modularityIndex);
+                return {
+                    id: nd.id,
+                    label: nd.label.split("\n")[0],
+                    connectionCount: cc,
+                    inDegree: inDeg.get(nd.id) || 0,
+                    outDegree: outDeg.get(nd.id) || 0,
+                    isOrphan,
+                    isHub,
+                    inCycle,
+                    normalizedFanInOutRatio,
+                    modularityIndex,
+                    couplingScore: normalizedFanInOutRatio,
+                    healthScore: modularityIndex,
+                };
+            });
+            // Calculate metrics
+            const disconnectedComponentCount = healthNodes.filter((n) => n.isOrphan).length;
+            const meanCouplingRatio = avgConn > 0 ? Math.round((totalConnections / realNodes.length / maxConn) * 10 * 10) / 10 : 0;
+            const maxFanInOutDegree = maxConn;
+            const disconnectionRatio = realNodes.length > 0 ? Math.round((disconnectedComponentCount / realNodes.length) * 100) : 0;
+            const highDegreeHubCount = healthNodes.filter((n) => n.isHub).length;
+            // Convert violations to issues
+            const ruleViolations = violations.map((v) => ({
+                type: 'rule-violation',
+                rule: v.rule,
+                level: v.level,
+                message: v.message,
+                nodeIds: v.nodeIds,
+                ruleType: v.ruleType,
+            }));
+            // Generate structural issues from metrics
+            const structuralIssues = [];
+            if (circularDependenciesCount > 0) {
+                for (const nodeId of Array.from(nodesInCycles).slice(0, 5)) {
+                    structuralIssues.push({
+                        type: 'structural',
+                        metric: 'circular-deps',
+                        level: 'warn',
+                        message: `${nodeMap.get(nodeId)?.label || nodeId} is part of a circular dependency`,
+                        nodeIds: [nodeId],
+                    });
+                }
+            }
+            for (const node of healthNodes) {
+                if (node.isHub) {
+                    structuralIssues.push({
+                        type: 'structural',
+                        metric: 'high-hub',
+                        level: 'warn',
+                        message: `${node.label} is a high-degree hub with ${node.connectionCount} connections`,
+                        nodeIds: [node.id],
+                    });
+                }
+                if (node.isOrphan) {
+                    structuralIssues.push({
+                        type: 'structural',
+                        metric: 'orphan',
+                        level: 'warn',
+                        message: `${node.label} has no connections (orphan component)`,
+                        nodeIds: [node.id],
+                    });
+                }
+            }
+            const allIssues = [...ruleViolations, ...structuralIssues];
+            const ruleViolationCount = ruleViolations.length;
+            const structuralIssueCount = structuralIssues.length;
             const errors = violations.filter((v) => v.level === "error").length;
-            const warnings = violations.filter((v) => v.level === "warn").length;
             res.writeHead(200, { "Content-Type": "application/json" });
             res.end(JSON.stringify({
                 passed: errors === 0,
-                errors,
-                warnings,
-                violations,
+                issues: allIssues,
+                summary: {
+                    ruleViolations: ruleViolationCount,
+                    structuralIssues: structuralIssueCount,
+                    totalIssues: allIssues.length,
+                },
+                metrics: {
+                    circularDependencies: circularDependenciesCount,
+                    highDegreeHubCount,
+                    disconnectedComponentCount,
+                    meanCouplingRatio,
+                    maxFanInOutDegree,
+                },
+                nodes: healthNodes,
+                rules: {
+                    builtin: [
+                        { name: "no-layer-bypass", level: "error", description: "Prevent connections that skip layers" },
+                        { name: "max-connections", level: "warn", description: "Flag components with too many connections" },
+                        { name: "no-orphans", level: "warn", description: "Flag components with no connections" },
+                        { name: "no-circular-deps", level: "error", description: "Detect circular dependency chains" },
+                    ],
+                    custom: [],
+                },
             }));
             return;
         }
+        // API: Health (deprecated - redirect to audit for backward compat)
+        if (url === "/api/health" && req.method === "GET") {
+            res.writeHead(307, { "Location": "/api/audit" });
+            res.end();
+            return;
+        }
+        // API: Rules — GET returns current rules config
+        if (url === "/api/rules" && req.method === "GET") {
+            const builtin = [
+                { name: "no-layer-bypass", level: "error", description: "Prevent connections that skip layers" },
+                { name: "max-connections", level: "warn", threshold: 6, description: "Flag components with too many connections" },
+                { name: "no-orphans", level: "warn", description: "Flag components with no connections" },
+                { name: "no-circular-deps", level: "error", description: "Detect circular dependency chains" },
+            ];
+            let custom = [];
+            try {
+                const yamlPath = path.join(config.workspaceRoot, ".archbyte/archbyte.yaml");
+                if (existsSync(yamlPath)) {
+                    const yamlContent = readFileSync(yamlPath, "utf-8");
+                    // Parse custom rules from YAML
+                    const rulesMatch = yamlContent.match(/^rules:\s*\n((?:\s+.*\n)*)/m);
+                    if (rulesMatch) {
+                        const rulesBlock = rulesMatch[1];
+                        const ruleRegex = /^\s+-\s+name:\s*"?([^"\n]+)"?\s*\n\s+from:\s*"?([^"\n]+)"?\s*\n\s+to:\s*"?([^"\n]+)"?\s*\n\s+level:\s*"?([^"\n]+)"?/gm;
+                        let m;
+                        while ((m = ruleRegex.exec(rulesBlock)) !== null) {
+                            custom.push({ name: m[1].trim(), from: m[2].trim(), to: m[3].trim(), level: m[4].trim() });
+                        }
+                    }
+                }
+            }
+            catch { /* ignore */ }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ builtin, custom }));
+            return;
+        }
+        // API: Rules — PUT saves rules config
+        if (url === "/api/rules" && req.method === "PUT") {
+            let body = "";
+            req.on("data", (chunk) => { body += chunk.toString(); });
+            req.on("end", async () => {
+                try {
+                    const { custom } = JSON.parse(body);
+                    const yamlDir = path.join(config.workspaceRoot, ".archbyte");
+                    if (!existsSync(yamlDir))
+                        await mkdir(yamlDir, { recursive: true });
+                    const yamlPath = path.join(yamlDir, "archbyte.yaml");
+                    let yamlContent = "";
+                    if (existsSync(yamlPath)) {
+                        yamlContent = readFileSync(yamlPath, "utf-8");
+                    }
+                    // Remove existing rules section
+                    yamlContent = yamlContent.replace(/^rules:\s*\n((?:\s+.*\n)*)/m, "");
+                    // Build new rules section
+                    if (custom && custom.length > 0) {
+                        let rulesYaml = "rules:\n";
+                        for (const rule of custom) {
+                            // Validate rule fields to prevent YAML injection
+                            const safeName = rule.name.replace(/["\n\r]/g, "");
+                            const safeFrom = rule.from.replace(/["\n\r]/g, "");
+                            const safeTo = rule.to.replace(/["\n\r]/g, "");
+                            const safeLevel = (rule.level === "error" || rule.level === "warn") ? rule.level : "warn";
+                            rulesYaml += `  - name: "${safeName}"\n    from: "${safeFrom}"\n    to: "${safeTo}"\n    level: "${safeLevel}"\n`;
+                        }
+                        yamlContent = yamlContent.trimEnd() + "\n\n" + rulesYaml;
+                    }
+                    await writeFile(yamlPath, yamlContent.trimEnd() + "\n");
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: true }));
+                }
+                catch (error) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: String(error) }));
+                }
+            });
+            return;
+        }
         // API: Export architecture as text format
         if (url.startsWith("/api/export") && req.method === "GET") {
             const arch = currentArchitecture || (await loadArchitecture());
@@ -379,12 +727,21 @@ function createHttpServer() {
             }
             const params = new URL(url, `http://localhost:${config.port}`).searchParams;
             const format = params.get("format") || "mermaid";
-            const supported = ["mermaid", "markdown", "json", "plantuml", "dot"];
+            const supported = ["mermaid", "markdown", "json", "plantuml", "dot", "html"];
             if (!supported.includes(format)) {
                 res.writeHead(400, { "Content-Type": "application/json" });
                 res.end(JSON.stringify({ error: `Unknown format: ${format}. Supported: ${supported.join(", ")}` }));
                 return;
             }
+            // HTML export requires Pro tier
+            if (format === "html") {
+                const license = loadLicenseInfo();
+                if (license.tier !== "premium") {
+                    res.writeHead(403, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "HTML export requires a Pro subscription." }));
+                    return;
+                }
+            }
             const realNodes = arch.nodes;
             const nodeMap = new Map();
             for (const nd of realNodes)
@@ -515,6 +872,43 @@ function createHttpServer() {
                     ext = "json";
                     break;
                 }
+                case "html": {
+                    // Build self-contained interactive HTML file
+                    const uiAssetsDir = path.join(UI_DIST, "assets");
+                    if (!existsSync(uiAssetsDir)) {
+                        res.writeHead(500, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "UI build not found. Run: npm run build:ui" }));
+                        return;
+                    }
+                    const { readdirSync } = await import("fs");
+                    const uiAssetFiles = readdirSync(uiAssetsDir);
+                    let cssInline = "";
+                    for (const f of uiAssetFiles.filter((f) => f.endsWith(".css"))) {
+                        cssInline += readFileSync(path.join(uiAssetsDir, f), "utf-8") + "\n";
+                    }
+                    let jsInline = "";
+                    for (const f of uiAssetFiles.filter((f) => f.endsWith(".js"))) {
+                        jsInline += readFileSync(path.join(uiAssetsDir, f), "utf-8") + "\n";
+                    }
+                    content = `<!DOCTYPE html>
+<html lang="en" data-theme="dark">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${config.name} - ArchByte Architecture</title>
+  <style>${cssInline}</style>
+</head>
+<body>
+  <script>try{if(localStorage.getItem('archbyte-theme')==='light')document.documentElement.setAttribute('data-theme','light')}catch(e){}</script>
+  <div id="root"></div>
+  <script>window.__ARCHBYTE_DATA__ = ${JSON.stringify(arch)};</script>
+  <script type="module">${jsInline}</script>
+</body>
+</html>`;
+                    contentType = "text/html";
+                    ext = "html";
+                    break;
+                }
                 default: { // markdown
                     const lines = [`# Architecture — ${config.name}`, "", `> Generated by ArchByte on ${new Date().toISOString().slice(0, 10)}`, ""];
                     lines.push("## Summary", "");
@@ -774,6 +1168,35 @@ function createHttpServer() {
             res.end(JSON.stringify({ running: runningWorkflows.has("__generate__") }));
             return;
         }
+        // API: Run analyze (static or LLM) + generate
+        if (url === "/api/analyze" && req.method === "POST") {
+            if (isAnalyzing) {
+                res.writeHead(409, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Analysis already running" }));
+                return;
+            }
+            let body = "";
+            req.on("data", (chunk) => { body += chunk.toString(); });
+            req.on("end", () => {
+                const { mode } = JSON.parse(body || "{}");
+                runAnalyzePipeline(mode === "llm" ? "llm" : "static");
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ ok: true, mode: mode || "static" }));
+            });
+            return;
+        }
+        // API: Analyze status
+        if (url === "/api/analyze/status" && req.method === "GET") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ running: isAnalyzing }));
+            return;
+        }
+        // API: Session changes feed — returns in-memory session change records (newest first)
+        if (url === "/api/session-changes" && req.method === "GET") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(sessionChanges));
+            return;
+        }
         // API: Run workflow
         if (url.startsWith("/api/workflow/run/") && req.method === "POST") {
             const id = url.split("/").pop();
@@ -858,13 +1281,13 @@ function createHttpServer() {
             req.on("end", () => {
                 const { interval } = JSON.parse(body || "{}");
                 const bin = getArchbyteBin();
-                const args = [bin, "patrol", "--watch"];
+                const args = [bin, "patrol"];
                 if (interval)
                     args.push("--interval", String(interval));
                 patrolProcess = spawn(process.execPath, args, {
                     cwd: config.workspaceRoot,
-                    stdio: ["ignore", "pipe", "pipe"],
-                    env: { ...process.env, FORCE_COLOR: "0" },
+                    stdio: ["ignore", "inherit", "inherit"],
+                    env: { ...process.env, FORCE_COLOR: "1" },
                 });
                 patrolRunning = true;
                 broadcastOpsEvent({ type: "patrol:started" });
@@ -1271,12 +1694,135 @@ async function startHttpServer() {
         });
     });
 }
-// Setup file watcher
-function setupWatcher() {
-    if (!existsSync(config.diagramPath))
+// Diff two architecture snapshots (lightweight, inline version of cli/diff.ts)
+function diffArchitectures(prev, curr) {
+    const prevNodeMap = new Map();
+    for (const n of prev.nodes)
+        prevNodeMap.set(n.id, n);
+    const currNodeMap = new Map();
+    for (const n of curr.nodes)
+        currNodeMap.set(n.id, n);
+    const prevNodeIds = new Set(prev.nodes.map((n) => n.id));
+    const currNodeIds = new Set(curr.nodes.map((n) => n.id));
+    const addedNodes = curr.nodes
+        .filter((n) => !prevNodeIds.has(n.id))
+        .map((n) => ({ id: n.id, label: n.label, type: n.type, layer: n.layer }));
+    const removedNodes = prev.nodes
+        .filter((n) => !currNodeIds.has(n.id))
+        .map((n) => ({ id: n.id, label: n.label, type: n.type, layer: n.layer }));
+    const modifiedNodes = [];
+    for (const n of curr.nodes) {
+        const old = prevNodeMap.get(n.id);
+        if (!old)
+            continue;
+        for (const field of ["label", "type", "layer"]) {
+            if (old[field] !== n[field]) {
+                modifiedNodes.push({ id: n.id, field, from: old[field], to: n[field] });
+            }
+        }
+    }
+    const edgeKey = (e) => `${e.source}->${e.target}`;
+    const prevEdgeKeys = new Set(prev.edges.map(edgeKey));
+    const currEdgeKeys = new Set(curr.edges.map(edgeKey));
+    const addedEdges = curr.edges
+        .filter((e) => !prevEdgeKeys.has(edgeKey(e)))
+        .map((e) => ({ source: e.source, target: e.target, label: e.label }));
+    const removedEdges = prev.edges
+        .filter((e) => !currEdgeKeys.has(edgeKey(e)))
+        .map((e) => ({ source: e.source, target: e.target, label: e.label }));
+    return { addedNodes, removedNodes, modifiedNodes, addedEdges, removedEdges };
+}
+// Run analyze → generate pipeline (used by /api/analyze and patrol)
+function runAnalyzePipeline(mode = "static", fileChanges) {
+    if (isAnalyzing)
         return;
-    diagramWatcher = watch(config.diagramPath, { ignoreInitial: true });
-    diagramWatcher.on("change", async () => {
+    isAnalyzing = true;
+    const pipelineStart = Date.now();
+    // Snapshot current architecture for diffing after pipeline completes
+    const prevArchitecture = currentArchitecture
+        ? { ...currentArchitecture, nodes: [...currentArchitecture.nodes], edges: [...currentArchitecture.edges] }
+        : null;
+    broadcastOpsEvent({ type: "analyzing:started", mode });
+    const bin = getArchbyteBin();
+    const analyzeArgs = [bin, "analyze", "--force"];
+    if (mode === "static")
+        analyzeArgs.push("--static");
+    const analyzeChild = spawn(process.execPath, analyzeArgs, {
+        cwd: config.workspaceRoot,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, FORCE_COLOR: "0" },
+    });
+    analyzeChild.on("close", (analyzeCode) => {
+        if (analyzeCode !== 0) {
+            isAnalyzing = false;
+            broadcastOpsEvent({ type: "analyzing:finished", code: analyzeCode, success: false });
+            return;
+        }
+        // Chain: generate after successful analyze
+        const genChild = spawn(process.execPath, [bin, "generate"], {
+            cwd: config.workspaceRoot,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: { ...process.env, FORCE_COLOR: "0" },
+        });
+        genChild.on("close", async (genCode) => {
+            isAnalyzing = false;
+            const durationMs = Date.now() - pipelineStart;
+            // Build session change record if we have a previous architecture to diff against
+            if (genCode === 0) {
+                try {
+                    const newArch = await loadArchitecture();
+                    if (newArch && prevArchitecture) {
+                        const diff = diffArchitectures(prevArchitecture, newArch);
+                        // Deduplicate file changes: keep latest event per path
+                        const dedupedFiles = new Map();
+                        for (const fc of (fileChanges || [])) {
+                            dedupedFiles.set(fc.path, fc);
+                        }
+                        const filesChanged = [...dedupedFiles.values()];
+                        const record = {
+                            id: `sc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+                            timestamp: new Date().toISOString(),
+                            filesChanged,
+                            diff,
+                            summary: {
+                                filesChanged: filesChanged.length,
+                                nodesAdded: diff.addedNodes.length,
+                                nodesRemoved: diff.removedNodes.length,
+                                nodesModified: diff.modifiedNodes.length,
+                                edgesAdded: diff.addedEdges.length,
+                                edgesRemoved: diff.removedEdges.length,
+                            },
+                            durationMs,
+                            mode,
+                        };
+                        sessionChanges.unshift(record);
+                        if (sessionChanges.length > MAX_SESSION_CHANGES)
+                            sessionChanges.pop();
+                        broadcastOpsEvent({ type: "session:change", change: record });
+                    }
+                }
+                catch {
+                    // Non-fatal — session change tracking is best-effort
+                }
+            }
+            broadcastOpsEvent({ type: "analyzing:finished", code: genCode, success: genCode === 0 });
+        });
+    });
+}
+// Setup file watcher — watches the .archbyte/ directory so it works
+// even when architecture.json doesn't exist yet (first-time users)
+function setupWatcher() {
+    const archbyteDir = path.dirname(config.diagramPath);
+    const diagramFilename = path.basename(config.diagramPath);
+    diagramWatcher = watch(archbyteDir, {
+        ignoreInitial: true,
+        depth: 0,
+    });
+    diagramWatcher.on("all", async (event, filePath) => {
+        if (path.basename(filePath) !== diagramFilename)
+            return;
+        if (event !== "change" && event !== "add")
+            return;
         console.error("[archbyte] Diagram changed, reloading...");
         currentArchitecture = await loadArchitecture();
         broadcastUpdate();
@@ -1323,7 +1869,8 @@ function setupShutdown() {
     process.on("SIGTERM", shutdown);
     process.on("SIGINT", shutdown);
 }
-// License info helper — reads ~/.archbyte/credentials.json
+// License info helper — reads login state from credentials.json,
+// tier from server-verified tier-cache.json (1-hour TTL, email-stamped)
 function loadLicenseInfo() {
     const defaults = {
         loggedIn: false,
@@ -1343,14 +1890,41 @@ function loadLicenseInfo() {
         const credPath = path.join(home, ".archbyte", "credentials.json");
         if (!existsSync(credPath))
             return defaults;
-        const creds = JSON.parse(readFileSync(credPath, "utf-8"));
+        const raw = JSON.parse(readFileSync(credPath, "utf-8"));
+        // Multi-account format (version 2): extract active account
+        let creds;
+        if (raw?.version === 2 && raw.accounts && typeof raw.active === "string") {
+            creds = raw.accounts[raw.active] ?? {};
+        }
+        else {
+            creds = raw;
+        }
         if (!creds.token)
             return defaults;
         // Check expiry
         if (creds.expiresAt && new Date(creds.expiresAt) < new Date()) {
             return { ...defaults, loggedIn: true, email: creds.email ?? null };
         }
-        const isPremium = creds.tier === "premium";
+        // Read tier from server-verified tier-cache.json (not user-editable credentials)
+        let isPremium = false;
+        const tierCachePath = path.join(home, ".archbyte", "tier-cache.json");
+        if (existsSync(tierCachePath)) {
+            try {
+                const cache = JSON.parse(readFileSync(tierCachePath, "utf-8"));
+                // Only trust cache if it matches current account and is within 1-hour TTL
+                const cacheAge = cache.verifiedAt ? Date.now() - new Date(cache.verifiedAt).getTime() : Infinity;
+                if (cache.email === creds.email && cacheAge < 60 * 60 * 1000) {
+                    isPremium = cache.tier === "premium";
+                }
+            }
+            catch {
+                // Corrupt cache — fall through to credentials fallback
+            }
+        }
+        // Fallback: if no valid tier cache, use credentials tier (less secure but functional)
+        if (!isPremium && creds.tier === "premium") {
+            isPremium = true;
+        }
         return {
             loggedIn: true,
             email: creds.email ?? null,