Task Graph Generation for Heterogeneous UAV Swarms in Partially Observable Adversarial Environments Authors: Wenxin Li, Yongxin Feng Published: 2026 ABSTRACT In partially observable adversarial environments, heterogeneous unmanned aerial vehicle (UAV) swarms must generate tasks online from noisy observations while respecting platform capabilities, consumable resources, and structural dependencies among tasks. This paper proposes a task graph generation method that converts local observations, target beliefs, and UAV resource states into executable task graphs with explicit resource semantics and inter-task relations. The method first constructs a sufficiently expressive candidate task graph in the belief and resource spaces. An offline search teacher then evaluates future trajectory particles, resource feasibility, and structural interaction values to produce supervision for node selection, marginal task value, and relation prediction. A relation-biased graph attention network learns to generate task graphs online, and a task manager further performs task filtering, dependency repair, conflict completion, and resource checking. Simulation results under complex observation pressure and unseen adversarial strategies show that the proposed method consistently improves structural generation quality and execution feasibility. Compared with Graphormer, it improves the task-graph utility, task-edge F1-score, and executable-graph ratio by 5.83%, 5.41%, and 2.68%, respectively, while reducing the infeasible-task ratio by 35.14%. These results indicate that combining an offline search teacher with resource-constrained graph modeling provides an effective front-end task organization mechanism for heterogeneous UAV swarm planning. 1. Introduction Unmanned aerial vehicle (UAV) swarms offer flexible deployment, wide-area coverage, platform redundancy, and rapid task response. Their use has expanded from single-platform autonomous flight to multi-UAV perception, dynamic resource scheduling, and autonomous decision making in adversarial environments. Recent studies have investigated multi-UAV systems for target search, disaster response, communication relay, boundary protection, and low-altitude security. As task scale and environmental uncertainty increase, swarm coordination depends not only on the motion-control accuracy of individual UAVs, but also on whether the system forms stable task organizations under local observations, limited communication, and heterogeneous resources [1,2,3]. From the viewpoint of uncertainty-aware decision making, the key difficulty is not only to allocate a known list of tasks, but also to decide which tasks should exist when the state of the adversarial environment is incompletely observed. Target-mode beliefs, observation confidence, communication quality, and resource margins form an evolving information state. Therefore, the proposed problem is closely related to entropy-based uncertainty representation and information-theoretic decision making, where a lower-ambiguity belief supports more decisive interception or blocking actions, whereas a high-entropy belief should trigger confirmation, tracking, or communication-support tasks before committing scarce strike resources [4,5]. In a typical adversarial scenario, a blue heterogeneous UAV swarm must respond to red-side behaviors such as direct penetration, flank maneuvering, electronic jamming, and decoy deception. Unlike routine inspection, fixed-route coverage, or target tracking with a given target set, these missions are closed-loop and strategic: red targets adapt their motion patterns in response to the blue deployment and interception posture, while blue sensors are affected by occlusion, noise, and electronic interference. The resulting situation is only partially observed and is represented by local measurements, historical tracks, and target beliefs. Directly feeding such a situation into a conventional task allocator often leads to missing task nodes, incorrect relation edges, and resource-infeasible assignments. In realistic adversarial operations, tasks must be generated online as the situation evolves, and the quality of the generated tasks directly affects downstream cooperative allocation and execution. Classical task allocation and resource-constrained mission planning provide the first methodological basis for this study. The classical consensus-based bundle algorithm (CBBA) solves multi-agent task allocation through distributed auctions and is effective when task rewards and constraints are explicitly available [6]. More general taxonomies of multi-robot task allocation emphasize that allocation algorithms usually start from an already defined set of tasks, agent capabilities, and constraints [7,8]. Recent work has introduced graph neural networks (GNNs), hybrid optimization, and reinforcement learning into UAV, unmanned ground vehicle, and multi-robot coordination. Examples include adaptive deep GNNs for UAV–CAV (connected and autonomous vehicle) dynamic task allocation [9]; decentralized graph-attention-based allocation for multi-robot target localization [10]; and joint trajectory, spectrum, routing, offloading, and computation optimization for UAV edge systems and communication networks [2,11]. These studies motivate our modeling of task resource requirements, communication constraints, and feasibility checks, but they mainly address allocation and scheduling after candidate tasks are already specified. Domain studies on UAV mission planning and coverage further show that platform heterogeneity, energy limits, communication reachability, and task timing strongly influence mission feasibility [3,12]. Resource-constrained scheduling theory also provides useful models for precedence and renewable/nonrenewable resource feasibility [13]. However, many scheduling and defense-allocation formulations assume that the task set or precedence graph is already known before optimization begins. Defense-oriented adversarial missions differ from pure coverage or search tasks because red-side motion deliberately creates false priorities, jams sensing links, and induces resource exhaustion. A problem-driven task-generation formulation is therefore needed: the planner must expose the intermediate task structure, make the uncertainty state visible to the decision process, and preserve resource and dependency information before downstream allocation is attempted. Partially observable planning, online replanning, and multi-agent reinforcement learning (MARL) constitute a second line of related work. Partially Observable Monte Carlo Planning (POMCP) approximates policies in large partially observable Markov decision processes (POMDPs) using sampling-based online search [14]. Such online search reacts to updated beliefs, but repeated expansion of a large task-structure search space is too expensive for frequent UAV replanning and does not by itself expose an editable task graph. Recent studies on privileged learning and asymmetric training further show how simulation-time access to global states provides useful supervision when execution must rely on local observations [15]. In MARL, graph-based information aggregation has been used to improve scalability [16]; centralized-training information has been used to guide individual exploration under sparse rewards [17]; scalable safe policy optimization has incorporated local interactions and safety constraints [18]; and communication-aware MARL has highlighted the importance of communication targets, contents, costs, and constraints under partial observability [19]. Recent multimodal learning and prompt-based fusion studies, including FMSA for few-shot multimodal sentiment analysis with integrated prompt learning and vision–language models, also indicate that reliable autonomous decision making increasingly depends on robust fusion under uncertain, heterogeneous observations [20,21,22]. These works inform our treatment of belief states, uncertainty, offline teacher search, and communication resources. However, their outputs are usually actions, policies, or value functions rather than explicit task structures containing precedence, support, and conflict relations. Task graph generation occupies an intermediate level between direct task assignment and end-to-end policy learning. Compared with direct assignment, it explicitly represents missing prerequisites, support requirements, mutually exclusive tasks, and infeasible resource combinations before UAV teams are allocated. Compared with an end-to-end policy, it yields an interpretable and editable structure that supports repair, checking, and transfer to different downstream allocators. This is particularly useful in dynamic UAV scenarios, where the system must revise not only who executes a task, but also whether reconnaissance, relay, blocking, or interception tasks should be generated at all. Relational graph modeling and graph generation provide a natural language for task-structure representation. Graph attention and coordination-graph models capture interactions among agents, tasks, and environmental entities. Hyper Graphical Attention Policy (HGAP) uses graph attention to satisfy permutation invariance and equivariance in partially observable multi-agent decision making [23], while Group-Aware Coordination Graph (GACG) infers coordination graphs from both individual relations and group dependencies [24]. Formal methods have also been used in dynamic multi-robot task allocation, where satisfiability modulo theories (SMT) solvers enforce completeness and constraint consistency [25]. These methods motivate graph-based task representation, yet generic graph generation models usually lack UAV-specific task types, resource semantics, time constraints, and downstream executability. Formal allocation methods, meanwhile, remain computationally stressed under severe uncertainty and large candidate-task combinations. Graph diffusion models are a promising family of generative models because discrete-state continuous-time diffusion and latent graph diffusion jointly generate node attributes, edge attributes, and graph structure [26,27]. Nevertheless, existing graph diffusion methods are not directly suitable for the present online task-generation problem without substantial modification. First, task graphs are subject to hard executability constraints: a generated interception node requires prior identification under low confidence, sufficient strike resources, and a nonconflicting support chain. Unconstrained denoising produces graphs that are locally plausible but violate resource, precedence, or conflict rules. Second, diffusion inference typically requires multiple denoising steps, which is expensive for online replanning when the UAV swarm updates the graph after each observation cycle. Third, relational consistency is typed and semantic: a support edge, a precedence edge, and a conflict edge have different feasibility implications and cannot be treated as exchangeable adjacency entries. A diffusion-based extension requires typed node-edge noise processes, resource-aware conditional embeddings, constraint-guided denoising, projection or repair layers after each denoising step, and few-step distillation for online inference. This extension is feasible when the diffusion process itself incorporates resource semantics, task dependencies, and executability checks, whereas this paper focuses on a supervised relation-biased graph generator with an explicit task-management layer. This paper studies task graph generation for heterogeneous UAV swarms in partially observable adversarial environments. The basic idea is to construct candidate task nodes and candidate relations from current observations, historical beliefs, and platform resources; distill supervision from an offline search teacher using future trajectories, resource feasibility, and structural value; and train a relation-biased graph network to generate executable task graphs online. The main contributions are as follows:(1)A resource-constrained task graph model is established for heterogeneous UAV swarms under partial observability. The model unifies current observations, target beliefs, and UAV resource states as task-generation inputs and represents tasks with task types, resource requirements, deadlines, reward-risk attributes, and structural edges.(2)An offline search teacher is proposed for task-graph supervision. Using simulated true states, future trajectory particles, and resource-feasibility evaluation, the teacher produces node-selection labels, marginal-value labels, and task-relation labels.(3)A relation-biased graph generation network and an online task manager are designed. The network jointly encodes spatial, semantic, temporal, and resource relations among candidate tasks, while the task manager performs filtering, dependency repair, conflict completion, and resource checking.(4)A task-generation-oriented experimental evaluation is constructed. The evaluation covers task-graph utility, node F1-score, edge F1-score, executable-graph ratio, graph edit distance, online latency, generalization to unseen adversarial strategies, tail risk, and module ablation. (1)A resource-constrained task graph model is established for heterogeneous UAV swarms under partial observability. The model unifies current observations, target beliefs, and UAV resource states as task-generation inputs and represents tasks with task types, resource requirements, deadlines, reward-risk attributes, and structural edges. A resource-constrained task graph model is established for heterogeneous UAV swarms under partial observability. The model unifies current observations, target beliefs, and UAV resource states as task-generation inputs and represents tasks with task types, resource requirements, deadlines, reward-risk attributes, and structural edges. (2)An offline search teacher is proposed for task-graph supervision. Using simulated true states, future trajectory particles, and resource-feasibility evaluation, the teacher produces node-selection labels, marginal-value labels, and task-relation labels. An offline search teacher is proposed for task-graph supervision. Using simulated true states, future trajectory particles, and resource-feasibility evaluation, the teacher produces node-selection labels, marginal-value labels, and task-relation labels. (3)A relation-biased graph generation network and an online task manager are designed. The network jointly encodes spatial, semantic, temporal, and resource relations among candidate tasks, while the task manager performs filtering, dependency repair, conflict completion, and resource checking. A relation-biased graph generation network and an online task manager are designed. The network jointly encodes spatial, semantic, temporal, and resource relations among candidate tasks, while the task manager performs filtering, dependency repair, conflict completion, and resource checking. (4)A task-generation-oriented experimental evaluation is constructed. The evaluation covers task-graph utility, node F1-score, edge F1-score, executable-graph ratio, graph edit distance, online latency, generalization to unseen adversarial strategies, tail risk, and module ablation. A task-generation-oriented experimental evaluation is constructed. The evaluation covers task-graph utility, node F1-score, edge F1-score, executable-graph ratio, graph edit distance, online latency, generalization to unseen adversarial strategies, tail risk, and module ablation. 2. System Model and Problem Formulation 2.1. Scenario and Notation Consider a two-dimensional continuous mission area(1)Ω=[0,L]×[0,L], where L is the side length. The blue heterogeneous UAV swarm defends a boundary located at x=x∂. Red targets enter from the far side of the boundary and approach it through direct penetration, flank maneuvering, jamming suppression, or decoy deception. We use the saturation operator(2)[z]ab=min{max{z,a},b}. The blue UAV set is(3)U={u1,u2,…,uN}, and the active red target set is(4)Et={e1,e2,…,eMt}. The state of UAV ui at time t is(5)xi(t)=pi(t),vi,Ei(t),ζi,αi,βi(t),νi(t), where pi(t) is the position, vi is the maximum speed, Ei(t) is the remaining energy, ζi is the platform role, αi is the non-consumable capability vector, βi(t) is the consumable resource vector, and νi(t)∈{0,1} denotes availability. The capability and resource vectors are(6)αi=[αi,1,αi,2,αi,3,αi,4]⊤, and(7)βi(t)=[βi,1(t),βi,2(t),βi,3(t),βi,4(t)]⊤. The meanings of the four capability and resource dimensions are summarized in Table 1 and Table 2, respectively. The true state of red target ej is(8)yj(t)=sj(t),s˙j(t),mj,νje(t), where sj(t) is the position, s˙j(t) is the velocity, mj is the target mode, and νje(t) is the target status. The mode set is(9)M={1,2,3,4}, corresponding to direct penetration, flank maneuvering, jamming suppression, and decoy deception. The online generator cannot access yj(t); it is used only for simulation evaluation and offline teacher labeling. Figure 1 summarizes the closed-loop model. The UAV swarm starts from local observations, updates target beliefs, constructs candidate task graphs in the belief and resource spaces, outputs executable task graphs through task management, and passes them to a downstream cooperative allocation module. 2.2. Current Observation and Belief State Because target maneuvers, occlusion, and jamming coexist, the blue side obtains only local noisy observations at time t. The observation of target ej by UAV ui is(10)oij(t)=s^ij(t),m^ij(t),dij(t),κi(t), where s^ij(t) is a noisy position measurement, m^ij(t) is an imperfect mode cue, dij(t)=∥pi(t)−sj(t)∥2 is the relative distance, and κi(t) is the local jamming intensity. Let Etκ denote the jamming target set. The jamming intensity at position p is(11)κ(p,t)=∑ej∈EtκRκ−∥p−sj(t)∥2Rκ01, where Rκ is the jamming radius. The effective detection range of UAV ui is(12)R¯i(t)=Ri1−aκκ(pi(t),t)(1−αi,4), where Ri is the nominal detection range, aκ is the attenuation coefficient, and αi,4 is the anti-jamming capability. If dij(t)≤R¯i(t), the detection probability is(13)Pij(t)=p0−apκi(t)+bpαi,1pminpmax. Once detected, the measured position satisfies(14)s^ij(t)=sj(t)+εij(t),εij(t)∼N0,σij2(t)I, with(15)σij(t)=σ0+aσκi(t). The raw observation set at time t is(16)Ot={oij(t)∣ui∈U,ej∈Et}. To mitigate incomplete single-step observations, the system maintains target beliefs(17)Bt={b1(t),b2(t),…,bMt(t)}. The belief of target ej is(18)bj(t)=μj(t),μ˙j(t),πj(t),ξj(t),Σj(t),tjℓ, where μj(t) and μ˙j(t) are position and velocity estimates, πj(t)∈R4 is the mode-probability vector, ξj(t) is the confidence, Σj(t) is the uncertainty scale, and tjℓ is the last observation time. If ej is observed by UAV set Ij(t), the fused position is(19)o¯j(t)=1|Ij(t)|∑i∈Ij(t)s^ij(t). The velocity, confidence, and uncertainty are updated as(20)μ˙j(t)=avo¯j(t)−μj(t−1),(21)ξj(t)=[ξ0+aξ|Ij(t)|]ξminξmax, and(22)Σj(t)=maxΣmin,Σ0|Ij(t)|. If the target is not observed, the belief is extrapolated over a finite horizon:(23)μj(t)=μj(tjℓ)+μ˙j(tjℓ)min(t−tjℓ,Hb),(24)ξj(t)=ξj(tjℓ)aℓt−tjℓ,Σj(t)=Σj(tjℓ)+aΣ(t−tjℓ). The current observation state is therefore(25)zt=Ot,Bt,{xi(t)}i=1N. 2.3. Resource-Constrained Task Graph At time t, the task structure is represented as a directed heterogeneous graph(26)Gt=(Vt,Rt), where Vt={τ1,τ2,…,τKt} is the task-node set, and Rt is the relation-edge set. Each task node is(27)τk=yk,gk,wk,ρk,ϱk,Tk,ψk,χk,ιk, where yk is the task type, gk is the target point, wk is the task reward, ρk∈R4 is the non-consumable capability requirement, ϱk∈R4 is the consumable resource requirement, Tk is the deadline, ψk is the risk, χk is the task confidence, and ιk is the associated target index. The task-type set is(28)Y={1,2,3,4,5}, representing target identification, target interception, area blocking, communication support, and boundary guarding. The resource semantics associated with these task types are summarized in Table 3. A task-relation edge is(29)rkl=(τk,τl,ℓkl),rkl∈Rt, where ℓkl∈{1,2,3} is the relation type. Specifically, ℓkl=1 denotes a precedence relation, ℓkl=2 denotes a support relation, and ℓkl=3 denotes a conflict relation. Figure 2 illustrates the task-node attributes, typed relations, and cooperative execution interface of the resource-constrained task graph. 2.4. Execution Interface and Problem Statement The downstream cooperative decision process is abstracted as a generic resource-aware allocation interface(30)Π:Gt,{xi(t)}i=1N↦At, where At={Ck(t)}k=1Kt and Ck(t)⊆U is the UAV team assigned to task τk. The interface supports auction, matching, tree search, graph optimization, and multi-agent policy implementations; this paper does not bind the generator to a specific allocator. For task τk, the non-consumable capability constraint is(31)∑ui∈Ck(t)αi,q≥ρk,q,q=1,2,3,4. The consumable resource constraint is(32)∑τk:ui∈Ck(t)Δik,h(t)≤βi,h(t),h=1,2,3,4, where Δik,h(t) is the amount of resource type h consumed by UAV ui when executing task τk. The consumable-resource constraint uses a linear additive accounting model. This approximation is adopted because it gives the task manager and downstream allocator fast feasibility checks during online graph generation. It is most appropriate when the execution costs of different tasks are weakly coupled over a short planning window. In real UAV operations, resource consumption becomes nonlinear when task interactions are strong. Cooperative sensing and relay tasks create synergy and reduce marginal cost; simultaneous communication and sensing cause bandwidth and payload contention; and the order in which reconnaissance, relay, and interception tasks are executed changes both energy consumption and success probability. The proposed graph represents these interaction effects at the structural level through precedence, support, and conflict relations, while the resource-cost function remains additive. A natural extension is to replace the additive term by pairwise interaction costs, submodular resource models, sequence-dependent costs, and learned resource predictors calibrated from real flight or hardware-in-the-loop data. Given the task graph and allocation, the structured execution value is(33)Jt(Gt,At)=∑τk∈VtJ1(τk,Ck)+∑rkl∈RtJ2(rkl,Ck,Cl)−J3(At), where J1 is the task-node execution value, J2 is the relation value, and J3 is the resource and load cost. The goal is to learn an observation-conditioned task graph generation policy(34)πθ:zt↦Gt, that maximizes the long-term expected return when coupled with the allocation interface:(35)maxθE∑t=0TγtRyt,Gt,At. The single-step reward is(36)Rt=ω1nt+−ω2nt−−ω3nt0−ω4et−ω5dt−ω6ot+ω7st, where nt+ is the number of successful interceptions, nt− is the number of boundary breakthroughs, nt0 is the number of remaining active targets, et is energy consumption, dt is response latency, ot is task-load cost, and st is the task-success statistic. 3. Proposed Method The proposed method takes the current observation state as input, constructs a candidate task graph, uses an offline search teacher to produce structured supervision, and trains a relation-biased graph attention network (GAT) for online task graph generation. It is designed for dynamic adversarial scenarios in which rule-based triggers cannot reliably cover the required task set. 3.1. Overall Framework Figure 3 shows the overall framework. During offline training, simulated partially observable trajectories are used to construct dense candidate task graphs from target beliefs. The search teacher evaluates candidate subgraphs using future trajectory particles, resource feasibility, and task relations, and then produces node, value, and edge labels. The relation-biased graph attention network is trained on these labels. During online deployment, the trained model generates a task graph from the current observation state, and the task manager filters, repairs, checks, and sends the graph to the execution interface. Let the current observation state at time t be zt and the candidate task graph be(37)G˜t=V˜t,R˜t. The relation-biased graph attention network learns(38)fθ:G˜t,zt↦p^t,v^t,E^t, where p^t contains candidate-node selection probabilities, v^t contains marginal task values, and E^t is the relation probability matrix. The final task graph is produced by the task-management operator(39)Gt=ΓG˜t,p^t,v^t,E^t. Algorithm 1 defines the input–output flow among four modules. The belief update module maps raw observations and UAV states into target beliefs Bt. The candidate graph constructor maps Bt and resource states into G˜t. The graph generator maps node and relation features into node-selection, value, and edge probabilities. The task manager then converts these probabilities into an executable graph by filtering, repairing, and completing relations, after which the generic execution policy returns assignments and resource updates for the next observation cycle. Algorithm 1 Observation-Conditioned Online Task Graph Generation1:Input: raw observations Ot; UAV states {xi(t)}i=1N; trained generator fθ; task manager Γ2:Output: executable task graph Gt; assignment result At3:Stage 1 – Belief update and candidate graph construction4:Fuse raw observations Ot and update belief tracks Bt5:Construct candidate task nodes V˜t from each belief track6:Construct initial relations R˜t using precedence, support, and conflict semantics7:Form G˜t=(V˜t,R˜t)8:Stage 2 – Graph inference9:Build node feature matrix Xt and pairwise relation tensor Rt10:(p^t,v^t,E^t)←fθ(Xt,Rt)11:Stage 3 – Task graph management12:Rank candidate tasks using p^t, v^t, and task risk13:Remove infeasible or redundant tasks according to resource constraints and per-target budgets14:Repair missing precedence and support tasks when high-confidence relations exist15:Add conflict edges for redundant attack tasks on the same target16:Obtain Gt=Γ(G˜t,p^t,v^t,E^t)17:Stage 4 – Generic collaborative execution18:Compute At←Π(Gt,{xi(t)}i=1N)19:Execute assigned tasks and update UAV resources20:return Gt, At 1:Input: raw observations Ot; UAV states {xi(t)}i=1N; trained generator fθ; task manager Γ Input: raw observations Ot; UAV states {xi(t)}i=1N; trained generator fθ; task manager Γ 2:Output: executable task graph Gt; assignment result At Output: executable task graph Gt; assignment result At 3:Stage 1 – Belief update and candidate graph construction Stage 1 – Belief update and candidate graph construction 4:Fuse raw observations Ot and update belief tracks Bt Fuse raw observations Ot and update belief tracks Bt 5:Construct candidate task nodes V˜t from each belief track Construct candidate task nodes V˜t from each belief track 6:Construct initial relations R˜t using precedence, support, and conflict semantics Construct initial relations R˜t using precedence, support, and conflict semantics 7:Form G˜t=(V˜t,R˜t) Form G˜t=(V˜t,R˜t) 8:Stage 2 – Graph inference Stage 2 – Graph inference 9:Build node feature matrix Xt and pairwise relation tensor Rt Build node feature matrix Xt and pairwise relation tensor Rt 10:(p^t,v^t,E^t)←fθ(Xt,Rt) (p^t,v^t,E^t)←fθ(Xt,Rt) 11:Stage 3 – Task graph management Stage 3 – Task graph management 12:Rank candidate tasks using p^t, v^t, and task risk Rank candidate tasks using p^t, v^t, and task risk 13:Remove infeasible or redundant tasks according to resource constraints and per-target budgets Remove infeasible or redundant tasks according to resource constraints and per-target budgets 14:Repair missing precedence and support tasks when high-confidence relations exist Repair missing precedence and support tasks when high-confidence relations exist 15:Add conflict edges for redundant attack tasks on the same target Add conflict edges for redundant attack tasks on the same target 16:Obtain Gt=Γ(G˜t,p^t,v^t,E^t) Obtain Gt=Γ(G˜t,p^t,v^t,E^t) 17:Stage 4 – Generic collaborative execution Stage 4 – Generic collaborative execution 18:Compute At←Π(Gt,{xi(t)}i=1N) Compute At←Π(Gt,{xi(t)}i=1N) 19:Execute assigned tasks and update UAV resources Execute assigned tasks and update UAV resources 20:return Gt, At return Gt, At 3.2. Candidate Task Graph Construction and Task Management Candidate construction aims to generate a sufficiently rich but size-controlled task set under the current belief state. For each target belief bj(t), the boundary urgency is(40)uj(t)=1−x∂−μj,x(t)Dmax01, where μj,x(t) is the estimated target abscissa, and Dmax is a normalization distance. The operator [z]01 is the saturation operator defined in Section 2.1. Here, x∂ denotes the defended boundary, and Dmax converts the distance-to-boundary term into a dimensionless urgency score. Therefore, uj(t) approaches one when the estimated target position μj,x(t) is close to the defended boundary and approaches zero when the target remains far from it. The attack tendency is(41)aj(t)=πj,1(t)+λaπj,2(t), The two mode probabilities are weighted differently because direct penetration and flank maneuvering imply different urgency. The component πj,1(t) corresponds to a direct approach toward the defended boundary and is therefore assigned full weight, whereas πj,2(t) corresponds to a flank maneuver whose threat depends on lateral position and remaining time. The coefficient λa downweights or upweights this second mode according to validation performance. and the overall risk is(42)ψj(t)=b1uj(t)+b2aj(t)+b3ξj(t)+b4Σj(t)Σmax01. The coefficients b1,b2,b3,b4 are nonnegative risk-aggregation weights fixed before testing. In the implementation, they are selected on validation episodes so that boundary urgency, attack tendency, belief confidence, and uncertainty scale contribute comparable normalized magnitudes to ψj(t). The risk score is used for candidate ranking and pruning rather than as an isolated decision rule, which reduces sensitivity to any single coefficient; nevertheless, the uncertainty and resource ablations in Section 4.12 examine whether the generator remains effective when these risk-related inputs or constraints are removed. For each target, the generator constructs five candidate tasks:(43)V˜j(t)={τj,1,τj,2,τj,3,τj,4,τj,5}, corresponding to target identification, target interception, area blocking, communication support, and boundary guarding. The five candidates are not all forced into the final graph. They form a fixed semantic menu for each active target: identification reduces belief ambiguity, interception acts on high-threat targets, blocking creates a defensive spatial barrier, communication support mitigates jamming or link loss, and boundary guarding protects the defended line when target intent is uncertain. The subsequent pruning and task-management stages remove candidates whose risk, confidence, reward, or resource feasibility is insufficient. Their target points are determined by target beliefs and task semantics:(44)gj,1(t)=μj(t),(45)gj,2(t)=[μj,x(t)+lj(t)]0x∂−ϵ,μj,y(t),(46)gj,3(t)=μj,x(t)+x∂2xminx∂−ϵ,μj,y(t),(47)gj,4(t)=[μj,x(t)+l4]x4−x4+,[μj,y(t)]y−y+,(48)gj,5(t)=x∂−l5,[μj,y(t)]y−y+. The boundary clipping in the interception and blocking points prevents generated target points from crossing the defended boundary. The small margin ϵ>0 keeps the generated point strictly inside the feasible defense side, which avoids numerical ambiguity when a target is estimated exactly on the boundary. The bounds xmin, x4−, x4+, y−, and y+ define the feasible spatial ranges for blocking and communication-support tasks. Candidate rewards, deadlines, and resource requirements are(49)wk=w0(yk)+c1(yk)ψk+c2(yk)χk+c3(yk)⊤πιk(t),(50)Tk=t+Tmax(yk)−uιk(t)[Tmax(yk)−Tmin(yk)], and(51)ρk=ρ0(yk)+ψkρψ(yk),ϱk=ϱ0(yk)+uιk(t)ϱu(yk). Relation edges are initialized from task semantics. A precedence edge is added when one task supplies a necessary precondition for another task; for example, target identification should precede interception when the belief confidence is below the attack threshold. A support edge is added when one task improves the feasibility or reliability of another task; for example, a communication-support task supports interception or blocking under strong jamming or weak connectivity. A conflict edge is added when two tasks compete for the same target, time window, spatial sector, or scarce strike resource. The candidate graph is then pruned by risk, reward, confidence, and resource feasibility to retain at most K˜max task nodes. Redundant tasks are removed when they cover the same target with lower value and no additional support role, whereas infeasible tasks are removed when no available UAV coalition satisfies their capability and consumable-resource requirements. The online task manager converts model outputs into an executable task graph. For task τk, the selection score is(52)sk=a1p^k+a2v^k+a3ψk+a4χk−a5Δk, where Δk is the infeasibility penalty relative to current resources. The manager selects tasks according to sk while enforcing the number constraint, per-target task budgets, precedence repair, support repair, and conflict-edge completion. The repair mechanism is rule-guided but score-aware. If an interception task for target ej is retained while a required identification task is absent and the belief confidence ξj(t) is below the confirmation threshold, the manager first attempts to insert the missing identification task. If the resource budget cannot support both tasks, the manager either removes the interception task or downgrades it to blocking or tracking according to the selection scores. Similarly, when strong jamming makes an attack chain depend on communication support, a missing support task is inserted if it has a feasible UAV coalition; otherwise, the unsupported high-risk task is penalized or removed. This repair step prevents locally high-scoring nodes from forming logically incomplete task chains. 3.3. Offline Search Teacher and Graph Generation Network Figure 4 illustrates the search teacher and the graph generation network. The teacher samples future trajectory particles in belief space; evaluates future coverage, resource feasibility, and structural interaction values; and searches for high-value task subgraphs. The graph generator learns node, value, and edge labels from the teacher. The offline teacher and the online generator use different information sets, as summarized in Table 4. The trained generator receives only the observation-conditioned belief state, candidate task graph, and current UAV resource states. Privileged simulator variables are used only for offline labeling, validation, and evaluation and are not provided to fθ during online deployment. The teacher first samples P future trajectories of horizon H for each active target:(53)Pj={sj,p0:H}p=1P. For candidate task τk, the future-coverage value is(54)Vkf=1P∑p=1Pφgk,sιk,p0:H,yk. The resource-feasibility value is(55)Vkr=maxC⊆U,|C|≤Cmax14∑q=14min1,∑ui∈Cαi,qρk,q+ϵ−λdd¯(C,gk)−λbb¯(C,τk), where d¯(C,gk) is the average team arrival cost, and b¯(C,τk) is the consumable resource cost. The task base value is(56)Vk0=λ1Vks+λ2Vkf+λ3Vkr+λ4ψk, where Vks is the task semantic value. For a task pair (τk,τl), the structural interaction value is(57)Vklg=ω1,ℓkl=1,ω2,ℓkl=2,−ω3,ℓkl=3,0,otherwise. Given a task subset S, the teacher evaluation function is(58)V(S)=∑τk∈SVk0+∑τk,τl∈S,k≠lVklg+λΔD(S)−λK[|S|−Kmax]0+∞. Here, D(S) encourages coverage of diverse targets and task types. The teacher searches for a high-value subset S★ through beam-limited Monte Carlo tree search and generates supervision accordingly. Algorithm 2 summarizes the offline search-teacher labeling procedure. Algorithm 2 Offline Search-Teacher Labeling1:Input: candidate graph G˜t; belief set Bt; UAV resource states; search budget B2:Output: node labels yn; value labels yv; edge labels Ye3:Construct future trajectory particles Pj for each active target belief4:for each candidate task τk∈V˜t do5: Compute semantic, future-coverage, and resource-feasibility values6: Construct task base value Vk07:end for8:for each candidate relation (τk,τl,ℓkl)∈R˜t do9: Compute structural interaction value Vklg10:end for11:Search for the best subset S★ using beam-guided tree search12:for each candidate task τk∈V˜t do13: Set ykn←I(τk∈S★)14: Set ykv←[V(S★)−V(S★∖{τk})]0115:end for16:for each candidate relation (τk,τl,ℓkl)∈R˜t do17: Set Ykle←I(τk,τl∈S★)18:end for19:return yn, yv, Ye 1:Input: candidate graph G˜t; belief set Bt; UAV resource states; search budget B Input: candidate graph G˜t; belief set Bt; UAV resource states; search budget B 2:Output: node labels yn; value labels yv; edge labels Ye Output: node labels yn; value labels yv; edge labels Ye 3:Construct future trajectory particles Pj for each active target belief Construct future trajectory particles Pj for each active target belief 4:for each candidate task τk∈V˜t do for each candidate task τk∈V˜t do 5: Compute semantic, future-coverage, and resource-feasibility values Compute semantic, future-coverage, and resource-feasibility values 6: Construct task base value Vk0 Construct task base value Vk0 7:end for end for 8:for each candidate relation (τk,τl,ℓkl)∈R˜t do for each candidate relation (τk,τl,ℓkl)∈R˜t do 9: Compute structural interaction value Vklg Compute structural interaction value Vklg 10:end for end for 11:Search for the best subset S★ using beam-guided tree search Search for the best subset S★ using beam-guided tree search 12:for each candidate task τk∈V˜t do for each candidate task τk∈V˜t do 13: Set ykn←I(τk∈S★) Set ykn←I(τk∈S★) 14: Set ykv←[V(S★)−V(S★∖{τk})]01 Set ykv←[V(S★)−V(S★∖{τk})]01 15:end for end for 16:for each candidate relation (τk,τl,ℓkl)∈R˜t do for each candidate relation (τk,τl,ℓkl)∈R˜t do 17: Set Ykle←I(τk,τl∈S★) Set Ykle←I(τk,τl∈S★) 18:end for end for 19:return yn, yv, Ye return yn, yv, Ye For each candidate task τk, the node feature is(59)xkτ=[e(yk),gk,wk,Tk,ψk,χk,ρk,ϱk,bιk(t),ηt], where e(yk) is the task-type embedding, and ηt is the team resource context. For task pair (τk,τl), the relation feature is(60)rkl=[Ik=l,Iιk=ιl,Iyk=yl,dkl,exp(−λddkl),Iℓkl=1,Iℓkl=2,Iℓkl=3,wk−wl,ψk−ψl,Tk−Tl,χk−χl]. The model embeds node features into the hidden space:(61)hk0=Φin(xkτ). For attention head a at layer l, the relation-biased attention is(62)Akla=(WQahk)⊤(WKahl)da+ϕa(rkl),(63)A¯kla=exp(Akla)∑l′exp(Akl′a). After multiple encoding layers, the outputs are(64)p^k=σ(Φn(hk)),v^k=σ(Φv(hk)),(65)E^kl=σΦe([hk,hl,rkl]). The training loss is(66)L=Ln+λvLv+λeLe+λoLo, where the first three terms are node-selection, value-regression, and edge-prediction losses. The final term is a ranking loss:(67)Lo=1|P+||P−|∑i∈P+∑j∈P−log1+exp(Δ−zi+zj), where P+ is the teacher-selected task set, P− is the unselected set, and zi is the node-selection logit. Algorithm 3 summarizes the training procedure of the relation-biased task graph generator. Algorithm 3 Training of the Relation-Biased Task Graph Generator1:Input: simulator episodes; candidate task factory; search teacher; graph generator fθ; iterations I; batch size M2:Output: trained generator parameters θ3:for each simulator episode do4: for each decision step t do5: Build current observation state zt and candidate graph G˜t6: Query the search teacher to obtain (yn,yv,Ye)7: Store the labeled graph sample in dataset D8: end for9:end for10:for i=1 I do11: Sample a mini-batch of M graph samples from D12: Build padded node features, relation tensors, and graph masks13: Predict node probabilities, values, and edge probabilities with fθ14: Compute node, value, edge, and ranking losses15: Update θ by gradient descent16:end for17:Tune task-selection thresholds, maximum task count, and per-target task budget on validation episodes18:return θ 1:Input: simulator episodes; candidate task factory; search teacher; graph generator fθ; iterations I; batch size M Input: simulator episodes; candidate task factory; search teacher; graph generator fθ; iterations I; batch size M 2:Output: trained generator parameters θ Output: trained generator parameters θ 3:for each simulator episode do for each simulator episode do 4: for each decision step t do for each decision step t do 5: Build current observation state zt and candidate graph G˜t Build current observation state zt and candidate graph G˜t 6: Query the search teacher to obtain (yn,yv,Ye) Query the search teacher to obtain (yn,yv,Ye) 7: Store the labeled graph sample in dataset D Store the labeled graph sample in dataset D 8: end for end for 9:end for end for 10:for i=1 I do for i=1 I do 11: Sample a mini-batch of M graph samples from D Sample a mini-batch of M graph samples from D 12: Build padded node features, relation tensors, and graph masks Build padded node features, relation tensors, and graph masks 13: Predict node probabilities, values, and edge probabilities with fθ Predict node probabilities, values, and edge probabilities with fθ 14: Compute node, value, edge, and ranking losses Compute node, value, edge, and ranking losses 15: Update θ by gradient descent Update θ by gradient descent 16:end for end for 17:Tune task-selection thresholds, maximum task count, and per-target task budget on validation episodes Tune task-selection thresholds, maximum task count, and per-target task budget on validation episodes 18:return θ return θ 3.4. Complexity and Method Characteristics Let K˜ be the number of candidate tasks, d the hidden dimension, and Lg the number of graph attention layers. The main cost of the relation-biased graph attention network comes from pairwise task encoding, and a forward pass has complexity(68)O(LgK˜2d). Candidate-graph pruning bounds online inference cost before the network forward pass. The search teacher is used only for offline labeling; its cost is controlled by limiting the search budget, caching future trajectory particles, and applying beam pruning. 4. Experiments and Analysis 4.1. Experimental Setup The experiments are conducted in a two-dimensional adversarial defense area of 1000m×1000m. The blue side consists of a heterogeneous UAV swarm, while red targets approach the boundary using direct penetration, flank maneuvering, electronic jamming, decoy deception, and mixed strategies. UAVs form current belief states from local sensing, communication links, and historical observations; the task generator then outputs task nodes, relation edges, resource requirements, and executability labels. In each episode, the number of targets, observation-missing rate, jamming intensity, decoy ratio, remaining resources, and communication reachability are randomly sampled to avoid overfitting to fixed scripted scenarios. Training uses multiple random seeds. Each seed corresponds to independent initial situations, target-behavior perturbations, and communication-noise sequences. During testing, all methods are evaluated under the same fixed seed set. Distributional experiments further sample different combinations of target scale and observation pressure and report mean, standard deviation, 5% quantile, median, and 95% quantile. The experiments are performed on Windows 11. The neural networks are implemented in PyTorch 2.11.0, with training and inference conducted on an NVIDIA RTX 4090 graphics processing unit (GPU). For paired comparisons, all methods are evaluated on the same scenario seeds and the same generated target-condition sequences. Unless otherwise specified, distributional figures aggregate 1500 final-test task-graph samples. Paired win rates are computed episode by episode or sample by sample under matched conditions. For scalar paired metrics, the Wilcoxon signed-rank test is used because the latency and infeasibility distributions are not assumed to be Gaussian; Holm–Bonferroni correction is applied across pairwise method comparisons. Effect sizes are reported as standardized mean differences, and 95% confidence intervals are estimated by bootstrap resampling over paired samples. In the text, an improvement is treated as practically meaningful only when it is consistent across the primary metrics and does not create an unacceptable latency or infeasibility increase. The experimental results are reported through integrated multi-panel figures that group related metrics by scenario dimension, uncertainty condition, and statistical quantity. Per-seed training traces and intermediate sensitivity plots are excluded from the main text because the primary comparisons are represented by distributional summaries, response surfaces, and paired statistical evidence. The main simulation parameters and their ranges are summarized in Table 5. The experiments are organized along four scenario dimensions: swarm size, target scale, uncertainty level, and computational-time focus. The final-test comparison aggregates standard adversarial episodes with 8∼32 UAVs and 6∼48 targets; the response-surface analysis isolates increasing target scale and observation pressure; the strong-jamming and decoy-deception analyses stress support-edge recovery, belief entropy, false-edge filtering, and tail risk; and the OOD experiment evaluates unseen flank, jamming, decoy, and mixed strategies. The implementation settings for these experiments are summarized in Table 6, while the offline wall-clock costs are reported subsequently. Table 6 reports the implementation-critical settings for the simulator, teacher-labeling process, generator training, evaluation protocol, task manager, and baseline tuning. The wall-clock cost of data collection, teacher labeling, and neural-network training is reported by pipeline stage in Table 7. The table separates workload, wall-clock time, and computing device for the offline preparation pipeline. Online inference latency is reported in Table 8; the subsequent Figures are introduced and discussed in numerical order, beginning with Figure 5. Six classes of metrics are used. Task-graph utility measures the overall value under threat coverage, reward–risk balance, deadline constraints, and resource cost. Task-node F1-score and task-edge F1-score evaluate whether task nodes and relation edges are correctly generated. The executable-graph ratio measures whether a generated graph passes resource, temporal, and logical consistency checks, while the infeasible-task ratio measures the fraction of task nodes that cannot be satisfied by any feasible UAV team. Graph edit distance measures the node and edge changes required to transform a generated graph into the teacher graph. Online generation latency measures the time from receiving the current observation to outputting the task graph. 4.2. Baselines and Adaptation Five strong baselines are selected, with recent applications in task planning, task allocation, or task generation used as references for adaptation. CBBA follows the Clustering-CBBA idea for heterogeneous multi-UAV task allocation [28]; candidate tasks under the current observation are treated as bundle elements, and bids are constructed from reward, distance, and residual resources. Because this family is mainly designed for task allocation, relation edges are completed according to execution order, resource competition, and temporal conflicts. GAT-based generation (GAT-Gen) follows graph-attention-based unsupervised multi-robot task allocation [29]; it takes candidate task nodes and UAV resource embeddings as inputs and outputs task structures through node and edge heads. Graphormer follows the use of GNNs and Transformers in UAV–CAV mission planning [30]; distance encodings, centrality encodings, and relation-type encodings are injected into the candidate graph. Decision Transformer-based generation (DT-Gen) follows the Goal-Conditioned Decision Transformer for multi-objective robot offline reinforcement learning [31]; task graph generation is reformulated as sequence generation conditioned on desired task return, observation embeddings, and historical graph segments. The POMCP-style planner follows constrained POMDP online Monte Carlo tree search (MCTS) [32]; it performs online tree search over the current belief state and uses the resulting high-value task structure as a strong planning reference. All baselines use the same candidate task set, observation input, resource-feasibility checker, and evaluation scripts. If an original method lacks resource constraints or a graph-relation prediction head, only necessary input–output adapters are added. These adapters do not include the proposed multi-step teacher distillation, uncertainty gating, or structural repair mechanisms. 4.3. Training Convergence and Data Efficiency Figure 5 reports training curves for task-graph utility, task-edge F1, executable-graph ratio, unseen-policy utility, loss decomposition, and labeled-data efficiency. Figure 5a–c show that the proposed method rises at a rate comparable to Graphormer and DT-Gen in early training but reaches a higher plateau in the middle and late stages. The final task-graph utility is around 0.85, approximately 3%∼5% higher than the Graphormer training plateau, with similar trends for task-edge F1 and executable-graph ratio. The advantage is traced to the supervision source: while Graphormer captures static candidate-graph relations, it mainly relies on local structural statistics. Under high observation pressure, locally similar geometries correspond to different task meanings. The proposed teacher includes multi-step belief rollout, allowing node and edge labels to reflect future executability rather than the current frame alone. Figure 5d indicates that the proposed method preserves high utility under unseen adversarial strategies. Figure 5e shows simultaneous decreases in node, relation, value, and resource-penalty losses, suggesting stable joint convergence between structural correctness and executability. Figure 5f further shows that the proposed method approaches a high validation utility even with a moderate number of labeled task graphs, demonstrating the high information density of the search-teacher labels. 4.4. Final Performance Distribution and Strong-Baseline Comparison Figure 6 gives the distributional results for task-graph utility, task-node F1, task-edge F1, executable-graph ratio, graph edit distance, and online generation latency. Table 8 summarizes the mean performance. The proposed method reaches an average task-graph utility of 0.851, improving over POMCP by 2.24% and over Graphormer by 5.83%. Its task-node F1 and task-edge F1 are 0.892 and 0.815, improving over Graphormer by 5.52% and 5.41%, respectively. The executable-graph ratio reaches 0.945, while the infeasible-task ratio is reduced to 0.024, corresponding to 25.80% and 33.65% reductions relative to POMCP and Graphormer, respectively. In graph edit distance, the proposed method reduces the distance by 13.90% compared with POMCP and by 20.67% compared with Graphormer. The distributions in Figure 6 show that the proposed method not only improves the mean but also shortens the low-utility tail. POMCP approaches the proposed method in utility, but its average latency is 232.18ms, whereas the proposed method reduces latency by 79.34%. This indicates that POMCP relies on extensive online expansion, while the proposed method compresses planning experience into a neural generator through offline teacher distillation. CBBA and GAT-Gen are faster, but their task-edge F1 and graph edit distance are substantially worse, indicating that fast task selection or local attention alone is insufficient for multi-relation task graphs in adversarial scenarios. 4.5. Response Under Complex Situations Figure 7 compares the proposed method and Graphormer under jointly varying target scale and observation pressure. Figure 7a–c show that both methods degrade as the number of targets and observation pressure increase. This behavior is consistent with partially observable adversarial operation. The proposed method remains above Graphormer over most of the surface, especially in high-scale, high-pressure regions where the executable-graph ratio decreases more slowly. Figure 7d shows that the proposed method is slower than Graphormer but remains far below POMCP, which requires large-scale online tree search. 4.6. Paired Statistical Evidence Figure 8 provides paired statistical evidence through utility win rates, standardized effect sizes, evidence-strength proxies, and latency win rates. The proposed method shows high utility win rates over CBBA, GAT-Gen, DT-Gen, and Graphormer. Its advantage over POMCP is smaller but remains positive, confirming that the improvement does not rely on weak baselines. The effect-size and evidence-strength panels further indicate that the proposed method is most advantageous over conventional task allocation and generic graph generation models, while its advantage over a strong online planner is more moderate. The latency results show a complementary trade-off: CBBA, GAT-Gen, and DT-Gen are faster but structurally weaker, whereas POMCP is structurally strong but computationally expensive. The proposed method achieves near-planner-quality task structures at neural-generator-level latency. 4.7. Teacher Budget, Prediction Horizon, and Data Efficiency Figure 9 analyzes the influence of teacher search budget, labeled data size, and prediction horizon. As the search budget increases from 8 to 256, validation utility first rises rapidly and then saturates. The horizon H=6 performs best overall; H=4 is slightly lower, while H=8 does not yield stable additional gains at high budgets. Increasing labeled task graphs improves all learning methods, but the proposed method reaches the high-utility region with moderate data. These results show that the teacher must provide causal supervision over a suitable horizon. Short horizons miss future values of support, suppression, and confirmation tasks, whereas overly long horizons mix multiple possible futures and make the teacher labels more dispersed. 4.8. Uncertainty Modeling and Success-Rate Correlation Figure 10 visualizes the relation among prediction confidence, belief entropy, and true success rate under clean observation, moderate noise, strong jamming, and unseen mixed strategies. In this experiment, belief entropy refers to the normalized Shannon entropy of the target-mode belief. For target ej, it is computed as(69)Hjπ(t)=−1log|M|∑m∈Mπj,m(t)logπj,m(t)+ϵH, where πj,m(t) is the belief probability of mode m, |M|=4, and ϵH is a small numerical constant. The sample-level belief entropy used in Figure 10 is the mean over active targets,(70)Hb(t)=1Mt∑j=1MtHjπ(t). Thus, Hb(t)∈[0,1] in the normalized case; larger values indicate more ambiguous target-mode beliefs and therefore greater uncertainty in task selection. Under clean observations, both the proposed method and Graphormer produce compact point clouds, but the proposed method achieves higher success rates in high-confidence regions. As noise and jamming increase, Graphormer’s point cloud spreads, and some high-confidence samples correspond to low success rates, indicating overconfidence. The proposed method also becomes more dispersed, but high-entropy samples are assigned lower confidence more clearly, preserving a better monotonic relationship between confidence and success rate. This behavior is caused by uncertainty gating and resource-feasibility checking: uncertain nodes tend to be routed to confirmation, tracking, or communication-support tasks rather than high-risk interception tasks. 4.9. Candidate Graph Complexity Figure 11 analyzes how candidate relation edges affect structural quality and online cost. As the number of candidate edges increases, all methods experience higher latency and lower task-edge F1 and executable-graph ratio. POMCP is most sensitive because the branching factor of its search tree grows rapidly with relation combinations. Graphormer grows more mildly in latency, but its task-edge F1 drops more sharply in high-complexity regions. The proposed method also becomes slower as complexity grows, yet its samples remain concentrated in regions with a higher task-edge F1 and lower infeasible-task ratio. This suggests that the main difficulty of task graph generation lies not only in the number of nodes but also in the combinatorial explosion of relation edges. 4.10. Generalization to Unseen Adversarial Strategies Figure 12 evaluates task graph generation under red-side strategies unseen during training. Flank maneuvering and strong jamming reduce both task-graph utility and task-edge F1, while mixed strategies produce the widest distributions, indicating larger structural uncertainty. The proposed method maintains better distributions because task generation is conditioned on belief states that include target motion, communication quality, decoy credibility, and resource margins. When an unseen strategy appears, the generator first detects changes in observation residuals and belief entropy and then reconstructs the graph by adjusting task types and relations. For example, strong jamming encourages communication recovery and target confirmation, while flank maneuvering increases lateral interception and preceding reconnaissance relations. 4.11. Tail Risk Figure 13 uses empirical cumulative distribution functions to analyze the generation loss, infeasible-task ratio, structural failures, and minimum defense margin. The proposed method shifts the curves in Figure 13a–c to the left, indicating fewer episodes with high loss, a high infeasible-task ratio, and many structural failures. In Figure 13d, it accumulates faster in larger defense-margin regions, suggesting that it retains more safety buffer in difficult episodes. The reduction of tail risk stems from the suppression of bad structures. Severe failures in adversarial scenarios are often triggered by a few erroneous edges, such as linking decoy confirmation directly to fire interception or generating high-bandwidth task chains under communication disruption. Explicit resource-margin checks, precedence reasoning, conflict edges, and repair of high-uncertainty edges reduce the chance that a local relation error propagates into an infeasible graph. 4.12. Ablation Study Figure 14 compares the full model with five ablation variants: removing the multi-step teacher, relation bias, uncertainty module, resource constraints, or edge repair. Removing the multi-step teacher reduces task-graph utility from about 0.842 to about 0.790, showing that one-step supervision cannot sufficiently encode the effect of current task structures on future execution. Removing relation bias causes the largest drop in task-edge F1, from about 0.812 to about 0.410, confirming that node recognition and relation recognition are distinct problems. Removing the uncertainty module decreases both utility and edge F1 and increases the infeasible-task ratio, indicating that belief entropy is important for difficult and ambiguous samples. Removing resource constraints raises the infeasible-task ratio to about 0.135, more than five times that of the full model. Removing edge repair causes a milder utility decrease but still increases infeasibility, showing its role in local conflict removal and tail-risk control. 4.13. Task Graph Visualization Figure 15 visualizes teacher graphs, Graphormer outputs, and the proposed outputs under moderate pressure, strong jamming, decoy deception, and flank maneuvering. Under moderate pressure, Graphormer tends to miss support edges, breaking task chains that require communication or confirmation prerequisites; the proposed method reaches a task-edge F1 of about 0.91. Under strong jamming, Graphormer produces relay-chain breaks and obtains a task-edge F1 of about 0.58, while the proposed method restores communication-support relations and increases the score to about 0.87. In decoy-deception scenarios, Graphormer often creates false edges pointing to decoy nodes, whereas the proposed method filters part of these relations through uncertainty and resource-feasibility checks. Under flank maneuvering, Graphormer creates cross-sector erroneous links, while the proposed method tends to preserve separation between different defensive sectors. 5. Limitations and Future Validation The results should be interpreted within the scope of simulation-based evaluation. The simulator includes partial observability, noisy sensing, jamming, decoy behavior, heterogeneous UAV resources, and structural task dependencies, but it does not fully reproduce real flight dynamics, airspace regulations, hardware failures, localization drift, packet-level communication protocols, or safety-certification constraints. The current resource model is also intentionally compact and uses additive consumable-resource accounting, while real missions exhibit nonlinear resource interactions, synergy, contention, and sequence-dependent costs. Consequently, the reported advantages demonstrate observation-conditioned task graph generation under controlled adversarial simulations, rather than direct evidence of operational deployment readiness. Future validation should therefore proceed in stages. First, measured communication, localization, and energy-consumption traces will calibrate the simulator and replace simplified resource-cost terms. Second, hardware-in-the-loop experiments will test whether the generated precedence, support, and conflict relations remain executable under real onboard computation and communication delays. Third, real or semi-real flight data will evaluate whether belief entropy, uncertainty gating, and task repair remain reliable when the observation model is affected by sensor bias, weather, and platform-specific payload constraints. 6. Conclusions This paper proposed a task graph generation method for heterogeneous UAV swarms in partially observable adversarial environments. The method converts local observations, target beliefs, and platform resources into task graphs with explicit task relations and resource semantics. By combining an offline search teacher, a relation-biased graph attention generator, and an online task manager, it generates task structures that are semantically coherent and executable in the considered simulation setting. The proposed resource-constrained task graph unifies task types, deadlines, resource requirements, and precedence, support, and conflict relations, enabling generated tasks to reflect both situational demand and execution constraints. The offline search teacher converts future trajectory information, resource feasibility, and structural value into node and edge supervision, reducing the short-horizon limitation of rule-based triggers. The relation-biased graph attention network then learns a fast mapping from candidate task graphs to executable task graphs, supporting online use in the simulator at substantially lower latency than online tree search. Simulation results show that the proposed method improves task-graph utility, relation prediction, and executability over the compared graph generation baselines. It achieves task-graph quality close to that of POMCP while greatly reducing online generation latency. These findings show that task graph generation serves as a useful front-end task organization mechanism between situation perception and cooperative execution in heterogeneous UAV swarm simulations. Further real-flight and hardware-in-the-loop validation is required before making stronger claims about deployment under hardware, communication, localization, or safety constraints.