Honour the worker's landing budget in the log capture drain

backend/src/CodeSpace.Core/Services/Agents/AgentRunExecutor.cs

@@ -4765,10 +4765,10 @@
     /// <summary>The same reconstruction from a payload that came from somewhere other than the row — an offloaded one fetched back out of the artifact store.</summary>
     private static AgentEvent ReplayedEvent(AgentEventKind kind, string? text, string? dataJson)
     {
         if (dataJson is not { Length: > 0 } json) return new AgentEvent { Kind = kind, Text = text };
 
         try { using var doc = JsonDocument.Parse(json); return new AgentEvent { Kind = kind, Text = text, Data = doc.RootElement.Clone() }; }
         catch (JsonException) { return new AgentEvent { Kind = kind, Text = text }; }
     }
 
     /// <summary>Ask the row, on a token of its own, whether the run actually reached a terminal state — the only honest answer to "did the landing take?" once an exception has been raised somewhere after the fenced write.</summary>
@@ -5087,6 +5087,15 @@
             {
                 TeamId = context.TeamId, AgentRunId = context.RunId, ActorId = context.ActorId,
                 WorkerFenceEpoch = context.WorkerFenceEpoch, Handle = handle, Source = source, Redactor = context.Redactor,
+                // A drain that waits out a destination which is refusing writes costs this run its VERDICT on a
+                // tear-down, in one of two ways depending on which capture is draining. For the session opened here on
+                // the LIVE path the token is the job's, and a drain that will not end is a tear-down that never STARTS
+                // — EndBrokeredAttemptOnShutdownAsync runs from the OperationCanceledException this drain is sitting
+                // on. For the session this very method opens again under EndBrokeredAttemptOnShutdownAsync the token
+                // IS ShutdownLeaseLandingBudget, and every second the drain spends is one the terminal write does not
+                // get. So the drain is told, with the same predicate the tear-down arm itself acts on — the HOST's own
+                // lifetime, never a cancelled job token.
+                HostShutdown = _lifetime?.ApplicationStopping ?? CancellationToken.None,
             }, cancellationToken).ConfigureAwait(false);
         }
         catch (Exception exception) when (exception is not OperationCanceledException || !cancellationToken.IsCancellationRequested)