Classical STRIPS planning searches over actions that change a state. Hierarchical Task Network planning adds abstract tasks and methods. A method does not execute; it explains how an abstract task can be replaced by a network of lower-level tasks subject to ordering constraints. The hierarchy can carry domain knowledge that makes otherwise huge searches tractable.

Time complicates the object. Every non-instantaneous action has a start and an end. Preconditions may be required at the start, the end or throughout an interval. Effects occur at particular endpoints. Actions may overlap, and overlap may be optional, beneficial or logically necessary.

The authors organise this expressiveness using Cushing’s three categories. Category one admits only sequential solution plans. Category two permits concurrency but also admits at least one sequential plan. Category three contains problems for which every valid solution requires concurrency. A planner that serialises all action interactions can address the first two categories but not the third.

Chronicle planners keep temporally indexed proposition values and refine constraint-rich timelines. They are expressive, including for necessary concurrency, but heuristic guidance can be weak because each partial object already carries substantial temporal machinery. State-space compilations can use mature classical heuristics, yet often restrict the solution language.

HTEP seeks an intermediate point. It keeps a flexible plan-space representation and temporal constraints, but conducts the structural search through non-temporal snap actions and POCL flaws. Only when a partial plan has no unresolved flaws does a CSP solver find timestamp assignments. The research question is whether this relaxation exposes useful non-temporal HTN guidance without destroying too much temporal meaning.

A snap action is a classical action tuple: a name, a set of preconditions and positive or negative effects. It occurs at one time point, so its start and end coincide. Preconditions hold strictly before that point; effects hold afterwards. A snap action refines a task when their names match.

A durative action contains named start and end snap actions, a set of invariant propositions and a strictly positive duration d. Its start and end variables satisfy v_end−v_start=d. The invariant must hold after the start event and until the beginning of the end event: the open interval between them.

An abstract task does not itself alter the state. A method maps it to a set of subtask symbols and qualitative temporal constraints among their start and end points. The point-algebra relations admitted include <, ≤, >, ≥, = and ≠. The parent’s bounds enclose the starts and ends of its children during refinement.

A partial temporal plan is π=(T, α, C, L): task symbols T; a mapping α from symbols to task names; temporal ordering constraints C; and causal links L. A causal link t_i: p→ t_j says the provider’s effect p supports the needer’s precondition p, with t_i ordered before t_j.

The initial partial plan contains two special snap actions. t₀ has the initial state as effects and no preconditions. t∞ has the goal as preconditions and no effects. Search refines everything between them until every task is a snap action, every precondition is supported, every threat is resolved and every time variable receives a consistent value.

Suppose method m refines abstract task t. The refined task set removes t and inserts the method’s subtask symbols. The new mapping keeps every old symbol except t and adds the method’s symbol-to-name assignments. Existing causal links remain; later search must support any new open preconditions.

The constraint set gains all method constraints. It also connects the parent interval to each child: the parent start is no later than every child start, and the parent end is no earlier than every child end. A start-before-end relation is kept for the parent boundary. The abstract symbol can therefore remain as a temporal envelope even though its executable content has been replaced.

This is plan-space refinement rather than forward execution. Search does not commit to one total order or simulate a single state after every step. It accumulates only those orderings needed by the method, causal support, threat repair and temporal consistency.

Different methods create branches. “Survey” might decompose into Move, Calibrate, Scan and Transmit, or into Move, QuickScan and Return. Plan-selection heuristics rank the resulting partial plans. Flaw selection then chooses which unresolved obligation inside the chosen plan to repair next.

Hierarchy often supplies useful ordering that a chronicle solver would otherwise derive from richer temporal constraints. This helps explain the paper’s empirical observation: although a chronicle can reject some temporally impossible partial refinements earlier, many benchmark failures arise from non-temporal flaws, and HTN methods already encode much of the necessary order.

For durative action a, the task symbol is replaced by v^s_a and v^e_a, mapped to start(a) and end(a). The constraint set gains v^s_a<v^e_a and v^e_a−v^s_a=d. These are retained for the timestamp CSP.

The invariant propositions are added to the preconditions of both endpoint actions in the authors’ compilation. For each invariant p, a causal link start(a): p→end(a) protects p over the interior. Any snap action that deletes p and could fall between the endpoints becomes a causal threat.

Threat resolution orders the deleter before the start or after the end. In this way a familiar POCL mechanism guards a temporal interval. The structural search can reason with provider, needer and threat relations without continuously solving a complete chronicle.

The relaxation is not an erasure of time. Exact duration constraints, method relations and added ordering constraints accumulate in C, and consistency is checked during refinement. At a flaw-free candidate, a CSP assigns all temporal variables. A structurally valid branch with no timestamp solution is rejected.

Yet the placement of invariants creates the expressiveness boundary. For necessary concurrency, an invariant may need to become true immediately after the start event through another concurrent action. Treating it as a precondition of start requires it too early. The compilation can therefore exclude valid category-three plans.

An open-precondition flaw occurs when a snap action requires p but no causal link supports it. A repair selects a preceding snap action that produces p and adds the link and necessary order. Existing actions can be reused when consistent.

A causal-threat flaw occurs when an action deletes p and remains unordered with respect to a link protecting p from provider to needer. The repair either promotes the threat before the provider or demotes it after the needer, provided the new temporal constraints remain consistent.

A decomposition flaw is an abstract task still awaiting a method. Each applicable method supplies a possible repair and branches the plan space. The resulting subtasks may themselves be abstract or durative, so one repair can introduce several future flaws.

A durative flaw is a durative action still represented as an unresolved task. Repair compiles it into start and end snap actions, adds exact-duration constraints and installs invariant causal links. The structural plan grows while temporal commitments remain partial.

Every flaw must eventually disappear, but order affects effort. A flaw with one possible resolver is attractive because failure is discovered without expanding several branches. The FAPE-inspired policy refines least-cost flaw repair by prioritising unresolved tasks and preconditions, giving the search hierarchy and causality early attention.

The initial plan π₀, bounded by t₀ and t∞, enters an open list. A plan-selection heuristic chooses which partial plan to explore. HTEP computes its flaws. If any remain, the flaw-selection heuristic chooses one and every consistent repair produces a successor plan added to open.

If no flaws remain, HTEP asks a CSP solver for values of all time variables satisfying C. A successful assignment returns the partial plan and timestamps. If the CSP fails, that structurally complete candidate is discarded and search continues with another plan.

The separation creates two decision layers. Plan selection controls which branch of the refinement tree receives attention, directly affecting performance and which solution quality is reached first. Flaw selection controls local branching within the chosen plan. Because every flaw must eventually be repaired, the authors say admissibility depends on plan selection, while flaw order still strongly affects runtime.

Constraint consistency is not necessarily postponed entirely to the leaf. Qualitative temporal constraints can be checked through the associated constraint graph; the paper notes polynomial-time consistency checking through strongly connected components for the relation set it defines. The final CSP nevertheless supplies concrete timestamps.

Failure of open means no solution exists within HTEP’s representation and search policy assumptions. It does not prove that a category-three plan is impossible in the original temporal domain, because compilation may have removed necessarily concurrent solutions before search began.

A plan-selection heuristic chooses among partial plans in open. The most elementary POCL signal is the number of open conditions. Task Decomposition Graphs enrich that signal by summarising which tasks and conditions must eventually appear under possible method refinements.

The paper describes h_TC as the cardinality of mandatory tasks expected in the decomposition and combines it with the number of flaws, producing h_#F+TC. It also describes h_MME, an estimate of modifications needed to reach a solution, and h_TDGm, a refinement that accounts for causal links already introduced.

A third plan score, h_FAPE, is taken from the FAPE chronicle planner and estimates remaining effort. Using it in both the temporal-event and chronicle representations creates the most direct representational comparison: HTEP+h_FAPE and Chr+h_FAPE differ principally in the constraints their search states carry.

Flaw selection is held common across the experimental configurations: the FAPE policy, described as a refinement of least-cost flaw repair. LCFR prioritises flaws with the fewest resolvers. FAPE’s ordering additionally gives priority to unrefined tasks and preconditions. This control matters because a different flaw policy could overwhelm the effect of plan scoring.

The article’s notation is not perfectly stable. The prose first defines h_#F+TC, while the experimental configuration is printed as h_#F+PC and the small figure label appears to contain an additional term. A faithful reading should flag that editorial ambiguity rather than invent a definition for the changed letters. The robust claim is about the flaw/task-decomposition-count family.

The configurations are HTEP+h_TDGm, HTEP with the flaw/task-count TDG family, HTEP+h_FAPE, and Chr+h_FAPE. The chronicle planner is encoded to mimic FAPE’s behaviour. All use the same FAPE-derived flaw-selection heuristic and the same CSP solver, reducing implementation asymmetry.

Problems are written in HDDL 2.1. Gripper is category one and sequential. Satellite is also category one but offers different sequential makespans. Rover is category two: concurrent solutions may improve duration, yet a sequential solution exists. Area Scan permits extensive cooperation and optional concurrency. No category-three benchmark appears because HTEP’s compilation cannot represent necessary concurrency.

Runs use one core of an Intel Core i7-9850H, at most 8 GB of RAM and a 600-second limit. Solving time covers instantiation through solution. Makespan is the time from the initial state to the final task endpoint. Both are converted to International Planning Competition-style scores, so larger bars mean better relative performance rather than raw seconds or raw plan length.

The prose says “three indicators” but lists solving time and makespan, two items. Figure 3’s caption says “five configurations” although the text enumerates and the chart displays four. These appear to be editorial slips. They do not justify creating a hidden metric or planner; a careful reconstruction keeps the observable design at two measures and four configurations.

The paper states that code and benchmarks would be made freely available if accepted. That statement is a reproducibility intention, not evidence in this reconstruction that an archived release was inspected. The present companion therefore assesses the reported design and figure without claiming an independent rerun.

Across every domain and compared under h_FAPE, HTEP’s solving-time score exceeds the chronicle counterpart. The authors attribute this to simpler non-temporal constraints and flaws. A chronicle can reject temporally impossible refinements earlier, but in these HTN domains method structure supplies much of the necessary order and non-temporal flaws dominate rejection.

The two classical HTN-guided HTEP configurations are the strongest time performers across the plotted domains. The flaw/task-count family is especially strong on Rover, while h_TDGm leads on the others. The authors emphasise that heuristic informativeness depends on the domain definition; there is no globally dominant formula independent of modelling choices.

For makespan, Chr+h_FAPE is generally strongest. Its fuller temporal representation can break ties between plans of equal heuristic value by preferring the schedule with better makespan. HTEP remains competitive in several domains, so the relaxation does not automatically force serial plans.

Rover exposes the cost of using refinement effort as a surrogate for temporal quality. HTEP+h_TDGm has the weakest makespan score there because it seeks a plan requiring fewer refinements regardless of resulting duration. A structurally economical plan can schedule poorly.

Area Scan needs special caution. The paper notes that one configuration’s apparently superior makespan score is partly caused by other configurations failing to solve some instances, which changes the score aggregation. Coverage and quality are entangled. A complete comparison should publish per-instance solving, raw time, raw makespan and coverage beside aggregate scores.

In category one, only sequential solutions exist. The compilation is well aligned with the domain because every required relation can be realised without overlap. In category two, overlap may shorten the plan but serial execution remains possible. HTEP can still find a solution and may preserve useful optional concurrency through partial order.

Category three is different. Some temporal condition forces overlap: no sequential plan exists. Cushing’s examples show why endpoint-only compilations are delicate. An invariant is semantically required just after the start, not necessarily strictly before it. Another action beginning at the same time may establish the condition in the interval.

HTEP adds the invariant to the start event’s preconditions. The provider must therefore precede the start under POCL causality. If the domain requires the provider to begin only after or simultaneously with that start, the compiled problem becomes inconsistent although the original temporal problem has a valid necessarily concurrent schedule.

This is not a bug discovered by the companion; it is the limitation named in the paper’s Discussion and Conclusion. The authors propose improving compilation to admit the third category. Until then, “temporal HTN planner” should be qualified: HTEP produces partial temporal plans for the first two categories represented by its compilation.

The boundary explains part of the speed advantage. A representation that excludes some interactions can search fewer possibilities and use cheaper heuristics. Efficiency and expressiveness are not independent axes; the experiment compares methods over the shared fragment, not over the entire language available to chronicles.

Gripper-style sequence orders Carry before Drop. Its schedule is category one: added serialisation changes nothing because the task order is already total.

Rover optional concurrency lets Move and Calibrate begin together, requires both before Scan, and requires Scan before Transmit. The earliest partial order overlaps the independent tasks. Safe serialisation remains valid but increases makespan, modelling a category-two choice.

Protected invariant places Reset before Observe and Archive afterwards. Reset deletes the fact stable, but its endpoint occurs outside Observe’s protected interval. The causal-threat audit therefore passes. Moving Reset inside would be a flaw requiring promotion or demotion.

The scheduler is an exact longest-path oracle for these acyclic precedence networks, not the historical planner. HTEP permits general point-algebra relations and delegates timestamp assignment to a CSP. The artefact isolates the paper’s core separation: a structural task network becomes event pairs, then receives a concrete time assignment.

Implement the formal objects exactly: snap, durative and abstract tasks; start and end variables; method constraints; the partial-plan tuple; causal links; threat semantics; and the two special boundary actions. Check that method refinement preserves parent bounds and that durative refinement adds both exact duration and invariant protection.

Reproduce the four visible configurations with the same CSP solver, grounding, open-list policy, FAPE flaw selection and stopping limits. Resolve the paper’s h_#F+TC/h_#F+PC notation from source code or author clarification before naming a fifth formula. Do not infer a fifth configuration from the figure caption.

Publish raw per-instance wall time, instantiation time, search nodes, CSP calls, coverage, makespan and IPC score. Report timeout and memory censoring. Aggregate quality only over a clearly stated common solved set, or show coverage alongside the conditional quality score so failure cannot improve the apparent average.

Include category-three tasks as a separate expressiveness suite. Failure there is expected under the published compilation and should not be blended anonymously with search time. For categories one and two, include method encodings with strong and weak ordering knowledge to test the authors’ explanation that hierarchy supplies temporal constraints before chronicles can exploit them.

Finally, ablate the representation and heuristic independently: HTEP and chronicle under h_FAPE; multiple plan scores inside HTEP; and temporal lower-bound tie-breaking added to HTEP. This factorial design reveals whether speed comes from cheaper nodes, better ranking, narrower expressiveness or their interaction.

Review one: scholarly fidelity and teaching. The reconstruction was checked against the seven-page primary source page by page. It preserves the three task kinds, the partial-plan tuple, the two refinement equations, four flaw types, open-list algorithm, two-stage structural/temporal logic and the category-three limitation. Each diagram is a new explanatory abstraction rather than a reproduction.

The main teaching risk was saying that HTEP “removes time”. It does not: duration and ordering constraints remain, consistency is checked and a timestamp CSP gates success. The page therefore uses “relaxation” and “defer concrete assignment”, and repeatedly distinguishes POCL causal closure from temporal executability.

Review two: evidence, language and accessibility. The empirical claims were limited to the four plotted configurations and four domains, with hardware, resource cap and IPC interpretation retained. The article’s “three indicators”/two-item list and “five configurations”/four-item chart inconsistencies are disclosed. No raw numerical value is reverse-engineered from chart pixels.

The strongest headline: HTEP outperforms chronicles on solving time: is paired with the chronicle makespan advantage, Rover exception, Area Scan coverage caveat and missing category-three tests. Prose was checked for inflated certainty and generic AI transitions. Figures have titles, descriptions and captions; controls are labelled; animation honours reduced-motion preferences; the laboratory publishes exact invariant tests.

Kambhampati’s dynamic-CSP reading of Graphplan translated planning extraction into a neighbouring formalism so that explanation-based learning and dependency-directed backtracking could be imported. Cavrel, Pellier and Fiorino likewise translate temporal HTN planning into event-based POCL structure so that non-temporal HTN heuristics can guide refinement.

Both papers treat representation as computational leverage. In Graphplan, smaller causal no-goods prune future branches. In HTEP, a relaxed structural state is cheaper to rank than a full chronicle. In both, the gain is bounded by what the abstraction omits: coupled causes limit memo generality, while necessary concurrency limits event compilation.

Canon 0088, Soutchanski and Young’s “Planning as Theorem Proving with Heuristics”, moves the translation again: this time into proof search. The sequence therefore traces a general research strategy: recast planning in a formal system with mature guidance, then audit whether the imported heuristic respects the original problem’s semantics.

This architecture works when the relaxed state contains signals correlated with final feasibility. The experiments suggest that in the selected HTN domains, method knowledge and non-temporal flaws do most of the discriminating work. Classical HTN heuristics can therefore direct search before full temporal structure earns its cost.

The trade-off is asymmetric. A chronicle remembers more and can improve makespan or express necessary concurrency, but pays for a richer search object. HTEP remembers less and searches faster, but no heuristic can recover schedules the compilation cannot express. Relaxation is a hypothesis about which details can safely wait.

The enduring lesson is not that time should always be postponed. It is to locate the earliest representation that preserves the causes of failure relevant to the objective. For time-to-first-plan in categories one and two, temporal events may suffice. For optimal makespan or required overlap, temporal information must enter guidance earlier.