diff --git a/CLAUDE.md b/CLAUDE.md
index 6e25f92ce..3ba56a31e 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -202,7 +202,7 @@ For complete navigation services architecture, Koin DI integration patterns, and
 - `objects/paths/` - Route management
 
 **Simulation engine:**
-- Built on kDisco library (`cz.hovorka.kdisco:kdisco-core-jvm:0.6.0`) — replaces jDisco entirely (Phase 1 migration complete 2026-03-20)
+- Built on kDisco library (`cz.ksimulantenbande.kdisco:kdisco-core-jvm:0.6.1-SNAPSHOT`) — replaces jDisco entirely (Phase 1 migration complete 2026-03-20)
 - kDisco repo: https://github.com/bedaHovorka/kdisco
 - `sim/` package contains simulation processes (e.g., `ShuntingLoop`)
 
diff --git a/TEAM.md b/TEAM.md
index 77a491fae..581c82fb2 100644
--- a/TEAM.md
+++ b/TEAM.md
@@ -29,7 +29,7 @@ This file defines specialized agent roles for the interlockSim project. When Cla
 
 **Focus Areas:**
 1. **Simulation Engine**
-   - kDisco 0.6.0 (Phase 1 migration complete 2026-03-20; Koin injection now allowed in sim/)
+   - kDisco 0.6.1-SNAPSHOT (Phase 1 migration complete 2026-03-20; Koin injection now allowed in sim/)
    - Kalasim migration planning (Goal 10, Phase 2, future)
    - `:fast-sim` native CLI subproject (linuxX64, PR #421)
    - Discrete-event simulation patterns
diff --git a/build.gradle.kts b/build.gradle.kts
index 424ccf71c..4dad072a5 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -50,7 +50,7 @@ val checkKdisco by tasks.registering {
     doLast {
         val kdiscoJar =
             file(
-                "${System.getProperty("user.home")}/.m2/repository/cz/hovorka/kdisco/kdisco-core-jvm/$kdiscoVersion/kdisco-core-jvm-$kdiscoVersion.jar",
+                "${System.getProperty("user.home")}/.m2/repository/cz/ksimulantenbande/kdisco/kdisco-core-jvm/$kdiscoVersion/kdisco-core-jvm-$kdiscoVersion.jar",
             )
 
         if (kdiscoJar.exists()) {
diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 6252fedd9..94c87df70 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -21,7 +21,7 @@
  *     which benefits from commonMain staying free of JVM-only APIs.
  *  3. kDisco 0.4.0 ships multiplatform artifacts (jvm + linuxX64
  *     klibs) and this module consumes the multiplatform coordinate
- *     (`cz.hovorka.kdisco:kdisco-core`; see commonMain dependencies
+ *     (`cz.ksimulantenbande.kdisco:kdisco-core`; see commonMain dependencies
  *     below). Remaining blockers for fully portable common code are
  *     test infrastructure (MockK/JUnit5 are JVM-only; commonTest is
  *     restricted to kotlin.test) and a Koin/xmlutil native audit on
@@ -129,7 +129,7 @@ kotlin {
         val commonMain by getting {
             dependencies {
                 // KMP multiplatform artifacts (jvm + linuxX64 klibsavailable in mavenLocal)
-                implementation("cz.hovorka.kdisco:kdisco-core:$kdiscoVersion")
+                implementation("cz.ksimulantenbande.kdisco:kdisco-core:$kdiscoVersion")
                 implementation("io.insert-koin:koin-core:$koinVersion")
                 implementation("io.github.oshai:kotlin-logging:$kotlinLoggingVersion")
                 implementation("org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion")
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/DefaultSimulationContext.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/DefaultSimulationContext.kt
index 5a2a2a6e1..630419be6 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/DefaultSimulationContext.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/DefaultSimulationContext.kt
@@ -9,10 +9,10 @@
  */
 package cz.vutbr.fit.interlockSim.context
 
-import cz.hovorka.kdisco.DiscoException
-import cz.hovorka.kdisco.Process
-import cz.hovorka.kdisco.Random
-import cz.hovorka.kdisco.Simulation
+import cz.ksimulantenbande.kdisco.DiscoException
+import cz.ksimulantenbande.kdisco.Process
+import cz.ksimulantenbande.kdisco.Random
+import cz.ksimulantenbande.kdisco.Simulation
 import cz.vutbr.fit.interlockSim.context.SimulationContext.ReportType
 import cz.vutbr.fit.interlockSim.context.navigation.BlockEvent
 import cz.vutbr.fit.interlockSim.context.navigation.PathReservationService
@@ -61,6 +61,7 @@ import cz.vutbr.fit.interlockSim.util.Util
 import cz.vutbr.fit.interlockSim.util.platformIdentityCode
 import io.github.oshai.kotlinlogging.KotlinLogging
 import kotlinx.coroutines.runBlocking
+import cz.ksimulantenbande.kdisco.SimulationEvent as KDiscoSimulationEvent
 import cz.vutbr.fit.interlockSim.sim.events.BlockEvent as AnimBlockEvent
 
 /**
@@ -206,7 +207,7 @@ open class DefaultSimulationContext(
 	private val pendingBlockEventListeners: MutableList<(BlockEvent) -> Unit> = mutableListOf()
 
 	/** Raw kdisco event listeners registered before run(); wired into kdisco at run() time. */
-	private val pendingSimEventListeners: MutableList<(cz.hovorka.kdisco.SimulationEvent) -> Unit> = mutableListOf()
+	private val pendingSimEventListeners: MutableList<(KDiscoSimulationEvent) -> Unit> = mutableListOf()
 
 	/** Spatial-conflict event listeners registered before run(); wired into kdisco at run() time. */
 	private val pendingConflictEventListeners: MutableList<(ConflictDetectedEvent) -> Unit> = mutableListOf()
@@ -1227,7 +1228,7 @@ open class DefaultSimulationContext(
 		pendingBlockEventListeners += listener
 	}
 
-	override fun onSimulationEvent(listener: (cz.hovorka.kdisco.SimulationEvent) -> Unit) {
+	override fun onSimulationEvent(listener: (KDiscoSimulationEvent) -> Unit) {
 		if (simulationHasStarted) return
 		pendingSimEventListeners += listener
 	}
@@ -1410,7 +1411,7 @@ open class DefaultSimulationContext(
 		if (listeners.isEmpty()) return
 		val snapshot = listeners.toList()
 		sim.onEvent { event ->
-			if (event is cz.hovorka.kdisco.SimulationEvent.Custom) {
+			if (event is KDiscoSimulationEvent.Custom) {
 				val payload = event.payload
 				if (payload is T) {
 					snapshot.forEach { it(payload) }
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/SimulationEnvironment.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/SimulationEnvironment.kt
index 42d85bb60..6716d21c3 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/SimulationEnvironment.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/SimulationEnvironment.kt
@@ -9,7 +9,7 @@
  */
 package cz.vutbr.fit.interlockSim.context
 
-import cz.hovorka.kdisco.Condition
+import cz.ksimulantenbande.kdisco.Condition
 import cz.vutbr.fit.interlockSim.context.navigation.BlockEvent
 import cz.vutbr.fit.interlockSim.context.navigation.PathResult
 import cz.vutbr.fit.interlockSim.context.navigation.RoutingServices
@@ -29,7 +29,7 @@ import cz.vutbr.fit.interlockSim.sim.conflict.TemporalConflictDetector
 import cz.vutbr.fit.interlockSim.sim.conflict.TemporalConflictEvent
 import cz.vutbr.fit.interlockSim.sim.events.BlockEventListener
 import cz.vutbr.fit.interlockSim.sim.metrics.MetricsServices
-import cz.hovorka.kdisco.SimulationEvent as KDiscoSimulationEvent
+import cz.ksimulantenbande.kdisco.SimulationEvent as KDiscoSimulationEvent
 import cz.vutbr.fit.interlockSim.sim.events.BlockEvent as AnimBlockEvent
 
 /**
@@ -150,7 +150,7 @@ interface SimulationEnvironment : NetworkState {
 	 * Create a kDisco [Condition] that becomes true when the path starting at
 	 * [separator] is reserved for [trainId].
 	 *
-	 * This lets a train process suspend with [cz.hovorka.kdisco.Process.waitUntil]
+	 * This lets a train process suspend with [cz.ksimulantenbande.kdisco.Process.waitUntil]
 	 * and resume deterministically as soon as the dispatcher reserves the path
 	 * (or as soon as a conflicting train releases the required blocks).
 	 *
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/navigation/BlockEvent.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/navigation/BlockEvent.kt
index 46b5120cf..722100c06 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/navigation/BlockEvent.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/navigation/BlockEvent.kt
@@ -6,7 +6,7 @@ import cz.vutbr.fit.interlockSim.objects.tracks.DynamicTrackBlock
 /**
  * Domain events emitted when block reservation or occupancy state changes.
  *
- * Delivered via kdisco's event bus as [cz.hovorka.kdisco.SimulationEvent.Custom] payloads.
+ * Delivered via kdisco's event bus as [cz.ksimulantenbande.kdisco.SimulationEvent.Custom] payloads.
  * Subscribe via [cz.vutbr.fit.interlockSim.context.SimulationEnvironment.onBlockEvent].
  *
  * All fields are captured at emission time (simulation-thread values).
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/navigation/DefaultPathReservationService.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/navigation/DefaultPathReservationService.kt
index 22d0a86ae..ca4759509 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/navigation/DefaultPathReservationService.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/navigation/DefaultPathReservationService.kt
@@ -9,8 +9,8 @@
  */
 package cz.vutbr.fit.interlockSim.context.navigation
 
-import cz.hovorka.kdisco.Process
-import cz.hovorka.kdisco.emitCustom
+import cz.ksimulantenbande.kdisco.Process
+import cz.ksimulantenbande.kdisco.emitCustom
 import cz.vutbr.fit.interlockSim.context.RouteFinder
 import cz.vutbr.fit.interlockSim.context.SimulationEnvironment
 import cz.vutbr.fit.interlockSim.exceptions.PathSeparatorChangeException
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/navigation/PathReservationRegistry.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/navigation/PathReservationRegistry.kt
index a5c94ff68..9d1358322 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/navigation/PathReservationRegistry.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/navigation/PathReservationRegistry.kt
@@ -9,7 +9,7 @@
  */
 package cz.vutbr.fit.interlockSim.context.navigation
 
-import cz.hovorka.kdisco.Condition
+import cz.ksimulantenbande.kdisco.Condition
 import cz.vutbr.fit.interlockSim.context.SimulationContext
 import cz.vutbr.fit.interlockSim.exceptions.requireValidState
 import cz.vutbr.fit.interlockSim.objects.cells.DynamicRailSwitch
@@ -506,7 +506,7 @@ class PathReservationRegistry(
 	 * The condition is deterministic: kDisco re-evaluates all wait notices after
 	 * every discrete event (including the block-release event that happens when
 	 * [unregister] or [unregisterBlock] removes the owner). A process can suspend
-	 * with [cz.hovorka.kdisco.Process.waitUntil] and resume without busy-polling.
+	 * with [cz.ksimulantenbande.kdisco.Process.waitUntil] and resume without busy-polling.
 	 *
 	 * @param block The block to wait for
 	 * @return A condition evaluating to true once the block is free
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/exceptions/SimulationException.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/exceptions/SimulationException.kt
index 96cc40d30..f2ae70e2a 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/exceptions/SimulationException.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/exceptions/SimulationException.kt
@@ -9,7 +9,7 @@
  */
 package cz.vutbr.fit.interlockSim.exceptions
 
-import cz.hovorka.kdisco.Process
+import cz.ksimulantenbande.kdisco.Process
 
 /**
  * Exception thrown during simulation - at start, between start and end of simulation.
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/objects/cells/DynamicRailSemaphore.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/objects/cells/DynamicRailSemaphore.kt
index ac1fb8b22..62c987b87 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/objects/cells/DynamicRailSemaphore.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/objects/cells/DynamicRailSemaphore.kt
@@ -9,7 +9,7 @@
  */
 package cz.vutbr.fit.interlockSim.objects.cells
 
-import cz.hovorka.kdisco.Process
+import cz.ksimulantenbande.kdisco.Process
 import cz.vutbr.fit.interlockSim.exceptions.PathSeparatorChangeException
 import cz.vutbr.fit.interlockSim.exceptions.requireSimulation
 import cz.vutbr.fit.interlockSim.objects.core.Cell
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/objects/cells/DynamicRailSwitch.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/objects/cells/DynamicRailSwitch.kt
index ef93f1b12..9045a72df 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/objects/cells/DynamicRailSwitch.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/objects/cells/DynamicRailSwitch.kt
@@ -9,7 +9,7 @@
  */
 package cz.vutbr.fit.interlockSim.objects.cells
 
-import cz.hovorka.kdisco.Process
+import cz.ksimulantenbande.kdisco.Process
 import cz.vutbr.fit.interlockSim.exceptions.PathSeparatorChangeException
 import cz.vutbr.fit.interlockSim.exceptions.requireSimulationNotNull
 import cz.vutbr.fit.interlockSim.objects.cells.RailSwitch.Conf
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/objects/paths/AbstractPath.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/objects/paths/AbstractPath.kt
index f21a6449b..402307496 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/objects/paths/AbstractPath.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/objects/paths/AbstractPath.kt
@@ -9,7 +9,7 @@
  */
 package cz.vutbr.fit.interlockSim.objects.paths
 
-import cz.hovorka.kdisco.Process
+import cz.ksimulantenbande.kdisco.Process
 import cz.vutbr.fit.interlockSim.context.SimulationContext
 import cz.vutbr.fit.interlockSim.context.SimulationContext.ReportType
 import cz.vutbr.fit.interlockSim.domain.ABSOLUTE_MAX_SPEED
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/objects/tracks/DynamicTrack.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/objects/tracks/DynamicTrack.kt
index fb77ad73c..cbfb8e0f0 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/objects/tracks/DynamicTrack.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/objects/tracks/DynamicTrack.kt
@@ -9,7 +9,7 @@
  */
 package cz.vutbr.fit.interlockSim.objects.tracks
 
-import cz.hovorka.kdisco.Process
+import cz.ksimulantenbande.kdisco.Process
 import cz.vutbr.fit.interlockSim.exceptions.TrackOperationException
 import cz.vutbr.fit.interlockSim.exceptions.requireSimulation
 import cz.vutbr.fit.interlockSim.exceptions.requireSimulationNotNull
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/objects/tracks/DynamicTrackBlock.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/objects/tracks/DynamicTrackBlock.kt
index f2161617e..99a96297a 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/objects/tracks/DynamicTrackBlock.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/objects/tracks/DynamicTrackBlock.kt
@@ -9,8 +9,8 @@
  */
 package cz.vutbr.fit.interlockSim.objects.tracks
 
-import cz.hovorka.kdisco.Process
-import cz.hovorka.kdisco.emitCustom
+import cz.ksimulantenbande.kdisco.Process
+import cz.ksimulantenbande.kdisco.emitCustom
 import cz.vutbr.fit.interlockSim.context.navigation.BlockEvent
 import cz.vutbr.fit.interlockSim.exceptions.TrackOperationException
 import cz.vutbr.fit.interlockSim.exceptions.requireSimulation
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/ports/DefaultNetworkPerceptionPort.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/ports/DefaultNetworkPerceptionPort.kt
index 4a23608b1..7b852efe5 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/ports/DefaultNetworkPerceptionPort.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/ports/DefaultNetworkPerceptionPort.kt
@@ -9,8 +9,8 @@
  */
 package cz.vutbr.fit.interlockSim.ports
 
-import cz.hovorka.kdisco.DiscoException
-import cz.hovorka.kdisco.Process
+import cz.ksimulantenbande.kdisco.DiscoException
+import cz.ksimulantenbande.kdisco.Process
 import cz.vutbr.fit.interlockSim.context.SimulationEnvironment
 import cz.vutbr.fit.interlockSim.objects.cells.DynamicRailSemaphore
 import cz.vutbr.fit.interlockSim.objects.cells.NodeCell
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/BlockResourceRegistry.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/BlockResourceRegistry.kt
index 070433751..bb13309f6 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/BlockResourceRegistry.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/BlockResourceRegistry.kt
@@ -9,7 +9,7 @@
  */
 package cz.vutbr.fit.interlockSim.sim
 
-import cz.hovorka.kdisco.Resource
+import cz.ksimulantenbande.kdisco.Resource
 import cz.vutbr.fit.interlockSim.context.SimulationContext
 import cz.vutbr.fit.interlockSim.objects.core.TrackFacility
 import cz.vutbr.fit.interlockSim.objects.tracks.DynamicTrackBlock
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/ContinuousInvariantChecker.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/ContinuousInvariantChecker.kt
index db8c5dc66..7f007e027 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/ContinuousInvariantChecker.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/ContinuousInvariantChecker.kt
@@ -9,8 +9,8 @@
  */
 package cz.vutbr.fit.interlockSim.sim
 
-import cz.hovorka.kdisco.Continuous
-import cz.hovorka.kdisco.Process
+import cz.ksimulantenbande.kdisco.Continuous
+import cz.ksimulantenbande.kdisco.Process
 import cz.vutbr.fit.interlockSim.exceptions.requireSimulation
 
 /**
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/DispatchObservation.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/DispatchObservation.kt
index 6d2322306..9eea89a3a 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/DispatchObservation.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/DispatchObservation.kt
@@ -82,6 +82,22 @@ data class QueuedTrainObservation(
  *   [ShuntingLoop]). `null` when no FREE next separator exists, in which case the
  *   dispatcher emits [DispatchDecision.NoAction] for this input (the train waits
  *   and is reconsidered next tick).
+ *
+ *   **Populated only where a forward reservation is possible** (Issue #749). The shell
+ *   resolves it exclusively for inputs satisfying
+ *   `!pathAlreadyExtendedBeyond && (isApproachingThisInput || pathSetUpTowardThisInput)`;
+ *   for every other input — FREE, not approaching this input, or already extended beyond
+ *   it — this is `null` **without the search having been run**. Resolving it means a BFS
+ *   plus a per-candidate topological-path enumeration
+ *   ([PathReservationService.findNextReservationTarget][cz.vutbr.fit.interlockSim.context.navigation.PathReservationService.findNextReservationTarget]);
+ *   running it for the ~98% of inputs whose value is then discarded cost ~9% of fast-sim
+ *   wall time.
+ *
+ *   A `null` here therefore means *"no forward-reservation target applies"*, not
+ *   *"the search found nothing"* — the two are indistinguishable to a dispatcher, and
+ *   both call for the same response (no reservation for this input on this tick).
+ *   Dispatcher implementations — including future LLM-backed ones — must not read
+ *   `toSeparatorName == null` as evidence that the track ahead is occupied.
  * @property state Occupancy state of the block.
  * @property ownerTrainId Name of the train associated with this block: the
  *   occupant's name when OCCUPIED, [cz.vutbr.fit.interlockSim.objects.tracks.DynamicTrackBlock.trainName]
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/Generator.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/Generator.kt
index 31dffb3e7..8a32cd519 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/Generator.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/Generator.kt
@@ -9,12 +9,12 @@
  */
 package cz.vutbr.fit.interlockSim.sim
 
-import cz.hovorka.kdisco.Process
-import cz.hovorka.kdisco.Random
-import cz.hovorka.kdisco.dtMax
-import cz.hovorka.kdisco.dtMin
-import cz.hovorka.kdisco.maxAbsError
-import cz.hovorka.kdisco.maxRelError
+import cz.ksimulantenbande.kdisco.Process
+import cz.ksimulantenbande.kdisco.Random
+import cz.ksimulantenbande.kdisco.dtMax
+import cz.ksimulantenbande.kdisco.dtMin
+import cz.ksimulantenbande.kdisco.maxAbsError
+import cz.ksimulantenbande.kdisco.maxRelError
 import cz.vutbr.fit.interlockSim.context.SimulationEnvironment
 import io.github.oshai.kotlinlogging.KotlinLogging
 
@@ -31,6 +31,13 @@ open class Generator(
 
 	override suspend fun startAction() {
 		dtMin = 1e-6
+		// Block-boundary and tail-entry events are now located by kDisco root-finding
+		// (`Process.waitCrossing`, see Train.kt) rather than by step granularity, so `dtMax` no
+		// longer has to be tiny to keep *those* events' overshoot negligible. Motor's
+		// AccelerationStopCondition (velocity-target detection, Train.kt) is NOT yet converted —
+		// it still relies on step granularity via plain `waitUntil` — so `dtMax` is deliberately
+		// left unchanged here rather than raised further; converting Motor and re-tuning dtMax
+		// is tracked separately (Issue #760, follow-up to #750).
 		dtMax = 1e-3
 		maxRelError = 1e-2
 		maxAbsError = 1e-2
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/InOutWorker.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/InOutWorker.kt
index 20e4c6ffe..7f5bee97b 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/InOutWorker.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/InOutWorker.kt
@@ -9,10 +9,10 @@
  */
 package cz.vutbr.fit.interlockSim.sim
 
-import cz.hovorka.kdisco.Condition
-import cz.hovorka.kdisco.Head
-import cz.hovorka.kdisco.Link
-import cz.hovorka.kdisco.Process
+import cz.ksimulantenbande.kdisco.Condition
+import cz.ksimulantenbande.kdisco.Head
+import cz.ksimulantenbande.kdisco.Link
+import cz.ksimulantenbande.kdisco.Process
 import cz.vutbr.fit.interlockSim.context.SimulationContext.ReportType
 import cz.vutbr.fit.interlockSim.context.SimulationEnvironment
 import cz.vutbr.fit.interlockSim.context.navigation.PathReservationService
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/LoopProcess.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/LoopProcess.kt
index 2b4c93b4d..e613a2d5d 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/LoopProcess.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/LoopProcess.kt
@@ -9,8 +9,8 @@
  */
 package cz.vutbr.fit.interlockSim.sim
 
-import cz.hovorka.kdisco.DiscoException
-import cz.hovorka.kdisco.Process
+import cz.ksimulantenbande.kdisco.DiscoException
+import cz.ksimulantenbande.kdisco.Process
 import io.github.oshai.kotlinlogging.KotlinLogging
 
 /**
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/MultiTrainLoop.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/MultiTrainLoop.kt
index 8167d8643..27b615974 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/MultiTrainLoop.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/MultiTrainLoop.kt
@@ -9,8 +9,8 @@
  */
 package cz.vutbr.fit.interlockSim.sim
 
-import cz.hovorka.kdisco.Process
-import cz.hovorka.kdisco.Resource
+import cz.ksimulantenbande.kdisco.Process
+import cz.ksimulantenbande.kdisco.Resource
 import cz.vutbr.fit.interlockSim.context.SimulationContext
 import cz.vutbr.fit.interlockSim.context.SimulationContext.ReportType
 import cz.vutbr.fit.interlockSim.context.SimulationEnvironment
@@ -52,7 +52,7 @@ import io.github.oshai.kotlinlogging.KotlinLogging
  * ## Determinism
  *
  * Train injection times come from caller-supplied specs, so runs are repeatable
- * when paired with a fixed kDisco seed. No standalone [cz.hovorka.kdisco.Random]
+ * when paired with a fixed kDisco seed. No standalone [cz.ksimulantenbande.kdisco.Random]
  * generator is required.
  *
  * ## Scope limitations (documented)
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/ShuntingLoop.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/ShuntingLoop.kt
index 1c9ffd00c..c516ae158 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/ShuntingLoop.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/ShuntingLoop.kt
@@ -9,7 +9,7 @@
  */
 package cz.vutbr.fit.interlockSim.sim
 
-import cz.hovorka.kdisco.Process
+import cz.ksimulantenbande.kdisco.Process
 import cz.vutbr.fit.interlockSim.context.RailwayNetGrid
 import cz.vutbr.fit.interlockSim.context.SimulationContext
 import cz.vutbr.fit.interlockSim.context.SimulationContext.ReportType
@@ -392,23 +392,50 @@ class ShuntingLoop(
 				TrackFacility.State.RESERVED -> block.trainName
 				TrackFacility.State.OCCUPIED -> requireSimulationNotNull(block.getTrackOccupant()).name
 			}
-		val toSeparatorName = pathReservationService.findNextReservationTarget(to)?.let(::nameOf)
+		val isApproachingThisInput =
+			state == TrackFacility.State.OCCUPIED &&
+				requireSimulationNotNull(block.getTrackOccupant()).nextSemaphore() == to
+		val pathSetUpTowardThisInput =
+			state == TrackFacility.State.RESERVED &&
+				block.isSetUpPath(env.toDynamic(block.getSecondEnd(to)))
+		val pathAlreadyExtendedBeyond = ownerTrainId != null && registry.isPathExtendedBeyond(ownerTrainId, to)
 		return BlockInputObservation(
 			blockId = requireNotNull(block.name) { "ShuntingLoop-owned blocks are always named" },
 			towardSemaphoreName = to.name,
-			toSeparatorName = toSeparatorName,
+			toSeparatorName =
+				findForwardReservationTargetName(
+					to,
+					isApproachingThisInput,
+					pathSetUpTowardThisInput,
+					pathAlreadyExtendedBeyond
+				),
 			state = state,
 			ownerTrainId = ownerTrainId,
-			isApproachingThisInput =
-				state == TrackFacility.State.OCCUPIED &&
-					requireSimulationNotNull(block.getTrackOccupant()).nextSemaphore() == to,
-			pathSetUpTowardThisInput =
-				state == TrackFacility.State.RESERVED &&
-					block.isSetUpPath(env.toDynamic(block.getSecondEnd(to))),
-			pathAlreadyExtendedBeyond = ownerTrainId != null && registry.isPathExtendedBeyond(ownerTrainId, to)
+			isApproachingThisInput = isApproachingThisInput,
+			pathSetUpTowardThisInput = pathSetUpTowardThisInput,
+			pathAlreadyExtendedBeyond = pathAlreadyExtendedBeyond
 		)
 	}
 
+	// Only inputs that can actually yield a forward reservation need a target searched for.
+	// findNextReservationTarget is a graph walk (BFS + per-candidate path enumeration); running
+	// it for FREE and already-extended inputs cost ~9% of fast-sim wall time (#738).
+	private fun findForwardReservationTargetName(
+		to: DynamicRailSemaphore,
+		isApproachingThisInput: Boolean,
+		pathSetUpTowardThisInput: Boolean,
+		pathAlreadyExtendedBeyond: Boolean
+	): String? {
+		val canReserveForward =
+			!pathAlreadyExtendedBeyond &&
+				(isApproachingThisInput || pathSetUpTowardThisInput)
+		return if (canReserveForward) {
+			pathReservationService.findNextReservationTarget(to)?.let(::nameOf)
+		} else {
+			null
+		}
+	}
+
 	/**
 	 * Name of a [DynamicPathSeparator] returned by
 	 * [PathReservationService.findNextReservationTarget] — a [DynamicInOut] or a
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleIntegration.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleIntegration.kt
index 70f5fba7a..4536a5260 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleIntegration.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleIntegration.kt
@@ -9,8 +9,8 @@
  */
 package cz.vutbr.fit.interlockSim.sim
 
-import cz.hovorka.kdisco.Continuous
-import cz.hovorka.kdisco.Variable
+import cz.ksimulantenbande.kdisco.Continuous
+import cz.ksimulantenbande.kdisco.Variable
 
 /**
  * Substitute for "SIMLIB Integrator"
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleLinearTrackTestProcess.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleLinearTrackTestProcess.kt
index 57aea31b7..e3644f602 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleLinearTrackTestProcess.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleLinearTrackTestProcess.kt
@@ -9,7 +9,7 @@
  */
 package cz.vutbr.fit.interlockSim.sim
 
-import cz.hovorka.kdisco.Process
+import cz.ksimulantenbande.kdisco.Process
 import cz.vutbr.fit.interlockSim.context.SimulationContext
 import cz.vutbr.fit.interlockSim.context.SimulationContext.ReportType
 import cz.vutbr.fit.interlockSim.context.SimulationEnvironment
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/Train.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/Train.kt
index b44e83554..7cbf034fc 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/Train.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/Train.kt
@@ -9,12 +9,12 @@
  */
 package cz.vutbr.fit.interlockSim.sim
 
-import cz.hovorka.kdisco.Condition
-import cz.hovorka.kdisco.Continuous
-import cz.hovorka.kdisco.Process
-import cz.hovorka.kdisco.Variable
-import cz.hovorka.kdisco.dtMin
-import cz.hovorka.kdisco.maxAbsError
+import cz.ksimulantenbande.kdisco.Condition
+import cz.ksimulantenbande.kdisco.Continuous
+import cz.ksimulantenbande.kdisco.Process
+import cz.ksimulantenbande.kdisco.Variable
+import cz.ksimulantenbande.kdisco.dtMin
+import cz.ksimulantenbande.kdisco.maxAbsError
 import cz.vutbr.fit.interlockSim.context.SimulationContext.ReportType
 import cz.vutbr.fit.interlockSim.context.SimulationEnvironment
 import cz.vutbr.fit.interlockSim.context.navigation.PathResult
@@ -238,9 +238,20 @@ class Train :
 				requireSimulation(position.isStarted() && pv.isStarted()) {
 					"Position and velocity integration must be active"
 				}
-				waitUntil {
-					// dtmin - horni odhad zmeny pri poslednim kroku numericke metody behem dobrzdovani k uzlu
-					position.state + dtMin >= nextLength
+				// State event (zero-crossing): resume exactly when the front reaches the section
+				// boundary. Root-finding locates the crossing time *within* one integration step,
+				// so `dtMax` no longer has to be tiny to keep the block-boundary overshoot
+				// negligible (Issue #750). The threshold mirrors the original
+				// `waitUntil { position.state + dtMin >= nextLength }`: the boundary counts as
+				// reached once the front is within `dtMin` of it. Keeping that `dtMin` slack is
+				// essential — a train decelerating to a STOP semaphore located *at* the boundary
+				// halts a few nanometres short (v→0 as distance→0), so an exact `nextLength -
+				// position` guard would asymptote to a tiny positive value and never cross zero.
+				// The `if` preserves the old "return immediately when already satisfied" semantics
+				// (`waitCrossing` otherwise waits for a *future* sign change).
+				val boundaryThreshold = nextLength - dtMin
+				if (position.state < boundaryThreshold) {
+					waitCrossing { boundaryThreshold - position.state }
 				}
 
 				position.state -= nextLength
@@ -1051,7 +1062,16 @@ class Train :
 
 		Process.activate(front)
 
-		waitUntil { front.getTotalDistance() >= getLength() }
+		// State event (zero-crossing): start the tail exactly when the front has advanced one
+		// train-length, located by root-finding within the integration step (Issue #750). The
+		// threshold carries the same `dtMin` slack as the block-boundary crossing above so that a
+		// front decelerating to a stop within one train-length of entry still triggers tail entry
+		// instead of asymptoting a few nanometres short and hanging. The `if` preserves
+		// `waitUntil`'s immediate-return-when-satisfied semantics for degenerate short-length cases.
+		val tailEntryThreshold = getLength() - dtMin
+		if (front.getTotalDistance() < tailEntryThreshold) {
+			waitCrossing { tailEntryThreshold - front.getTotalDistance() }
+		}
 		Process.activate(tail)
 
 		out()
@@ -1324,7 +1344,7 @@ class Train :
 	 * is `true`: register this method as the halt callback via
 	 * `collisionDetectionService.registerHaltCallback(train.name, train::requestHalt)`.
 	 *
-	 * **Thread safety:** This method modifies kDisco [cz.hovorka.kdisco.Variable] state.
+	 * **Thread safety:** This method modifies kDisco [cz.ksimulantenbande.kdisco.Variable] state.
 	 * It must only be called from the simulation thread (e.g., from within the
 	 * [DefaultCollisionDetectionService] warning delivery, which runs on that thread).
 	 *
diff --git a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/collision/DefaultCollisionDetectionService.kt b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/collision/DefaultCollisionDetectionService.kt
index 064bb572c..cd83be136 100644
--- a/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/collision/DefaultCollisionDetectionService.kt
+++ b/core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/collision/DefaultCollisionDetectionService.kt
@@ -9,7 +9,7 @@
  */
 package cz.vutbr.fit.interlockSim.sim.collision
 
-import cz.hovorka.kdisco.SimulationEvent
+import cz.ksimulantenbande.kdisco.SimulationEvent
 import cz.vutbr.fit.interlockSim.context.SimulationEnvironment
 import cz.vutbr.fit.interlockSim.context.navigation.BlockEvent
 import cz.vutbr.fit.interlockSim.objects.tracks.DynamicTrackBlock
diff --git a/core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/ContinuousInvariantCheckerTest.kt b/core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/ContinuousInvariantCheckerTest.kt
index 901113895..860b47307 100644
--- a/core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/ContinuousInvariantCheckerTest.kt
+++ b/core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/ContinuousInvariantCheckerTest.kt
@@ -11,7 +11,7 @@ package cz.vutbr.fit.interlockSim.sim
 
 import assertk.assertFailure
 import assertk.assertions.isInstanceOf
-import cz.hovorka.kdisco.DiscoException
+import cz.ksimulantenbande.kdisco.DiscoException
 import kotlin.test.Test
 
 /**
diff --git a/core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/InOutWorkerPathHandlingTest.kt b/core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/InOutWorkerPathHandlingTest.kt
index 326760718..28a3e64a9 100644
--- a/core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/InOutWorkerPathHandlingTest.kt
+++ b/core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/InOutWorkerPathHandlingTest.kt
@@ -13,7 +13,7 @@ import assertk.assertThat
 import assertk.assertions.isFalse
 import assertk.assertions.isNotNull
 import assertk.assertions.isTrue
-import cz.hovorka.kdisco.Head
+import cz.ksimulantenbande.kdisco.Head
 import cz.vutbr.fit.interlockSim.context.SimulationContext
 import cz.vutbr.fit.interlockSim.objects.cells.DynamicInOut
 import cz.vutbr.fit.interlockSim.objects.cells.RailSemaphore
diff --git a/core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/KDiscoNativeCompatibilityTest.kt b/core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/KDiscoNativeCompatibilityTest.kt
index b425ba0eb..57df40b68 100644
--- a/core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/KDiscoNativeCompatibilityTest.kt
+++ b/core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/KDiscoNativeCompatibilityTest.kt
@@ -3,9 +3,9 @@ package cz.vutbr.fit.interlockSim.sim
 import assertk.assertThat
 import assertk.assertions.isEqualTo
 import assertk.assertions.isNotNull
-import cz.hovorka.kdisco.Continuous
-import cz.hovorka.kdisco.Process
-import cz.hovorka.kdisco.Variable
+import cz.ksimulantenbande.kdisco.Continuous
+import cz.ksimulantenbande.kdisco.Process
+import cz.ksimulantenbande.kdisco.Variable
 import cz.vutbr.fit.interlockSim.context.SimulationProcessFactory
 import cz.vutbr.fit.interlockSim.testutil.commonCoreTestModule
 import org.koin.core.component.KoinComponent
diff --git a/core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleIntegrationTest.kt b/core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleIntegrationTest.kt
index 5f3ac1bd2..eb31ba91f 100644
--- a/core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleIntegrationTest.kt
+++ b/core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleIntegrationTest.kt
@@ -13,7 +13,7 @@ package cz.vutbr.fit.interlockSim.sim
 import assertk.assertThat
 import assertk.assertions.isEqualTo
 import assertk.assertions.isNotNull
-import cz.hovorka.kdisco.Variable
+import cz.ksimulantenbande.kdisco.Variable
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 
diff --git a/core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleTestProcess.kt b/core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleTestProcess.kt
index b79456025..2dd8ed723 100644
--- a/core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleTestProcess.kt
+++ b/core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleTestProcess.kt
@@ -9,7 +9,11 @@
  */
 package cz.vutbr.fit.interlockSim.sim
 
-import cz.hovorka.kdisco.Process
+import cz.ksimulantenbande.kdisco.Process
+import cz.ksimulantenbande.kdisco.dtMax
+import cz.ksimulantenbande.kdisco.dtMin
+import cz.ksimulantenbande.kdisco.maxAbsError
+import cz.ksimulantenbande.kdisco.maxRelError
 import io.github.oshai.kotlinlogging.KotlinLogging
 
 /**
@@ -121,6 +125,18 @@ class SimpleTestProcess(
 	 * The train's actions() method will then begin executing.
 	 */
 	override suspend fun startAction() {
+		// Mirrors Generator.startAction()'s physics tolerances (see Generator.kt). Unlike
+		// Generator, this coordinator never runs one, so without this the simulation falls
+		// back to kDisco's own raw defaults (dtMin=1e-5, maxAbsError=1e-5 -- nearly equal in
+		// magnitude). Train's block-boundary/tail-entry waitCrossing guards (Train.kt) are
+		// designed to leave a structural gap of exactly `dtMin` at the moment a threshold is
+		// reached (see Train.kt comments), which is negligible against the intended
+		// maxAbsError=1e-2 but can spuriously trip LengthChecker's invariant when dtMin and
+		// maxAbsError are left at kDisco's near-equal raw defaults instead.
+		dtMin = 1e-6
+		dtMax = 1e-3
+		maxRelError = 1e-2
+		maxAbsError = 1e-2
 		logger.debug { "SimpleTestProcess: Starting test with train ${train.name}" }
 		Process.activate(train) // CRITICAL: activate the train process
 	}
diff --git a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/context/DefaultSimulationContextControllerTest.kt b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/context/DefaultSimulationContextControllerTest.kt
index afce55b9b..ed0d4b74e 100644
--- a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/context/DefaultSimulationContextControllerTest.kt
+++ b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/context/DefaultSimulationContextControllerTest.kt
@@ -13,7 +13,6 @@ import assertk.assertThat
 import assertk.assertions.isEqualTo
 import assertk.assertions.isGreaterThan
 import assertk.assertions.isGreaterThanOrEqualTo
-import assertk.assertions.isLessThan
 import cz.vutbr.fit.interlockSim.sim.ShuntingLoop
 import cz.vutbr.fit.interlockSim.testutil.FakeSimulationController
 import cz.vutbr.fit.interlockSim.testutil.KoinTestBase
@@ -187,41 +186,18 @@ class DefaultSimulationContextControllerTest : KoinTestBase() {
 		assertThat(controller.awaitCalls).isGreaterThanOrEqualTo(1)
 	}
 
-	// ── Overhead test ─────────────────────────────────────────────────────────
-
-	/**
-	 * Verifies that the controlled loop overhead (FakeSimulationController with no sleep)
-	 * is less than 5% compared to the [NoOpSimulationController] baseline.
-	 *
-	 * Both runs use a 300s ShuntingLoop at maximum speed.  The FakeSimulationController
-	 * does nothing in [throttle] and [awaitIfPaused], so any overhead is purely from the
-	 * additional method dispatch and bookkeeping in the `beforeEvent` hook.
-	 */
-	@Test
-	@Timeout(120, unit = TimeUnit.SECONDS)
-	@DisplayName("controlled loop overhead vs NoOpSimulationController is < 5%")
-	fun controlledLoopOverheadIsNegligible() {
-		// Baseline: NoOpSimulationController (zero overhead by definition)
-		val baselineNs = System.nanoTime()
-		loadShuntingLoop(300L).use { ctx ->
-			ctx.run(NoOpSimulationController)
-		}
-		val baselineMs = (System.nanoTime() - baselineNs) / 1_000_000.0
-
-		// With FakeSimulationController that does nothing (no sleep)
-		val fakeController = FakeSimulationController()
-		val withLoopNs = System.nanoTime()
-		loadShuntingLoop(300L).use { ctx ->
-			ctx.run(fakeController)
-		}
-		val withLoopMs = (System.nanoTime() - withLoopNs) / 1_000_000.0
-
-		val overheadPct = (withLoopMs - baselineMs) / baselineMs * 100.0
-		logger.info {
-			"Controlled loop overhead: ${"%.2f".format(overheadPct)}% " +
-				"(baseline=${"%.1f".format(baselineMs)}ms, withLoop=${"%.1f".format(withLoopMs)}ms, " +
-				"throttleCalls=${fakeController.throttleCalls})"
-		}
-		assertThat(overheadPct).isLessThan(5.0)
-	}
+	// ── Overhead ──────────────────────────────────────────────────────────────
+	//
+	// Controlled-loop overhead is a *performance* claim and is measured by
+	// `ControlledLoopOverheadBenchmark` in `desktop-ui/src/jmh`, not here.
+	//
+	// It previously lived in this class as `controlledLoopOverheadIsNegligible`,
+	// which timed two single ShuntingLoop runs and asserted the wall-clock ratio
+	// was < 5%. That is not a property a shared CI runner can honour: one sample
+	// per arm, no JIT warmup (the baseline arm ran first and absorbed it, biasing
+	// the ratio negative), and runner CPU-steal variance well above the 5%
+	// threshold. It failed CI at 5.33% on run 29165254178.
+	//
+	// Run the benchmark with:
+	//   ./gradlew :desktop-ui:jmh -Pjmh.includes='ControlledLoopOverhead'
 }
diff --git a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/context/navigation/BlockEventSubscriptionTest.kt b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/context/navigation/BlockEventSubscriptionTest.kt
index a2b506ee0..b3befe26b 100644
--- a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/context/navigation/BlockEventSubscriptionTest.kt
+++ b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/context/navigation/BlockEventSubscriptionTest.kt
@@ -16,7 +16,7 @@ import org.junit.jupiter.api.Tag
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.Timeout
 import java.util.concurrent.TimeUnit
-import cz.hovorka.kdisco.SimulationEvent as KDiscoSimulationEvent
+import cz.ksimulantenbande.kdisco.SimulationEvent as KDiscoSimulationEvent
 
 @Tag("integration-test")
 @DisplayName("BlockEvent subscription — #569 event delivery")
diff --git a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/context/navigation/BlockReleaseWaitTest.kt b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/context/navigation/BlockReleaseWaitTest.kt
index 9a2d4d3d0..f5a15148c 100644
--- a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/context/navigation/BlockReleaseWaitTest.kt
+++ b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/context/navigation/BlockReleaseWaitTest.kt
@@ -16,8 +16,8 @@ import assertk.assertions.isGreaterThanOrEqualTo
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isSameInstanceAs
 import assertk.assertions.isTrue
-import cz.hovorka.kdisco.Process
-import cz.hovorka.kdisco.Simulation
+import cz.ksimulantenbande.kdisco.Process
+import cz.ksimulantenbande.kdisco.Simulation
 import cz.vutbr.fit.interlockSim.context.DefaultSimulationContext
 import cz.vutbr.fit.interlockSim.context.SimulationContextFactory
 import cz.vutbr.fit.interlockSim.objects.core.DynamicPathSeparator
diff --git a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/GeneratorTest.kt b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/GeneratorTest.kt
index 971bc10ac..74f462c22 100644
--- a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/GeneratorTest.kt
+++ b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/GeneratorTest.kt
@@ -298,7 +298,7 @@ class GeneratorTest : KoinTestBase() {
 			val generator = Generator(mockContext, shuffleInOuts = true)
 			val randomField = Generator::class.java.getDeclaredField("random")
 			randomField.isAccessible = true
-			val kdiscoRandom = randomField.get(generator) as cz.hovorka.kdisco.Random
+			val kdiscoRandom = randomField.get(generator) as cz.ksimulantenbande.kdisco.Random
 
 			// Act: shuffle a 3-element list 8 times, mirroring the shuffle step in
 			// generateRandomTimetable() without calling Process.time().
diff --git a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/LoopProcessTest.kt b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/LoopProcessTest.kt
index 43503d300..8d49a5c08 100644
--- a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/LoopProcessTest.kt
+++ b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/LoopProcessTest.kt
@@ -11,7 +11,7 @@ import assertk.assertThat
 import assertk.assertions.isGreaterThan
 import assertk.assertions.isGreaterThanOrEqualTo
 import assertk.assertions.isLessThanOrEqualTo
-import cz.hovorka.kdisco.Process
+import cz.ksimulantenbande.kdisco.Process
 import cz.vutbr.fit.interlockSim.context.DefaultSimulationContext
 import cz.vutbr.fit.interlockSim.context.SimulationContext.ReportType
 import cz.vutbr.fit.interlockSim.context.SimulationContextFactory
diff --git a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/MultiTrainLoopTest.kt b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/MultiTrainLoopTest.kt
index 25e1c41b8..08122fce2 100644
--- a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/MultiTrainLoopTest.kt
+++ b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/MultiTrainLoopTest.kt
@@ -14,7 +14,7 @@ import assertk.assertions.isEqualTo
 import assertk.assertions.isGreaterThanOrEqualTo
 import assertk.assertions.isTrue
 import assertk.assertions.isZero
-import cz.hovorka.kdisco.emitCustom
+import cz.ksimulantenbande.kdisco.emitCustom
 import cz.vutbr.fit.interlockSim.context.DefaultSimulationContext
 import cz.vutbr.fit.interlockSim.objects.tracks.DynamicTrackBlock
 import cz.vutbr.fit.interlockSim.sim.collision.CollisionWarning
@@ -33,7 +33,7 @@ private val logger = KotlinLogging.logger {}
 
 /**
  * Goal 1 first-slice scenarios: deterministic multi-train dispatcher using
- * kDisco [cz.hovorka.kdisco.Resource] setup-time gating and
+ * kDisco [cz.ksimulantenbande.kdisco.Resource] setup-time gating and
  * [cz.vutbr.fit.interlockSim.context.navigation.PathReservationService] ownership.
  */
 @Tag("integration-test")
diff --git a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/ShuntingLoopReservationTargetLazinessTest.kt b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/ShuntingLoopReservationTargetLazinessTest.kt
new file mode 100644
index 000000000..791637aa2
--- /dev/null
+++ b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/ShuntingLoopReservationTargetLazinessTest.kt
@@ -0,0 +1,135 @@
+package cz.vutbr.fit.interlockSim.sim
+
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isGreaterThan
+import assertk.assertions.isNull
+import cz.vutbr.fit.interlockSim.context.DefaultSimulationContext
+import cz.vutbr.fit.interlockSim.context.EditingContext
+import cz.vutbr.fit.interlockSim.context.JvmEditingContextFactory
+import cz.vutbr.fit.interlockSim.context.SimulationContextFactory
+import cz.vutbr.fit.interlockSim.objects.core.TrackFacility
+import cz.vutbr.fit.interlockSim.testutil.KoinTestBase
+import cz.vutbr.fit.interlockSim.testutil.TestFixtures
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.Timeout
+import org.koin.test.inject
+import java.util.concurrent.TimeUnit
+
+/**
+ * Locks in the sensor-port contract that keeps the forward-reservation graph search
+ * off the per-tick hot path.
+ *
+ * [ShuntingLoop.toBlockInputObservation] resolves [BlockInputObservation.toSeparatorName]
+ * via [PathReservationService.findNextReservationTarget][cz.vutbr.fit.interlockSim.context.navigation.PathReservationService.findNextReservationTarget],
+ * which is a BFS plus a per-candidate topological-path enumeration. Running it for every
+ * block input on every tick — including inputs that provably cannot take a forward
+ * reservation — accounted for ~9% of `fast-sim example shuntingLoop 300` wall time.
+ *
+ * The contract: `toSeparatorName` is populated **only** for inputs that could actually
+ * yield a [DispatchDecision.ReservePath] — a train occupying the block and approaching this
+ * input, or a path already set up toward it — and only when the path is not already extended
+ * beyond it. For every other input it is `null`.
+ *
+ * [RuleBasedDispatcher.checkInput] returns `null` for exactly those non-eligible cases, so
+ * narrowing the contract is behaviour-preserving; the golden `shuntingLoop` output is
+ * byte-for-byte unchanged.
+ *
+ * Reverting the gate (computing `toSeparatorName` unconditionally) makes this test fail:
+ * FREE inputs with clear track ahead resolve to a non-null target.
+ */
+@DisplayName("ShuntingLoop forward-reservation-target laziness contract")
+@Tag("integration-test")
+class ShuntingLoopReservationTargetLazinessTest : KoinTestBase() {
+	private val editingContextFactory: JvmEditingContextFactory by inject()
+	private val simulationContextFactory: SimulationContextFactory by inject()
+
+	private fun loadVyhybnaContext(): DefaultSimulationContext =
+		TestFixtures.loadShuntingXml().use { xmlStream ->
+			val editingContext = editingContextFactory.createContext(xmlStream) as EditingContext
+			simulationContextFactory.createContext(editingContext) as DefaultSimulationContext
+		}
+
+	@Test
+	@Timeout(value = 60, unit = TimeUnit.SECONDS)
+	fun `toSeparatorName is null for every input that cannot take a forward reservation`() {
+		val context = loadVyhybnaContext()
+		context.getInOuts()
+
+		val loop = ShuntingLoop(context, endTime = 120L)
+		wireSynchronousDispatcher(context, loop)
+
+		// Observations are published before the control-step listener fires, so reading them
+		// from a listener installed *after* the wiring sees the current tick's data.
+		val wired = loop.controlStepListener
+		var inputsSeen = 0
+		var freeInputsSeen = 0
+		var eligibleInputsSeen = 0
+		val violations = mutableListOf<String>()
+
+		loop.controlStepListener =
+			ControlStepListener {
+				val inputs = loop.getInnerBlockInputs() + loop.getOuterBlockInputs()
+				for (input in inputs) {
+					inputsSeen++
+					if (input.state == TrackFacility.State.FREE) freeInputsSeen++
+
+					val canReserveForward =
+						!input.pathAlreadyExtendedBeyond &&
+							(input.isApproachingThisInput || input.pathSetUpTowardThisInput)
+					if (canReserveForward) {
+						eligibleInputsSeen++
+					} else if (input.toSeparatorName != null) {
+						violations +=
+							"block=${input.blockId} toward=${input.towardSemaphoreName} state=${input.state} " +
+							"approaching=${input.isApproachingThisInput} " +
+							"setUpToward=${input.pathSetUpTowardThisInput} " +
+							"extendedBeyond=${input.pathAlreadyExtendedBeyond} " +
+							"toSeparatorName=${input.toSeparatorName}"
+					}
+				}
+				wired?.onControlStep()
+			}
+
+		context.setMainProcess(loop)
+		context.run()
+
+		// The run must have exercised the interesting states, otherwise the assertion is vacuous.
+		assertThat(inputsSeen, "block inputs observed").isGreaterThan(0)
+		assertThat(freeInputsSeen, "FREE inputs observed").isGreaterThan(0)
+		assertThat(eligibleInputsSeen, "reservation-eligible inputs observed").isGreaterThan(0)
+
+		assertThat(violations.size, "non-eligible inputs carrying a toSeparatorName: $violations").isEqualTo(0)
+	}
+
+	@Test
+	@Timeout(value = 60, unit = TimeUnit.SECONDS)
+	fun `a FREE block input never carries a forward-reservation target`() {
+		val context = loadVyhybnaContext()
+		context.getInOuts()
+
+		val loop = ShuntingLoop(context, endTime = 120L)
+		wireSynchronousDispatcher(context, loop)
+		val wired = loop.controlStepListener
+
+		val freeWithTarget = mutableListOf<String>()
+		loop.controlStepListener =
+			ControlStepListener {
+				(loop.getInnerBlockInputs() + loop.getOuterBlockInputs())
+					.filter { it.state == TrackFacility.State.FREE }
+					.forEach { input ->
+						if (input.toSeparatorName != null) {
+							freeWithTarget += "${input.blockId}->${input.towardSemaphoreName}=${input.toSeparatorName}"
+						}
+					}
+				wired?.onControlStep()
+			}
+
+		context.setMainProcess(loop)
+		context.run()
+
+		assertThat(freeWithTarget.firstOrNull(), "FREE input with a forward-reservation target").isNull()
+	}
+}
diff --git a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleLinearTrackTestProcessTest.kt b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleLinearTrackTestProcessTest.kt
index 3e251484e..7f3e54adf 100644
--- a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleLinearTrackTestProcessTest.kt
+++ b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleLinearTrackTestProcessTest.kt
@@ -15,7 +15,7 @@ import assertk.assertions.isGreaterThan
 import assertk.assertions.isGreaterThanOrEqualTo
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isLessThanOrEqualTo
-import cz.hovorka.kdisco.Process
+import cz.ksimulantenbande.kdisco.Process
 import cz.vutbr.fit.interlockSim.context.DefaultSimulationContext
 import cz.vutbr.fit.interlockSim.context.navigation.PathReservationService
 import cz.vutbr.fit.interlockSim.testutil.KoinTestBase
@@ -61,14 +61,15 @@ class SimpleLinearTrackTestProcessTest : KoinTestBase() {
 
 	private fun specAB(
 		inTime: Double = 1.0,
-		outTime: Double = 15.0
+		outTime: Double = 15.0,
+		length: Double = 20.0
 	): SimpleLinearTrackTestProcess.TrainSpec =
 		SimpleLinearTrackTestProcess.TrainSpec(
 			inName = "A",
 			outName = "B",
 			inTime = inTime,
 			outTime = outTime,
-			length = 20.0
+			length = length
 		)
 
 	/** Scenario 1: train follows a pre-reserved path A→B and makes genuine forward progress. */
@@ -244,4 +245,53 @@ class SimpleLinearTrackTestProcessTest : KoinTestBase() {
 		assertThat(train.totalDistance).isGreaterThan(distanceBeforeRelease)
 		assertThat(process.getBlockTransitions(train.name)).isGreaterThan(0)
 	}
+
+	/**
+	 * Scenario 5 (Issue #750/#760 follow-up): proves the `waitCrossing` block-boundary
+	 * conversion (Train.kt:254) actually locates each section boundary rather than hanging.
+	 * The A->Sem->B topology (linearPathWithSemaphoreSimulation) has two 100.0m blocks, so
+	 * reaching B means both boundary crossings fired; total distance exceeding the first
+	 * block's length is direct evidence the A->Sem crossing was located correctly.
+	 */
+	@Test
+	@Timeout(value = 60, unit = TimeUnit.SECONDS)
+	fun `train crosses both block boundaries and reaches destination`() {
+		val ctx = loadLinearContext()
+		val inOuts = ctx.getInOuts().toList()
+		val a = inOuts.single { it.name == "A" }
+		val b = inOuts.single { it.name == "B" }
+		val reservationService = ctx.getRoutingServices().getPathReservationService()
+
+		var capturedTrain: Train? = null
+		val process =
+			SimpleLinearTrackTestProcess(
+				ctx,
+				endTime = 50L,
+				trainSpecs = listOf(specAB()),
+				onTrainCreated = { train ->
+					capturedTrain = train
+					val res = reservationService.reservePath(train.name, a, b)
+					assertThat(res).isInstanceOf<PathReservationService.ReservationResult.Success>()
+				}
+			)
+		ctx.setMainProcess(process)
+		ctx.run()
+
+		val train = requireNotNull(capturedTrain) { "onTrainCreated was never called" }
+		// Reaching B proves both waitCrossing block-boundary calls (A->Sem, Sem->B) fired.
+		assertThat(process.getTrainsExited()).isEqualTo(1)
+		// Exceeding the first block's length (100.0m) is direct evidence the A->Sem
+		// waitCrossing call actually located that boundary rather than stalling on it.
+		assertThat(train.totalDistance).isGreaterThan(100.0)
+	}
+
+	// Note: the tail-entry "already satisfied" branch (Train.kt:1072, `if (front.getTotalDistance()
+	// < tailEntryThreshold)`) is only reachable when `length <= dtMin` (1e-6) -- but `dtMin` is
+	// itself far below `ContinuousInvariantChecker`'s `maxAbsError` (1e-2), i.e. below the
+	// simulation's own numerical noise floor for front/tail position tracking. An end-to-end
+	// scenario exercising that branch (tried during this change's verification, e.g.
+	// length = 1e-7) reliably trips the invariant checker's FATAL guard well before completion --
+	// independent of waitUntil vs waitCrossing, since it is a property of train-length realism,
+	// not of the crossing-detection primitive. This degenerate branch is effectively unreachable
+	// for any physically valid train and is not exercised here for that reason.
 }
diff --git a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleTestProcessTest.kt b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleTestProcessTest.kt
index 4e9489796..d9e79b936 100644
--- a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleTestProcessTest.kt
+++ b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleTestProcessTest.kt
@@ -247,7 +247,13 @@ class SimpleTestProcessTest : KoinTestBase() {
 			val finalState = testProcess.getTrainState()
 			assertThat(finalState).isNotNull()
 			assertThat(finalState.velocity).isGreaterThanOrEqualTo(0.0)
-			assertThat(finalState.position).isGreaterThanOrEqualTo(0.0)
+			// `position` can be transiently negative by up to `dtMin` immediately after a
+			// block-boundary crossing (Train.kt:257, `position.state -= nextLength`) -- the
+			// `waitCrossing` guard intentionally fires `dtMin` short of the boundary so it
+			// reliably crosses zero rather than asymptoting forever (see Train.kt comments
+			// on the block-boundary waitCrossing call). This was never a documented
+			// invariant; tolerate the bounded transient rather than requiring an exact >= 0.
+			assertThat(finalState.position).isGreaterThanOrEqualTo(-1e-5)
 		}
 	}
 }
diff --git a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/TrainPhysicsTest.kt b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/TrainPhysicsTest.kt
index b6cb68cf4..c6e53f5d8 100644
--- a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/TrainPhysicsTest.kt
+++ b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/TrainPhysicsTest.kt
@@ -544,7 +544,7 @@ class TrainPhysicsTest : KoinTestBase() {
 		velocityField.isAccessible = true
 
 		// Get the Variable object and set its state
-		val velocityVariable = velocityField.get(train) as cz.hovorka.kdisco.Variable
+		val velocityVariable = velocityField.get(train) as cz.ksimulantenbande.kdisco.Variable
 		velocityVariable.state = velocity
 
 		// Verify the velocity was actually set
diff --git a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/TrainSetTargetSpeedGateTest.kt b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/TrainSetTargetSpeedGateTest.kt
index dd3181456..ffebe2202 100644
--- a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/TrainSetTargetSpeedGateTest.kt
+++ b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/TrainSetTargetSpeedGateTest.kt
@@ -17,7 +17,7 @@ import assertk.assertions.isEqualTo
 import assertk.assertions.isGreaterThan
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isNotEmpty
-import cz.hovorka.kdisco.DiscoException
+import cz.ksimulantenbande.kdisco.DiscoException
 import cz.vutbr.fit.interlockSim.context.DefaultSimulationContext
 import cz.vutbr.fit.interlockSim.context.SimulationContext
 import cz.vutbr.fit.interlockSim.context.SimulationContextFactory
diff --git a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/TwoTrainConcurrencyTest.kt b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/TwoTrainConcurrencyTest.kt
index 715c51b47..99824a1bd 100644
--- a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/TwoTrainConcurrencyTest.kt
+++ b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/TwoTrainConcurrencyTest.kt
@@ -138,13 +138,26 @@ class TwoTrainConcurrencyTest : KoinTestBase() {
 
 		// Per-train: each train's TRAIN_APPROVED must precede its own "ends" event.
 		// Trains may run sequentially, so global ordering across both trains is not required.
+		//
+		// Train names come from a process-global counter that is never reset (Train.countValue),
+		// so by the time this test runs the numbers may be multi-digit. Names must therefore be
+		// compared as extracted whole tokens: a substring test would match "Train #1" inside
+		// "Train #12". Likewise, positions must come from withIndex() rather than List.indexOf(),
+		// which returns the first *equal* LogEntry rather than this one.
 		val trainNameRegex = Regex("""Train #\d+""")
+
+		fun LogEntry.trainName(): String? = trainNameRegex.find(message)?.value
+
+		val indexOfEntry: (LogEntry) -> Int = { target ->
+			log.withIndex().first { (_, entry) -> entry === target }.index
+		}
+
 		for (approvalEntry in approvedEntries) {
-			val trainName = trainNameRegex.find(approvalEntry.message)?.value ?: continue
-			val approvalIdx = log.indexOf(approvalEntry)
-			val endsEntry = endsEntries.firstOrNull { it.message.contains(trainName) }
+			val trainName = approvalEntry.trainName() ?: continue
+			val approvalIdx = indexOfEntry(approvalEntry)
+			val endsEntry = endsEntries.firstOrNull { it.trainName() == trainName }
 			requireNotNull(endsEntry) { "No 'ends' event found for $trainName" }
-			val endsIdx = log.indexOf(endsEntry)
+			val endsIdx = indexOfEntry(endsEntry)
 			assertThat(endsIdx).isGreaterThan(approvalIdx)
 		}
 	}
diff --git a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/collision/AutoPauseHaltTest.kt b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/collision/AutoPauseHaltTest.kt
index 348bcb800..48b5d1ad5 100644
--- a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/collision/AutoPauseHaltTest.kt
+++ b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/collision/AutoPauseHaltTest.kt
@@ -11,7 +11,7 @@ package cz.vutbr.fit.interlockSim.sim.collision
 
 import assertk.assertThat
 import assertk.assertions.isEqualTo
-import cz.hovorka.kdisco.emitCustom
+import cz.ksimulantenbande.kdisco.emitCustom
 import cz.vutbr.fit.interlockSim.context.DefaultSimulationContext
 import cz.vutbr.fit.interlockSim.objects.tracks.DynamicTrackBlock
 import cz.vutbr.fit.interlockSim.sim.LoopProcess
diff --git a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/collision/BlockEntryViolationWarningTest.kt b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/collision/BlockEntryViolationWarningTest.kt
index 2bc823905..37b3e6e23 100644
--- a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/collision/BlockEntryViolationWarningTest.kt
+++ b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/collision/BlockEntryViolationWarningTest.kt
@@ -13,7 +13,7 @@ import assertk.assertThat
 import assertk.assertions.containsExactly
 import assertk.assertions.isFalse
 import assertk.assertions.isTrue
-import cz.hovorka.kdisco.emitCustom
+import cz.ksimulantenbande.kdisco.emitCustom
 import cz.vutbr.fit.interlockSim.context.DefaultSimulationContext
 import cz.vutbr.fit.interlockSim.objects.tracks.DynamicTrackBlock
 import cz.vutbr.fit.interlockSim.sim.LoopProcess
diff --git a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/collision/CollisionDetectionActivationTest.kt b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/collision/CollisionDetectionActivationTest.kt
index fcc207529..1e973cddd 100644
--- a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/collision/CollisionDetectionActivationTest.kt
+++ b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/collision/CollisionDetectionActivationTest.kt
@@ -11,7 +11,7 @@ package cz.vutbr.fit.interlockSim.sim.collision
 
 import assertk.assertThat
 import assertk.assertions.isTrue
-import cz.hovorka.kdisco.emitCustom
+import cz.ksimulantenbande.kdisco.emitCustom
 import cz.vutbr.fit.interlockSim.context.DefaultSimulationContext
 import cz.vutbr.fit.interlockSim.context.SimulationController
 import cz.vutbr.fit.interlockSim.objects.tracks.DynamicTrackBlock
diff --git a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/collision/CollisionDetectionIntegrationTest.kt b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/collision/CollisionDetectionIntegrationTest.kt
index f796fe762..ca5b68371 100644
--- a/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/collision/CollisionDetectionIntegrationTest.kt
+++ b/core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/collision/CollisionDetectionIntegrationTest.kt
@@ -15,7 +15,7 @@ import assertk.assertions.isEmpty
 import assertk.assertions.isEqualTo
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isNotNull
-import cz.hovorka.kdisco.emitCustom
+import cz.ksimulantenbande.kdisco.emitCustom
 import cz.vutbr.fit.interlockSim.context.DefaultSimulationContext
 import cz.vutbr.fit.interlockSim.context.navigation.PathReservationService
 import cz.vutbr.fit.interlockSim.objects.tracks.DynamicTrackBlock
diff --git a/desktop-ui/build.gradle.kts b/desktop-ui/build.gradle.kts
index 4366d1942..1d1b838fd 100644
--- a/desktop-ui/build.gradle.kts
+++ b/desktop-ui/build.gradle.kts
@@ -45,7 +45,7 @@ java {
 }
 
 dependencies {
-    implementation("cz.hovorka.kdisco:kdisco-core-jvm:$kdiscoVersion")
+    implementation("cz.ksimulantenbande.kdisco:kdisco-core-jvm:$kdiscoVersion")
     implementation("org.slf4j:slf4j-api:$slf4jVersion")
     implementation("ch.qos.logback:logback-classic:$logbackVersion")
     implementation("io.github.oshai:kotlin-logging-jvm:$kotlinLoggingVersion")
diff --git a/desktop-ui/src/jmh/kotlin/README.md b/desktop-ui/src/jmh/kotlin/README.md
index c2a717eaa..bb0be925a 100644
--- a/desktop-ui/src/jmh/kotlin/README.md
+++ b/desktop-ui/src/jmh/kotlin/README.md
@@ -33,7 +33,7 @@ cd ~/work/interlockSim
 
 Verify installation:
 ```bash
-ls ~/.m2/repository/cz/hovorka/kdisco/kdisco-core-jvm/0.5.0/
+ls ~/.m2/repository/cz/ksimulantenbande/kdisco/kdisco-core-jvm/0.5.0/
 # Should show: kdisco-core-jvm-0.5.0.jar, kdisco-core-jvm-0.5.0.pom
 ```
 
diff --git a/desktop-ui/src/jmh/kotlin/cz/vutbr/fit/interlockSim/benchmarks/ControlledLoopOverheadBenchmark.kt b/desktop-ui/src/jmh/kotlin/cz/vutbr/fit/interlockSim/benchmarks/ControlledLoopOverheadBenchmark.kt
new file mode 100644
index 000000000..fb2c34351
--- /dev/null
+++ b/desktop-ui/src/jmh/kotlin/cz/vutbr/fit/interlockSim/benchmarks/ControlledLoopOverheadBenchmark.kt
@@ -0,0 +1,195 @@
+/* Brno University of Technology
+ * Faculty of Information Technology
+ *
+ * BSc Thesis  2006/2007
+ *
+ * Railway Interlocking Simulator - Performance Benchmarks
+ *
+ * Bedrich Hovorka
+ */
+package cz.vutbr.fit.interlockSim.benchmarks
+
+import cz.vutbr.fit.interlockSim.context.DefaultSimulationContext
+import cz.vutbr.fit.interlockSim.context.NoOpSimulationController
+import cz.vutbr.fit.interlockSim.context.SimulationContextFactory
+import cz.vutbr.fit.interlockSim.context.SimulationController
+import cz.vutbr.fit.interlockSim.di.interlockSimModule
+import cz.vutbr.fit.interlockSim.sim.ShuntingLoop
+import org.koin.core.context.startKoin
+import org.koin.core.context.stopKoin
+import org.koin.java.KoinJavaComponent
+import org.openjdk.jmh.annotations.Benchmark
+import org.openjdk.jmh.annotations.BenchmarkMode
+import org.openjdk.jmh.annotations.Fork
+import org.openjdk.jmh.annotations.Level
+import org.openjdk.jmh.annotations.Measurement
+import org.openjdk.jmh.annotations.Mode
+import org.openjdk.jmh.annotations.OutputTimeUnit
+import org.openjdk.jmh.annotations.Scope
+import org.openjdk.jmh.annotations.Setup
+import org.openjdk.jmh.annotations.State
+import org.openjdk.jmh.annotations.TearDown
+import org.openjdk.jmh.annotations.Warmup
+import org.openjdk.jmh.infra.Blackhole
+import java.io.InputStream
+import java.util.concurrent.TimeUnit
+
+/**
+ * Measures the cost of the controlled simulation loop in [DefaultSimulationContext.run].
+ *
+ * `run(controller)` invokes [SimulationController.throttle] and
+ * [SimulationController.awaitIfPaused] from the `beforeEvent` hook on every simulation
+ * event.  The question this benchmark answers is: how much does that hook cost when the
+ * controller does nothing at all?
+ *
+ * Two arms, reported independently rather than as a ratio:
+ *
+ * - [baselineNoOpController] passes [NoOpSimulationController], the `object` singleton.
+ *   Being a singleton it is monomorphic at the call site, so the JIT can devirtualize and
+ *   inline the empty bodies away.
+ * - [withBenchmarkController] passes a fresh [BenchmarkController], a distinct class whose
+ *   method bodies are equally empty.
+ *
+ * The delta between the two arms is therefore the real dispatch/bookkeeping cost of the
+ * hook, and it is exactly the asymmetry that the JUnit test which used to live in
+ * `DefaultSimulationContextControllerTest` was silently measuring.
+ *
+ * ## Why this is a benchmark and not a test
+ *
+ * This measurement used to be a JUnit assertion (`controlledLoopOverheadIsNegligible`),
+ * timing one run of each arm with [System.nanoTime] and asserting the wall-clock ratio was
+ * below 5%.  That cannot work on a shared CI runner: a single sample per arm, no JIT
+ * warmup — the baseline arm ran first and absorbed it, biasing the ratio negative — and
+ * runner CPU-steal variance far exceeding the 5% threshold.  It failed CI at 5.33%.
+ * JMH supplies the forks, warmup and measurement iterations that make the number mean
+ * something.  There is no threshold assertion here; read the numbers.
+ *
+ * ## Why SingleShotTime
+ *
+ * The payload is one whole simulation run against a single-use context, so each invocation
+ * needs a freshly built [DefaultSimulationContext]. Under [Mode.AverageTime] JMH drives tens
+ * of thousands of invocations per iteration, and that context churn hits a hard limit:
+ * [DefaultSimulationContext] derives its Koin scope id from an identity hash code
+ * (`platformIdentityCode(this)`), which is not unique, so at that volume ids collide and Koin
+ * throws `ScopeAlreadyCreatedException`. [Mode.SingleShotTime] measures one full run per
+ * invocation and keeps the number of contexts in the hundreds, which is both the honest shape
+ * for a millisecond-scale payload and well clear of the collision threshold.
+ *
+ * Run with:
+ * ```
+ * ./gradlew :desktop-ui:jmh -Pjmh.includes='ControlledLoopOverhead'
+ * ```
+ *
+ * @see DefaultSimulationContext.run
+ * @see NoOpSimulationController
+ */
+@State(Scope.Benchmark)
+@BenchmarkMode(Mode.SingleShotTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@Warmup(iterations = 10)
+@Measurement(iterations = 20)
+@Fork(value = 3)
+open class ControlledLoopOverheadBenchmark {
+	/**
+	 * Simulation end time, in simulated seconds.
+	 *
+	 * The retired JUnit test used 300s.  60s is used here to keep total benchmark
+	 * wall-time reasonable across 3 forks x (3 warmup + 5 measurement) iterations; the
+	 * per-event hook cost this benchmark isolates does not depend on the horizon.
+	 */
+	private val simulationEndTime: Long = 60L
+
+	@Setup(Level.Trial)
+	fun startDi() {
+		stopKoin() // Clean slate — a previous trial in this JVM may have left Koin running.
+		startKoin { modules(interlockSimModule) }
+	}
+
+	@TearDown(Level.Trial)
+	fun stopDi() {
+		stopKoin()
+	}
+
+	/**
+	 * Railway network XML stream. Uses vyhybna.xml (shunting loop), the standard test network.
+	 */
+	private fun railwayNetworkXml(): InputStream =
+		javaClass.getResourceAsStream("/cz/vutbr/fit/interlockSim/resource/vyhybna.xml")
+			?: error("Railway network XML not found on the benchmark classpath")
+
+	/**
+	 * The context under measurement, rebuilt before every invocation.
+	 *
+	 * A [DefaultSimulationContext] is single-use — [DefaultSimulationContext.run] consumes it —
+	 * so each invocation needs a fresh one. It is built in [prepareContext] rather than inside
+	 * the `@Benchmark` body so that XML parsing and context construction, which cost far more
+	 * than the per-event hook under test, stay *outside* the timed region. JMH excludes
+	 * [Level.Invocation] fixture time from the measurement.
+	 */
+	private var context: DefaultSimulationContext? = null
+
+	@Setup(Level.Invocation)
+	fun prepareContext() {
+		val factory =
+			KoinJavaComponent.get<SimulationContextFactory>(SimulationContextFactory::class.java)
+		val ctx = railwayNetworkXml().use { factory.createContext(it) } as DefaultSimulationContext
+		ctx.getInOuts()
+		ctx.setMainProcess(ShuntingLoop(ctx, simulationEndTime))
+		context = ctx
+	}
+
+	@TearDown(Level.Invocation)
+	fun releaseContext() {
+		context?.close()
+		context = null
+	}
+
+	/**
+	 * A [SimulationController] that does nothing, as a distinct class rather than a singleton.
+	 *
+	 * Deliberately not an `object`: the point of the second arm is to present the call site
+	 * with an implementation the JIT cannot assume is the only one.
+	 */
+	private class BenchmarkController : SimulationController {
+		override suspend fun awaitIfPaused() {
+			// No-op: never paused.
+		}
+
+		override fun throttle(simDeltaSeconds: Double) {
+			// No-op: no wall-clock pacing.
+		}
+
+		override fun isPaused(): Boolean = false
+
+		override fun pollStepEvent(): Boolean = false
+
+		override fun pollStepTime(): Double? = null
+
+		override fun requestPause() {
+			// No-op: benchmark runs headless.
+		}
+	}
+
+	/**
+	 * Baseline: the controlled loop driven by the [NoOpSimulationController] singleton.
+	 */
+	@Benchmark
+	fun baselineNoOpController(blackhole: Blackhole) {
+		val ctx = requireNotNull(context) { "prepareContext() must run before the benchmark body" }
+		ctx.run(NoOpSimulationController)
+		blackhole.consume(ctx)
+	}
+
+	/**
+	 * The controlled loop driven by a non-singleton no-op controller.
+	 *
+	 * The difference against [baselineNoOpController] is the hook's dispatch and bookkeeping
+	 * cost per simulation event.
+	 */
+	@Benchmark
+	fun withBenchmarkController(blackhole: Blackhole) {
+		val ctx = requireNotNull(context) { "prepareContext() must run before the benchmark body" }
+		ctx.run(BenchmarkController())
+		blackhole.consume(ctx)
+	}
+}
diff --git a/desktop-ui/src/main/kotlin/cz/vutbr/fit/interlockSim/gui/animation/AnimationStateCapture.kt b/desktop-ui/src/main/kotlin/cz/vutbr/fit/interlockSim/gui/animation/AnimationStateCapture.kt
index a6e3fb0ec..be2f4ad09 100644
--- a/desktop-ui/src/main/kotlin/cz/vutbr/fit/interlockSim/gui/animation/AnimationStateCapture.kt
+++ b/desktop-ui/src/main/kotlin/cz/vutbr/fit/interlockSim/gui/animation/AnimationStateCapture.kt
@@ -9,8 +9,8 @@
  */
 package cz.vutbr.fit.interlockSim.gui.animation
 
-import cz.hovorka.kdisco.DiscoException
-import cz.hovorka.kdisco.Process
+import cz.ksimulantenbande.kdisco.DiscoException
+import cz.ksimulantenbande.kdisco.Process
 import cz.vutbr.fit.interlockSim.context.SimulationContext
 import cz.vutbr.fit.interlockSim.objects.cells.DynamicRailSemaphore
 import cz.vutbr.fit.interlockSim.objects.cells.DynamicRailSwitch
diff --git a/desktop-ui/src/test/kotlin/cz/vutbr/fit/interlockSim/gui/SimulationSpeedGoldenTest.kt b/desktop-ui/src/test/kotlin/cz/vutbr/fit/interlockSim/gui/SimulationSpeedGoldenTest.kt
index 9bc10b609..d41e2d70a 100644
--- a/desktop-ui/src/test/kotlin/cz/vutbr/fit/interlockSim/gui/SimulationSpeedGoldenTest.kt
+++ b/desktop-ui/src/test/kotlin/cz/vutbr/fit/interlockSim/gui/SimulationSpeedGoldenTest.kt
@@ -453,7 +453,7 @@ class SimulationSpeedGoldenTest : KoinTestBase() {
 	/**
 	 * **The [Generator] produces identical train-generation sequences across independent runs.**
 	 *
-	 * [Generator] uses a [cz.hovorka.kdisco.Random] seeded with `0L` and inter-arrival
+	 * [Generator] uses a [cz.ksimulantenbande.kdisco.Random] seeded with `0L` and inter-arrival
 	 * distribution `exp(43.0)`. Two independent runs from the same seed must produce
 	 * identical event timestamps, event types, and all train-lifecycle metrics.
 	 *
diff --git a/dispatcher-agent/build.gradle.kts b/dispatcher-agent/build.gradle.kts
index c81712e19..0782707a7 100644
--- a/dispatcher-agent/build.gradle.kts
+++ b/dispatcher-agent/build.gradle.kts
@@ -86,7 +86,7 @@ dependencies {
     // kDisco: :core uses implementation() so the kDisco API is not exported transitively;
     // add explicitly so test code that compiles against ShuntingLoop (a kDisco Process
     // subclass) can resolve kDisco supertype members.
-    testImplementation("cz.hovorka.kdisco:kdisco-core-jvm:$kdiscoVersion")
+    testImplementation("cz.ksimulantenbande.kdisco:kdisco-core-jvm:$kdiscoVersion")
     // kotlinx-coroutines-core: :core uses implementation() so it is not exported
     // transitively; add explicitly for test code that uses runBlocking (e.g. AgentLoopDriverTest).
     testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVersion")
diff --git a/docs/KOTLIN_STYLE_GUIDE.md b/docs/KOTLIN_STYLE_GUIDE.md
index 9e00ea89f..ed779c756 100644
--- a/docs/KOTLIN_STYLE_GUIDE.md
+++ b/docs/KOTLIN_STYLE_GUIDE.md
@@ -1792,7 +1792,7 @@ Which parameterized annotation to use?
 ### Dependency Management
 
 Dependencies are managed via Gradle with fallback strategy:
-- **kDisco 0.6.0** - Discrete event simulation library (Kotlin Multiplatform, replaces jDisco)
+- **kDisco 0.6.1-SNAPSHOT** - Discrete event simulation library (Kotlin Multiplatform, replaces jDisco)
   - Repository: https://github.com/bedaHovorka/kdisco
   - Published to GitHub Packages: `https://maven.pkg.github.com/bedaHovorka/kdisco`
   - Fallback order: `mavenLocal()` (local cache) → GitHub Packages → build fails
@@ -1846,7 +1846,7 @@ Then run Gradle normally. Because `mavenLocal()` is checked before GitHub Packag
 
 Verify installation:
 ```bash
-ls ~/.m2/repository/cz/hovorka/kdisco/kdisco-core-jvm/0.5.0/
+ls ~/.m2/repository/cz/ksimulantenbande/kdisco/kdisco-core-jvm/0.5.0/
 # Should show: kdisco-core-jvm-0.5.0.jar, kdisco-core-jvm-0.5.0.pom
 ```
 
diff --git a/gradle.properties b/gradle.properties
index 5149f05c4..0a67b040c 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -15,7 +15,7 @@ javaVersion=21
 kotlinVersion=2.3.20
 
 # Dependency versions (updated for Java 21 compatibility)
-kdiscoVersion=0.6.0
+kdiscoVersion=0.6.1-SNAPSHOT
 slf4jVersion=2.0.17
 # Logback 1.5.37 — latest 1.5.x release (2026-06-26). Covers CVE-2026-1225
 # (fixed since 1.5.25, 2026-01-17) and CVE-2026-13006 (fixed in 1.5.37 itself).