noteconnection 1.1.2 → 1.3.0

package/README.md

@@ -1,4 +1,4 @@
-# 2026-01-23 v1.1.2
+# 2026-01-24 v1.3.0
 
 # NoteConnection Knowledge Graph
 
@@ -45,7 +45,15 @@ Unlike traditional "network" views that show a messy web of links, NoteConnectio
 
 <img width="3723" height="1992" alt="image" src="https://github.com/user-attachments/assets/9e56e567-1742-48cf-b720-cf65a47fd317" />
 
-### 3. Performance & Control
+### 3. Path Mode: Structured Learning (v1.2.0)
+
+- **Curriculum Generation**: Instantly transforms your graph into linear learning paths.
+  - **Domain Learning**: Master an entire concept cluster (Topological Sort).
+  - **Diffusion Learning**: Find the most efficient path to a specific goal (Shortest Path + Prerequisites).
+- **Hybrid Architecture**: Connects to a high-fidelity **Godot 4.3 Desktop Renderer** via WebSocket (`ws://localhost:9876`) for AAA-quality visualization, while maintaining full web compatibility.
+- **Smart Strategies**: Choose "Foundational" (Base-first) or "Core" (Importance-first) sorting to suit your learning style.
+
+### 4. Performance & Control
 
 - **High-Capacity Parallel Processing**: Utilizes Node.js `worker_threads` (up to 12 cores) to distribute computationally intensive keyword matching.
 - **Simulation Controls (v0.9.0)**: Fine-tune the physics with a **Speed/Damping Slider** or use the **Freeze Layout** switch to stop the simulation for stable manual arrangement.
@@ -108,6 +116,10 @@ NoteConnection is built on a modular architecture designed for performance and e
 - **State Management**: `SettingsManager` persists user preferences (Physics, Visuals) to `localStorage`.
 - **Layout Logic**: Custom algorithms for Sugiyama-style layering and Force-directed physics.
 
+### Desktop Bridge (`src/core`)
+
+- **PathBridge**: standard WebSocket server (Port 9876) that exposes the internal graph state to external applications (e.g., Godot Engine), enabling hybrid web/native visualization pipelines.
+
 ---
 
 <a id="quick-start-en"></a>
@@ -266,6 +278,33 @@ For optimal performance with "GPU Optimised Rendering", especially on AMD RDNA c
 
 ## 📅 Changelog
 
+### v1.3.0 - Path Mode Polish & UI Refinements (2026-01-24)
+
+- **Reader Integration**:
+  - **Seamless Access**: Double-clicking the central node in "Orbital Layout" now instantly opens the `Reader`, displaying full node content.
+  - **Data Fetching**: Fixed a critical issue where the reader would open empty; now correctly retrieves full metadata from the global graph state.
+- **Visual Polish**:
+  - **Orbital Layout**: Significantly improved node dispersion (Radius 350-950px) to reduce label overlap.
+  - **Edge Clarity**: In Orbital mode, strictly hides edges not connected to the central node, reducing visual clutter by 90%.
+  - **Label Visibility**: Peripheral nodes now always display labels, sized proportionally to their distance (max 16px).
+  - **Depth of Field**: Adjusted opacity falloff to ensure distant nodes remain visible (min 0.4 opacity).
+- **UX Improvements**:
+  - **Target Selection**: Increased the "Target Node" search limit from 20 to 300, ensuring users can find any node in the graph.
+  - **Interactive Layers**: Fixed `z-index` layering issues where the Reader window was previously hidden behind the Path visualization.
+
+### v1.2.0 - Path Mode & Desktop Renderer (2026-01-23)
+
+- **Path Mode**: Introduced a major new feature set for converting graphs into linear learning paths.
+  - **Learning Modes**: 'Domain Learning' (Topological) and 'Diffusion Learning' (Goal-oriented).
+  - **Visualization**: New Radial and Tree layouts powered by D3/Canvas.
+  - **Strategies**: 'Foundational' and 'Core' sorting algorithms.
+- **Hybrid Architecture**:
+  - **Godot Bridge**: Implemented `PathBridge.ts` to sync graph state with external renderers via WebSocket (Port 9876).
+  - **Native Rendering**: Added support for Godot 4.3 to render the graph with high-fidelity Vulkan graphics (Source in `path_mode/`).
+- **DevOps**:
+  - **NPM Scripts**: Added `pathmode:dev` and `pathmode:test` workflows.
+  - **UI Stability**: Fixed critical bugs in Radial Layout visibility (`centerView`) and Exit Mode logic.
+
 ### v1.1.2 - Path Resolution & UI Stability (2026-01-23)
 
 - **Backend Protocol Fix**:
@@ -726,7 +765,15 @@ For optimal performance with "GPU Optimised Rendering", especially on AMD RDNA c
 
 <img width="3723" height="2007" alt="image" src="https://github.com/user-attachments/assets/10978984-3e2d-4ab6-8b44-342d4f3c3800" />
 
-### 3. 性能与控制
+### 3. Path Mode (路径模式): 结构化学习 (v1.2.0)
+
+- **课程生成**: 将复杂的网状图瞬间转化为线性的学习路径。
+  - **领域学习 (Domain Learning)**: 掌握整个概念集群（拓扑排序）。
+  - **扩散学习 (Diffusion Learning)**: 寻找通往特定目标的最优路径（最短路径 + 前置依赖）。
+- **混合架构**: 通过 WebSocket (`ws://localhost:9876`) 连接到高保真 **Godot 4.3 桌面渲染器**，实现 3A 级的可视化效果，同时保持完全的 Web 兼容性。
+- **智能策略**: 支持 "基础优先" (Foundational) 或 "核心优先" (Core) 排序，适应不同的学习风格。
+
+### 4. 性能与控制 (Performance & Control)
 
 - **高容量并行处理**: 利用 Node.js `worker_threads` (最多 12 核) 分发计算密集的关键词匹配任务。
 - **模拟控制 (v0.9.0)**: 通过 **速度/阻尼滑块** 微调物理效果，或使用 **冻结布局** 开关停止模拟以进行稳定的手动排列。
@@ -789,6 +836,10 @@ NoteConnection 基于模块化架构构建，旨在实现高性能和可扩展
 - **状态管理**: `SettingsManager` 将用户偏好（物理、视觉）持久化到 `localStorage`。
 - **布局逻辑**: 自定义的 Sugiyama 风格分层算法和力导向物理算法。
 
+### 桌面桥接 (Desktop Bridge) (`src/core`)
+
+- **PathBridge**: 标准 WebSocket 服务器 (端口 9876)，将内部图谱状态暴露给外部应用程序（例如 Godot 引擎），实现混合 Web/原生可视化管线。
+
 ---
 
 <a id="quick-start-zh"></a>
@@ -934,6 +985,33 @@ npm start -- --path "E:/Knowledge/ObsidianVault" --no-gpu
 
 ## 📅 更新日志 (Changelog)
 
+### v1.3.0 - 路径模式打磨与 UI 优化 (Path Mode Polish & UI Refinements) (2026-01-24)
+
+- **阅读器集成 (Reader Integration)**:
+  - **无缝访问**: 在“轨道布局”中双击中心节点现在会立即打开`阅读器`，显示完整的节点内容。
+  - **数据获取**: 修复了阅读器打开为空的关键问题；现在可以正确地从全局图状态检索完整的元数据。
+- **视觉打磨 (Visual Polish)**:
+  - **轨道布局**: 显著改进了节点分散度（半径 350-950px），减少了标签重叠。
+  - **边缘清晰度**: 在轨道模式下，严格隐藏未连接到中心节点的边，将视觉混乱减少了 90%。
+  - **标签可见性**: 周围节点现在总是显示标签，并根据距离按比例缩放（最大 16px）。
+  - **景深 (DoF)**: 调整了不透明度衰减，以确保远处的节点保持可见（最小 0.4 不透明度）。
+- **用户体验改进 (UX Improvements)**:
+  - **目标选择**: 将“目标节点”搜索限制从 20 增加到 300，确保用户可以找到图中的任何节点。
+  - **交互层级**: 修复了 `z-index` 层级问题，之前的阅读器窗口被隐藏在路径可视化后面。
+
+### v1.2.0 - 路径模式与桌面渲染器 (2026-01-23)
+
+- **路径模式 (Path Mode)**: 引入了一套主要的新功能，用于将图谱转化为线性的学习路径。
+  - **学习模式**: '领域学习' (拓扑排序) 和 '扩散学习' (目标导向)。
+  - **可视化**: 由 D3/Canvas 驱动的全新径向和树状布局。
+  - **策略**: '基础优先' 和 '核心优先' 排序算法。
+- **混合架构**:
+  - **Godot 桥接**: 实现了 `PathBridge.ts`，通过 WebSocket (端口 9876) 与外部渲染器同步图谱状态。
+  - **原生渲染**: 添加了对 Godot 4.3 的支持，以渲染高保真的 Vulkan 图形 (源码位于 `path_mode/`).
+- **运维 (DevOps)**:
+  - **NPM 脚本**: 添加了 `pathmode:dev` 和 `pathmode:test` 工作流。
+  - **UI 稳定性**: 修复了径向布局可见性 (`centerView`) 和退出模式逻辑中的关键 Bug。
+
 ### v1.1.2 - 路径解析与 UI 稳定性 (2026-01-23)
 
 - **后端协议修复**:

package/dist/src/core/Graph.js

@@ -124,5 +124,89 @@ class Graph {
             edges: Array.from(this.adjacencyList.values()).flat()
         };
     }
+    /**
+     * Gets all predecessor nodes (transitive closure of incoming edges).
+     * 获取所有前驱节点（入边的传递闭包）。
+     * @param id Target node ID
+     */
+    getPredecessors(id) {
+        const predecessors = new Set();
+        const queue = [id];
+        const visited = new Set();
+        visited.add(id);
+        while (queue.length > 0) {
+            const current = queue.shift();
+            const incoming = this.getIncomingEdges(current);
+            for (const edge of incoming) {
+                if (!visited.has(edge.source)) {
+                    visited.add(edge.source);
+                    predecessors.add(edge.source);
+                    queue.push(edge.source);
+                }
+            }
+        }
+        return predecessors;
+    }
+    /**
+     * Gets all successor nodes (transitive closure of outgoing edges).
+     * 获取所有后继节点（出边的传递闭包）。
+     * @param id Source node ID
+     */
+    getSuccessors(id) {
+        const successors = new Set();
+        const queue = [id];
+        const visited = new Set();
+        visited.add(id);
+        while (queue.length > 0) {
+            const current = queue.shift();
+            const outgoing = this.getOutgoingEdges(current);
+            for (const edge of outgoing) {
+                if (!visited.has(edge.target)) {
+                    visited.add(edge.target);
+                    successors.add(edge.target);
+                    queue.push(edge.target);
+                }
+            }
+        }
+        return successors;
+    }
+    /**
+     * Calculates the shortest path between two nodes (unweighted BFS).
+     * 计算两个节点之间的最短路径 (无权 BFS)。
+     * @param source Source node ID
+     * @param target Target node ID
+     * @returns Array of node IDs representing the path, or empty if no path found
+     */
+    getShortestPath(source, target) {
+        if (source === target)
+            return [source];
+        const queue = [source];
+        const visited = new Set();
+        const parent = new Map();
+        visited.add(source);
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (current === target)
+                break;
+            const neighbors = this.getNeighbors(current);
+            for (const neighbor of neighbors) {
+                if (!visited.has(neighbor)) {
+                    visited.add(neighbor);
+                    parent.set(neighbor, current);
+                    queue.push(neighbor);
+                }
+            }
+        }
+        if (!visited.has(target))
+            return [];
+        // Reconstruct path
+        const path = [target];
+        let curr = target;
+        while (curr !== source) {
+            curr = parent.get(curr);
+            path.unshift(curr);
+        }
+        return path;
+    }
 }
 exports.Graph = Graph;

package/dist/src/core/PathBridge.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathBridge = void 0;
+const ws_1 = require("ws");
+class PathBridge {
+    constructor(port = 9876) {
+        this.clients = new Set();
+        this.port = port;
+        this.wss = new ws_1.WebSocketServer({ port });
+        console.log(`[PathBridge] WebSocket Server started on port ${port}`);
+        this.wss.on('connection', (ws) => {
+            console.log('[PathBridge] Client connected');
+            this.clients.add(ws);
+            ws.on('message', (message) => {
+                try {
+                    const data = JSON.parse(message.toString());
+                    this.handleMessage(data, ws);
+                }
+                catch (e) {
+                    console.error('[PathBridge] Message error:', e);
+                }
+            });
+            ws.on('close', () => {
+                console.log('[PathBridge] Client disconnected');
+                this.clients.delete(ws);
+            });
+        });
+    }
+    handleMessage(data, sender) {
+        // Handle messages from Godot (e.g., node clicks)
+        if (data.type === 'nodeClick') {
+            console.log(`[PathBridge] Godot clicked node: ${data.payload}`);
+            // Broadcast to all clients (including Frontend)
+            this.broadcast('nodeClick', data.payload);
+        }
+    }
+    broadcast(type, payload) {
+        const msg = JSON.stringify({ type, payload });
+        this.clients.forEach(client => {
+            if (client.readyState === ws_1.WebSocket.OPEN) {
+                client.send(msg);
+            }
+        });
+    }
+    close() {
+        this.wss.close();
+    }
+}
+exports.PathBridge = PathBridge;

package/dist/src/core/PathEngine.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathEngine = void 0;
+class PathEngine {
+    constructor(graph) {
+        this.graph = graph;
+    }
+    /**
+     * Domain Learning: Extracts an efficient learning path for a set of nodes (or all nodes).
+     * 领域学习：为一组节点（或所有节点）提取高效的学习路径。
+     * @param nodeIds Specific nodes to learn (optional, defaults to all)
+     * @param strategy prioritization strategy
+     */
+    domainLearning(nodeIds, strategy) {
+        const targetNodes = nodeIds ? new Set(nodeIds) : new Set(this.graph.getNodes().map(n => n.id));
+        // For Domain Learning, we want to learn *everything* in the set.
+        // We strictly respect dependencies within the graph.
+        // If a node in the set depends on a node OUTSIDE the set, we assume the outside node is already known 
+        // OR we must add it. Requirement implies "user-defined domain", so usually we strictly stay inside or include prereqs.
+        // Let's assume we need to be strictly self-contained or include necessary prerequisites.
+        // Safe bet: Extract subgraph of targetNodes + all their ancestors to ensure validity.
+        const relevantNodes = this.expandToIncludePrerequisites(targetNodes);
+        return this.generateLearningPath(relevantNodes, strategy);
+    }
+    /**
+     * Diffusion Learning: Extracts shortest learning path to a specific target node.
+     * 扩散学习：提取通往特定目标节点的最短学习路径。
+     * @param targetId Target node ID
+     * @param strategy prioritization strategy for tie-breaking
+     */
+    diffusionLearning(targetId, strategy) {
+        if (!this.graph.hasNode(targetId)) {
+            throw new Error(`Node ${targetId} not found in graph`);
+        }
+        // 1. Identify all ancestors (prerequisites)
+        const ancestors = this.graph.getPredecessors(targetId);
+        ancestors.add(targetId);
+        // 2. Generate path for this subset
+        return this.generateLearningPath(ancestors, strategy);
+    }
+    /**
+     * Core generation logic using Priority-Queue Topological Sort.
+     */
+    generateLearningPath(nodesOfInterest, strategy) {
+        const nodes = Array.from(nodesOfInterest).map(id => this.graph.getNode(id));
+        const nodeMap = new Map(nodes.map(n => [n.id, n]));
+        // Build local in-degrees for the subgraph
+        const localInDegree = new Map();
+        const localAdjacency = new Map();
+        nodes.forEach(node => {
+            localInDegree.set(node.id, 0);
+            localAdjacency.set(node.id, []);
+        });
+        // Populate edges restricted to the subgraph
+        const relevantEdges = [];
+        nodes.forEach(node => {
+            const outgoing = this.graph.getOutgoingEdges(node.id);
+            outgoing.forEach(edge => {
+                if (nodesOfInterest.has(edge.target)) {
+                    localAdjacency.get(node.id).push(edge.target);
+                    localInDegree.set(edge.target, (localInDegree.get(edge.target) || 0) + 1);
+                    relevantEdges.push(edge);
+                }
+            });
+        });
+        // Initialize queue with nodes having 0 in-degree (within subgraph)
+        let available = [];
+        nodes.forEach(node => {
+            if (localInDegree.get(node.id) === 0) {
+                available.push(node.id);
+            }
+        });
+        const learnedPath = [];
+        const visited = new Set();
+        let step = 1;
+        // Helper to process a node and unlock neighbors
+        const processNode = (currentId) => {
+            visited.add(currentId);
+            const currentNode = nodeMap.get(currentId);
+            // Add to path
+            learnedPath.push({
+                ...currentNode,
+                stepOrder: step++,
+                isCompleted: false,
+                unlocks: localAdjacency.get(currentId)
+            });
+            // "Unlock" neighbors
+            const neighbors = localAdjacency.get(currentId);
+            neighbors.forEach(neighborId => {
+                // Only decrement if neighbor not visited (avoid double counting in cycles)
+                if (!visited.has(neighborId)) {
+                    const newDegree = (localInDegree.get(neighborId) || 0) - 1;
+                    localInDegree.set(neighborId, newDegree);
+                    if (newDegree <= 0) { // Changed to <= 0 to be robust against negative logic errors
+                        // Check if already in available to prevent duplicates
+                        if (!available.includes(neighborId)) {
+                            available.push(neighborId);
+                        }
+                    }
+                }
+            });
+        };
+        while (learnedPath.length < nodes.length) {
+            if (available.length > 0) {
+                // Normal Topological Sort Step
+                available.sort((a, b) => this.compareNodes(a, b, strategy));
+                const currentId = available.shift();
+                if (!visited.has(currentId)) {
+                    processNode(currentId);
+                }
+            }
+            else {
+                // Cycle Detected or Disconnected Components with strict dependencies
+                // Strategy: Break cycle by picking the "best" remaining node 
+                // Prioritize nodes with HIGHEST Out-Degree (unlocks the most)
+                // or lowest remaining in-degree?
+                // "Lowest In-Degree" is usually the best heuristic for Feedback Arc Set.
+                // Find remaining nodes
+                const remainingIds = [];
+                nodes.forEach(n => {
+                    if (!visited.has(n.id))
+                        remainingIds.push(n.id);
+                });
+                if (remainingIds.length === 0)
+                    break; // Done
+                // Sort by In-Degree (Ascending) -> Strategy Score (Desc)
+                remainingIds.sort((a, b) => {
+                    const degA = localInDegree.get(a) || 0;
+                    const degB = localInDegree.get(b) || 0;
+                    if (degA !== degB)
+                        return degA - degB;
+                    return this.compareNodes(a, b, strategy);
+                });
+                const forceId = remainingIds[0];
+                // Force process strict dependency validation
+                localInDegree.set(forceId, 0); // Pretend it's free
+                processNode(forceId);
+            }
+        }
+        return {
+            nodes: learnedPath,
+            edges: relevantEdges,
+            strategy,
+            coverage: learnedPath.length / nodes.length
+        };
+    }
+    /**
+     * Helper to ensure valid learning set (closure of predecessors).
+     */
+    expandToIncludePrerequisites(initialNodes) {
+        const result = new Set(initialNodes);
+        let changed = true;
+        // Iteratively add parents until stable
+        // Optimally we just merge getPredecessors for all nodes
+        // But getPredecessors returns full closure, so we only need to do it once per node.
+        for (const nodeId of initialNodes) {
+            const preds = this.graph.getPredecessors(nodeId);
+            preds.forEach(p => result.add(p));
+        }
+        return result;
+    }
+    /**
+     * Strategy Comparator
+     * Returns negative if A is better than B (for sorting A before B).
+     */
+    compareNodes(idA, idB, strategy) {
+        const nodeA = this.graph.getNode(idA);
+        const nodeB = this.graph.getNode(idB);
+        // Primary Metric: Strategy Score
+        const scoreA = this.calculateScore(nodeA, strategy);
+        const scoreB = this.calculateScore(nodeB, strategy);
+        if (scoreA !== scoreB) {
+            return scoreB - scoreA; // Higher score first
+        }
+        // Tie-breaker: ID (stable sort)
+        return idA.localeCompare(idB);
+    }
+    calculateScore(node, strategy) {
+        // Avoid division by zero
+        const safeInDegree = node.inDegree + 1;
+        if (strategy === 'foundational') {
+            // Foundational: Low In-Degree (Global), High Out-Degree (Global)
+            // "Low in-degree yet highly correlated with other required nodes (out-degree)"
+            // Score = OutDegree / InDegree
+            return (node.outDegree + 0.1) / safeInDegree;
+        }
+        else {
+            // Core: High Centrality, Low In-Degree (in learning set context)
+            // Note: In-degree in context is already 0 (since they are in 'available' list).
+            // So we use Global Centrality as the main differentiator.
+            // "Highly correlated (Centrality) ... low in-degree (Global)"
+            return (node.centrality || 0) * 10 - node.inDegree;
+        }
+    }
+}
+exports.PathEngine = PathEngine;

package/dist/src/core/PathEngine.test.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Graph_1 = require("./Graph");
+const PathEngine_1 = require("./PathEngine");
+describe('PathEngine', () => {
+    let graph;
+    let engine;
+    beforeEach(() => {
+        graph = new Graph_1.Graph();
+        engine = new PathEngine_1.PathEngine(graph);
+    });
+    const createNode = (id, inDegree = 0, outDegree = 0, centrality = 0) => ({
+        id,
+        label: id,
+        inDegree,
+        outDegree,
+        centrality
+    });
+    test('Domain Learning: Simple Linear Chain', () => {
+        // A -> B -> C
+        graph.addNode(createNode('A'));
+        graph.addNode(createNode('B'));
+        graph.addNode(createNode('C'));
+        graph.addEdge('A', 'B');
+        graph.addEdge('B', 'C');
+        const result = engine.domainLearning(null, 'foundational');
+        expect(result.nodes.map(n => n.id)).toEqual(['A', 'B', 'C']);
+        expect(result.coverage).toBe(1);
+    });
+    test('Domain Learning: Branching with Strategy', () => {
+        // A -> B
+        // A -> C
+        // B and C are available after A.
+        // Make B "Foundational" (high out-degree) and C "Core" (high centrality)
+        graph.addNode(createNode('A', 0, 2, 0.1));
+        graph.addNode(createNode('B', 1, 5, 0.2)); // High out-degree
+        graph.addNode(createNode('C', 1, 0, 0.9)); // High centrality
+        graph.addEdge('A', 'B');
+        graph.addEdge('A', 'C');
+        // Foundational should pick B first (High Out / Low In)
+        const resFoundational = engine.domainLearning(null, 'foundational');
+        expect(resFoundational.nodes.slice(1).map(n => n.id)).toEqual(['B', 'C']);
+        // Core should pick C first (High Centrality)
+        const resCore = engine.domainLearning(null, 'core');
+        expect(resCore.nodes.slice(1).map(n => n.id)).toEqual(['C', 'B']);
+    });
+    test('Diffusion Learning: Prerequisites Extraction', () => {
+        // A -> B -> Target
+        // X -> Y (unrelated)
+        graph.addNode(createNode('A'));
+        graph.addNode(createNode('B'));
+        graph.addNode(createNode('Target'));
+        graph.addNode(createNode('X'));
+        graph.addNode(createNode('Y'));
+        graph.addEdge('A', 'B');
+        graph.addEdge('B', 'Target');
+        graph.addEdge('X', 'Y');
+        const result = engine.diffusionLearning('Target', 'foundational');
+        expect(result.nodes.length).toBe(3);
+        expect(result.nodes.map(n => n.id)).toContain('A');
+        expect(result.nodes.map(n => n.id)).toContain('B');
+        expect(result.nodes.map(n => n.id)).toContain('Target');
+        expect(result.nodes.map(n => n.id)).not.toContain('X');
+    });
+    test('Complex Prerequisite Chain', () => {
+        //     A
+        //    / \
+        //   B   C
+        //    \ /
+        //     D
+        graph.addNode(createNode('A'));
+        graph.addNode(createNode('B'));
+        graph.addNode(createNode('C'));
+        graph.addNode(createNode('D'));
+        graph.addEdge('A', 'B');
+        graph.addEdge('A', 'C');
+        graph.addEdge('B', 'D');
+        graph.addEdge('C', 'D');
+        const result = engine.domainLearning(null, 'foundational');
+        const order = result.nodes.map(n => n.id);
+        expect(order[0]).toBe('A');
+        expect(order[3]).toBe('D');
+        expect(order.includes('B')).toBeTruthy();
+        expect(order.includes('C')).toBeTruthy();
+    });
+});

package/dist/src/electron/main.js

@@ -37,7 +37,9 @@ const electron_1 = require("electron");
 const path = __importStar(require("path"));
 const url = __importStar(require("url"));
 const controller_1 = require("../backend/controller");
+const PathBridge_1 = require("../core/PathBridge");
 let mainWindow = null;
+let pathBridge = null;
 // Knowledge Base Path Management
 const DEFAULT_KB_PATH = path.join(process.cwd(), 'Knowledge_Base');
 let currentKbRoot = DEFAULT_KB_PATH;
@@ -329,6 +331,18 @@ const createWindow = async () => {
 };
 electron_1.app.whenReady().then(async () => {
     log('App Ready');
+    // Initialize Path Bridge (WebSocket)
+    try {
+        pathBridge = new PathBridge_1.PathBridge(9876);
+        log('PathBridge initialized on port 9876');
+    }
+    catch (e) {
+        log(`Failed to initialize PathBridge: ${e}`);
+    }
+    electron_1.app.on('before-quit', () => {
+        if (pathBridge)
+            pathBridge.close();
+    });
     // Suppress security warnings in dev mode (unsafe-eval is required for GPU.js)
     process.env['ELECTRON_DISABLE_SECURITY_WARNINGS'] = 'true';
     // Load saved knowledge base path or show first-run setup