feat(worker): expose usage/model-usage hub surface and persist run model

Adds GetUsageSnapshot/GetModelUsage/GetTaskUsage to WorkerHub (backed by a
shared UsageSnapshotBuilder), a UsageUpdated broadcast fired after every
UsageMonitorService poll cycle, and records the resolved model on each
task_runs row so per-model/per-task usage can be reported from history.

src/ClaudeDo.Worker/Usage/UsageMonitorService.cs

@@ -1,4 +1,5 @@
 using ClaudeDo.Worker.Config;
+using ClaudeDo.Worker.Hub;
 using ClaudeDo.Worker.Usage.Interfaces;
 
 namespace ClaudeDo.Worker.Usage;
@@ -7,6 +8,8 @@ namespace ClaudeDo.Worker.Usage;
 /// Polls <see cref="IUsageClient"/> on <see cref="WorkerConfig.UsagePollIntervalSeconds"/> and keeps
 /// <see cref="UsageState"/> current. Polls once immediately at startup. A failure is logged as a
 /// warning at most once per distinct error message, to avoid log spam on a persistent outage.
+/// Broadcasts <see cref="HubBroadcaster.UsageUpdated"/> after every poll cycle, success or failure,
+/// so the UI can reflect a stale/blocked state as soon as it happens.
 /// </summary>
 public sealed class UsageMonitorService : BackgroundService
 {
@@ -14,15 +17,20 @@ public sealed class UsageMonitorService : BackgroundService
     private readonly UsageState _state;
     private readonly WorkerConfig _config;
     private readonly ILogger<UsageMonitorService> _logger;
+    private readonly UsageSnapshotBuilder _snapshotBuilder;
+    private readonly HubBroadcaster _broadcaster;
     private string? _lastLoggedError;
 
     public UsageMonitorService(
-        IUsageClient client, UsageState state, WorkerConfig config, ILogger<UsageMonitorService> logger)
+        IUsageClient client, UsageState state, WorkerConfig config, ILogger<UsageMonitorService> logger,
+        UsageSnapshotBuilder snapshotBuilder, HubBroadcaster broadcaster)
     {
         _client = client;
         _state = state;
         _config = config;
         _logger = logger;
+        _snapshotBuilder = snapshotBuilder;
+        _broadcaster = broadcaster;
     }
 
     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
@@ -64,5 +72,8 @@ public sealed class UsageMonitorService : BackgroundService
                 _lastLoggedError = ex.Message;
             }
         }
+
+        var dto = await _snapshotBuilder.BuildAsync(ct);
+        await _broadcaster.UsageUpdated(dto);
     }
 }

src/ClaudeDo.Worker/Usage/UsageSnapshotBuilder.cs

@@ -0,0 +1,63 @@
+using ClaudeDo.Data;
+using ClaudeDo.Data.Repositories;
+using ClaudeDo.Worker.Config;
+using ClaudeDo.Worker.Hub;
+using ClaudeDo.Worker.Usage.Interfaces;
+using Microsoft.EntityFrameworkCore;
+
+namespace ClaudeDo.Worker.Usage;
+
+/// <summary>
+/// Builds the Hub-facing usage snapshot DTO from UsageState + IUsageGate + AppSettings
+/// thresholds. Shared by WorkerHub.GetUsageSnapshot and UsageMonitorService's post-poll
+/// broadcast so both surfaces agree on staleness/threshold logic.
+/// </summary>
+public sealed class UsageSnapshotBuilder
+{
+    private readonly UsageState _state;
+    private readonly IUsageGate _gate;
+    private readonly IDbContextFactory<ClaudeDoDbContext> _dbFactory;
+    private readonly WorkerConfig _cfg;
+
+    public UsageSnapshotBuilder(
+        UsageState state, IUsageGate gate, IDbContextFactory<ClaudeDoDbContext> dbFactory, WorkerConfig cfg)
+    {
+        _state = state;
+        _gate = gate;
+        _dbFactory = dbFactory;
+        _cfg = cfg;
+    }
+
+    public async Task<UsageSnapshotDto> BuildAsync(CancellationToken ct = default)
+    {
+        var snapshot = _state.Snapshot;
+        var lastError = _state.LastError;
+
+        Data.Models.AppSettingsEntity settings;
+        using (var context = _dbFactory.CreateDbContext())
+            settings = await new AppSettingsRepository(context).GetAsync(ct);
+
+        var decision = await _gate.EvaluateAsync(ct);
+
+        var maxAge = TimeSpan.FromSeconds(_cfg.UsagePollIntervalSeconds * 3);
+        var isStale = snapshot is null || lastError is not null || (DateTime.UtcNow - snapshot.FetchedAtUtc) > maxAge;
+
+        var limits = (snapshot?.Limits ?? Array.Empty<UsageLimitRow>())
+            .Select(l => new UsageLimitDto(l.Kind, l.Group, l.Percent, l.Severity, l.ResetsAt, l.ScopeModelDisplayName, l.IsActive))
+            .ToList();
+
+        return new UsageSnapshotDto(
+            snapshot?.FiveHour?.Utilization,
+            snapshot?.FiveHour?.ResetsAt,
+            snapshot?.SevenDay?.Utilization,
+            snapshot?.SevenDay?.ResetsAt,
+            limits,
+            settings.UsageGateFiveHourPct,
+            settings.UsageGateSevenDayPct,
+            decision.IsBlocked,
+            decision.Reason,
+            snapshot?.FetchedAtUtc,
+            isStale,
+            lastError);
+    }
+}