refactor(runtime): delete the dead in-place ApplyDelta seam; config change = respawn only (#665)

Since #516 a DriverConfig change is stop + respawn, so DriverSpawnPlan.ToApplyDelta
was always empty and the in-place path had no producer. #663 and #664 were both
latent bugs in it. This deletes it:
- host: ApplyChildDelta, _pendingDelta, HandleApplyResult and HandleDeltaApplied
- plan: DriverSpawnPlan.ToApplyDelta
- actor: the ApplyDelta, ApplyResult and DeltaApplied messages, the Connected
  reinit handler and the mid-connect AdoptConfigDuringInit
- tests: the actor tests that drove the seam

IDriver.ReinitializeAsync and each driver's implementation and unit tests stay.
Comments and docs that cited AdoptConfigDuringInit as the reason a driver must
release prior state at init now cite the IDriver contract and overlapping
retries, which still apply.

Claude-Session: https://claude.ai/code/session_01Ef2ozxS7QPanGT8uoATbTe

src/Server/ZB.MOM.WW.OtOpcUa.Runtime/Drivers/DeploymentArtifact.cs

@@ -406,7 +406,7 @@ internal sealed class ParsedDeploymentArtifact : IDisposable
         // v3: each spec's DriverConfig is the MERGED config the driver factory binds from —
         // DriverConfig (protocol/channel) + per-Device DeviceConfig (endpoint) + the driver's authored
         // raw tags (RawTags array, keyed by RawPath) — folded once here via DriverDeviceConfigMerger so
-        // both spawn (TryCreate) and redeploy (ApplyDelta) hand the driver the same shape.
+        // the factory (TryCreate) and the init (InitializeRequested) hand the driver the same shape.
         var rawTagsByDriver = BuildRawTagsByDriver(root);
         var deviceRowsByDriver = BuildDeviceRowsByDriver(root);
 

src/Server/ZB.MOM.WW.OtOpcUa.Runtime/Drivers/DriverHostActor.cs

@@ -391,10 +391,6 @@ public sealed class DriverHostActor : ReceiveActor, IWithTimers, IWithUnboundedS
     /// value maps so stale condition state never leaks across redeploys.</summary>
     private readonly NativeAlarmProjector _nativeAlarmProjector = new();
 
-    /// <summary>In-flight <see cref="DriverInstanceActor.ApplyDelta"/> sends, keyed by correlation, so
-    /// <see cref="HandleApplyResult"/> can advance the cached spec only once the child confirms it adopted
-    /// the config (#516). Bounded by the number of driver children with a delta in flight.</summary>
-    private readonly Dictionary<CorrelationId, DriverInstanceSpec> _pendingDelta = new();
 
     /// <summary>One driver child's desired subscription payload — exactly the
     /// <see cref="DriverInstanceActor.SetDesiredSubscriptions"/> the apply's bulk push sent it.</summary>
@@ -1345,8 +1341,6 @@ public sealed class DriverHostActor : ReceiveActor, IWithTimers, IWithUnboundedS
         Receive<DriverInstanceActor.AttributeAlarmPublished>(ForwardNativeAlarm);
         Receive<DriverInstanceActor.ConnectivityChanged>(OnDriverConnectivityChanged);
         Receive<CommsRecoveryAudit>(HandleCommsRecoveryAudit);
-        Receive<DriverInstanceActor.DeltaApplied>(HandleDeltaApplied);
-        Receive<DriverInstanceActor.ApplyResult>(HandleApplyResult);
         Receive<RestartDriver>(HandleRestartDriver);
         Receive<DriverInstanceActor.ReprovisionRequested>(HandleReprovisionRequested);
         Receive<ReprovisionDeferred>(m => ReprovisionChild(m.Request, m.Child));
@@ -1408,8 +1402,6 @@ public sealed class DriverHostActor : ReceiveActor, IWithTimers, IWithUnboundedS
         Receive<DriverInstanceActor.AttributeAlarmPublished>(ForwardNativeAlarm);
         Receive<DriverInstanceActor.ConnectivityChanged>(OnDriverConnectivityChanged);
         Receive<CommsRecoveryAudit>(HandleCommsRecoveryAudit);
-        Receive<DriverInstanceActor.DeltaApplied>(HandleDeltaApplied);
-        Receive<DriverInstanceActor.ApplyResult>(HandleApplyResult);
         Receive<RestartDriver>(HandleRestartDriver);
         Receive<DriverInstanceActor.ReprovisionRequested>(HandleReprovisionRequested);
         Receive<ReprovisionDeferred>(m => ReprovisionChild(m.Request, m.Child));
@@ -2284,10 +2276,6 @@ public sealed class DriverHostActor : ReceiveActor, IWithTimers, IWithUnboundedS
         // Likewise the 03/S15 recovery audit: a timer armed before the host went Stale has nothing to report
         // on (no latch was set while Stale, and the rebuild re-establishes every node's status anyway).
         Receive<CommsRecoveryAudit>(_ => { });
-        // A late DeltaApplied (an apply completed just before the DB went Stale) — re-register the driver's
-        // mux adapter anyway; it simply re-reads the driver's current refs (harmless, no DB access).
-        Receive<DriverInstanceActor.DeltaApplied>(HandleDeltaApplied);
-        Receive<DriverInstanceActor.ApplyResult>(HandleApplyResult);
         Receive<SubscribeAck>(_ => { /* PubSub ack */ });
         Timers.StartPeriodicTimer("retry-db", RetryConfigDbConnection.Instance, ReconnectInterval);
     }
@@ -2704,7 +2692,7 @@ public sealed class DriverHostActor : ReceiveActor, IWithTimers, IWithUnboundedS
 
     /// <summary>
     ///     Read the deployment artifact + reconcile the set of running <see cref="DriverInstanceActor"/>
-    ///     children. Spawn missing, ApplyDelta on config change, stop removed/disabled drivers.
+    ///     children. Spawn missing, respawn on config change, stop removed/disabled drivers.
     ///     When the artifact blob is empty (legacy ControlPlane tests, smoke fixtures) the reconcile is
     ///     SKIPPED outright — see the issue #485 guard below — and when the configured
     ///     <see cref="IDriverFactory"/> can't materialise any of the requested types this is a no-op.
@@ -2917,16 +2905,11 @@ public sealed class DriverHostActor : ReceiveActor, IWithTimers, IWithUnboundedS
         var plan = DriverSpawnPlanner.Compute(snapshots, specs);
 
         foreach (var id in plan.ToStop) StopChild(id);
-        foreach (var spec in plan.ToApplyDelta) ApplyChildDelta(spec);
         foreach (var spec in plan.ToSpawn) SpawnChild(spec);
 
         // v3 (WP7): a dependency-consumer driver's declared dependency refs change when its tags/scripts are
-        // edited — the adapter must re-register the NEW set on the mux. Newly-spawned adapters register in
-        // PreStart; an ApplyDelta'd driver's adapter is re-registered when the child reports it finished
-        // reinitialising (DriverInstanceActor.DeltaApplied → HandleDeltaApplied). That notification is
-        // sequenced AFTER ReinitializeAsync rebuilds DependencyRefs — a synchronous re-register HERE would
-        // re-read the STALE ref set (ApplyDelta runs asynchronously on the child), so it is deliberately NOT
-        // done inline.
+        // edited. That edit changes its DriverConfig, which respawns it (#516), and the respawned driver's
+        // adapter registers the NEW set in PreStart — no separate re-register is needed (#665).
     }
 
     /// <summary>
@@ -3557,69 +3540,6 @@ public sealed class DriverHostActor : ReceiveActor, IWithTimers, IWithUnboundedS
             Context.Stop(adapter);
     }
 
-    /// <summary>
-    ///     Sends an in-place config delta to a running child.
-    ///     <para><b>Unreachable from the reconcile path since #516</b> — a DriverConfig change is now a
-    ///     stop + respawn (<see cref="DriverSpawnPlanner"/>), so <c>ToApplyDelta</c> is always empty.
-    ///     Kept because the seam is still exercised by <c>DriverInstanceActor</c>'s own mid-connect config
-    ///     adoption.</para>
-    ///     <para><b>Two seals were removed here.</b> This used to overwrite the cached
-    ///     <c>Spec</c> SYNCHRONOUSLY, before the child had even dequeued the message — so the host
-    ///     immediately believed the new config was live, the NEXT reconcile computed no delta against it,
-    ///     and any drift was sealed permanently. It also <c>Tell</c>d with no <c>Receive&lt;ApplyResult&gt;</c>
-    ///     handler registered, so a FAILED reinit — including Galaxy's deliberate
-    ///     <c>NotSupportedException</c> — dead-lettered and was never surfaced.</para>
-    /// </summary>
-    private void ApplyChildDelta(DriverInstanceSpec spec)
-    {
-        if (!_children.TryGetValue(spec.DriverInstanceId, out var entry)) return;
-        var correlation = CorrelationId.NewId();
-        _pendingDelta[correlation] = spec;
-        entry.Actor.Tell(new DriverInstanceActor.ApplyDelta(spec.DriverConfig, correlation), Self);
-        _log.Debug("DriverHost {Node}: ApplyDelta queued for {Id}", _localNode, spec.DriverInstanceId);
-    }
-
-    /// <summary>
-    ///     A child's reply to <see cref="ApplyChildDelta"/>. On success the cached <c>Spec</c> is advanced —
-    ///     only now, when the child has actually adopted the config, so a failed reinit leaves the host
-    ///     believing the OLD config is live and the next reconcile re-attempts the change instead of
-    ///     silently treating the drift as applied. A failure is logged at Error rather than swallowed.
-    /// </summary>
-    private void HandleApplyResult(DriverInstanceActor.ApplyResult msg)
-    {
-        if (msg.Success)
-        {
-            if (_pendingDelta.Remove(msg.Correlation, out var spec)
-                && _children.TryGetValue(spec.DriverInstanceId, out var entry))
-            {
-                // A delta can change Name, Enabled, ClusterId etc. alongside the config.
-                _children[spec.DriverInstanceId] = entry with { Spec = spec };
-            }
-            return;
-        }
-
-        _pendingDelta.Remove(msg.Correlation, out var failed);
-        _log.Error(
-            "DriverHost {Node}: driver {Id} REJECTED an in-place config change ({Reason}) — the host keeps " +
-            "the previous config so the next reconcile re-attempts it",
-            _localNode, failed?.DriverInstanceId ?? "<unknown>", msg.Reason ?? "no reason given");
-    }
-
-    /// <summary>
-    ///     A driver child finished applying an in-place <see cref="DriverInstanceActor.ApplyDelta"/> (its
-    ///     <see cref="IDriver.ReinitializeAsync"/> completed). Re-register THAT driver's dependency-consumer
-    ///     mux adapter so a changed dependency-ref set (calc tags/scripts edited during the redeploy) is
-    ///     adopted on the mux. This runs AFTER reinit — closing the ordering hazard where a synchronous
-    ///     re-register at ApplyDelta dispatch would re-read the driver's stale
-    ///     <see cref="IDependencyConsumer.DependencyRefs"/>. A Tell (no blocking); a no-op for a driver with no
-    ///     adapter (not an <see cref="IDependencyConsumer"/>, or no mux wired on this node).
-    /// </summary>
-    private void HandleDeltaApplied(DriverInstanceActor.DeltaApplied msg)
-    {
-        if (_depConsumerAdapters.TryGetValue(msg.DriverInstanceId, out var adapter))
-            adapter.Tell(new ZB.MOM.WW.OtOpcUa.Runtime.VirtualTags.DependencyConsumerMuxAdapter.ReRegister());
-    }
-
     private void StopChild(string driverInstanceId)
     {
         if (!_children.TryGetValue(driverInstanceId, out var entry)) return;

src/Server/ZB.MOM.WW.OtOpcUa.Runtime/Drivers/DriverInstanceActor.cs

@@ -25,8 +25,7 @@ file sealed class HealthPollTick
 ///   <item><c>Failed</c> — terminal until parent restarts the actor.</item>
 /// </list>
 ///
-/// Engine wiring (subscriptions → AttributeValueUpdate publishes, ApplyDelta-driven Reinitialize,
-/// per-tag write Asks) is staged for follow-up F7. This skeleton compiles + has a working
+/// Engine wiring (subscriptions → AttributeValueUpdate publishes, per-tag write Asks) is staged for follow-up F7. This skeleton compiles + has a working
 /// state machine so the Phase 6 control-plane integration tests can target it.
 /// </summary>
 public sealed class DriverInstanceActor : ReceiveActor, IWithTimers
@@ -41,7 +40,7 @@ public sealed class DriverInstanceActor : ReceiveActor, IWithTimers
     /// <c>Connected=true</c> on entering the Connected state, <c>false</c> on entering Reconnecting. The host
     /// annotates this driver's native alarm conditions' source-data Quality from it (comms lost → Bad,
     /// restored → Good) — independently of alarm transitions, since a comms-lost driver emits no alarm
-    /// events. Fire-and-forget, mirroring <see cref="DeltaApplied"/>.</summary>
+    /// events. Fire-and-forget.</summary>
     public sealed record ConnectivityChanged(string DriverInstanceId, bool Connected);
 
     /// <summary>
@@ -62,18 +61,6 @@ public sealed class DriverInstanceActor : ReceiveActor, IWithTimers
     /// <param name="DriverInstanceId">The driver instance that was restarted.</param>
     /// <param name="Reason">The type name of the exception that tripped supervision, for the host's log.</param>
     public sealed record ReprovisionRequested(string DriverInstanceId, string Reason);
-    public sealed record ApplyDelta(string DriverConfigJson, CorrelationId Correlation);
-    public sealed record ApplyResult(bool Success, string? Reason, CorrelationId Correlation);
-    /// <summary>
-    ///     Sent to the parent (<see cref="DriverHostActor"/>) AFTER an <see cref="ApplyDelta"/> has fully
-    ///     re-initialised the driver (i.e. <see cref="IDriver.ReinitializeAsync"/> completed). The host uses
-    ///     it to re-register this driver's dependency-consumer mux adapter: a driver may rebuild its declared
-    ///     <see cref="IDependencyConsumer.DependencyRefs"/> during reinit (the Calculation driver re-binds its
-    ///     calc tags), so the re-register MUST happen after reinit — NOT synchronously alongside the ApplyDelta
-    ///     dispatch, which would re-read the STALE ref set. Emitted only on a successful apply.
-    /// </summary>
-    /// <param name="DriverInstanceId">The instance whose adapter should be re-registered.</param>
-    public sealed record DeltaApplied(string DriverInstanceId);
     public sealed record WriteAttribute(string TagId, object Value);
     public sealed record WriteAttributeResult(bool Success, string? Reason);
     /// <summary>
@@ -221,15 +208,9 @@ public sealed class DriverInstanceActor : ReceiveActor, IWithTimers
     private readonly ILoggingAdapter _log = Context.GetLogger();
     private string? _currentConfigJson;
 
-    /// <summary>#664: set when <see cref="AdoptConfigDuringInit"/> adopts a new config mid-connect; the next
-    /// (generation-matched) <see cref="InitializeSucceeded"/> sends <see cref="DeltaApplied"/> to the parent and
-    /// clears it, so a dependency consumer's mux interest is re-registered against the ADOPTED config — the
-    /// same post-reinit notification the Connected <see cref="HandleApplyDeltaAsync"/> path sends.</summary>
-    private bool _adoptedConfigPendingNotify;
-
     /// <summary>Monotonic token tagging each <see cref="InitializeAsync"/> attempt. An init result is
     /// honoured only when its generation matches the latest; an older result is from a superseded attempt
-    /// (e.g. an <see cref="ApplyDelta"/> adopted a new config mid-(re)connect) and is dropped. Touched only
+    /// (a retry tick that overlapped a still-running attempt) and is dropped. Touched only
     /// on the actor thread, so no lock is needed.</summary>
     private int _initGeneration;
 
@@ -442,7 +423,6 @@ public sealed class DriverInstanceActor : ReceiveActor, IWithTimers
         // Stubbed drivers accept the standard message contracts but return deterministic
         // success without touching real hardware. Read returns null; Write succeeds.
         Receive<InitializeRequested>(_ => { /* no-op */ });
-        Receive<ApplyDelta>(msg => Sender.Tell(new ApplyResult(true, "stubbed", msg.Correlation)));
         Receive<WriteAttribute>(_ => Sender.Tell(new WriteAttributeResult(true, "stubbed")));
         // Stubbed drivers have no upstream alarm system — swallow the ack (it's fire-and-forget, no reply).
         Receive<RouteAlarmAck>(_ => { /* stubbed drivers have no alarm backend */ });
@@ -468,13 +448,11 @@ public sealed class DriverInstanceActor : ReceiveActor, IWithTimers
         // fire-and-forget — no reply to surface — and the OPC UA condition state already committed locally).
         Receive<RouteAlarmAck>(_ =>
             _log.Debug("DriverInstance {Id}: alarm ack arrived during connect — dropped (driver not connected)", _driverInstanceId));
-        Receive<ApplyDelta>(AdoptConfigDuringInit);
         Receive<InitializeSucceeded>(msg =>
         {
             if (msg.Generation != _initGeneration) return;
             _log.Info("DriverInstance {Id}: connected", _driverInstanceId);
             Become(Connected);
-            NotifyAdoptedConfig();
             PublishHealthSnapshot();
             ResubscribeDesired();
             AttachAlarmSource();
@@ -522,7 +500,6 @@ public sealed class DriverInstanceActor : ReceiveActor, IWithTimers
         // reconnects but never manages a read is measured from THIS connect, not from a stale earlier one.
         _connectedSinceUtc = DateTime.UtcNow;
 
-        ReceiveAsync<ApplyDelta>(HandleApplyDeltaAsync);
         Receive<DisconnectObserved>(msg =>
         {
             _log.Warning("DriverInstance {Id}: disconnect observed ({Reason}); reconnecting",
@@ -771,14 +748,12 @@ public sealed class DriverInstanceActor : ReceiveActor, IWithTimers
         // no reply — the OPC UA condition state already committed locally on the Part 9 ack).
         Receive<RouteAlarmAck>(_ =>
             _log.Debug("DriverInstance {Id}: alarm ack arrived during reconnect — dropped (driver not connected)", _driverInstanceId));
-        Receive<ApplyDelta>(AdoptConfigDuringInit);
         Receive<InitializeSucceeded>(msg =>
         {
             if (msg.Generation != _initGeneration) return;
             Timers.Cancel("retry-connect");
             _log.Info("DriverInstance {Id}: reconnected", _driverInstanceId);
             Become(Connected);
-            NotifyAdoptedConfig();
             PublishHealthSnapshot();
             ResubscribeDesired();
             AttachAlarmSource();
@@ -875,94 +850,6 @@ public sealed class DriverInstanceActor : ReceiveActor, IWithTimers
         });
     }
 
-    /// <summary>Adopt a new config while not connected: ApplyDelta in Connecting/Reconnecting re-inits
-    /// immediately with the new config. <see cref="InitializeAsync"/> swaps <c>_currentConfigJson</c> and
-    /// bumps the generation, so the in-flight (old-config) init is superseded and its result is dropped.
-    /// The actor stays in its current state; the new init's result drives the next transition. In
-    /// Reconnecting the retry timer is left running — if this immediate attempt fails it keeps retrying
-    /// the new config (a redundant concurrent attempt is deduped by the generation guard).</summary>
-    private void AdoptConfigDuringInit(ApplyDelta msg)
-    {
-        _log.Info("DriverInstance {Id}: ApplyDelta during (re)connect — adopting new config, re-initialising now",
-            _driverInstanceId);
-        InitializeAsync(msg.DriverConfigJson);
-        _adoptedConfigPendingNotify = true;
-        Sender.Tell(new ApplyResult(true, "config adopted; reinitializing", msg.Correlation));
-    }
-
-    /// <summary>Send the deferred <see cref="DeltaApplied"/> for a mid-connect adoption (#664) once the driver
-    /// has actually initialised on the adopted config. A no-op otherwise.</summary>
-    private void NotifyAdoptedConfig()
-    {
-        if (!_adoptedConfigPendingNotify) return;
-        _adoptedConfigPendingNotify = false;
-        Context.Parent.Tell(new DeltaApplied(_driverInstanceId));
-    }
-
-    /// <summary>Adopt a new config while Connected, in place, via <see cref="IDriver.ReinitializeAsync"/>.
-    /// <para>#663: every driver's reinit releases its device/session state (#630), so the driver-side data and
-    /// native-alarm subscriptions do not survive it — but this handler used to keep both handles, and the
-    /// health-poll reconcile only re-subscribes a MISSING handle, so the driver went silent until a
-    /// reconnect or respawn. Both subscriptions are now released explicitly BEFORE the reinit (explicitly,
-    /// not just by nulling the handles, so a driver whose reinit keeps its subscriptions is not left
-    /// holding two) and re-established after it — in a <c>finally</c>, because a failed reinit has already
-    /// lost them too. Reinit stays the adoption path rather than shutdown + initialise: Calculation and
-    /// Galaxy take their config at construction and ignore <see cref="IDriver.InitializeAsync"/>'s JSON.</para>
-    /// <para>Not reachable from a deploy since #516 (a DriverConfig change respawns the driver).</para></summary>
-    private async Task HandleApplyDeltaAsync(ApplyDelta msg)
-    {
-        var replyTo = Sender;
-        await UnsubscribeAsync();
-        await ReleaseAlarmSubscriptionAsync();
-        try
-        {
-            await _driver.ReinitializeAsync(msg.DriverConfigJson, CancellationToken.None);
-            _currentConfigJson = msg.DriverConfigJson;
-            // The driver may have rebuilt its dependency-consumer interest during reinit (the Calculation
-            // driver re-binds its calc tags + dependency refs). Notify the parent so it re-registers this
-            // driver's mux adapter AFTER reinit completed — a synchronous re-register at ApplyDelta-dispatch
-            // time would re-read the driver's STALE DependencyRefs. Parent Tell (fire-and-forget); the
-            // continuation resumes on the actor context (no ConfigureAwait) so Context.Parent is live.
-            Context.Parent.Tell(new DeltaApplied(_driverInstanceId));
-            replyTo.Tell(new ApplyResult(true, null, msg.Correlation));
-        }
-        catch (Exception ex)
-        {
-            replyTo.Tell(new ApplyResult(false, ex.Message, msg.Correlation));
-        }
-        finally
-        {
-            ResubscribeDesired();
-            AttachAlarmSource();
-            SubscribeDesiredAlarms();
-        }
-    }
-
-    /// <summary>Release the native-alarm subscription at the driver (best-effort, bounded) and drop the
-    /// actor's handler + handle. The in-place reinit counterpart of the data <see cref="UnsubscribeAsync"/>
-    /// (#663).</summary>
-    private async Task ReleaseAlarmSubscriptionAsync()
-    {
-        if (_driver is IAlarmSource src && _alarmSubscriptionHandle is { } handle)
-        {
-            try
-            {
-                using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
-                await _invoker.ExecuteAsync(
-                    DriverCapability.AlarmSubscribe,
-                    _driverInstanceId,
-                    async ct => await src.UnsubscribeAlarmsAsync(handle, ct),
-                    cts.Token);
-            }
-            catch (Exception ex)
-            {
-                _log.Warning(ex, "DriverInstance {Id}: releasing the native-alarm subscription ({Diag}) threw (continuing)",
-                    _driverInstanceId, handle.DiagnosticId);
-            }
-        }
-        DetachAlarmSource();
-    }
-
     private async Task HandleWriteAsync(WriteAttribute msg)
     {
         var replyTo = Sender;

src/Server/ZB.MOM.WW.OtOpcUa.Runtime/Drivers/DriverSpawnPlan.cs

@@ -3,38 +3,31 @@ namespace ZB.MOM.WW.OtOpcUa.Runtime.Drivers;
 /// <summary>
 ///     Pure diff between the currently-running driver children (keyed by
 ///     <c>DriverInstance.DriverInstanceId</c>) and the target spec list from a freshly-applied
-///     deployment artifact. The DriverHostActor consumes the three lists and calls
-///     spawn / ApplyDelta / stop on its child actors accordingly.
+///     deployment artifact. The DriverHostActor consumes the two lists and calls
+///     spawn / stop on its child actors accordingly. There is no in-place config path: since #516 a config
+///     change is a stop + respawn, and #665 deleted the unreachable in-place <c>ApplyDelta</c> seam.
 /// </summary>
-/// <param name="ToSpawn">Specs with no current child — create a new actor.</param>
-/// <param name="ToApplyDelta">
-///     In-place config deltas. <b>Always empty since #516</b> — a DriverConfig change is now a
-///     stop + respawn so the factory is the single parse authority. Retained because
-///     <c>DriverInstanceActor</c> still handles <c>ApplyDelta</c> on its own config-adoption path
-///     (a config arriving mid-connect), and removing the list would hide that seam.
-/// </param>
+/// <param name="ToSpawn">Specs with no current child (or whose child is being replaced) — create a new actor.</param>
 /// <param name="ToStop">DriverInstanceIds currently running but missing from the new artifact, or now disabled.</param>
 public sealed record DriverSpawnPlan(
     IReadOnlyList<DriverInstanceSpec> ToSpawn,
-    IReadOnlyList<DriverInstanceSpec> ToApplyDelta,
     IReadOnlyList<string> ToStop);
 
 public static class DriverSpawnPlanner
 {
     /// <summary>
-    ///     Compute the spawn/delta/stop sets. Disabled entries in <paramref name="target"/> are
+    ///     Compute the spawn/stop sets. Disabled entries in <paramref name="target"/> are
     ///     treated as "not desired here": if a child exists for the id it goes into ToStop,
     ///     otherwise the row is dropped entirely (no spawn for a disabled driver).
     /// </summary>
     /// <param name="current">The currently running driver children keyed by ID.</param>
     /// <param name="target">The target driver instances from the deployment artifact.</param>
-    /// <returns>The computed <see cref="DriverSpawnPlan"/> with spawn, apply-delta, and stop sets.</returns>
+    /// <returns>The computed <see cref="DriverSpawnPlan"/> with spawn and stop sets.</returns>
     public static DriverSpawnPlan Compute(
         IReadOnlyDictionary<string, DriverChildSnapshot> current,
         IReadOnlyList<DriverInstanceSpec> target)
     {
         var toSpawn = new List<DriverInstanceSpec>();
-        var toDelta = new List<DriverInstanceSpec>();
         var toStop = new List<string>();
 
         var targetById = new Dictionary<string, DriverInstanceSpec>(StringComparer.Ordinal);
@@ -83,7 +76,7 @@ public static class DriverSpawnPlanner
             toSpawn.Add(spec);
         }
 
-        return new DriverSpawnPlan(toSpawn, toDelta, toStop);
+        return new DriverSpawnPlan(toSpawn, toStop);
     }
 }