feat(infra): Flowable RegistratieVerlopen worker + document-wait completion (refs #102)

FlowableWorkflowClient implements IRegistratieVerlopenClient (acquire/complete the
RegistratieVerlopen jobs) and CompleteDocumentWaitAsync (complete WachtOpDocumenten,
best-effort). Wires the RegistratieVerlopenProcessor + hosted RegistratieVerlopenPump
into the domain host and excludes the pump from mutation (like the other pumps).
Fakes updated for the new IWorkflowClient member.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

services/domain/Big.Infrastructure/FlowableWorkflowClient.cs

@@ -15,12 +15,14 @@ namespace Big.Infrastructure;
 /// The REST contract here is the one verified against a live flowable-rest engine (ADR-0009).
 /// </summary>
 public sealed class FlowableWorkflowClient(HttpClient http, FlowableOptions options)
-    : IWorkflowClient, IExternalWorkerClient, IUserTaskClient, IBeoordelingEscalatieClient
+    : IWorkflowClient, IExternalWorkerClient, IUserTaskClient, IBeoordelingEscalatieClient, IRegistratieVerlopenClient
 {
     private const string Topic = "OpenZaakAanmaken";
     private const string EscalatieTopic = "BeoordelingEscaleren";
+    private const string VerlopenTopic = "RegistratieVerlopen";
     private const string ProcessDefinitionKey = "registratie";
     private const string BeoordelenTaskKey = "Beoordelen";
+    private const string WachtOpDocumentenTaskKey = "WachtOpDocumenten";
     private const string BehandelaarGroup = "behandelaar";
     private const string TeamleadGroup = "teamlead";
     private const string RegistrationIdVariable = "registrationId";
@@ -114,6 +116,25 @@ public sealed class FlowableWorkflowClient(HttpClient http, FlowableOptions opti
         response.EnsureSuccessStatusCode();
     }
 
+    public async Task CompleteDocumentWaitAsync(string processInstanceId, CancellationToken ct = default)
+    {
+        // Find the still-open WachtOpDocumenten task in this instance and complete it, so the process
+        // leaves the 30-day wait and continues to beoordeling (S-10a, ADR-0017). If the instance is no
+        // longer parked there (already continued, or the timer already cancelled it) this is a
+        // best-effort no-op — mirroring the withdrawal/escalation correlation (§8.6).
+        var query = new TaskByInstanceQueryRequest(processInstanceId, WachtOpDocumentenTaskKey);
+        var page = await PostAsync<TaskByInstanceQueryRequest, TaskQueryResult>(
+            "service/query/tasks", query, ct);
+
+        var task = page?.Data?.FirstOrDefault();
+        if (task is null)
+            return;
+
+        using var response = await SendAsync(
+            $"service/runtime/tasks/{task.Id}", new CompleteTaskRequest("complete", []), ct);
+        response.EnsureSuccessStatusCode();
+    }
+
     public async Task<IReadOnlyList<EscalatieJob>> AcquireBeoordelingEscalatieJobsAsync(int maxJobs, CancellationToken ct = default)
     {
         var request = new AcquireJobsRequest(EscalatieTopic, options.LockDuration, maxJobs, options.WorkerId);
@@ -155,6 +176,23 @@ public sealed class FlowableWorkflowClient(HttpClient http, FlowableOptions opti
         response.EnsureSuccessStatusCode();
     }
 
+    public async Task<IReadOnlyList<RegistratieVerlopenJob>> AcquireRegistratieVerlopenJobsAsync(int maxJobs, CancellationToken ct = default)
+    {
+        var request = new AcquireJobsRequest(VerlopenTopic, options.LockDuration, maxJobs, options.WorkerId);
+
+        var jobs = await PostAsync<AcquireJobsRequest, List<AcquiredJob>>(
+            "external-job-api/acquire/jobs", request, ct) ?? [];
+
+        return [.. jobs.Select(job => new RegistratieVerlopenJob(job.Id, RegistrationId.Parse(job.RegistrationId())))];
+    }
+
+    public async Task CompleteRegistratieVerlopenJobAsync(string jobId, CancellationToken ct = default)
+    {
+        using var response = await SendAsync(
+            $"external-job-api/acquire/jobs/{jobId}/complete", new CompleteJobRequest(options.WorkerId, []), ct);
+        response.EnsureSuccessStatusCode();
+    }
+
     private async Task<TResponse?> GetAsync<TResponse>(string path, CancellationToken ct)
     {
         var message = new HttpRequestMessage(HttpMethod.Get, new Uri(options.BaseUrl, path));

services/domain/Big.Infrastructure/RegistratieVerlopenPump.cs

@@ -0,0 +1,49 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace Big.Infrastructure;
+
+/// <summary>
+/// The hosted polling loop of the document-timeout worker (S-10a, ADR-0017): on an interval it
+/// resolves a scoped <see cref="RegistratieVerlopenProcessor"/> and asks it to drain the parked
+/// <c>RegistratieVerlopen</c> jobs. A deliberately thin shell — all acquire/expire/complete logic
+/// lives in the processor, which is unit-tested; this class only owns the timer, the per-tick scope,
+/// and loop resilience. Structurally identical to <see cref="BeoordelingEscalatiePump"/>.
+/// </summary>
+public sealed class RegistratieVerlopenPump(
+    IServiceScopeFactory scopeFactory,
+    FlowableOptions options,
+    ILogger<RegistratieVerlopenPump> logger) : BackgroundService
+{
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            try
+            {
+                using var scope = scopeFactory.CreateScope();
+                var processor = scope.ServiceProvider.GetRequiredService<RegistratieVerlopenProcessor>();
+                await processor.PumpOnceAsync(options.MaxJobsPerPoll, stoppingToken);
+            }
+            catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
+            {
+                break;
+            }
+            catch (Exception ex)
+            {
+                // A transient fault (e.g. Flowable briefly unreachable) must not kill the loop.
+                logger.LogError(ex, "RegistratieVerlopen job poll failed; retrying after the poll interval.");
+            }
+
+            try
+            {
+                await Task.Delay(options.PollInterval, stoppingToken);
+            }
+            catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
+            {
+                break;
+            }
+        }
+    }
+}