fix(kernel): respect the outbox snapshot refresh interval

Avoid a full backlog scan after every successful claim. Prove continued
dispatch with a retained snapshot before the configured interval and a
refresh at its exact monotonic-clock boundary.

ADR: 0046

Author: cemililik

backend/src/LearnStack.Api/Messaging/OutboxProcessor.cs

@@ -99,7 +99,7 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
                         _observation.Progress();
                     }
 
-                    await RefreshAsync(didWork, stoppingToken).ConfigureAwait(false);
+                    await RefreshAsync(force: false, stoppingToken).ConfigureAwait(false);
                 }
                 catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
                 {

backend/tests/LearnStack.Tests.Integration/Database/OutboxProcessorTests.cs

@@ -195,6 +195,55 @@ public async Task Real_provisioning_rows_remain_Pending_across_hosted_polls_with
         (await test.ReadTerminalAuditsAsync()).Should().BeEmpty();
     }
 
+    [Fact]
+    public async Task Successful_claims_keep_the_snapshot_until_its_interval_and_refresh_at_the_boundary()
+    {
+        await using var test = await WorkerDatabase.CreateAsync(schema.Postgres);
+        var time = new SnapshotTimeProvider();
+        var bounds = Bounds with
+        {
+            SnapshotInterval = TimeSpan.FromSeconds(1),
+            PublishTimeout = TimeSpan.FromSeconds(10),
+            LeaseDuration = TimeSpan.FromSeconds(30),
+            ProgressTimeout = TimeSpan.FromSeconds(45),
+        };
+        test.Start(bounds, time);
+        await UntilAsync(() => test.Observation.IsHealthy);
+        var initial = test.Observation.Snapshot;
+        initial.LastSnapshotTimestamp.Should().Be(0);
+
+        var first = await test.InsertAsync();
+        await UntilAsync(async () => (await test.ReadAsync(first)).ProcessedAt is not null);
+        var secondPartition = Guid.CreateVersion7();
+        var second = test.Callbacks.Hold(secondPartition);
+        var secondId = await test.InsertAsync(partition: secondPartition);
+        await second.Entered.Task.WaitAsync(ProofDeadline);
+        // Entering the next callback proves the preceding iteration (including
+        // its refresh decision) completed. Wall-clock duration cannot expire this clock.
+        test.Observation.Snapshot.Queue.Should().BeSameAs(initial.Queue);
+
+        time.Advance(bounds.SnapshotInterval - TimeSpan.FromTicks(1));
+        second.ReleaseCallback.TrySetResult();
+        await UntilAsync(async () => (await test.ReadAsync(secondId)).ProcessedAt is not null);
+        var thirdPartition = Guid.CreateVersion7();
+        var third = test.Callbacks.Hold(thirdPartition);
+        var thirdId = await test.InsertAsync(partition: thirdPartition);
+        await third.Entered.Task.WaitAsync(ProofDeadline);
+        test.Observation.Snapshot.Queue.Should().BeSameAs(initial.Queue);
+        test.Observation.Snapshot.LastSnapshotTimestamp.Should().Be(0);
+
+        time.Advance(TimeSpan.FromTicks(1));
+        third.ReleaseCallback.TrySetResult();
+        await UntilAsync(() => test.Observation.Snapshot.LastSnapshotTimestamp == time.GetTimestamp());
+
+        (await test.ReadAsync(thirdId)).ProcessedAt.Should().NotBeNull();
+        test.Observation.Snapshot.Queue.Should().NotBeSameAs(initial.Queue);
+        test.Observation.Snapshot.Queue.PendingCount.Should().Be(0);
+        test.Observation.Snapshot.LastSnapshotTimestamp.Should().Be(bounds.SnapshotInterval.Ticks);
+        test.Callbacks.Constructions.Should().Be(3);
+        test.Observation.IsHealthy.Should().BeTrue();
+    }
+
     [Fact]
     public async Task A_poison_first_row_terminalizes_with_MUST_audit_and_the_following_real_handler_progresses()
     {
@@ -558,6 +607,14 @@ private sealed record Row(int Attempts, string? Token, DateTimeOffset? Processed
         DateTimeOffset AvailableAfter, string Type, string Payload);
     private sealed record TerminalAudit(string OperationType, string OperationClass, string Correlation, string Metadata);
 
+    private sealed class SnapshotTimeProvider : TimeProvider
+    {
+        private long _timestamp;
+        public override long TimestampFrequency => TimeSpan.TicksPerSecond;
+        public override long GetTimestamp() => Interlocked.Read(ref _timestamp);
+        public void Advance(TimeSpan duration) => Interlocked.Add(ref _timestamp, duration.Ticks);
+    }
+
     /// <summary>Controls shutdown deadlines while all other host timers keep running normally.</summary>
     private sealed class ShutdownTimeProvider(TimeSpan shutdownTimeout) : TimeProvider
     {

docs/roadmap/phase-02b-events-auth.md

@@ -2050,6 +2050,18 @@ Both correction rounds and local validation are complete. Exact correction-head
 CI remains pending in this local receipt; the PR description owns live checks
 and artifact-backed evidence after publication.
 
+#### Snapshot interval correction (2026-10-13)
+
+The dispatch loop no longer forces a full queue snapshot after every successful
+claim. It checks `SnapshotInterval` after completed iterations, while `didWork`
+still controls idle polling. A controlled monotonic-clock integration case
+dispatches three real rows: the initial snapshot survives successful work and
+the last tick before the interval; the exact boundary refreshes it after the
+next completed dispatch. Release build reports zero warnings/errors; format,
+1,847 unit, 287 architecture and all 17 worker integration cases pass, with zero
+failures/skips. Independent correction reviews and new-head CI remain pending
+in this initial local receipt.
+
 ### Durable outbox dispatch
 
 P02b-1 Steps 2/3 implement `IOutbox`, replace Packet 3's step-7 shell with