chore(claude-do): UsageGate: Parallelitaet stufenweise drosseln statt erst bei

## Kontext: Limits sind Fenster, nicht Summen

Die Runs laufen ueber das Claude-Abo. Limits greifen pro 5h-Fenster und pro 7 Tage. Nicht die Wochensumme tut weh, sondern dass ein Agent-Burst ein Fenster leerraeumt, in dem Mika selbst interaktiv arbeiten will.

## Messgrundlage (alle Transcripts unter ~/.claude/projects)

Agent-Runs sind ueber die ganze Historie nur **18,4 %** des Account-Verbrauch

ClaudeDo-Task: 87105f5e-c4f4-4af4-ae60-89cd2e153e3c

src/ClaudeDo.Worker/Usage/UsageSnapshotBuilder.cs

@@ -46,6 +46,17 @@ public sealed class UsageSnapshotBuilder
             .Select(l => new UsageLimitDto(l.Kind, l.Group, l.Percent, l.Severity, l.ResetsAt, l.ScopeModelDisplayName, l.IsActive))
             .ToList();
 
+        var configuredSlots = Math.Max(1, settings.MaxParallelExecutions);
+        var effectiveSlots = snapshot is null || lastError is not null
+            ? configuredSlots
+            : UsageThrottle.EffectiveSlots(
+                configuredSlots, snapshot.FiveHour?.Utilization, snapshot.SevenDay?.Utilization,
+                settings.UsageThrottleSoftPct, settings.UsageThrottleHardPct,
+                settings.UsageGateFiveHourPct, settings.UsageGateSevenDayPct);
+        var throttleBucket = effectiveSlots < configuredSlots
+            ? DecisiveBucket(snapshot?.FiveHour?.Utilization, snapshot?.SevenDay?.Utilization)
+            : null;
+
         return new UsageSnapshotDto(
             snapshot?.FiveHour?.Utilization,
             snapshot?.FiveHour?.ResetsAt,
@@ -58,6 +69,15 @@ public sealed class UsageSnapshotBuilder
             decision.Reason,
             snapshot?.FetchedAtUtc,
             isStale,
-            lastError);
+            lastError,
+            configuredSlots,
+            effectiveSlots,
+            throttleBucket);
+    }
+
+    private static string? DecisiveBucket(double? fiveHourPct, double? sevenDayPct)
+    {
+        if (fiveHourPct is null && sevenDayPct is null) return null;
+        return (fiveHourPct ?? 0) >= (sevenDayPct ?? 0) ? "five_hour" : "seven_day";
     }
 }

src/ClaudeDo.Worker/Usage/UsageThrottle.cs

@@ -0,0 +1,38 @@
+namespace ClaudeDo.Worker.Usage;
+
+/// <summary>
+/// Pure staged throttle sitting ahead of <see cref="UsageGate"/>'s hard pause: as the 5h/7d usage
+/// window fills up, the queue's effective parallelism steps down before it hits zero, instead of
+/// running at full tilt right up to the gate threshold. Whichever of the two buckets is more
+/// utilized decides the stage. A missing bucket (null) is treated as 0% for that bucket only —
+/// callers with no snapshot at all should skip this and use <paramref name="configuredSlots"/>
+/// directly (fail-open), same policy as <see cref="UsageGate"/>.
+/// </summary>
+public static class UsageThrottle
+{
+    public static int EffectiveSlots(
+        int configuredSlots,
+        double? fiveHourPct,
+        double? sevenDayPct,
+        int softPct,
+        int hardPct,
+        int gateFiveHourPct,
+        int gateSevenDayPct)
+    {
+        var slots = Math.Max(1, configuredSlots);
+
+        if (gateFiveHourPct > 0 && fiveHourPct is { } five && five >= gateFiveHourPct)
+            return 0;
+        if (gateSevenDayPct > 0 && sevenDayPct is { } seven && seven >= gateSevenDayPct)
+            return 0;
+
+        var worst = Math.Max(fiveHourPct ?? 0, sevenDayPct ?? 0);
+
+        if (hardPct > 0 && worst >= hardPct)
+            return Math.Min(slots, 1);
+        if (softPct > 0 && worst >= softPct)
+            return Math.Min(slots, 2);
+
+        return slots;
+    }
+}