Paper deep dive
Dynamic Haven Selection for Multi-Agent Pickup and Delivery in Constrained Warehouses
Taisei Hirayama, Kohei Yoshida, Hiroki Sakaji, Itsuki Noda
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 94%
Last extracted: 8/28/2026, 2:55:12 AM
Summary
The paper introduces A-sharp (Adaptive SHARP), a dynamic Haven selection method for Multi-Agent Pickup and Delivery (MAPD) in constrained warehouse layouts. Unlike the prior SHARP method which uses fixed initial positions as retreat Havens, A-sharp allows agents to dynamically select nearby available Havens as retreat targets at task assignment time. To prevent collisions and deadlocks caused by naive switching, A-sharp employs an availability test checking both exclusive ownership and future path reservations, along with a pending-release rule that protects the previous Haven until the agent departs. The authors prove invariant preservation and finite-release completeness. Experimental results across 72,000 runs show A-sharp significantly improves makespan compared to SHARP in most configurations.
Entities (6)
Relation Signals (7)
A-sharp → solves → MAPD
confidence 98% · Dynamic Haven Selection for Multi-Agent Pickup and Delivery... We present A♯ sharp... a dynamic Haven selection method
A-sharp → extends → SHARP
confidence 95% · We present A♯ sharp (Adaptive SHARP...), a dynamic Haven selection method... The Safe HAven Retreat Planner (SHARP) introduced a mechanism...
A-sharp → uses → availability test
confidence 95% · A-sharp prevents these failures with an availability test for candidate Havens and a pending-release rule
A-sharp → uses → pending-release rule
confidence 95% · A-sharp prevents these failures with an availability test for candidate Havens and a pending-release rule that keeps the previous Haven protected until the agent departs.
A-sharp → improves → Makespan
confidence 94% · A-sharp significantly better in 107 configurations... on the tested tree map, the median reduction is 16.7%.
SHARP → uses → fixed Havens
confidence 93% · fixed-Haven commitments can send agents toward distant Havens after deliveries... SHARP reserves... retreat path to the agent’s dedicated initial position.
A-sharp → uses → SIPP
confidence 92% · Under explicit Haven-structure and Safe Interval Path Planning (SIPP) assumptions, we prove invariant preservation
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Space-efficient warehouse layouts often contain single-agent-width aisles and dead-end workstations where robots have few places to wait without blocking others. In Multi-Agent Pickup and Delivery (MAPD) on such constrained layouts, robots must accept online pickup-delivery tasks while preserving protected waiting locations called Havens. The Safe HAven Retreat Planner (SHARP) introduced a mechanism that extends each committed task path with a validated retreat to the agent's dedicated initial Haven, but fixed-Haven commitments can send agents toward distant Havens after deliveries. We present A-sharp (Adaptive SHARP), which changes an agent's retreat target at task assignment time. A naive switch can cause two agents to rely on the same waiting location or let another committed path pass through a location that is still occupied or reserved. A-sharp prevents these failures with an availability test for candidate Havens and a pending-release rule that keeps the previous Haven protected until the agent departs. Under explicit Haven-structure and Safe Interval Path Planning (SIPP) assumptions, we prove invariant preservation and finite-release completeness: every task in any finite release sequence is delivered in finite time. Across 72,000 runs on 14,400 paired map-agent-count-rate-seed cases over four maps, both SHARP and A-sharp complete their respective 14,400 runs. For makespan (final delivery time), a prespecified paired comparison with Holm correction over all 138 configurations with more Havens than agents finds A-sharp significantly better in 107 configurations and never significantly worse than SHARP; on the tested tree map, the median reduction is 16.7%.
Tags
Links
- Source: https://arxiv.org/abs/2608.26939v1
- Canonical: https://arxiv.org/abs/2608.26939v1
Trouble viewing inline? Open PDF directly →
Full Text
74,701 characters extracted from source content.
Expand or collapse full text
*1 Dynamic Haven Selection for Multi-Agent Pickup and Delivery in Constrained Warehouses Taisei Hirayama Kohei Yoshida Hiroki Sakaji Itsuki Noda Abstract Space-efficient warehouse layouts often contain single-agent-width aisles and dead-end workstations where robots have few places to wait without blocking others. In Multi-Agent Pickup and Delivery (MAPD) on such constrained layouts, robots must accept online pickup-delivery tasks while preserving protected waiting locations, called Havens, to avoid collisions and deadlocks. The Safe HAven Retreat Planner (SHARP) introduced a mechanism that extends each committed task path with a validated retreat to the agent’s dedicated initial Haven. These fixed-Haven commitments can still send agents toward distant Havens after deliveries. We present A♯ (Adaptive SHARP, pronounced “A-sharp”), a dynamic Haven selection method that allows an agent’s retreat target to change at task assignment time. The central difficulty is that a naive switch can make two agents rely on the same waiting location or let another committed path pass through a location that is still occupied or reserved. A♯ addresses this difficulty through an availability test for candidate Havens and a pending-release rule that keeps the previous Haven protected until the agent actually departs. Under explicit Haven-structure and Safe Interval Path Planning (SIPP) assumptions, we prove invariant preservation and finite-release completeness, meaning that every task in any finite release sequence is delivered. Across 72,000 runs on 14,400 paired map–agent-count–rate–seed cases over four maps, both SHARP and A♯ complete all 14,400 runs assigned to each method. For makespan (final delivery time), a prespecified paired comparison with Holm correction over all 138 Haven-surplus configurations (|A|<|H||A|<|H|) finds that A♯ is significantly better in 107 configurations and never significantly worse than SHARP; on the tested tree map, the median reduction is 16.7%. Reductions in average release-to-delivery time are strong on the tested tree map but not uniform on the two narrow-biconnected maps. keywords Multi-Agent Pickup and Delivery ,Multi-Agent Path Finding ,Warehouse Robotics ,Safe Interval Path Planning †copyrightyear: 2026†copyright: Copyright for this paper by its authors. Use permitted under Creative Commons License Attribution 4.0 International (C BY 4.0).†venue: Joint Workshop on Planning for Complex Real-World Applications (CAIPI) and Bridging the Gap Between AI Planning and (Reinforcement) Learning (PRL), co-located with IJCAI-ECAI 2026, August 17, 2026, Bremen, Germany†email: hirayama.h77@gmail.com†email: kohei.yoshida.ab@mail.toyota-shokki.co.jp†email: sakaji@ist.hokudai.ac.jp†email: i.noda@ist.hokudai.ac.jp†address: Hokkaido University, Sapporo 060-0808, Japan†address: Toyota Industries Corporation, Aichi 474-8601, Japan†corresp: Corresponding author. 1 Introduction Automated warehouses and similar logistics systems require fleets of mobile robots to repeatedly transport items while avoiding collisions. Multi-Agent Pickup and Delivery (MAPD) models this problem as online pickup-delivery task assignment and path planning on a graph Ma et al. (2017); Ma et al. (2019). Guaranteeing completion, meaning that every task in any finite release sequence is eventually delivered, is difficult because agents that are waiting, returning, or temporarily blocked can obstruct narrow corridors and dead ends. Classical complete MAPD methods therefore impose structural assumptions, such as well-formedness for Token Passing (TP) Ma et al. (2017); Čáp et al. (2015) or biconnectivity for Priority Inheritance with Backtracking (PIBT) Okumura et al. (2019). These assumptions are useful, but they can be violated in dense warehouse layouts with single-agent-width aisles, dead-end workstations, or tree-like guidepaths. We treat these guidepaths as application-derived graph abstractions: a narrow aisle permits no side-by-side passing, a dead-end workstation offers no through route, and a parked robot can disconnect the remaining traffic area. This yields a concrete logistics-planning problem rather than an idealized open-grid benchmark. Safe-haven retreat is a complementary design pattern for such constrained layouts: every committed task path is paired with a validated return path to a protected waiting location. Prior SHARP reserves both a task-execution path and a retreat path to the agent’s dedicated initial position using Safe Interval Path Planning (SIPP), and it can overwrite a returning agent’s remaining retreat suffix only after validating a new task path and retreat Hirayama et al. (2026); Phillips and Likhachev (2011). This keeps a validated fallback path available while allowing agents to accept new tasks before physically returning home. The limitation is that the retreat target itself is fixed. We use retreat target for the Haven selected for a committed path. If a retreat suffix remains in force after delivery, heading back to a static start or home location can add travel that is unnecessary when other safe waiting locations are nearby. It is tempting to replace the fixed-Haven target with the nearest available safe location. However, this change is not just a heuristic substitution. Other agents plan while treating exclusive Havens as blocked vertices, and committed paths are represented in a space-time reservation table. If Haven ownership is updated naively, another agent may plan through a vertex still physically occupied by the previous owner, or a new owner may select a Haven already reserved by another agent’s committed future path. Thus dynamic Haven selection needs an ownership-transfer protocol. This paper presents A♯ (Adaptive SHARP), a safe dynamic Haven extension of fixed-Haven retreat planning for online MAPD with finite task releases. Despite the pronunciation, A♯ is not a variant of A-star search. Upon task assignment, A♯ selects a nearby available Haven and commits a full path through pickup, delivery, and the selected Haven. Availability checks both exclusive ownership and future reservations. When an agent switches away from a Haven that it still occupies, a pending-release rule keeps the old Haven exclusive until the agent actually departs. The key contribution is an ownership-transfer protocol that links online task assignment, future path reservations, and exclusive waiting-location ownership while preserving the safety structure of safe-haven retreat planning. In the experiments, the label SHARP denotes the restricted fixed-Haven reimplementation used as the baseline; the full prior system is discussed only as the source of the retreat-planning mechanism. We target graph-level MAPD instances abstracted from real warehouse constraints and maintain completion guarantees on narrow or dead-end-heavy guidepath structures. Thus, the contribution is an application-driven planning algorithm; learning is not required for its safety guarantee, although a learned or optimization-based selector can propose Havens subject to the same availability test. The contributions are: • We propose A♯ , a dynamic Haven extension of safe-haven retreat planning with an availability-checked, pending-release ownership-transfer protocol. • We prove that, under explicit Haven structure and SIPP planning assumptions, dynamic Haven updates preserve exclusivity and reservation invariants and deliver every task in any finite release sequence. • We evaluate A♯ over 72,000 runs on 14,400 paired map–agent-count–rate–seed cases; both SHARP and A♯ achieve 100% success, and a prespecified paired comparison finds a significant makespan improvement in 107 of 138 Haven-surplus configurations, with no significant makespan losses after Holm correction across all 138 comparisons. 2 Background and Positioning 2.1 MAPD and Structural Assumptions MAPD extends Multi-Agent Path Finding (MAPF) by introducing online pickup-delivery tasks Stern et al. (2019); Ma et al. (2017). Each task has a pickup vertex, a delivery vertex, and a release time; an assigned agent must visit pickup before delivery. The finite-release setting assumes that only finitely many tasks are released, and a planner is complete if all released tasks are delivered in finite time. Existing guarantees often rely on graph structure. TP is complete on well-formed MAPD instances, where there are enough non-task endpoints and paths between endpoints can avoid all other endpoints Ma et al. (2017). PIBT provides reachability guarantees on graphs where every adjacent pair of vertices lies on a simple cycle, such as biconnected graphs Okumura et al. (2019). Fujitani et al. extend this idea to a biconnected main area with attached trees under additional restrictions Fujitani et al. (2022). We use the label PIBTTP-TA for our implementation of their PIBT with temporary priority and temporary avoidance Fujitani et al. (2022). Parking and dummy-endpoint mechanisms also address fallback locations: Liu et al. reserve dummy paths to designated parking locations in offline MAPD, Xu et al. use dummy endpoints in multi-goal MAPD, and Yamauchi et al. choose standby nodes dynamically Liu et al. (2019); Xu et al. (2022); Yamauchi et al. (2022). These mechanisms are related precedents for waiting-location management, but their guarantee classes and transfer semantics differ from ours. Liu et al. and Xu et al. use designated or dummy endpoints to support task planning, whereas A♯ transfers an agent’s protected retreat target under already committed future reservations. Standby-based methods dynamically choose temporary standby nodes to avoid indefinite waiting near congested goals. They integrate standby-node management with Token Passing, whereas our baseline and A♯ commit complete SIPP paths that end at persistently protected retreat targets. Miyashita et al. study distributed MAPD with asynchronous execution, occasional delays, local navigation, and flexible working endpoints Miyashita et al. (2023). Their flexible endpoints relax endpoint and execution constraints, whereas A♯ assumes deterministic centralized reservation-table execution and atomically transfers persistent exclusive Haven ownership under already committed future reservations. The execution models and guarantee targets are therefore complementary rather than equivalent. The Standby-Based Deadlock Avoidance (SBDA) method could in principle be ported to our maps, but a controlled comparison would require reimplementing its task-execution, standby-node, and coordination semantics inside the common simulator; we therefore do not present an empirical comparison that would confound those changes with Haven selection. Here, persistent ownership means that other agents must treat the retreat target as blocked even after the finite path reservation has ended. In contrast to standby-node use, A♯ transfers that ownership while a reservation-backed commitment is active. The update is atomic: no other assignment or planning step may observe only one of the new path reservations and the new exclusive Haven ownership. The central distinction is therefore not merely that the waiting location changes online, but that A♯ proves finite-release completion while transferring exclusive retreat-Haven ownership in a reservation-based retreat planner. The structural assumptions above remain restrictive when task endpoints lie on narrow aisles or dead-end workstations. Other MAPD and lifelong MAPF work emphasizes throughput and scalability in large warehouses, online arrival models, integrated task assignment and path planning, capacity constraints, or energy-aware multi-task routing Wurman et al. (2008); Švancara et al. (2019); Li et al. (2021); Chen et al. (2021); Kudo and Cai (2023); Kudo and Cai (2024). For example, throughput-oriented Rolling-Horizon Collision Resolution (RHCR) decomposes lifelong MAPF into rolling-window MAPF instances and scales to large warehouse settings Li et al. (2021). Delay-robust MAPD, dynamic-environment MAPD, and external-agent MAPD study imperfect execution, disturbance handling, or non-communicating moving agents Lodigiani et al. (2023); Flammini et al. (2024); Bonalumi et al. (2025). Those settings are orthogonal to the deterministic reservation-transfer problem studied here. Rather than claiming throughput state of the art, this paper isolates the completion-oriented constraints of exclusive Haven retreat and asks whether its retreat target can be changed online without breaking the reservation semantics. 2.2 Prior SHARP and the Fixed-Haven Retreat Design Prior SHARP introduced safe-haven retreat for application-derived multi-task warehouse operations Hirayama et al. (2026). It models richer warehouse operations, including orders with multiple pickup or delivery requirements, outbound and inbound task types, kinematic costs, and dwell times. The part most relevant here is the safe-haven retreat mechanism: when an agent accepts a task, the planner reserves both the task path and a retreat path back to the agent’s dedicated initial position. SIPP is used to generate collision-free space-time paths under a reservation table Phillips and Likhachev (2011). If an agent is already retreating, a new task can overwrite the remaining retreat suffix only when the new task path and subsequent retreat are validated. Our setting is deliberately narrower. We study standard online MAPD with one pickup and one delivery per task, finite releases, and graph-level collision constraints. We inherit the idea of maintaining a committed path ending at a safe retreat target, but ask a different question: can the retreat target itself be changed online while preserving safety and completeness? The answer is nontrivial because fixed-Haven SHARP makes the design choice to keep every agent’s initial Haven for the entire run and therefore never transfers ownership of a safe waiting location. A♯ introduces exactly this missing transfer mechanism. The contribution here is separate from the full prior system: we isolate the retreat-target mechanism, introduce dynamic Haven ownership transfer, and develop the invariants, proof obligations, and experiments needed for that transfer problem. In short, the baseline fixes the retreat target, whereas A♯ keeps the reservation-backed retreat idea but allows target ownership to change only through an availability-checked transfer. 3 Problem Setting and Haven Conditions We consider discrete time on an undirected graph G=(V,E)G=(V,E). At each timestep an agent may wait or move to an adjacent vertex. We disallow vertex collisions and edge-swap collisions. Let A be the set of agents and posa(t)pos_a(t) the position of agent a at time t. We assume A is nonempty. Definition 1 (Task). A task τ is a tuple ⟨sτ,gτ,rτ⟩ s_τ,g_τ,r_τ , where sτ∈Vs_τ∈ V is the pickup vertex, gτ∈Vg_τ∈ V is the delivery vertex, and rτr_τ is the release time. A released task is pending until assigned, in progress until its assigned agent reaches gτg_τ, and completed at delivery. Tasks are assigned at most once and are not preempted or transferred before delivery. Let H⊂VH⊂ V be a designated set of Haven candidates and let F:=V∖HF:=V H be the task-supporting core. We write G[F]G[F] for the subgraph of G induced by the vertices in F. The current Haven assignment at time t is ηt:A→H _t:A→ H. Unlike fixed-Haven planning, ηt(a) _t(a) may change at task assignment time. Each agent a also has an exclusive set Xt(a)⊆HX_t(a) H containing Haven vertices that remain protected for that agent. It always contains the current Haven ηt(a) _t(a) and, during a transfer, may temporarily also contain the occupied previous Haven. We use candidate Haven for an eligible vertex in H, and protected Haven for a candidate currently in some agent’s exclusive set Xt(a)X_t(a). A candidate can be unassigned, and it is not blocked solely because it belongs to H. It becomes blocked to another agent only when protected by an exclusive set or occupied by a committed space-time reservation; otherwise, SIPP may traverse it as an ordinary vertex. It must nevertheless pass the availability test below before an agent can select it as its current Haven. The completeness proof below uses paths in G[F]G[F] as a sufficient construction. Definition 2 (Haven structure conditions). The pair (G,H)(G,H) satisfies the Haven structure conditions when: 1. G[F]G[F] is connected; 2. every Haven h∈Hh∈ H has at least one neighbor in F; and 3. all task endpoints lie in F. We additionally assume that agents start at distinct Haven candidates, so |A|≤|H||A|≤|H| initially. The injectivity invariant below maintains distinct current Havens at all later timesteps. These conditions are sufficient for the feasible path construction used in Lemma 2 and hence for the finite-release completeness guarantee; they are not necessary conditions for an individual instance to be solvable. They express that the task area remains connected after removing Havens, and every Haven can be entered from that connected area. They also separate task endpoints from exclusive waiting locations. 4 Why Naive Dynamic Haven Switching Fails The fixed-Haven retreat mechanism can overwrite a retreat suffix, but the endpoint of that suffix remains the same dedicated initial position. When the endpoint itself can change, two Haven-switching failures appear, and suffix overwrite also requires careful handling of stale self-reservations. For this section, write ℛb(t′)=vR_b(t )=v when agent b has committed to occupy vertex v at time t′t , and use t+t^+ for the phase-local state immediately after a successful commitment at time t. Safe transfer requires the following three obligations: ηt+(a)≠hold∧posa(t)=hold _t^+(a)≠ h_old\ \ pos_a(t)=h_old ⟹hold∈Xt+(a), \; \;h_old∈ X_t^+(a), (1) Availt(a,h) _t(a,h) ⟹∀b≠a,∀t′≥t:ℛb(t′)≠h, \; \;∀ b≠ a,\ ∀ t ≥ t:\ R_b(t )≠ h, (2) Commit(a,π,h) (a,π,h) ⟹(ℛa>t,ηt(a),Xt(a)) are replaced as one state transition. \; \;(R_a^>t, _t(a),X_t(a)) are replaced as one state transition. (3) The counterexamples below respectively negate these obligations: exposing an occupied old Haven violates execution safety, selecting a future-reserved Haven violates reservation exclusion, and retaining stale self-reservations violates replacement semantics. Example 1 (Premature release of an occupied Haven). Suppose an idle agent a is physically located at its old Haven holdh_old at time t. If a is assigned a task and immediately releases holdh_old while its first planned move leaves at time t+1t+1, another agent may plan through holdh_old at time t or t+1t+1. The ownership function would say the vertex is free, but the execution state says it is occupied. The ownership view and the execution view of the vertex disagree. Example 2 (Selecting a future-reserved Haven). Suppose a candidate Haven h is not currently owned by another agent but appears in another agent’s committed future path. If a selects h using ownership alone, then the new path may create a vertex-time conflict with that already committed passage. Conversely, if the planner relies only on finite path reservations and ignores exclusive ownership, it may miss that a current Haven is persistently protected for its owner. Safe switching therefore needs both ownership and future-reservation tests. Example 3 (Self-collision with stale reservations). When a retreating agent accepts a new task, its own unexecuted future reservations must be overwritten. Treating the old retreat suffix as an obstacle to the replacement plan may incorrectly reject feasible updates, while retaining stale reservations after commitment can block later agents. The first two failures are specific to changing the retreat target. A♯ addresses them by defining availability over both ownership and future reservations, and by delaying the release of a still-occupied old Haven until departure. Equations (1)–(3) isolate the roles of the protocol components: the future-reservation test prevents selecting a candidate with another committed vertex-time use, pending release prevents premature access to an occupied old Haven, and controlled replacement of the selected agent’s own future reservations prevents self-blocking. 5 A♯ : Dynamic Haven Retreat Planning As introduced above, each agent has a current Haven assignment ηt(a) _t(a) and an exclusive set Xt(a)⊆HX_t(a) H. Here Xt(a)X_t(a) records Haven vertices protected for a. The current Haven ηt(a) _t(a) is always in Xt(a)X_t(a). During pending release, Xt(a)X_t(a) may also contain the previous Haven until a departs from it. An available Haven is a candidate that passes both the ownership test induced by these exclusive sets and the future-reservation test in Definition 3. Other agents treat ⋃b≠aXt(b) _b≠ aX_t(b) as static vertex exclusions while planning; the reservation table stores finite vertex-time reservations, and directed moves induced by consecutive vertex reservations are checked to forbid edge swaps. For an agent a being replanned at time t, its replaceable future reservations are its own reservations at times t′>t >t. The time-t reservation is not replaceable because the replacement path must start at the agent’s current reserved position. Definition 3 (Available Haven). A Haven candidate h∈Hh∈ H is available for agent a at time t if: 1. h∉⋃b≠aXt(b)h∉ _b≠ aX_t(b); and 2. no agent b≠ab≠ a has a committed reservation occupying h at any time t′≥t ≥ t. Availability is agent-relative: the tests ignore a’s own exclusive set and reservations. The reservation at time t is allowed because the replacement path starts at posa(t)pos_a(t), while a’s reservations at times t′>t >t are replaceable by a successful commitment. We write Availt(a,h)Avail_t(a,h) for the conjunction of the two availability conditions above. Self-availability. Under the execution and reservation invariants below, agent a’s current Haven is available to a: disjoint exclusive sets prevent another owner, reservation-exclusion prevents another future reservation there, and a’s own waiting reservations are ignored when replanning for a. Thus the available Haven set used by the algorithm is nonempty whenever the invariants hold. Formal–implementation correspondence. The two data structures have different roles. The exclusive sets XtX_t persistently block protected Havens, while the reservation table stores only the finite committed path to the selected Haven. A vertex reservation (v,t)(v,t) denotes occupancy of v at time t, and consecutive reservations of the same agent induce the directed moves used for edge-swap checking. After the finite path ends, XtX_t continues protecting the Haven without requiring infinitely many wait reservations. We use t for the decision phase before executing the transition to t+1t+1. Within that phase, the phase-local state is the within-timestep version of ηt _t, XtX_t, and ℛR; each successful commitment updates it immediately, and later candidate evaluations see the updated state. More precisely, write St(k)=(ηt(k),Xt(k),ℛt(k))S_t^(k)=( _t^(k),X_t^(k),R_t^(k)) for the phase-local state after the kkth successful commitment, with St(0)S_t^(0) denoting the timestep-boundary state; unindexed state in an assignment-loop iteration means the current St(k)S_t^(k). The assignment loop is invoked at every timestep while pending tasks remain; an iteration with no feasible commitment leaves the pending tasks for later timesteps. The timestep order is assignment, execution of one reserved transition, and post-execution pending-release cleanup. An agent is task-executing until it reaches the delivery vertex of its assigned task. After delivery, it is retreating until it reaches its current Haven. An agent is idle when it waits at its current Haven with no assigned task. Non-idle agents are task-executing or retreating agents with a finite committed path. Only idle and retreating agents are eligible for a new assignment. An agent that still holds a pending-release old Haven has not departed from that Haven after a previous assignment and is task-executing, hence it is not eligible for another assignment until the pending release is cleaned up. When an idle or retreating agent is considered for assignment, A♯ chooses a pending task by nearest pickup distance and chooses a target Haven by nearest delivery-to-Haven distance among available candidates. Here distdist is shortest-path distance on G with unit edge costs; SIPP validation, not this distance heuristic, decides feasibility under reservations and exclusive Havens. Let diam(G[F])diam(G[F]) denote the diameter of the task-supporting core. For a SIPP segment starting at absolute time tst_s, the relative planning horizon TmaxT_ permits arrivals through time ts+Tmaxt_s+T_ . We require Tmax≥diam(G[F])+1T_ (G[F])+1 in the theorem below. The abstract helper routine PlanFullPath(a,τ,h,t,ℛ,Xt,Tmax)(a,τ,h,t,R,X_t,T_ ) returns a Boolean success flag and, when successful, a full path π from the current position through pickup and delivery to the selected Haven. It concatenates three SIPP segments, posa(t)→sτpos_a(t)→ s_τ, sτ→gτs_τ→ g_τ, and gτ→hg_τ→ h. Each segment starts at the arrival time of the previous segment and may include wait actions; successful segments are concatenated after dropping the duplicated endpoint entry at each join. Each segment treats other agents’ reservations and exclusive Havens as constraints, and excludes agent a’s replaceable future reservations because a successful commitment atomically deletes and replaces them. The routine is side-effect free: if any segment fails, no reservation or ownership state is changed. If validation succeeds, A♯ commits by keeping a’s time-t vertex reservation fixed, deleting a’s vertex reservations for times t′>t >t, inserting the future vertex entries of the new full path, treating consecutive entries of that path from time t onward as the induced directed moves, updating ηt(a) _t(a) and Xt(a)X_t(a), and setting pending release for the old Haven when needed. After the finite path reaches the selected retreat target, the agent waits at that current Haven under the persistent protection described above. If the selected Haven is the current Haven, the ownership update is a no-op and no pending-release Haven is created. After the execution step, A♯ removes a pending old Haven from Xt+1(a)X_t+1(a) exactly when agent a has departed from that Haven. Until cleanup, the old Haven remains blocked to others. The SHARP comparison isolates the effect of dynamic Haven ownership transfer within the same one-pickup-one-delivery MAPD simulator. In each assignment-loop pass, the variable c∗c^* stores the best validated candidate ranked by pickup distance; at most one such candidate is committed before the next pass begins. More explicitly, a pass evaluates one greedy task–Haven candidate for every currently eligible agent against the same phase-local state, chooses one globally best validated candidate, commits it, and then recomputes all candidates in the updated state. Algorithm 1 gives the adaptive case; Appendix B gives the restricted fixed-Haven baseline. During active traffic, A♯ evaluates only one greedy task–Haven pair per considered agent: the nearest-pickup pending task and the nearest available Haven for that task. If validation fails, assignment may be delayed even when another pending task or a farther available Haven would validate. This restriction is a throughput heuristic, not a safety condition. Segment-wise validation is a sound feasibility check for the committed path, but during active traffic it is not a global completeness claim over all possible intermediate arrival times and Haven choices. Algorithm 1 A♯ assignment loop 1: Decision time t; pending tasks Q; agents A; Haven candidates H; assignments ηt _t; exclusive sets XtX_t; reservation table ℛR; segment horizon TmaxT_ 2: Updated Q, ηt _t, XtX_t, ℛR, and agent commitments 3: Add tasks released at time t to the pending set Q 4: I←I← idle or retreating agents with no pending-release old Haven 5: while Q≠∅Q≠ and I≠∅I≠ do 6: c∗←⊥c^*← ; d∗←∞d^*←∞ 7: for each a∈Ia∈ I do 8: τ←argminτ′∈Qdist(posa(t),sτ′)τ← _τ ∈ Qdist(pos_a(t),s_τ ) 9: ℋa(t)←h′∈H:Availt(a,h′)H_a(t)←\h ∈ H:\ Avail_t(a,h )\ 10: h←argminh′∈ℋa(t)dist(gτ,h′)h← _h _a(t)dist(g_τ,h ) 11: (,π)←PlanFullPath(a,τ,h,t,ℛ,Xt,Tmax)(success,π)← PlanFullPath(a,τ,h,t,R,X_t,T_ ) 12: if anddist(posa(t),sτ)<d∗success\ and\ dist(pos_a(t),s_τ)<d^* then 13: c∗←(a,τ,h,π)c^*←(a,τ,h,π); d∗←dist(posa(t),sτ)d^* (pos_a(t),s_τ) 14: if c∗=⊥c^*= then 15: break 16: Let (a,τ,h,π)←c∗(a,τ,h,π)← c^* and let hold←ηt(a)h_old← _t(a) 17: Keep a’s vertex reservation at time t fixed 18: Delete a’s vertex reservations for t′>t >t and insert the future vertex entries of π in ℛR 19: Treat consecutive entries of π from time t onward as a’s committed directed moves 20: Assign τ to a and mark a task-executing 21: if h≠holdh≠ h_old then 22: ηt(a)←h _t(a)← h 23: Xt(a)←hX_t(a)←\h\ 24: if posa(t)=holdpos_a(t)=h_old then 25: Xt(a)←Xt(a)∪holdX_t(a)← X_t(a)∪\h_old\ 26: else 27: Leave ηt(a) _t(a) and Xt(a)X_t(a) unchanged because h=holdh=h_old 28: Remove the selected agent and task from I and Q 29: Execute one timestep along committed reservations 30: After delivery mark an agent retreating; at its current Haven with no task mark it idle 31: Release holdh_old when posa(t+1)≠holdpos_a(t+1)≠ h_old; then renew rolling wait reservations for agents with no task One assignment-loop pass scans the pending task set Q and the Haven candidates for each agent in the eligible set I, and performs at most one full-path SIPP validation per agent. Here |⋅||·| denotes set cardinality. Assuming shortest-path distance fields used by the greedy selectors are precomputed or cached, this costs O(|I|(|Q|+|H|Cavail+CSIPP))O(|I|(|Q|+|H|C_avail+C_SIPP)) per pass, where CavailC_avail is the cost of one availability test and CSIPPC_SIPP is the cost of the three SIPP segment searches. A timestep can contain up to min(|I|,|Q|) (|I|,|Q|) successful passes until either eligible agents or pending tasks are exhausted. Ignoring the shrinkage of I and Q across successful passes, this gives a worst-case per-timestep cost of O(min(|I|,|Q|)|I|(|Q|+|H|Cavail+CSIPP))O( (|I|,|Q|)|I|(|Q|+|H|C_avail+C_SIPP)). A timestep may also include one final failed pass before the loop breaks; this does not change the asymptotic bound. Because the current Haven is available to its owner under the invariants, ℋa(t)H_a(t) is nonempty. If no alternative is available, A♯ selects its current Haven and performs no ownership transfer for that assignment. When current Havens are initialized to the baseline’s fixed Havens and no ownership transfer has occurred, this coincides with the fixed-Haven SHARP choice. All loops and argmin operations use deterministic task, agent, and Haven orders; equal-distance best candidates retain the first item in these orders. The experimental protocol below specifies the orders. 6 Theoretical Guarantees We state the proof for the finite-release MAPD setting above, where each task has one pickup and one delivery. Prior SHARP provides the motivating safe-haven retreat mechanism, but the dynamic Haven invariant and theorem below are specific to A♯ . Throughout this section, invariants are evaluated at the beginning of a timestep, after the previous execution and pending-release cleanup have finished. The guarantee applies to graph-level finite-release MAPD instances with deterministic discrete-time execution, a centralized reservation table, distinct initial Havens, non-preemptive one-pickup-one-delivery tasks, maps satisfying Definition 2, and SIPP soundness for all validation calls. The assignment loop is invoked at every timestep while pending tasks remain and considers only idle or retreating agents with no pending-release old Haven. SIPP validation is assumed sound with respect to static vertex exclusions induced by exclusive Haven sets, finite vertex-time reservations, and edge-swap constraints induced by consecutive reservations. Its completeness assumption is limited to the quiescent segment subproblems used in Lemma 2 within each per-segment horizon Tmax≥diam(G[F])+1T_ (G[F])+1 under the same static exclusions and finite reservation constraints. It does not model execution delays, localization errors, dynamic obstacles, or shared parking. Committed future path reservations are respected during validation, while exclusive Haven sets provide persistent static exclusions for protected waiting locations. The proof structure is as follows: Proposition 1 handles ownership updates, Lemma 1 preserves safety and reservation invariants for one timestep, Lemma 2 gives progress once the system is quiescent, and Theorem 1 combines finite releases with repeated assignment-loop invocation. 6.1 Invariants Definition 4 (Execution invariants). At every timestep: 1. ηt _t is injective; 2. for every agent a, ηt(a)∈Xt(a) _t(a)∈ X_t(a); 3. for any a≠ba≠ b, Xt(a)∩Xt(b)=∅X_t(a)∩ X_t(b)= ; and 4. Xt(a)∖ηt(a)X_t(a) \ _t(a)\ contains at most one pending-release old Haven, which is removed by the post-execution cleanup immediately after a departs from it. Definition 5 (Reservation invariants). At every timestep: 1. at most one agent reserves any vertex-time pair; 2. no committed directed moves form an edge swap; 3. for every agent a, posa(t)pos_a(t) matches the vertex reserved for a at time t, and each executed transition follows the corresponding reserved transition, which is either a wait or an edge in G; 4. every non-idle agent has a finite committed path ending at its current Haven; 5. idle agents wait at their current Havens, which are persistently protected by their exclusive sets; and 6. (reservation-exclusion) for any agents a≠ba≠ b and any h∈Xt(a)h∈ X_t(a), agent b has no committed reservation occupying h at any time t′≥t ≥ t. Proposition 1 (Dynamic Haven update preserves exclusive-set invariants). Assume the execution invariants hold before an assignment at time t. Assume also that the selected eligible agent a has no pending-release old Haven before this assignment. If a selects an available Haven hnewh_new and applies the ownership update in Algorithm 1, then the execution invariants continue to hold. The proof separates the no-op case hnew=holdh_new=h_old from a transfer and uses availability, pending release, and the eligibility rule to preserve injectivity, disjointness, and the one-pending-Haven bound. Full details appear in Appendix A. Lemma 1 (One-timestep invariant preservation). If the execution and reservation invariants hold at the beginning of timestep t, then after Algorithm 1 completes its assignment phase, executes one reserved transition, and performs pending-release cleanup, the invariants hold at the beginning of timestep t+1t+1. The proof applies Proposition 1 and planner soundness to each atomic commitment in phase-local order, then observes that reserved execution and post-departure cleanup preserve the resulting conditions at t+1t+1. Full details appear in Appendix A. 6.2 Finite-Release Completeness Definition 6 (Quiescent configuration). The system is quiescent at time T if every agent is idle at its current Haven, no finite committed movement suffix remains, and the only persistent Haven constraints are the exclusive sets. An implementation may materialize a bounded number of wait reservations at an idle agent’s Haven and renew them as time advances; these are rolling wait entries. They do not represent a movement suffix, are ignored when that same agent replans, and therefore do not change the quiescence condition. The next lemma does not rely on the nearest-Haven heuristic; it shows that, once traffic has quiesced, every available Haven gives a feasible full path. Lemma 2 (Planning succeeds in quiescence). Assume the Haven structure conditions and SIPP completeness for the quiescent segment subproblems, under the static vertex exclusions induced by exclusive Haven sets and the finite reservation constraints, within a horizon at least diam(G[F])+1diam(G[F])+1 for each segment. In a quiescent configuration, for any pending task τ, any agent a, and any Haven h available for a, PlanFullPath succeeds for the path posa(T)→sτ→gτ→hpos_a(T)→ s_τ→ g_τ→ h under the reservation and exclusivity constraints stated above. The proof constructs all three segments through the connected core G[F]G[F], using one additional edge to leave the start Haven and one to enter the target Haven; availability and quiescence remove conflicting ownership and movement reservations. Full details appear in Appendix A. Theorem 1 (Finite-release completeness). Assume the Haven structure conditions, distinct initial Havens, initial execution and reservation invariants, deterministic execution of committed reservations, non-preemptive tasks assigned at most once, finitely many task releases, and assignment-loop invocation at every timestep while pending tasks remain using the eligibility rule in Algorithm 1. Assume also SIPP soundness for all validation calls and SIPP completeness for the quiescent segment subproblems of Lemma 2 under static Haven exclusions and finite reservation constraints within each per-segment horizon TmaxT_ with Tmax≥diam(G[F])+1T_ (G[F])+1. Then A♯ delivers every released task in finite time. The proof assumes an unfinished task persists, takes a time after the last release and last successful commitment, and lets all finite committed suffixes reach quiescence. Because task-executing agents are ineligible for reassignment, an assigned task’s pickup–delivery prefix is not replaced before delivery. Lemma 2 then forces another successful commitment, contradicting the choice of that time. Full details appear in Appendix A. Corollary 1 (Fixed-Haven case). If A♯ always selects the current Haven and current Havens are initialized to the baseline’s fixed Havens, Haven ownership never changes. The algorithm then recovers the restricted fixed-Haven baseline used in our experiments, and Theorem 1 applies under the same assumptions. 7 Experiments 7.1 Maps and Setup We evaluate A♯ on four maps with different structural properties (Figure 1). The well-formed map is the public MAPD benchmark from Ma et al. (2017), reflecting Kiva-style warehouse layouts Wurman et al. (2008). The constrained maps are narrow-biconnected (narrow-bi), narrow-biconnected with depth-1 dead ends (narrow-bi-dead), and a tree-like task-area layout; the latter two include structures excluded by well-formedness or biconnectivity assumptions. The tree map represents a tree-structured warehouse guidepath with narrow aisles and branches that provide access to workstations and storage locations. Such patterns arise in space-efficient automated warehouses and are studied in prior warehouse-layout and MAPD work Iida et al. (2023); Hirayama et al. (2025); Azadeh et al. (2017); Roy et al. (2017). All maps were checked against the Haven structure conditions before evaluation: the core is connected, every Haven is adjacent to the core, and task endpoints are sampled from the core. (a) well-formed (b) narrow-bi (c) narrow-bi-dead (d) tree Figure 1: Maps used in the evaluation. Orange cells are Haven candidates, gray cells are task endpoint candidates, and black cells are obstacles. The well-formed map is the public benchmark, narrow-biconnected (narrow-bi) keeps biconnectivity with single-width aisles, narrow-biconnected with depth-1 dead ends (narrow-bi-dead) adds dead-end workstations, and tree violates biconnectivity with a tree-like task area. Table 1: Map statistics. PendP_end denotes the endpoint-candidate set. Map Size |V||V| |F||F| |H||H| |Pend||P_end| Obstacles diam(G[F])diam(G[F]) well-formed 37×2337×23 635 483 152 200 216 54 narrow-bi 37×1837×18 360 248 112 120 306 49 narrow-bi-dead 37×1837×18 376 264 112 136 290 49 tree 45×1845×18 268 238 30 195 542 66 We vary |A|∈5,10,15,20,25,30|A|∈\5,10,15,20,25,30\ and task generation rate λ∈0.5,1.0,1.5,2.0,2.5,3.0λ∈\0.5,1.0,1.5,2.0,2.5,3.0\. For each map, task rate, and seed, we generate one schedule and replay it for every agent count and algorithm. The resulting 2,400 unique schedules define 14,400 paired map–agent-count–rate–seed cases and 72,000 runs across TP, PIBT, PIBTTP-TA, SHARP, and A♯ . Within each such case, all five algorithms therefore receive the same pre-generated task schedule. For each map, agent count, and seed s∈1001,…,1100s∈\1001,…,1100\, the implementation seeds Python’s pseudorandom-number generator with s, sorts Haven coordinates in row-major order, samples |A||A| distinct Havens uniformly without replacement, and assigns the sampled sequence to agents in increasing ID order. Every algorithm uses the same initial agent–Haven mapping in a paired case; consequently, the 100 seeds vary both the initial fixed-Haven assignment and the task schedule, although these two factors are not independently crossed. For each timestep t∈0,…,300t∈\0,…,300\, the number of released tasks is ⌊λ⌋+Bernoulli(λ−⌊λ⌋) λ +Bernoulli(λ- λ ). Because the maps in Table 1 have no explicit delivery-only cells, each task samples pickup and delivery as two distinct vertices from this endpoint-candidate set; sampling is with replacement across different tasks. The SHARP baseline and A♯ use the same nearest-pickup task selection and path-validation rules. The evaluated A♯ instantiation adds nearest-available-Haven selection and the availability-checked, pending-release ownership transfer, whereas SHARP retains its initial Haven. The protocol’s safety and completeness results are selector-independent under the stated assumptions, but the empirical efficiency results are specific to this nearest-Haven selector. For both safe-haven retreat variants, the per-segment SIPP horizon is set to Tmax=diam(G[F])+1T_ =diam(G[F])+1 on each map; from Table 1, the largest value is 67 on the tree map. Ties are deterministic: pre-generated task schedules are ordered by release time and task ID, nearest-task ties follow task iteration order, equal-distance best feasible candidates retain the first agent in increasing agent ID order, and ties among available Havens in A♯ use lexicographic grid-coordinate order. TP and PIBT are based on publicly available implementations, and PIBTTP-TA is reimplemented from Fujitani et al. (2022); these baselines use their own assignment and movement rules, so they serve primarily to expose the effect of structural assumptions on the same paired task streams. Thus their role is diagnostic: they expose where standard structural assumptions fail, while the main efficiency comparison is SHARP versus A♯ . TP, PIBT, and PIBTTP-TA respectively represent the well-formed-instance, simple-cycle, and biconnected-main-area-with-attached-trees assumptions. All five algorithms use the same collision, stall, timeout, and task-completion criteria. A run succeeds only if all released tasks are delivered within 10,000 timesteps. We mark a run as failed if it has a vertex collision, edge-swap collision, invalid non-adjacent move, 3,000-second per-run wall-clock timeout, or 1,000-timestep stall without task progress. These safeguards are treated as operational failures in the simulation. We report success rate as the fraction of runs that complete all released tasks, makespan as the final delivery timestep rather than the time for all agents to return to Havens, service time as the average release-to-delivery duration over completed tasks, and computation time as simulator wall-clock milliseconds per step. Absolute values reported with ± are means plus or minus one standard deviation over 100 paired seeds. The retreat-to-Haven suffix remains part of each committed path; final-delivery makespan is used only as the service-performance metric. Under an industrial reporting constraint, we do not tabulate the author-measured absolute makespan and service-time values for the constrained maps; absolute values are reported for the public well-formed benchmark, and computation times are reported for all maps. For the constrained maps, we report success rates, paired relative improvements, normalized trends, and statistical outcomes without disclosing normalization anchors in absolute units. This reporting restriction does not prevent independent reproduction: the released implementation, machine-readable maps, task generator, seed protocol, and experiment configuration allow readers to rerun the experiments and obtain their own measurements. Paired performance comparisons are made only among algorithms with 100% success in a configuration, avoiding survivorship bias. For statistical testing, samples are paired by random seed within each map, agent count, task generation rate, and metric. The prespecified primary comparison is SHARP versus A♯ on the 138 Haven-surplus configurations, defined by |A|<|H||A|<|H|. For makespan and service time separately, we apply two-sided paired Wilcoxon signed-rank tests and Holm correction across all 138 configuration-level tests; zero differences are omitted, no continuity correction is used, and SciPy 1.11.3 with method=auto uses its asymptotic calculation for these 100-pair tests. We use significance level α=0.05α=0.05 throughout; comparisons involving TP, PIBT, and PIBTTP-TA are descriptive diagnostics rather than members of the primary testing family. 7.2 Success and Task Performance Figure 2 shows the success-rate heatmap. TP, PIBT, and PIBTTP-TA are included as structural-assumption baselines; the heatmap should be read primarily as a stress test of their graph assumptions. The figure is intended to be read categorically: green cells denote completed configurations, while red or orange cells identify configurations where structural assumptions or operational safeguards fail in this diagnostic benchmark. The SHARP baseline and A♯ both achieve 100% success in every configuration, supporting the claim that dynamic Haven updates preserve the robustness of safe-haven retreat. Figure 2: Success rate across the four maps, agent counts, and task generation rates. Cell values give success rates, and color only highlights high versus low rates. TP, PIBT, and PIBTTP-TA serve as structural-assumption diagnostics; the main efficiency comparison is SHARP versus A♯ . Only SHARP and A♯ achieve 100% success in every tested configuration. Figures 3 and 4 summarize service-time and makespan trends. Values are normalized per map and metric by an endpoint anchor SHARP mean: the task-rate sweeps use the high-rate endpoint (|A|=30,λ=3.0|A|=30,λ=3.0), and the agent-count sweeps use the left endpoint at the same task rate (|A|=5,λ=3.0|A|=5,λ=3.0). These endpoint anchors keep each sweep normalized within the same map and metric, rather than mixing task-rate and agent-count effects. For each algorithm, we plot only configurations in which it completes all 100 paired seeds, matching SHARP; failed configurations are omitted from these trend plots. For constrained maps, normalized values are shown without reporting the absolute SHARP anchors in the paper. On the public well-formed map with 30 agents and λ=3.0λ=3.0, SHARP obtains makespan 695.2±16.8695.2± 16.8 and service time 174.8±5.7174.8± 5.7, while A♯ obtains makespan 682.6±15.7682.6± 15.7 and service time 173.8±6.3173.8± 6.3. The improvement is modest on the public well-formed map, as expected, because fixed Havens are less harmful in this layout (1.8% makespan and 0.6% service-time reduction in this setting). The effect is larger in constrained layouts: on the tree map with 20 agents and λ=3.0λ=3.0, A♯ reduces makespan and service time by 20.4% and 16.2%, respectively. Table 2 breaks down the primary SHARP/A♯ comparison for Haven-surplus configurations (|A|<|H||A|<|H|). Haven surplus guarantees that at least one candidate is not a current Haven, but not that an alternative is available at every decision because ownership and future reservations can temporarily exclude candidates. Configurations with |A|=|H||A|=|H| are excluded because A♯ then makes the same retreat-target choice as SHARP in the tested setup. The map/metric-level median Δ is the primary effect-size summary. Across the two metric-wise families, 199 of the 276 map–metric–configuration pairs show a significant difference after Holm correction within their 138-test family; 175 favor A♯ and 24 favor SHARP. The significant SHARP wins occur only for service time on the two narrow-biconnected maps, where nearest-Haven selection can create local congestion even though it shortens retreat targets. A♯ is therefore not uniformly better for service time: in several narrow-biconnected configurations, the greedy nearest-Haven selector favors the fixed-Haven SHARP baseline. These losses isolate a selector-level trade-off rather than a failure of the ownership-transfer protocol. On the tree map, A♯ is significantly better in all 30 configurations with |A|<|H||A|<|H| for both metrics. When |A|=|H||A|=|H| on the tree map, no alternative Haven is available and A♯ uses the same retreat-target choice as SHARP. Table 2: Primary SHARP/A♯ comparison on Haven-surplus configurations (|A|<|H||A|<|H|). Δ=100(fixed−adaptive)/fixed =100(fixed-adaptive)/fixed, so positive values favor A♯ . Only relative effects are reported. The last column counts significant A♯ wins, significant SHARP wins, and non-significant pairs after Holm correction across all 138 tests separately for each metric. Map Metric Configs Median Δ Sig. A♯ / SHARP/ not sig. well-formed makespan 36 +1.5% 33 / 0 / 3 well-formed service time 36 +1.0% 21 / 0 / 15 narrow-bi makespan 36 +1.0% 17 / 0 / 19 narrow-bi service time 36 -0.7% 8 / 15 / 13 narrow-bi-dead makespan 36 +1.6% 27 / 0 / 9 narrow-bi-dead service time 36 0.0% 9 / 9 / 18 tree makespan 30 +16.7% 30 / 0 / 0 tree service time 30 +15.3% 30 / 0 / 0 (a) Service time vs. task generation rate (30 agents). (b) Service time vs. agents (λ=3.0λ=3.0). Figure 3: Normalized service time, divided by the SHARP anchor mean for each map and aggregation axis. Lower is better. Error bars denote one standard deviation over paired seeds; absolute anchors for constrained maps are not reported in the paper. (a) Makespan vs. task generation rate (30 agents). (b) Makespan vs. agents (λ=3.0λ=3.0). Figure 4: Normalized makespan under the same per-map, per-axis anchor normalization as Figure 3. Lower is better. Error bars denote one standard deviation over paired seeds; absolute anchors for constrained maps are not reported in the paper. 7.3 Computation Time Table 3 reports representative computation times. In these representative settings, A♯ is not consistently more expensive than SHARP; the results are consistent with shorter retreat commitments offsetting some additional Haven-availability checks. The only slowdown shown here occurs in the tree setting with |A|=|H|=30|A|=|H|=30, where A♯ has no alternative Haven and the remaining difference is overhead. Unlike Table 2, these timing ratios include all 144 SHARP/A♯ configurations, including those with no alternative Haven. Across all 144 SHARP and A♯ configurations, the median A♯ /SHARP ratio is 0.83 for milliseconds per step, with a range from 0.40 to 1.03. Because A♯ often shortens the number of simulated timesteps, the corresponding median ratio for total simulator computation time per completed run is 0.81, with a range from 0.33 to 1.03. All algorithms were evaluated in the same Python simulator using paired task sequences, without GPU acceleration; reported times are simulator wall-clock measurements and should be interpreted as implementation-level timing rather than asymptotic evidence or deployed-product performance. The host environment was Ubuntu 24.04.3 under WSL2 on an Intel Core i7-14650HX, with 24 logical processors exposed and 15 GiB RAM. Simulation jobs ran in an Ubuntu 22.04 Docker container with Python 3.11; each simulator process was single-threaded, and independent runs were parallelized. Research artifact. The source code, machine-readable maps, paired-task generator, experiment scripts, and reproduction instructions are publicly available at https://github.com/abigworld1/A-SHARP. The source code is provided for evaluation and research purposes under the repository-specific terms. Table 3: Representative computation time in ms/step. Dashes indicate failure before all tasks are completed. Map / setting TP PIBT PIBTTP-TA SHARP A♯ well-formed, 10 agents, λ=1.0λ=1.0 0.99 0.65 0.70 2.20 1.96 well-formed, 30 agents, λ=3.0λ=3.0 6.33 2.04 2.36 26.2 19.6 tree, 10 agents, λ=1.0λ=1.0 – – – 15.1 5.98 tree, 30 agents, λ=3.0λ=3.0 – – – 137.5 141.4 8 Discussion and Limitations Confidential task-performance values. To avoid misinterpretation as performance specifications of an affiliated company’s commercial products, we do not report our measured absolute makespan and service-time values on the constrained maps. The constrained-map task-performance results should therefore be interpreted as paired relative algorithmic comparisons in simulation rather than benchmarks of a deployed product; the public well-formed benchmark and computation times are reported in absolute units. The public artifact nevertheless permits independent reruns; values obtained in another environment are not product-performance claims. Map and demand coverage. Each structural category is represented by one map, and the 100 seeds vary initial Haven assignments and task sequences rather than map topology. Task endpoints are sampled uniformly from the stated candidate set. The results therefore establish behavior on the four tested layouts and demand model, not across a distribution of tree-like or narrow-biconnected topologies or nonuniform warehouse demand patterns. Execution model. The guarantee assumes deterministic discrete-time execution and a centralized reservation table. Unexpected delays, mechanical failures, and localization errors are outside the current theorem. Existing robust, dynamic-environment, and external-agent MAPD work addresses related disturbances and moving agents outside the planned team Lodigiani et al. (2023); Flammini et al. (2024); Bonalumi et al. (2025). Handling such disturbances in A♯ would require reservation repair, temporal slack, or online replanning policies layered on top of the present ownership-transfer mechanism. Haven density. The current framework assumes distinct Havens and therefore |A|≤|H||A|≤|H|. This is natural when robots have dedicated parking or charging cells, but denser fleets would require shared parking, queueing, or buffer-cell rules. Heuristic choice. Nearest-pickup task selection and nearest-available-Haven selection are simple heuristics. They are not the safety contribution; congestion-aware selection can be substituted as long as candidate Havens satisfy availability and commitments preserve the same invariants. The service-time losses on some narrow-biconnected configurations are consistent with this limitation: a locally nearest Haven can attract traffic to a constrained area even when the ownership-transfer protocol itself remains safe. This pattern points to replacing the selector, not to weakening the availability and pending-release protocol. The same protocol can also constrain learned or optimization-based task and Haven selectors, provided they preserve the same commitment semantics and return only available Havens. 9 Conclusion A♯ addresses the main difficulty created by dynamic retreat targets: future path reservations and persistent Haven ownership must be updated together. The availability check and pending-release rule provide this ownership-transfer protocol while keeping the safety structure of safe-haven retreat planning intact. Under explicit Haven structure conditions and SIPP planning assumptions, we proved that A♯ preserves exclusivity and reservation invariants and delivers every task in any finite release sequence. In the experiments, both SHARP and A♯ achieved 100% success across all tested configurations, showing that dynamic Haven ownership transfer did not weaken the robustness of the fixed-Haven baseline. For makespan, A♯ was significantly better in 107 of 138 Haven-surplus configurations and never significantly worse than SHARP after Holm correction across all 138 primary comparisons; the largest map-level median gain was 16.7% on the tested tree map. These results show that completion-oriented safe-haven retreat can be made dynamic in narrow or dead-end-heavy layouts, while leaving congestion-aware, learned, or optimization-based Haven selection as a natural next step. Appendix A Detailed Proofs Proof of Proposition 1. Let hold=ηt(a)h_old= _t(a). If hnew=holdh_new=h_old, no ownership transfer occurs, so injectivity and disjointness are unchanged and no new pending-release Haven is created. Otherwise, availability ensures hnewh_new is not in another agent’s exclusive set, so adding it to Xt(a)X_t(a) and setting ηt(a)=hnew _t(a)=h_new preserves injectivity and disjointness. If a is still located at holdh_old, pending release keeps that vertex in Xt(a)X_t(a), so other agents continue to treat it as blocked. If a has already left holdh_old, releasing it cannot allow another agent to plan through a vertex occupied by a. The update creates at most one pending-release old Haven for a because the selected agent is removed from I after a successful commitment and therefore cannot receive a second ownership update in the same assignment loop. Across timesteps, a pending old Haven exists only until a departs; post-execution cleanup then removes it before a becomes eligible again. ∎ Proof of Lemma 1. During the assignment phase at time t, each successful commitment is applied to the phase-local state before the next candidate is evaluated. The argument below first shows that these phase-local execution and reservation conditions are preserved after each commitment, and then applies the execution and cleanup step to obtain the beginning-of-timestep invariants at t+1t+1. Consider one successful commitment inside the assignment loop. PlanFullPath validates a candidate full path that starts at posa(t)pos_a(t), uses only wait actions and graph edges, ends at the selected Haven, and avoids other agents’ reservations and exclusive Havens. Agent a’s replaceable vertex reservations for times t′>t >t are ignored only during validation; commitment atomically removes those reservations and inserts the validated path while keeping the time-t vertex reservation fixed. The induced directed moves from time t onward are exactly the consecutive entries of the inserted path. Thus no stale self-reservations remain, the position-reservation consistency for a is re-established by the inserted path, and planner soundness preserves vertex and edge-swap reservation constraints. The selected agent is eligible, so it has no pending-release old Haven before the commitment by the state classification above. Proposition 1 handles the corresponding ownership update. The reservation-exclusion invariant is also preserved. The inserted path avoids every other agent’s exclusive set, so agent a does not newly reserve any vertex in Xt(b)X_t(b) for b≠ab≠ a. If the selected Haven becomes part of Xt(a)X_t(a), availability ensures that no other agent has a committed reservation for it at any time t′≥t ≥ t. If the old Haven remains pending in Xt(a)X_t(a), the invariant already excluded other agents’ reservations for that Haven before the update; if it is released, it is no longer subject to the invariant for a. Because commitments in the same while loop are sequential, each later validation sees the reservations and exclusive Havens inserted by earlier commitments; repeated commitments therefore preserve the invariants by induction. The final execution step preserves the reservation invariants because agents follow committed moves that match their reserved transitions, and pending-release Havens remain blocked to other agents until the owning agent has departed. The post-execution release step removes an old Haven only after its owner has left it, so it cannot expose a currently occupied vertex to other agents. Idle agents wait at their Havens. ∎ Proof of Lemma 2. In quiescence, no finite movement suffix remains. By the self-availability observation after Definition 3, agent a’s current Haven is available to itself. If the selected Haven is ηT(a) _T(a), the final segment returns to the same protected vertex after leaving it; a’s own exclusive set and own finite wait entries do not block its replan. If h≠ηT(a)h≠ _T(a), availability ensures that h is neither owned by another agent nor occupied by another agent’s committed future reservation. For the first segment, agent a leaves its current Haven ηT(a) _T(a) through a neighbor in F and then follows a path in G[F]G[F] to sτs_τ. The pickup-to-delivery segment stays inside G[F]G[F]. For the final segment, the agent follows a core path from gτg_τ to a neighbor of the selected Haven h and then enters h. Thus the first and final segments have length at most diam(G[F])+1diam(G[F])+1, and the middle segment has length at most diam(G[F])diam(G[F]). The constructed paths use no Haven vertices except a’s start Haven and the final selected Haven h; these may be the same vertex when h=ηT(a)h= _T(a). They therefore avoid other agents’ exclusive Havens and finite future non-Haven reservations by quiescence. This construction proves that feasible segments exist; SIPP need not return these exact paths, but quiescent-segment completeness within the stated horizon implies that the three segment validations can succeed. ∎ Proof of Theorem 1. Suppose some released task remains unfinished forever. Any assigned task has a finite committed path that reaches its delivery before ending at a Haven, so an unfinished task that persists forever must eventually remain pending. Because only finitely many tasks are released, there is a time T0T_0 after which no new task is released. Each successful commitment removes one pending task from the pending set and tasks are assigned at most once, so only finitely many successful commitments can occur. If no successful commitment occurs at or after T0T_0, set T1=T0T_1=T_0; otherwise let T1≥T0T_1≥ T_0 be a time after the final successful commitment. Temporary validation failures during active traffic do not affect this argument: after T1T_1, all remaining committed finite suffixes are simply executed to their current Havens, and no new task release creates additional work. By the reservation invariant, every non-idle agent after T1T_1 follows a finite suffix to its current Haven, so the system reaches a quiescent configuration at some later time T2T_2. At T2T_2 at least one released task is still pending by the supposition above. Every idle agent has at least one available Haven, namely its current Haven by Definition 3 and the reservation-exclusion invariant. Lemma 2 therefore implies that every idle agent can validate a full path for a pending task to at least one available Haven. Because Lemma 2 quantifies over any pending task and any available Haven, it applies in particular to the nearest pending task and nearest available Haven selected by Algorithm 1; the greedy task-Haven choice therefore cannot block progress in quiescence. Since the assignment loop is invoked while pending tasks remain, at least one candidate must validate and the loop must commit a task at or after T2T_2, contradicting the choice of T1T_1 as after the final successful commitment. ∎ Appendix B Restricted Fixed-Haven Baseline Algorithm 2 records the fixed-Haven comparison used in the experiments. It uses the same task selector, SIPP validation, and commitment order as Algorithm 1, but always retains the initial injective Haven assignment η0η^0. Algorithm 2 Restricted fixed-Haven SHARP assignment loop 1: Decision time t; pending tasks Q; agents A; fixed injective Haven assignment η0η^0; static exclusive sets X0(a)=η0(a)X^0(a)=\η^0(a)\; reservation table ℛR; segment horizon TmaxT_ 2: Updated Q, ℛR, and agent commitments 3: Add tasks released at time t to Q; let I be the idle or retreating agents 4: while Q≠∅Q≠ and I≠∅I≠ do 5: c∗←⊥c^*← ; d∗←∞d^*←∞ 6: for each a∈Ia∈ I do 7: τ←argminτ′∈Qdist(posa(t),sτ′)τ← _τ ∈ Qdist(pos_a(t),s_τ ) 8: (,π)←PlanFullPath(a,τ,η0(a),t,ℛ,X0,Tmax)(success,π)← PlanFullPath(a,τ,η^0(a),t,R,X^0,T_ ) 9: if success and dist(posa(t),sτ)<d∗dist(pos_a(t),s_τ)<d^* then 10: c∗←(a,τ,π)c^*←(a,τ,π); d∗←dist(posa(t),sτ)d^* (pos_a(t),s_τ) 11: if c∗=⊥c^*= then 12: break 13: Let (a,τ,π)←c∗(a,τ,π)← c^* and keep a’s time-t vertex reservation fixed 14: Delete a’s reservations for t′>t >t and insert the future entries of π in ℛR 15: Assign τ to a and mark a task-executing 16: Remove the selected agent and task from I and Q 17: Execute one timestep along committed reservations Declaration on Generative AI During the preparation of this work, the authors used OpenAI Codex in order to: Paraphrase and reword, Improve writing style, and Grammar and spelling check. The authors supplied and verified the scientific content and arguments, reviewed and edited all tool-assisted changes, and take full responsibility for the publication’s content. References Ma et al. (2017) H. Ma, J. Li, T. K. S. Kumar, S. Koenig, Lifelong multi-agent path finding for online pickup and delivery tasks, in: Proceedings of the 16th Conference on Autonomous Agents and MultiAgent Systems (AAMAS), 2017, p. 837–845. Ma et al. (2019) H. Ma, W. Hönig, T. K. S. Kumar, N. Ayanian, S. Koenig, Lifelong path planning with kinematic constraints for multi-agent pickup and delivery, in: Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, 2019, p. 7651–7658. Čáp et al. (2015) M. Čáp, J. Vokřínek, A. Kleiner, Complete decentralized method for on-line multi-robot trajectory planning in well-formed infrastructures, in: Proceedings of the 25th International Conference on Automated Planning and Scheduling (ICAPS), 2015, p. 324–332. Okumura et al. (2019) K. Okumura, M. Machida, X. Défago, Y. Tamura, Priority inheritance with backtracking for iterative multi-agent path finding, in: Proceedings of the 28th International Joint Conference on Artificial Intelligence (IJCAI), 2019, p. 535–542. Hirayama et al. (2026) T. Hirayama, K. Yoshida, H. Sakaji, I. Noda, SHARP: A complete multi-task MAPD planner for realistic warehouse scenarios, in: Proceedings of the 18th International Conference on Agents and Artificial Intelligence - Volume 1: ICAART, INSTICC, SciTePress, 2026, p. 648–659. doi:10.5220/0014489600004052. Phillips and Likhachev (2011) M. Phillips, M. Likhachev, SIPP: Safe interval path planning for dynamic environments, in: 2011 IEEE International Conference on Robotics and Automation (ICRA), 2011, p. 5628–5635. Stern et al. (2019) R. Stern, N. Sturtevant, A. Felner, S. Koenig, H. Ma, T. Walker, J. Li, D. Atzmon, L. Cohen, T. K. S. Kumar, R. Bartak, E. Boyarski, Multi-agent pathfinding: Definitions, variants, and benchmarks, in: Proceedings of the 12th International Symposium on Combinatorial Search (SoCS), 2019, p. 151–159. Fujitani et al. (2022) Y. Fujitani, T. Yamauchi, Y. Miyashita, T. Sugawara, Deadlock-free method for multi-agent pickup and delivery problem using priority inheritance with temporary priority, Procedia Computer Science 207 (2022) 1552–1561. doi:10.1016/j.procs.2022.09.212. Liu et al. (2019) M. Liu, H. Ma, J. Li, S. Koenig, Task and path planning for multi-agent pickup and delivery, in: Proceedings of the 18th International Conference on Autonomous Agents and MultiAgent Systems (AAMAS), 2019, p. 1152–1160. Xu et al. (2022) Q. Xu, J. Li, S. Koenig, H. Ma, Multi-goal multi-agent pickup and delivery, in: 2022 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), 2022, p. 9964–9971. doi:10.1109/IROS47612.2022.9981785. Yamauchi et al. (2022) T. Yamauchi, Y. Miyashita, T. Sugawara, Standby-based deadlock avoidance method for multi-agent pickup and delivery tasks, in: Proceedings of the 21st International Conference on Autonomous Agents and MultiAgent Systems (AAMAS), 2022, p. 1427–1435. Miyashita et al. (2023) Y. Miyashita, T. Yamauchi, T. Sugawara, Distributed planning with asynchronous execution with local navigation for multi-agent pickup and delivery problem, in: Proceedings of the 22nd International Conference on Autonomous Agents and Multiagent Systems (AAMAS), 2023, p. 914–922. Wurman et al. (2008) P. R. Wurman, R. D’Andrea, M. Mountz, Coordinating hundreds of cooperative, autonomous vehicles in warehouses, AI Magazine 29 (2008) 9–19. Švancara et al. (2019) J. Švancara, M. Vlk, R. Stern, D. Atzmon, R. Barták, Online multi-agent pathfinding, in: Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, 2019, p. 7732–7739. Li et al. (2021) J. Li, A. Tinka, S. Kiesel, J. W. Durham, T. K. S. Kumar, S. Koenig, Lifelong multi-agent path finding in large-scale warehouses, in: Proceedings of the AAAI Conference on Artificial Intelligence, volume 35, 2021, p. 11272–11281. Chen et al. (2021) Z. Chen, J. Alonso-Mora, X. Bai, D. D. Harabor, P. J. Stuckey, Integrated task assignment and path planning for capacitated multi-agent pickup and delivery, IEEE Robotics and Automation Letters 6 (2021) 5816–5823. Kudo and Cai (2023) F. Kudo, K. Cai, A TSP-based online algorithm for multi-task multi-agent pickup and delivery, IEEE Robotics and Automation Letters 8 (2023) 5910–5917. Kudo and Cai (2024) F. Kudo, K. Cai, Anytime multi-task multi-agent pickup and delivery under energy constraint, IEEE Robotics and Automation Letters 9 (2024) 10145–10152. Lodigiani et al. (2023) G. Lodigiani, N. Basilico, F. Amigoni, Robust multi-agent pickup and delivery with delays, arXiv preprint arXiv:2303.17422, 2023. Flammini et al. (2024) B. Flammini, D. Azzalini, F. Amigoni, Preventing deadlocks for multi-agent pickup and delivery in dynamic environments, in: Proceedings of the 23rd International Conference on Autonomous Agents and Multiagent Systems (AAMAS), 2024, p. 580–588. Bonalumi et al. (2025) L. Bonalumi, B. Flammini, D. Azzalini, F. Amigoni, Multi-agent pickup and delivery with external agents, Robotics and Autonomous Systems 191 (2025) 105000. doi:10.1016/j.robot.2025.105000. Iida et al. (2023) T. Iida, I. Noda, T. Kondo, H. Soda, N. Ueda, M. Nawa, N. Kato, Negotiation algorithm for multi-agent pickup and delivery tasks, in: Highlights in Practical Applications of Agents, Multi-Agent Systems, and Cognitive Mimetics: The PAAMS Collection, volume 1838 of Communications in Computer and Information Science, Springer, 2023, p. 145–157. doi:10.1007/978-3-031-37593-4_12. Hirayama et al. (2025) T. Hirayama, I. Noda, H. Sakaji, N. Kato, Optimal assignment of immediate tasks in multi-agent pickup and delivery, in: Technologies and Applications of Artificial Intelligence, volume 2415 of Communications in Computer and Information Science, Springer, 2025, p. 70–86. doi:10.1007/978-981-96-4596-1_6. Azadeh et al. (2017) K. Azadeh, R. de Koster, D. Roy, Robotized Warehouse Systems: Developments and Research Opportunities, Technical Report ERS-2017-009-LIS, Erasmus Research Institute of Management, 2017. URL: http://hdl.handle.net/1765/99983. Roy et al. (2017) D. Roy, A. Krishnamurthy, S. S. Heragu, C. Malmborg, A multi-tier linking approach to analyze performance of autonomous vehicle-based storage and retrieval systems, Computers & Operations Research 83 (2017) 173–188. doi:10.1016/j.cor.2017.02.012.