Budgetende, Stufe 3: Nachholen nur im Spielraum des Tages, keine Kappung bei 500 (#716)

- TaskSchedule.OccurrencesBetween zaehlt, wie oft eine Aufgabe bis zu einem
  Zeitpunkt noch laeuft, einschliesslich eines jetzt faelligen Laufs.
- BudgetHeadroom (ILateRunGate): Ein mitgenommener oder nachzuholender Lauf
  startet nur, wenn er in den Spielraum passt: Grenze minus Verbrauch minus
  Reservierung minus Bedarf der restlichen geplanten Laeufe bis Mitternacht
  minus 10 % Reserve. Das gilt je Agent und je Instanz, fuer Kosten und Tokens.
  Anderes Spaetwerk zaehlt nicht als Bedarf, sonst blockierten sich
  mitgenommene Aufgaben gegenseitig.
- Der Scanner fragt den Spielraum nur fuer Spaetwerk und protokolliert, wenn es
  warten muss. Die Engine gibt ihren BudgetGuard heraus, damit Scanner und
  Engine dieselben Reservierungen sehen.
- Ersetzt den pauschalen 25-%-Anteil aus dem Konzept (dort nachgezogen): Ein
  fester Anteil ist an vollen Tagen zu viel, an ruhigen zu wenig.

Drei weitere stille Kappungen bei 500 beseitigt (ListAllAsync, ungekappt):
Kostenprognose (Aufgaben ueber 500 fehlten), Waisenabgleich beim Import und
task_find aus #674, wo Dubletten unter aelteren Aufgaben mit niedriger
Prioritaet unsichtbar wurden.

Tests: BudgetHeadroomTests (9), Scanner-Pforte (1), Dublette hinter 500
Aufgaben (1). 1.257 gruen.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

src/ClawdDotNet.Core/Tasks/TaskScanner.cs

@@ -44,6 +44,15 @@ public interface IMarketCalendar
     bool IsOpen(DateTime nowUtc);
 }
 
+/// <summary>
+/// #716: Decides whether a late run — carried-over work or a catch-up — may start now.
+/// Without one, late runs only wait for the regular ones of the same tick.
+/// </summary>
+public interface ILateRunGate
+{
+    Task<bool> HasRoomAsync(TaskItem lateTask, IReadOnlyList<TaskItem> runnable, DateTime nowUtc, CancellationToken ct);
+}
+
 /// <summary>Bis C1 kommt: der Markt gilt als immer offen.</summary>
 public sealed class AlwaysOpenMarketCalendar : IMarketCalendar
 {
@@ -110,6 +119,11 @@ public sealed class TaskScanner : IAsyncDisposable
     private readonly Dictionary<string, (int Misses, int CarriedOver, int CatchUps)> _missesToday = new(StringComparer.OrdinalIgnoreCase);
     private DateOnly? _missDay;
 
+    private readonly ILateRunGate? _lateRunGate;
+
+    /// <summary>How many late runs waited for budget headroom at the last tick.</summary>
+    private int _lastWaitingForHeadroom;
+
     private readonly CancellationTokenSource _cts = new();
     private Task? _loop;
 
@@ -122,7 +136,8 @@ public sealed class TaskScanner : IAsyncDisposable
         TimeSpan? tick = null,
         TimeSpan? lease = null,
         int maxParallelRuns = DefaultMaxParallelRuns,
-        Func<TaskItem, BudgetMissPolicy>? budgetMissPolicy = null)
+        Func<TaskItem, BudgetMissPolicy>? budgetMissPolicy = null,
+        ILateRunGate? lateRunGate = null)
     {
         _repo = repo;
         _dispatcher = dispatcher;
@@ -133,6 +148,7 @@ public sealed class TaskScanner : IAsyncDisposable
         _lease = lease ?? TimeSpan.FromMinutes(15);
         _maxParallelRuns = Math.Max(1, maxParallelRuns);
         _missPolicy = budgetMissPolicy ?? (_ => BudgetMissPolicy.Expire);
+        _lateRunGate = lateRunGate;
     }
 
     /// <summary>How many scheduled runs may be in flight at once (#682).</summary>
@@ -319,7 +335,8 @@ public sealed class TaskScanner : IAsyncDisposable
 
         var launched = new List<Task>();
         var waiting = 0;
-        foreach (var (task, occ, _) in due)
+        var waitingForHeadroom = 0;
+        foreach (var (task, occ, late) in due)
         {
             // OpenCount also counts runs started by hand (RunTaskNowAsync) — they take a
             // slot, even though they did not wait for one.
@@ -329,6 +346,14 @@ public sealed class TaskScanner : IAsyncDisposable
                 continue;
             }
 
+            // #716: Late work only uses what the rest of the day does not need.
+            if (late && _lateRunGate is not null
+                && !await _lateRunGate.HasRoomAsync(task, candidates, now, ct))
+            {
+                waitingForHeadroom++;
+                continue;
+            }
+
             var token = Guid.NewGuid().ToString("N");
             if (await _repo.TryClaimAsync(task.Id, occ, token, now, leaseCutoff, ct))
                 launched.Add(Track(RunLoggedAsync(task, token, ct)));
@@ -347,6 +372,16 @@ public sealed class TaskScanner : IAsyncDisposable
             _lastWaiting = waiting;
         }
 
+        if (waitingForHeadroom != _lastWaitingForHeadroom)
+        {
+            if (waitingForHeadroom > 0)
+                _logger.LogInformation(
+                    "{Waiting} carried-over or catch-up run(s) waiting for budget headroom — "
+                    + "the rest of today's schedule comes first",
+                    waitingForHeadroom);
+            _lastWaitingForHeadroom = waitingForHeadroom;
+        }
+
         return launched;
     }