Method getMergedGraph

frontend/src/cache.ts:746–924

* Get merged graph for display from cached files

(filePaths?: string[])

     * Get merged graph for display from cached files
     */
    async getMergedGraph(filePaths?: string[]): Promise<WorkflowGraph | null> {
        await this.initPromise;

        // Normalize input paths to relative paths (cache keys are always relative)
        const targetFiles = filePaths
            ? filePaths.map(fp => this.toRelativePath(fp))
            : Object.keys(this.files);
        const allNodes: WorkflowNode[] = [];
        const allEdges: WorkflowEdge[] = [];
        const nodeIds = new Set<string>();
        const llmsDetected = new Set<string>();

        // Collect from cached files (dedupe nodes by ID, keep most complete)
        const nodeById = new Map<string, WorkflowNode>();
        for (const fp of targetFiles) {
            const cached = this.files[fp];
            if (cached) {
                for (const node of cached.nodes) {
                    const existing = nodeById.get(node.id);
                    // Keep node with more complete info (has source.line vs doesn't)
                    if (!existing || (node.source?.line && !existing.source?.line)) {
                        nodeById.set(node.id, node);
                    }
                    nodeIds.add(node.id);
                    if (node.model) llmsDetected.add(node.model);
                }
                allEdges.push(...cached.internalEdges);
            }
        }
        allNodes.push(...nodeById.values());

        // Sanitize purely-numeric labels (LLM sometimes returns sequence numbers instead of names).
        // Replace with the function name from source metadata.
        for (const node of allNodes) {
            if (/^\d+$/.test(node.label) && node.source?.function) {
                node.label = node.source.function.replace(/\(\)$/, '');
            }
        }

        if (allNodes.length === 0) return null;

        // Add valid cross-file edges with fuzzy ID resolution
        // This handles cases where LLM uses shortened paths (e.g., "file.py::func")
        // but actual node IDs have full paths (e.g., "dir/file.py::func")
        const lookup = buildNodeLookup(allNodes);
        for (const edge of this.crossFileEdges) {
            let resolvedSource = findMatchingNodeId(edge.sourceNodeId, lookup);
            let resolvedTarget = findMatchingNodeId(edge.targetNodeId, lookup);

            // Create stub node for cross-file edge targets that don't exist as cached nodes.
            if (resolvedSource && !resolvedTarget) {
                const targetId = edge.targetNodeId;
                const parts = targetId.split('::');
                const isRealFile = parts.length >= 2 && /\.\w+$/.test(parts[0]);

                let stubNode: WorkflowNode | null = null;

                if (isRealFile) {