taskmeld 0.1.1

package/dist/src/pipeline/workflow/routes.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRouteListWithDefaults = exports.DEFAULT_BRANCH_ROUTE_VALUE = exports.MAINLINE_ROUTE_VALUE = void 0;
+exports.MAINLINE_ROUTE_VALUE = "yes";
+exports.DEFAULT_BRANCH_ROUTE_VALUE = "no";
+const normalizeRouteListWithDefaults = (routes) => {
+    const normalized = new Set([exports.MAINLINE_ROUTE_VALUE, exports.DEFAULT_BRANCH_ROUTE_VALUE]);
+    for (const route of routes) {
+        const trimmed = route.trim();
+        if (!trimmed)
+            continue;
+        normalized.add(trimmed);
+    }
+    return [...normalized];
+};
+exports.normalizeRouteListWithDefaults = normalizeRouteListWithDefaults;

package/dist/src/pipeline/workflow/template-mapper.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeTemplateNodesIntoWorkflow = exports.workflowToTemplateNodes = void 0;
+const validate_1 = require("./validate");
+const toUniqueList = (items) => [...new Set(items)];
+// ====== Workflow → Template nodes (unified, with dedup) ======
+/**
+ * 从 WorkflowDefinitionRuntime 提取模板节点（仅 dependency 类型的出边）。
+ * 这是 workflow → template 映射的唯一权威实现。
+ */
+const workflowToTemplateNodes = (workflow) => {
+    const incomingByNodeId = new Map();
+    for (const edge of workflow.edges) {
+        // template.dependsOn 只表达依赖边；路由边属于分流语义，不能回写成普通依赖。
+        if (edge.when !== null)
+            continue;
+        const prev = incomingByNodeId.get(edge.to) ?? [];
+        prev.push(edge.from);
+        incomingByNodeId.set(edge.to, toUniqueList(prev));
+    }
+    return workflow.nodes.map((node) => ({
+        id: node.id,
+        title: node.name,
+        executor: node.executor,
+        instruction: node.instruction,
+        outputSpec: node.outputSpec,
+        dependsOn: incomingByNodeId.get(node.id) ?? [],
+        allowReject: node.allowReject,
+        maxRejectCount: node.maxRejectCount,
+    }));
+};
+exports.workflowToTemplateNodes = workflowToTemplateNodes;
+// ====== Merge template nodes into workflow ======
+const mergeTemplateNodesIntoWorkflow = (current, nextTemplateNodes) => {
+    const currentNodeById = new Map(current.nodes.map((node) => [node.id, node]));
+    const nodeIds = new Set(nextTemplateNodes.map((node) => node.id));
+    const groupIds = new Set(current.groups.map((group) => group.id));
+    const mergedNodes = nextTemplateNodes.map((tpl) => {
+        const existing = currentNodeById.get(tpl.id);
+        if (!existing) {
+            return {
+                id: tpl.id,
+                name: tpl.title,
+                type: "task",
+                enabled: true,
+                isMainline: true,
+                lane: "main",
+                parallelGroupId: null,
+                executor: tpl.executor,
+                inputMode: "single",
+                outputMode: "single",
+                dependencyPolicy: "all",
+                routePolicy: null,
+                retryPolicy: {
+                    maxAttempts: 2,
+                    backoffMs: 0,
+                },
+                outputSpec: tpl.outputSpec,
+                instruction: tpl.instruction,
+                allowReject: tpl.allowReject,
+                maxRejectCount: tpl.maxRejectCount,
+            };
+        }
+        return {
+            ...existing,
+            name: tpl.title,
+            executor: tpl.executor,
+            instruction: tpl.instruction,
+            outputSpec: tpl.outputSpec,
+            allowReject: tpl.allowReject,
+            maxRejectCount: tpl.maxRejectCount,
+        };
+    });
+    const unconditionalEdges = [];
+    for (const node of nextTemplateNodes) {
+        for (const dep of node.dependsOn) {
+            if (!nodeIds.has(dep))
+                continue;
+            unconditionalEdges.push({
+                from: dep,
+                to: node.id,
+                when: null,
+            });
+        }
+    }
+    const conditionalEdges = current.edges.filter((edge) => edge.when !== null &&
+        (nodeIds.has(edge.from) || groupIds.has(edge.from)) &&
+        (nodeIds.has(edge.to) || groupIds.has(edge.to)));
+    const allEdges = [...unconditionalEdges, ...conditionalEdges];
+    const edgeSeen = new Set();
+    const mergedEdges = [];
+    for (const edge of allEdges) {
+        const key = `${edge.from}|${edge.when ?? ""}|${edge.to}`;
+        if (edgeSeen.has(key))
+            continue;
+        edgeSeen.add(key);
+        mergedEdges.push(edge);
+    }
+    const mergedGroups = current.groups.filter((group) => group.members.every((member) => nodeIds.has(member)));
+    const merged = {
+        version: "3.0",
+        scheduler: current.scheduler,
+        plugins: current.plugins,
+        output: current.output,
+        nodes: mergedNodes,
+        edges: mergedEdges,
+        groups: mergedGroups,
+    };
+    if (!(0, validate_1.validateWorkflowGraph)(merged).ok)
+        return current;
+    return merged;
+};
+exports.mergeTemplateNodesIntoWorkflow = mergeTemplateNodesIntoWorkflow;

package/dist/src/pipeline/workflow/validate.js

@@ -0,0 +1,312 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateWorkflowDefinition = exports.validateWorkflowOutputConfig = exports.validateWorkflowGraph = void 0;
+const branch_rules_1 = require("./branch-rules");
+const routes_1 = require("./routes");
+// ====== Validation ======
+const validateWorkflowGraph = (workflow) => {
+    if (workflow.nodes.length === 0) {
+        return workflow.edges.length === 0 && workflow.groups.length === 0
+            ? { ok: true }
+            : { ok: false, error: "invalid_workflow_definition", detail: "空 workflow 不能包含 edges 或 groups" };
+    }
+    const nodeIds = new Set(workflow.nodes.map((node) => node.id));
+    if (nodeIds.size !== workflow.nodes.length) {
+        return { ok: false, error: "invalid_workflow_definition", detail: "workflow.nodes 存在重复 id" };
+    }
+    const groupIds = new Set(workflow.groups.map((group) => group.id));
+    const entityIds = new Set([...nodeIds, ...groupIds]);
+    const outgoing = new Map();
+    const indegree = new Map();
+    for (const node of workflow.nodes) {
+        outgoing.set(node.id, []);
+        indegree.set(node.id, 0);
+    }
+    for (const group of workflow.groups) {
+        outgoing.set(group.id, []);
+        indegree.set(group.id, 0);
+    }
+    const edgeDedupe = new Set();
+    for (const edge of workflow.edges) {
+        if (!entityIds.has(edge.from) || !entityIds.has(edge.to)) {
+            return { ok: false, error: "invalid_workflow_definition", detail: `边引用了不存在实体: ${edge.from} -> ${edge.to}` };
+        }
+        if (edge.from === edge.to) {
+            return { ok: false, error: "invalid_workflow_definition", detail: `检测到自环边: ${edge.from} -> ${edge.to}` };
+        }
+        const key = `${edge.from}|${edge.when ?? ""}|${edge.to}`;
+        if (edgeDedupe.has(key)) {
+            return { ok: false, error: "invalid_workflow_definition", detail: `检测到重复边: ${edge.from} -> ${edge.to}` };
+        }
+        edgeDedupe.add(key);
+        outgoing.set(edge.from, [...(outgoing.get(edge.from) ?? []), edge.to]);
+        indegree.set(edge.to, (indegree.get(edge.to) ?? 0) + 1);
+    }
+    const outgoingKindsBySource = new Map();
+    const edgesBySource = new Map();
+    for (const edge of workflow.edges) {
+        const kind = edge.when === null ? "dependency" : "route";
+        const kinds = outgoingKindsBySource.get(edge.from) ?? new Set();
+        kinds.add(kind);
+        outgoingKindsBySource.set(edge.from, kinds);
+        edgesBySource.set(edge.from, [...(edgesBySource.get(edge.from) ?? []), edge]);
+    }
+    for (const [sourceId, kinds] of outgoingKindsBySource.entries()) {
+        if (kinds.size <= 1)
+            continue;
+        const sourceNode = workflow.nodes.find((node) => node.id === sourceId);
+        if (sourceNode?.routePolicy)
+            continue;
+        // 非分流节点仍禁止同一节点混合依赖边和路由边，避免无条件放行导致重复执行。
+        return {
+            ok: false,
+            error: "mixed_outgoing_edge_kinds_forbidden",
+            detail: `节点 ${sourceId} 同时存在 dependency 与 route 出边，已禁止保存`,
+        };
+    }
+    // Phase 2: 基于显式 scope 的跨支线边检测。
+    // computeNodeScopes + isCrossBranchEdgeByScope 使用显式 branchScopeId（缺失时从 route 边推导）。
+    {
+        const explicitScopes = new Map();
+        const mergeNodeIds = new Set();
+        for (const node of workflow.nodes) {
+            if (node.branchScopeId != null) {
+                explicitScopes.set(node.id, node.branchScopeId);
+            }
+            // merge 节点（dependencyPolicy !== "all"）是显式分支汇聚点，接受来自不同 scope 的依赖边
+            if (node.dependencyPolicy && node.dependencyPolicy !== "all") {
+                mergeNodeIds.add(node.id);
+            }
+        }
+        const nodeScopes = (0, branch_rules_1.computeNodeScopes)(workflow.nodes, workflow.edges, explicitScopes);
+        // 对 merge 节点清除 scope，避免其被误判为跨支线（与 workflow-graph.ts 的 buildIndices 保持一致）
+        for (const nodeId of mergeNodeIds) {
+            nodeScopes.set(nodeId, null);
+        }
+        const scopeCrossEdges = workflow.edges.filter((edge) => (0, branch_rules_1.isCrossBranchEdgeByScope)(edge, nodeScopes));
+        if (scopeCrossEdges.length > 0) {
+            return {
+                ok: false,
+                error: "cross_branch_edge_forbidden",
+                detail: `禁止跨支线无条件边: ${scopeCrossEdges[0].from} -> ${scopeCrossEdges[0].to}（from 分支 ${nodeScopes.get(scopeCrossEdges[0].from) ?? "main"} -> to 分支 ${nodeScopes.get(scopeCrossEdges[0].to) ?? "main"}，跨支线依赖边需要显式 merge 节点）`,
+            };
+        }
+    }
+    const uniqueGroupIds = new Set();
+    const explicitGroupById = new Map(workflow.groups.map((group) => [group.id, group]));
+    for (const group of workflow.groups) {
+        if (uniqueGroupIds.has(group.id)) {
+            return { ok: false, error: "invalid_workflow_definition", detail: `并行组 id 重复: ${group.id}` };
+        }
+        uniqueGroupIds.add(group.id);
+        for (const member of group.members) {
+            if (!nodeIds.has(member)) {
+                return { ok: false, error: "invalid_workflow_definition", detail: `并行组 ${group.id} 引用了不存在成员 ${member}` };
+            }
+        }
+    }
+    for (const node of workflow.nodes) {
+        const groupId = node.parallelGroupId?.trim();
+        if (!groupId)
+            continue;
+        const group = explicitGroupById.get(groupId);
+        if (!group)
+            return { ok: false, error: "invalid_workflow_definition", detail: `节点 ${node.id} 引用了不存在并行组 ${groupId}` };
+        if (!group.members.includes(node.id)) {
+            return { ok: false, error: "invalid_workflow_definition", detail: `节点 ${node.id} 未加入其声明的并行组 ${groupId}` };
+        }
+    }
+    for (const group of workflow.groups) {
+        const memberSet = new Set(group.members);
+        const groupIncoming = new Set(workflow.edges
+            .filter((edge) => edge.to === group.id)
+            .map((edge) => edge.from));
+        for (const edge of workflow.edges) {
+            if (edge.when !== null)
+                continue;
+            if (!memberSet.has(edge.to))
+                continue;
+            if (edge.to === group.id)
+                continue;
+            if (edge.from === group.id)
+                return { ok: false, error: "invalid_workflow_definition", detail: `并行组 ${group.id} 不能直接连入成员节点` };
+            if (memberSet.has(edge.from))
+                return { ok: false, error: "invalid_workflow_definition", detail: `并行组 ${group.id} 成员之间禁止直接依赖` };
+            if (groupIncoming.has(edge.from))
+                return { ok: false, error: "invalid_workflow_definition", detail: `并行组 ${group.id} 的入口节点不能直连成员` };
+        }
+    }
+    for (const group of workflow.groups) {
+        // joinPolicy 仅支持 "all"；any/quorum 运行时未实现，保存时显式拒绝
+        if (group.joinPolicy !== "all") {
+            return {
+                ok: false,
+                error: "join_policy_not_supported",
+                detail: `并行组 ${group.id} 的 joinPolicy "${group.joinPolicy}" 未支持，当前仅支持 "all"`,
+            };
+        }
+    }
+    for (const node of workflow.nodes) {
+        if (node.routePolicy) {
+            const { allowed } = node.routePolicy;
+            if (allowed.length < 2 || allowed.length > 5) {
+                return { ok: false, error: "invalid_workflow_definition", detail: `节点 ${node.id} 的路由集合长度非法` };
+            }
+            if (!allowed.includes(routes_1.MAINLINE_ROUTE_VALUE) || !allowed.includes(routes_1.DEFAULT_BRANCH_ROUTE_VALUE)) {
+                return { ok: false, error: "invalid_workflow_definition", detail: `节点 ${node.id} 开启分流后必须包含 yes 和 no` };
+            }
+            const outgoingEdges = edgesBySource.get(node.id) ?? [];
+            const dependencyEdges = outgoingEdges.filter((edge) => edge.when === null);
+            if (dependencyEdges.length > 1) {
+                return { ok: false, error: "invalid_workflow_definition", detail: `节点 ${node.id} 的 yes 主线依赖边最多只能有 1 条` };
+            }
+            const routeEdgeCounts = new Map();
+            for (const edge of outgoingEdges.filter((item) => item.when !== null)) {
+                routeEdgeCounts.set(edge.when ?? "", (routeEdgeCounts.get(edge.when ?? "") ?? 0) + 1);
+                if (edge.when === routes_1.MAINLINE_ROUTE_VALUE) {
+                    return { ok: false, error: "invalid_workflow_definition", detail: `节点 ${node.id} 的 yes 不能保存为路由边` };
+                }
+                if (!allowed.includes(edge.when ?? "")) {
+                    return { ok: false, error: "invalid_workflow_definition", detail: `节点 ${node.id} 存在未声明的路由边: ${edge.when}` };
+                }
+                const targetNode = workflow.nodes.find((candidate) => candidate.id === edge.to);
+                const targetGroup = workflow.groups.find((group) => group.id === edge.to);
+                const targetGroupMembers = targetGroup
+                    ? targetGroup.members.map((memberId) => workflow.nodes.find((candidate) => candidate.id === memberId)).filter(Boolean)
+                    : [];
+                const isBranchTarget = targetNode?.lane === "branch" || (targetGroupMembers.length > 0 && targetGroupMembers.every((member) => member?.lane === "branch"));
+                if (!isBranchTarget) {
+                    return { ok: false, error: "invalid_workflow_definition", detail: `节点 ${node.id} 的路由 ${edge.when} 只能指向支线节点或支线并行组` };
+                }
+            }
+            for (const route of allowed.filter((item) => item !== routes_1.MAINLINE_ROUTE_VALUE)) {
+                if ((routeEdgeCounts.get(route) ?? 0) !== 1) {
+                    return { ok: false, error: "invalid_workflow_definition", detail: `节点 ${node.id} 的路由 ${route} 必须配置且只能配置 1 个支线目标` };
+                }
+            }
+        }
+        if (node.dependencyPolicy !== undefined && node.dependencyPolicy !== "all" && node.dependencyPolicy !== "any") {
+            return { ok: false, error: "invalid_workflow_definition", detail: `节点 ${node.id} 的 dependencyPolicy 非法` };
+        }
+    }
+    const queue = [...[...entityIds].filter((id) => (indegree.get(id) ?? 0) === 0)];
+    let visited = 0;
+    while (queue.length > 0) {
+        const nodeId = queue.shift();
+        visited += 1;
+        for (const nextId of outgoing.get(nodeId) ?? []) {
+            const nextDegree = (indegree.get(nextId) ?? 0) - 1;
+            indegree.set(nextId, nextDegree);
+            if (nextDegree === 0) {
+                queue.push(nextId);
+            }
+        }
+    }
+    if (visited !== entityIds.size) {
+        return { ok: false, error: "invalid_workflow_definition", detail: "工作流存在环路，无法拓扑排序" };
+    }
+    return { ok: true };
+};
+exports.validateWorkflowGraph = validateWorkflowGraph;
+const validateWorkflowOutputConfig = (workflow) => {
+    const output = workflow.output ?? { mode: "mainline_last", nodeId: null };
+    if (workflow.nodes.length === 0) {
+        return output.mode === "explicit" && output.nodeId
+            ? { ok: false, error: "invalid_workflow_output_config", detail: "空 workflow 不能指定输出节点" }
+            : { ok: true };
+    }
+    if (output.mode === "explicit") {
+        if (!output.nodeId) {
+            return { ok: false, error: "invalid_workflow_output_config", detail: "mode=explicit 时 nodeId 必填" };
+        }
+        const node = workflow.nodes.find((n) => n.id === output.nodeId);
+        if (!node) {
+            return { ok: false, error: "invalid_workflow_output_config", detail: `输出节点 ${output.nodeId} 不存在` };
+        }
+        if (!node.enabled) {
+            return { ok: false, error: "invalid_workflow_output_config", detail: `输出节点 ${output.nodeId} 必须 enabled` };
+        }
+        if (node.lane !== "main") {
+            return { ok: false, error: "invalid_workflow_output_config", detail: `输出节点 ${output.nodeId} 必须是主线节点` };
+        }
+        if (node.branchScopeId) {
+            return { ok: false, error: "invalid_workflow_output_config", detail: `输出节点 ${output.nodeId} 不能属于支线 scope` };
+        }
+        return { ok: true };
+    }
+    // mode === "mainline_last" — auto-derive unique mainline sink via reachability
+    const mainlineNodeIds = new Set(workflow.nodes
+        .filter((n) => n.enabled && n.lane === "main" && !n.branchScopeId && !n.routeSourceNodeId && !n.routeValue)
+        .map((n) => n.id));
+    if (mainlineNodeIds.size === 0) {
+        return { ok: false, error: "invalid_workflow_output_config", detail: "没有可用的主线节点" };
+    }
+    // Build full adjacency (all nodes, all edges) for reachability DFS
+    const allNodeIds = new Set(workflow.nodes.map((n) => n.id));
+    const successors = new Map();
+    for (const id of allNodeIds)
+        successors.set(id, []);
+    for (const edge of workflow.edges) {
+        const list = successors.get(edge.from);
+        if (list)
+            list.push(edge.to);
+    }
+    // Build indegree/outdegree in full graph (used for orphan detection)
+    const indegree = new Map();
+    const outdegree = new Map();
+    for (const id of allNodeIds) {
+        indegree.set(id, 0);
+        outdegree.set(id, 0);
+    }
+    for (const edge of workflow.edges) {
+        outdegree.set(edge.from, (outdegree.get(edge.from) ?? 0) + 1);
+        indegree.set(edge.to, (indegree.get(edge.to) ?? 0) + 1);
+    }
+    // Route nodes are routers, never endpoints
+    const routeNodeIds = new Set(workflow.nodes.filter((n) => n.routePolicy != null).map((n) => n.id));
+    // DFS from each mainline candidate: can it reach another mainline node?
+    const canReachMainline = new Set();
+    for (const nodeId of mainlineNodeIds) {
+        const visited = new Set();
+        const stack = [...(successors.get(nodeId) ?? [])];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            if (visited.has(current))
+                continue;
+            visited.add(current);
+            if (mainlineNodeIds.has(current)) {
+                canReachMainline.add(nodeId);
+                break;
+            }
+            for (const next of successors.get(current) ?? []) {
+                if (!visited.has(next))
+                    stack.push(next);
+            }
+        }
+    }
+    // A sink is a mainline node that:
+    //   - cannot reach another mainline node (no downstream path)
+    //   - is NOT a route node (routers forward to branches, not endpoints)
+    const sinkNodes = [...mainlineNodeIds].filter((id) => !canReachMainline.has(id) && !routeNodeIds.has(id));
+    // Orphans: disconnected nodes (no in/out edges at all) are not real sinks.
+    // But if ALL candidates are orphans, treat them as valid (single-node case).
+    const orphanIds = new Set([...mainlineNodeIds].filter((id) => (indegree.get(id) ?? 0) === 0 && (outdegree.get(id) ?? 0) === 0));
+    const allOrphans = orphanIds.size === mainlineNodeIds.size;
+    const effectiveSinks = allOrphans
+        ? sinkNodes // all candidates are orphans, keep as-is
+        : sinkNodes.filter((id) => !orphanIds.has(id)); // exclude orphans
+    if (effectiveSinks.length === 0) {
+        return { ok: false, error: "invalid_workflow_output_config", detail: "无法推导唯一主线 sink 节点" };
+    }
+    if (effectiveSinks.length > 1) {
+        return {
+            ok: false,
+            error: "invalid_workflow_output_config",
+            detail: `存在多个主线 sink 节点: ${effectiveSinks.join(", ")}，请切换到 mode=explicit 并指定 nodeId`,
+        };
+    }
+    return { ok: true };
+};
+exports.validateWorkflowOutputConfig = validateWorkflowOutputConfig;
+const validateWorkflowDefinition = (workflow) => (0, exports.validateWorkflowGraph)(workflow);
+exports.validateWorkflowDefinition = validateWorkflowDefinition;

package/dist/src/pipeline/workflow-graph.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkflowGraph = exports.workflowToTemplateNodes = void 0;
+const template_mapper_1 = require("./workflow/template-mapper");
+const branch_rules_1 = require("./workflow/branch-rules");
+// Re-export for backward compatibility
+var template_mapper_2 = require("./workflow/template-mapper");
+Object.defineProperty(exports, "workflowToTemplateNodes", { enumerable: true, get: function () { return template_mapper_2.workflowToTemplateNodes; } });
+const buildIndices = (workflow) => {
+    const nodeById = new Map();
+    const incomingEdgesByTarget = new Map();
+    const outgoingEdgesBySource = new Map();
+    for (const node of workflow.nodes) {
+        nodeById.set(node.id, node);
+    }
+    for (const edge of workflow.edges) {
+        const incoming = incomingEdgesByTarget.get(edge.to) ?? [];
+        incoming.push(edge);
+        incomingEdgesByTarget.set(edge.to, incoming);
+        const outgoing = outgoingEdgesBySource.get(edge.from) ?? [];
+        outgoing.push(edge);
+        outgoingEdgesBySource.set(edge.from, outgoing);
+    }
+    // 计算节点 branch scope：优先使用显式 branchScopeId，缺失时从 route 边推导。
+    // 将 nodes 和 groups 都纳入 scope 计算，确保 group 的 scope 被正确传播。
+    const explicitScopes = new Map();
+    for (const node of workflow.nodes) {
+        if (node.branchScopeId != null) {
+            explicitScopes.set(node.id, node.branchScopeId);
+        }
+    }
+    const allEntities = [
+        ...workflow.nodes.map((n) => ({ id: n.id })),
+        ...workflow.groups.map((g) => ({ id: g.id })),
+    ];
+    const nodeScopes = (0, branch_rules_1.computeNodeScopes)(allEntities, workflow.edges, explicitScopes);
+    // explicitScopeIds: 显式声明了非默认 merge 策略的节点（dependencyPolicy != "all"），
+    // 是多个分支的显式汇聚点，应接受来自不同 scope 的依赖边。
+    // 将其 scope 重置为 null，避免跨支线误判阻断合法的分支合并。
+    for (const node of workflow.nodes) {
+        if (node.dependencyPolicy && node.dependencyPolicy !== "all") {
+            nodeScopes.set(node.id, null);
+        }
+    }
+    const explicit = workflow.groups.filter((group) => group.type === "parallel" && group.members.length >= 2);
+    const seen = new Set(explicit.map((group) => group.id));
+    const inferredMembers = new Map();
+    for (const workflowNode of workflow.nodes) {
+        const groupId = workflowNode.parallelGroupId?.trim();
+        if (!groupId || seen.has(groupId))
+            continue;
+        const current = inferredMembers.get(groupId) ?? [];
+        current.push(workflowNode.id);
+        inferredMembers.set(groupId, current);
+    }
+    const inferred = [...inferredMembers.entries()]
+        .filter(([, members]) => members.length >= 2)
+        .map(([id, members]) => ({
+        id,
+        type: "parallel",
+        members,
+        joinPolicy: "all",
+    }));
+    const groups = [...explicit, ...inferred];
+    const groupById = new Map(groups.map((group) => [group.id, group]));
+    const parallelGroupByMemberNodeId = new Map();
+    for (const group of groups) {
+        for (const memberId of group.members) {
+            parallelGroupByMemberNodeId.set(memberId, group);
+        }
+    }
+    return {
+        nodeById,
+        incomingEdgesByTarget,
+        outgoingEdgesBySource,
+        groupById,
+        parallelGroupByMemberNodeId,
+        groups,
+        nodeScopes,
+    };
+};
+const createWorkflowGraph = (initialWorkflow, initialTemplateNodes) => {
+    let workflow = initialWorkflow;
+    let templateNodes = initialTemplateNodes ?? (0, template_mapper_1.workflowToTemplateNodes)(initialWorkflow);
+    let indices = buildIndices(workflow);
+    const rebuild = () => {
+        indices = buildIndices(workflow);
+    };
+    const setWorkflow = (nextWorkflow) => {
+        workflow = nextWorkflow;
+        templateNodes = (0, template_mapper_1.workflowToTemplateNodes)(nextWorkflow);
+        rebuild();
+    };
+    const setTemplateNodes = (nextTemplateNodes) => {
+        templateNodes = nextTemplateNodes;
+        workflow = (0, template_mapper_1.mergeTemplateNodesIntoWorkflow)(workflow, nextTemplateNodes);
+        rebuild();
+    };
+    const getIncomingEdges = (targetId) => indices.incomingEdgesByTarget.get(targetId) ?? [];
+    const getOutgoingEdges = (sourceId) => indices.outgoingEdgesBySource.get(sourceId) ?? [];
+    const getWorkflowNodeById = (nodeId) => indices.nodeById.get(nodeId) ?? null;
+    const getWorkflowGroupById = (groupId) => indices.groupById.get(groupId) ?? null;
+    const getParallelGroupByMemberNodeId = (nodeId) => indices.parallelGroupByMemberNodeId.get(nodeId) ?? null;
+    const isWorkflowNodeEnabled = (nodeId) => getWorkflowNodeById(nodeId)?.enabled !== false;
+    const isGroupId = (id) => indices.groupById.has(id);
+    // Phase 2: 基于 scope 判断支线身份，替代入边形状推断。
+    // scope 为 null → 主线节点；scope 非 null → 支线节点。
+    const isBranchNode = (nodeId) => {
+        const scope = indices.nodeScopes.get(nodeId);
+        return scope != null;
+    };
+    // Phase 2: 基于 scope 判断跨支线边，替代入边形状推断。
+    // 旧版在存在 B1→B2 普通边时会因 B2 不再"纯支线"而漏判，新版不受此影响。
+    const isCrossBranchEdge = (edge) => (0, branch_rules_1.isCrossBranchEdgeByScope)(edge, indices.nodeScopes);
+    const getNodeScope = (nodeId) => indices.nodeScopes.get(nodeId) ?? null;
+    const getNodesWithWorkflowMeta = (nodes) => nodes.map((node) => {
+        const matched = getWorkflowNodeById(node.id);
+        return {
+            ...node,
+            isMainline: matched?.isMainline ?? true,
+            lane: matched?.lane ?? "main",
+            parallelGroupId: matched?.parallelGroupId ?? null,
+        };
+    });
+    const syncRunGroupsFromWorkflow = (run) => {
+        const current = new Map((run.groups ?? []).map((group) => [group.id, group]));
+        run.groups = indices.groups.map((group) => ({
+            id: group.id,
+            title: `并行组 ${group.id}`,
+            status: current.get(group.id)?.status ?? "blocked",
+            members: group.members,
+            joinPolicy: group.joinPolicy,
+            artifacts: current.get(group.id)?.artifacts ?? [],
+            startedAt: current.get(group.id)?.startedAt ?? null,
+            finishedAt: current.get(group.id)?.finishedAt ?? null,
+            lastError: current.get(group.id)?.lastError ?? null,
+        }));
+        if (!run.groupItemRuns)
+            run.groupItemRuns = [];
+        const groupIds = new Set(indices.groups.map((group) => group.id));
+        run.groupItemRuns = run.groupItemRuns.filter((item) => groupIds.has(item.groupId));
+    };
+    const getRunGroupMeta = (groupId, groups) => groups.find((group) => group.id === groupId) ?? null;
+    return {
+        getWorkflow: () => workflow,
+        setWorkflow,
+        getTemplateNodes: () => templateNodes,
+        setTemplateNodes,
+        getIndices: () => indices,
+        getIncomingEdges,
+        getOutgoingEdges,
+        getWorkflowNodeById,
+        getWorkflowGroupById,
+        getParallelGroupByMemberNodeId,
+        isWorkflowNodeEnabled,
+        isGroupId,
+        isBranchNode,
+        isCrossBranchEdge,
+        getNodeScope,
+        getNodesWithWorkflowMeta,
+        syncRunGroupsFromWorkflow,
+        getRunGroupMeta,
+    };
+};
+exports.createWorkflowGraph = createWorkflowGraph;