A classical plan chooses actions that transform an initial state into one satisfying a goal. An HTN plan carries additional knowledge: a compound task such as inspect a remote site is not executed directly but refined by a method into preparation, travel, measurement and reporting subtasks. Methods encode acceptable ways of accomplishing work, not merely facts that should eventually become true.

Real deployments need more than an ordered list. A drone can warm a sensor while a communication link is established; two robots may lift together; a diagnostic process must remain powered throughout calibration; a report can start only after every measurement ends. Duration, overlap, synchronisation and resource-related numerical conditions are part of the problem. Different temporal-HTN planners historically used different input languages, making models and results difficult to exchange.

HDDL emerged from community discussion around the first hierarchical track of the 2020 International Planning Competition. It extended PDDL with tasks and decomposition methods, but left temporal and numerical features out to keep the first language and tool effort manageable. PDDL 2.1 already supplied a vocabulary for durative actions and numeric resources, yet it had no HTN methods. Joining the two requires more than concatenating grammars: decomposition must preserve temporal scope and execution must explain what happens when boundaries coincide.

The 2023 report takes inspiration from PDDL 2.1 and ANML, offers formal definitions for a temporal HTN core, points to an open-source repository with proposed syntax and benchmarks, and mentions parser work in PDDL4J. Its explicit aim is to open discussion towards a future standard. The paper itself later says it does not explicitly report the full syntax and omits or leaves underspecified several features. Its contribution is best read as a carefully exposed semantic draft.

The language contains constants for objects, variables and predicates. Formulae are built from predicates, negation, disjunction, conjunction and quantifiers. Because there are no function symbols and the object set is finite for grounding, quantified formulae can be expanded into finite propositional combinations: a universal becomes a conjunction over constants and an existential becomes a disjunction.

A state is a set of ground predicates and is read as a Herbrand interpretation: listed atoms are true and unlisted atoms false. This is a conventional closed-world planning state. A planning domain then contains the logical language, tasks, task identifiers, a mapping from identifiers to tasks, actions and methods. The planning problem adds an initial state, an initial temporal task network and a goal formula.

Task identifiers deserve attention. A network may contain two occurrences of inspect(?site) with the same arguments but different temporal roles. Treating the task name as the node would collapse them. An arbitrary identifier labels each occurrence, while a mapping says which task it denotes. Ordering and duration constraints attach to the occurrence through its identifier.

The paper defines semantics on ground instances, treating the lifted input as a compact description. Parameter constraints are discharged by grounding. This choice keeps execution definitions readable, but it leaves practical grounding strategy to established HTN work. It also means a syntactic model can be small even when its fully grounded network is large.

A snap action contains a name, a first-order precondition and disjoint positive and negative effects. It has zero duration for semantic purposes: preconditions are inspected and effects applied at one happening event. Snap actions are primitive tasks in their own right and also serve as the boundaries of durative actions.

A durative action contains its name, a start snap action, an end snap action, an invariant and a duration δ. Executing the start checks its precondition and applies its effects. While the action is open, the invariant must hold at relevant states. At the closing boundary, the end snap checks and changes state. The duration locates the end relative to the start.

This structure separates three obligations that are easy to blur. A start condition concerns the instant before the action opens. An invariant constrains the interval after the start and before the end. An end condition concerns the closing instant. An effect at one boundary does not automatically persist unless the state transition and later actions preserve it.

The formal core uses natural-number start dates and durations. A footnote contrasts this with PDDL 2.1’s rational dates and warns that unrestricted rationals can make planning undecidable. Integer time is therefore a simplifying semantic choice, not a claim that physical systems only change at whole seconds. Later, the discussion explicitly reopens the choice between constant and variable time sampling.

A method is a triple: a name, the compound task it refines, and the temporal task network that performs the refinement. Several methods may refine the same task, representing alternative operational strategies. Introduced subtasks may themselves be compound, so decomposition repeats until every remaining occurrence is primitive.

A temporal task network pairs a set of task identifiers with four constraint sets. Qualitative ordering constraints compare the start or end events of occurrences using the point-algebra relations <, ≤, >, ≥, = and ≠. Parameter constraints equate or distinguish variables and constants. Duration constraints restrict task durations. Temporal decomposition constraints require a state formula at a specified event date.

The network is a multiset in effect: identifiers allow the same task to occur more than once. It is ground when every variable has been bound to a constant and primitive when every referenced task is carried out by a snap or durative action. Partial order allows concurrency wherever the constraints and execution semantics permit it; the method does not need to decide a total sequence.

A compound task is also associated with start and end events even though it has no direct action effects. These events delimit the temporal scope into which its method’s subtasks are placed. Decomposition replaces the selected compound occurrence, unions the method’s parameter, duration and state constraints with the parent network, and adds ordering relations that keep the replacement within the relevant temporal envelope.

A temporal sequence assigns each ground task a natural-number starting date and duration. Collect every start date and every end date e+δ, remove duplicates and sort the result. These dates are the plan’s happening events. Several action boundaries may belong to the same happening, which is how concurrency enters the state-transition semantics.

A sequence is primitive only when every task is carried out by an action. Compound tasks do not have intrinsic bounded durations: their realised span depends on whatever subtasks their selected methods introduce and how those subtasks overlap. A primitive duration, by contrast, comes from the action definition.

The representation distinguishes a task occurrence from its boundary events. A durative occurrence contributes a start snap to one happening and an end snap to another. A zero-duration snap contributes one boundary. The state trajectory advances from happening to happening rather than once per listed task.

This event-based view makes simultaneous effects explicit. If one action ends exactly when another begins, both boundary snaps belong to the same set. Their compatibility must therefore be checked together, not by inventing a favourable micro-order. That choice matches the parallel-step spirit used in PDDL temporal semantics.

At happening date e, collect the start snaps of actions beginning there and the end snaps of actions closing there. Also collect invariants of durative actions whose start is strictly earlier and end strictly later. The incoming state must satisfy every boundary precondition and every active invariant.

Boundary actions at the same date must be pairwise non-interfering. The paper states four symmetric tests: neither action’s preconditions may overlap the other’s positive or negative effects, and neither action’s positive effects may overlap the other’s negative effects. This excludes concurrency whose meaning would depend on an order hidden inside the instant.

If the gates pass, all negative effects are removed from the incoming state and all positive effects added. The combined update creates the next state. Because every snap reads the same incoming state, one simultaneous action cannot use a fact another adds at that happening. The sequence repeats across sorted dates.

The invariant set excludes an action exactly at its own start and end, because its boundary preconditions handle those instants. At interior happenings, the invariant is checked in the incoming state. The paper’s model evaluates states at happenings; it does not fully specify continuous change between them. This becomes one of its stated open questions about sampling and interval semantics.

A temporal task network is executable when there exists an executable temporal sequence using exactly its task identifiers and satisfying its qualitative ordering, duration and state-at-time constraints. Parameter constraints have already been handled during grounding. This existential schedule turns a partially ordered network into a dated witness.

Decomposition selects an occurrence whose task matches a method’s compound task, removes that identifier and inserts the method network’s identifiers. Constraint sets are unioned. Additional temporal relations align the earliest and latest boundaries of introduced subtasks with the replaced occurrence’s temporal scope. Repeated decomposition grows a constraint history while eliminating compound nodes.

A solution network must be reachable from the initial network by a sequence of such method applications. It must be executable from the initial state, and the resulting temporal state sequence must reach a state satisfying the goal. A primitive network that executes but cannot be obtained from the declared hierarchy is not a solution; a properly decomposed network with no legal schedule is not one either.

This two-witness structure: decomposition sequence plus executable schedule: is the conceptual core of temporal HTN planning. The hierarchy constrains which plans count as acceptable ways of doing the work. The temporal state semantics constrains whether those ways can actually happen.

Given a ground primitive schedule, execution produces a temporal sequence of states indexed by happenings. A decomposition constraint of the form (at e φ) requires formula φ in the state associated with the specified in-scope event date. Each referenced event must belong to the temporal scope of the network, preventing a method from imposing conditions on arbitrary dates outside its decomposition.

The authors distinguish temporal decomposition constraints inspired by PDDL 3 trajectory constraints from classical HTN constraints such as before, after and between. They suggest retaining PDDL 3-style syntax and semantics for consistency across the language family. Classical method preconditions and interval constraints can be expressed in terms of event-pinned state formulae.

An at start condition attaches to the opening boundary, at end to the closing boundary and overall to relevant states throughout the task. Before, after and between constraints relate state conditions to task events or the region between them. Rewriting these into a common primitive form gives validators one semantic target.

The account is intentionally preliminary. The five-page paper sketches how the families align rather than publishing a complete production grammar and validation algorithm. Its value is to make the semantics discussable: every surface construct should say which event or interval it denotes and which state is tested.

ANML can place effects at intervals inside an action. The authors suggest representing intermediate effects in HDDL 2.1 by splitting one action into separate durative actions and constraining their relationship. This provides a possible encoding, but it changes model granularity and may be verbose. A future standard must decide which interval constructs deserve direct syntax.

Some planners delay ordering constraints. A model may require an action to occur at least a specified time after another ends. The proposed core can simulate such a gap with an auxiliary primitive task of the desired duration and no effects. Again, simulation shows expressibility but not necessarily desirable authoring practice. The paper explicitly says point-algebra delays are not directly allowed.

Time sampling is open. Constant sampling divides time into regularly spaced steps. Variable sampling creates points when preconditions or effects matter, and may use a Simple Temporal Problem to manage difference constraints. Interval Temporal Logic offers another route when truth should be defined over intervals rather than points. These choices affect expressivity, decidability, validation and implementation.

For fuller compatibility with PDDL 3, axioms and preferences would need semantics, parsing and validation support. Continuous effects are not detailed. Numerical expressions motivate the extension and appear in the repository ambition, but the report’s formal definitions primarily establish temporal task-network semantics. The authors call the work a baseline for the community to build upon.

Its strongest contribution is the integrated account of tasks, methods, start and end boundaries, partial temporal order, decomposition-state constraints, concurrent happenings and goal-reaching execution. Eleven definitions take a reader from a lifted domain to a solution network. The account also shows where PDDL 2.1 semantics can be reused and where hierarchy requires new rules.

The public repository, example syntax, benchmarks and PDDL4J parser direction give the discussion an implementable centre. Yet the report contains no empirical planner comparison and no validation experiment. It does not establish complexity bounds or prove equivalence to every existing temporal HTN language. It proposes a basis on which such work and community standardisation can proceed.

For practitioners, the paper offers a model-review checklist. Does every repeated task have a distinct occurrence identifier? Are compound tasks refined until primitive? Do dates satisfy method constraints? Are simultaneous boundaries non-interfering? Are active invariants true at every represented happening? Does the final trajectory satisfy both decomposition constraints and the goal? These questions travel across planner implementations.

In the canon, Paper 0108 follows two other semantic bridges. Paper 0106 joined logical choices to continuous numeric constraints; Paper 0107 compiled open-world ontology queries into a closed-world planner. Here the bridge joins hierarchical intent to temporal execution. Paper 0109 will push time further, using interval-logic satisfiability for autonomous-system planning.