docs(architecture): ADR-0011 approval status flow + demo note (refs #75)

Records the two non-obvious decisions: the ACL resolves the zaaktype eindstatus
(domain stays ZGW-ignorant), and the event-subscriber projects INGESCHREVEN from
the notification alone (hoofdObject + any status-create), never reading OpenZaak.

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

CHANGELOG.md

@@ -2,130 +2,19 @@
 
 All notable changes to this project. Generated from Conventional Commits by git-cliff.
 
-## v2026.07.0 — 2026-07-14
+## Unreleased
-
-### Architecture
-- ADR-0005 adopt Stryker.NET for mutation testing (refs #47)
-- ADR-0006 — provision the ACL integration test against the compose stack (refs #46)
-- ADR-0007 + runbooks for the OZ→NRC notification wiring (refs #56)
-- ADR-0009 external-task job-worker pattern (refs #6, #60)
-- ADR-0010 BFF OIDC validation + downstream boundaries (refs #8, #63)
-
-### Bug Fixes
-- Pin OpenZaak/NRC image tags; add smoke log capture on failure (refs #30)
-- Harden oz-db healthcheck and raise compose-up timeout (refs #30)
-- Bake config into images so compose-smoke passes on CI (refs #30)
-- Nrc-init runs migrations only, not setup_configuration (refs #30)
-- Smoke waits on durable services, not the whole project (refs #30)
-- Portable health poll instead of compose --wait (refs #30)
-- Pin upload-artifact to @v3 — @v4 refuses to run on Gitea (refs #47)
-- Buffer the zaak POST body so OpenZaak accepts it (refs #46)
-- Keep dotnet format green under the shared .editorconfig (refs #65)
-- Re-export the full Utrecht package from libs/ui (refs #67)
-- Run checkAuth() at startup to end the login redirect loop (refs #67)
-- Health-check nginx over IPv4 (127.0.0.1) (refs #68)
-- Treat the http portal origin as secure so DigiD PKCE login works (refs #68)
-- Attach the DigiD token to relative BFF calls (refs #68)
-
-### Build
-- Pin Stryker.NET as a local dotnet tool (refs #47)
 
 ### CI
 - Gitea Actions pipeline + runner runbook (refs #30) (#37)
-- ACL Dockerfile + full compose stack for smoke test (refs #30)
-- Switch runner label to ubuntu-latest (refs #30)
-- Run the mutation ratchet as a parallel CI job (refs #47)
-- Publish the Stryker HTML report as a CI artifact (refs #47)
-- Run the ACL integration test as a Gitea Actions job (refs #46)
-- Keep the integration lane local-only; document the runner gap (refs #46)
-- Run the ACL integration test in CI inside the compose network (closes #55) (refs #46)
-- Run the Event Subscriber + projection-api in compose and verify end-to-end (refs #7)
-- Containerize, wire into compose, and verify end-to-end (refs #6)
-- Make Stryker report upload best-effort (refs #62)
-- Retrigger after runner cleanup (refs #6)
-- Retrigger CI (refs #6)
-- Retrigger CI after gitea restart (refs #6)
-- Compose wiring, verify-bff live check, mutation baseline (refs #8)
-- Nx frontend lane (lint/test/build) (refs #65)
-- Serve the self-service app in compose (refs #68)
-- Run Vitest ahead of the production build to stop worker-start timeout (refs #68)
-- Cache the NuGet package store across the .NET jobs (refs #73)
-- Run Playwright from the prebuilt image instead of downloading browsers (refs #73)
 
 ### Chores
 - Add idempotent Gitea backlog seeder
 - Remove bootstrap scripts from main (#35)
-- Contributor workflow — templates, git-cliff, gitea-workflow doc (closes #31) (#38)
 
 ### Documentation
 - Split S-00 into sub-slices (refs #1) (#33)
-- MkDocs scaffold + ADR-0001 + README quickstart (closes #32) (#39)
-- Tighten gitea-actions-gotchas, add local compose (refs #30)
-- ADR-0008 read projection store + demo note for the event path (refs #7)
-- Demo note for submitting a registration (S-05) (refs #6)
-- Demo note for the BFF front door (S-07) (refs #8)
-- Split S-08 into S-08a-d (refs #65)
-- Frontend-decisions + demo note for S-08a (refs #65)
-- Record the orval generator choice (refs #66)
-- Record NL DS + DigiD decisions and demo note (refs #67)
-- Serving/e2e decisions + walking-skeleton demo note (refs #68)
 
 ### Features
 - Placeholder BFF + /health endpoint (closes #28) (#34)
 - Containerize BFF + compose-up smoke (closes #29) (#36)
-- OpenZaak + Postgres + Redis up in compose (refs #10) (#40)
-- Seed BIG catalogus + JWT client for OpenZaak (refs #2) (#41)
-- Open Notificaties up + shared network (closes #2) (#42)
-- Keycloak with four mock realms (closes #3) (#43)
-- Flowable + registratie.bpmn external task (closes #4) (#44)
-- ACL skeleton — OpenZaak default-fill (refs #5) (#45)
-- Add bind-mount local compose for no-make/Windows dev (refs #30)
-- Publish the BIG zaaktype on demand via OZ_PUBLISH (refs #46)
-- Wire OpenZaak → Open Notificaties notifications (refs #56)
-- Project zaak-created notifications into the read projection (refs #7)
-- Persist the read projection and expose webhook + read APIs (refs #7)
-- Enforce the callback bearer before reading the body (refs #7)
-- Implement the Registration aggregate invariants (refs #6)
-- Implement SubmitRegistration and OpenZaakWorker (refs #6)
-- Implement the Flowable Workflow Client and ACL client (refs #6)
-- Expose POST /registrations and the read endpoint (refs #6)
-- Implement self-service submit and openbaar lookup (refs #8)
-- Committed OpenAPI contract + drift guard (refs #8)
-- Self-service portal placeholder page (refs #65)
-- Expose the generated BFF client + repeatable generate target (refs #66)
-- Implement the DigiD registration submit page (refs #67)
-- Runtime config + nginx serve/proxy image (refs #68)
-- Surface submit failures with a retryable alert (refs #68)
-- One citizen reference across self-service and the openbaar register (#79)
-
-### Other
-- Openbaar Register portal — public lookup (#76)
-- Approval flow — temp admin endpoint + status transition to projection (#77)
-
-### Refactor
-- Bake config via dockerfile_inline, drop Dockerfile files (refs #30)
-- Use upstream images verbatim, seed config via docker cp (refs #30)
-- One verify-stack stage for all live-stack checks (closes #58) (refs #46 #56)
-
-### Tests
-- BDD acceptance scenario for opening a zaak (closes #5) (#49)
-- Kill surviving mutants — assert CRS headers, guards, error paths, JWT claims (refs #47)
-- Add Stryker config + mutation make target recording the 95% baseline (refs #47)
-- Integration test opens a real zaak against OpenZaak (refs #46)
-- Verify-notifications smoke + CI job for the OZ→NRC path (refs #56)
-- Project zaak-created notifications into the read projection (refs #7)
-- Ratchet projector mutation baseline to 100% (refs #7)
-- Registration aggregate invariants (refs #6)
-- SubmitRegistration + OpenZaakWorker use cases (refs #6)
-- Workflow Client, ACL client, store and job processor (refs #6)
-- Acceptance scenario for submitting a registration (refs #6)
-- Mutation baseline 90 (achieved 97.7%) + CI/Makefile wiring (refs #6)
-- Endpoints, JWT auth and public-safe projection (refs #8)
-- Acceptance scenario for BFF access (valid/invalid tokens) (refs #8)
-- Self-service portal placeholder renders (refs #65)
-- Generated BFF client is exposed and calls the endpoints (refs #66)
-- DigiD-guarded registration submit page (refs #67)
-- Walking-skeleton Playwright happy path + verify-e2e lane (refs #68)
-- Submit surfaces BFF failures instead of swallowing them (refs #68)
-- Guard that the DigiD token attaches to relative BFF calls (refs #68)
 

apps/openbaar/src/app/register/register-page.html

@@ -43,7 +43,7 @@
         <tbody>
           @for (entry of entries(); track entry.id) {
             <tr>
-              <td>{{ entry.reference }}</td>
+              <td>{{ entry.id }}</td>
               <td>{{ entry.status }}</td>
             </tr>
           }

apps/openbaar/src/app/register/register-page.spec.ts

@@ -5,8 +5,8 @@ import { axe } from 'vitest-axe';
 import { RegisterPage } from './register-page';
 
 const sample: OpenbaarEntry[] = [
-  { id: 'zaak-abc', status: 'INGEDIEND', reference: 'REG-abc' },
+  { id: 'zaak-abc', status: 'INGEDIEND' },
-  { id: 'zaak-def', status: 'INGESCHREVEN', reference: 'REG-def' },
+  { id: 'zaak-def', status: 'INGESCHREVEN' },
 ];
 
 function providers(get = vi.fn().mockReturnValue(of(sample))) {
@@ -22,11 +22,9 @@ describe('RegisterPage', () => {
     await render(RegisterPage, { providers: providers(get).providers });
 
     expect(get).toHaveBeenCalled();
-    // The Referentie column shows the citizen's reference (matches the submit confirmation, #78),
+    expect(await screen.findByText(/zaak-abc/)).toBeTruthy();
-    // not the internal zaak id.
-    expect(await screen.findByText(/REG-abc/)).toBeTruthy();
     expect(screen.getByText(/INGEDIEND/)).toBeTruthy();
-    expect(screen.getByText(/REG-def/)).toBeTruthy();
+    expect(screen.getByText(/zaak-def/)).toBeTruthy();
   });
 
   it('searches by the entered term', async () => {

docs/architecture/adr-0012-citizen-reference-correlation.md

@@ -1,104 +0,0 @@
-# ADR-0012: One citizen-facing reference across self-service and the openbaar register
-
-- **Status:** Accepted
-- **Date:** 2026-07-14
-- **Deciders:** Respellion engineering
-- **Relates to:** #78 (adr-proposal); builds on ADR-0008 (read projection), ADR-0001 (loose coupling), ADR-0009 (external-task worker / zaak creation)
-
-## Context
-
-A citizen submits through the self-service portal and is shown a confirmation with a
-**reference** so they can find their registration back in the public register. But the two
-sides showed **different identifiers**:
-
-- The self-service confirmation shows the **domain `registrationId`** — a GUID minted by the
-  domain aggregate (`RegistrationId.New()`) when the registration is created, before any zaak
-  exists.
-- The openbaar register showed the **zaak id** — the UUID from the NRC `hoofdObject` URL,
-  assigned by OpenZaak when the ACL opens the zaak.
-
-These never match, so the reference on the confirmation was useless for looking the entry up.
-The two identifiers live on opposite sides of the ACL boundary and are generated by different
-systems at different times, so there is no way to reconcile them after the fact without a
-correlating value carried across the boundary.
-
-The NRC notification the Event Subscriber consumes carries only the zaak URL plus the fixed
-`kenmerken` (`bronorganisatie`, `zaaktype`, `vertrouwelijkheidaanduiding`) — **not** the
-`registrationId`, the bsn, or the `identificatie`. ADR-0008 already recorded that filling any
-such field means reading the zaak **through the ACL** (§8.1) and deferred it as a follow-up.
-This is that follow-up, scoped to the one field the citizen actually needs.
-
-## Decision
-
-**Use the domain `registrationId` as the zaak's `identificatie`, and surface that single value
-as the citizen-facing `reference` on both portals. The Event Subscriber enriches the projection
-with the reference by reading the zaak through the ACL, and stores it in the replay log so
-rebuild stays log-only.**
-
-Concretely, following the request path:
-
-1. **Domain → ACL (write).** When the OpenZaak worker opens a zaak, it passes
-   `registration.Id` to the ACL (`IAclClient.OpenZaakAsync(bsn, reference, …)`). The ACL sets
-   it as the zaak's `identificatie` on `POST /zaken`. OpenZaak's `identificatie` is unique per
-   `bronorganisatie` and ≤ 40 chars — a GUID string fits. The ACL remains the only code that
-   constructs ZGW payloads (§8.1); the domain never sees a ZGW URL.
-2. **Event Subscriber → ACL (read).** On a notification, the subscriber asks the ACL for the
-   zaak's reference via a new `POST /zaken/reference` endpoint (`{ zaakUrl } → { reference }`),
-   which reads the zaak's `identificatie` through the ACL's OpenZaak gateway. The subscriber
-   still never talks to ZGW itself (§8.1) — it depends only on the ACL, over HTTP.
-3. **Projection + replay log.** The reference is written both to the `register_projection` row
-   **and** to the `processed_notifications` replay log (a new nullable `reference` column on
-   each). Storing it in the log is what keeps ADR-0008's "**rebuild replays the log, not
-   OpenZaak**" invariant true: `POST /admin/rebuild` reproduces the reference from the log
-   without re-reading the ACL.
-4. **BFF + openbaar.** The public view (`OpenbaarProjection.PublicView`) exposes
-   `id`, `status`, and `reference` (never bsn/naam), and the openbaar search matches on either
-   `id` or `reference`. The openbaar register's "Referentie" column now renders `reference`.
-
-The end-to-end guarantee is asserted in the Playwright walking-skeleton: the reference captured
-from the submit confirmation must appear as a cell in the public register.
-
-### Why HTTP to the ACL, not the ACL as a library
-
-ADR-0008 floated "extend the ACL with a zaak-read operation, consumed as a library." We instead
-call the ACL **over HTTP**, consistent with every other cross-service hop in this system
-(portals→BFF, domain→ACL). Sharing the ACL as a library would couple the subscriber to the
-ACL's infrastructure assembly and its ZGW client configuration, defeating the anti-corruption
-boundary. The HTTP endpoint keeps the ACL the single owner of ZGW access and its config.
-
-## Consequences
-
-**Positive**
-
-- One reference, end to end: the citizen's confirmation value is exactly what the public
-  register shows and searches by.
-- §8.1 stays intact — only the ACL reads or writes ZGW; the subscriber depends on the ACL, not
-  OpenZaak.
-- Rebuild stays log-only (ADR-0008): the reference is replayed from `processed_notifications`,
-  so `/admin/rebuild` needs no ACL/ZGW access.
-- The column additions are nullable and additive; older rows without a reference are tolerated.
-
-**Negative / costs**
-
-- A new coupling: the Event Subscriber now depends on the ACL being reachable
-  (`Acl__BaseUrl`, compose `depends_on: acl`). A registration whose reference read fails will
-  need the notification redelivered (NRC already redelivers; the projection upsert is
-  idempotent).
-- One extra HTTP hop per notification (subscriber→ACL→OpenZaak) on the projection path. Bounded:
-  one small GET per zaak, off the citizen's request path.
-- `identificatie` now carries semantic meaning (it equals the `registrationId`). If OpenZaak
-  were ever configured to auto-generate `identificatie`, the correlation would break; the ACL
-  setting it explicitly is now load-bearing.
-
-## Alternatives considered
-
-- **Carry the `registrationId` in the notification** — rejected: NRC `kenmerken` are fixed and
-  the notification content is not ours to extend; it would also couple the projection to a
-  bespoke notification shape.
-- **Show the zaak id on the confirmation instead** — rejected: the zaak does not exist yet when
-  the confirmation is returned (the worker opens it asynchronously, ADR-0009), so the domain has
-  no zaak id to show at submit time.
-- **Store only on the projection row, re-read the ACL on rebuild** — rejected: it would make
-  rebuild depend on the ACL/ZGW, breaking ADR-0008's log-only rebuild invariant.
-- **Reconcile the two ids in a lookup table** — rejected: adds write-only state and a second
-  source of truth for a value that can simply be the same on both sides.

docs/demo-script.md

@@ -227,24 +227,3 @@ curl -fsS http://localhost:8140/openbaar/register | jq
 > **End of walking skeleton** (S-09 + S-09b): submit → process → projection → public visibility, from
 > INGEDIEND through approval to INGESCHREVEN. The subscriber takes any post-creation status-set as the
 > approval (ADR-0011) — a walking-skeleton assumption that tightens when more transitions arrive (S-12+).
-
-## #78 — One reference across both portals (ADR-0012)
-
-Before this change the self-service confirmation and the openbaar register showed **different**
-identifiers, so a citizen could not look their registration back up. Now both show the same
-**reference**: the domain `registrationId` is set as the zaak's `identificatie` by the ACL, and the
-Event Subscriber enriches the projection with it by reading the zaak through the ACL (§8.1) — storing
-it in the replay log so rebuild stays log-only (ADR-0008).
-
-**The path:** domain passes `registrationId` → ACL sets it as `zaak.identificatie` → NRC →
-Event Subscriber asks the ACL for the reference → projection row + replay log → openbaar register.
-
-```bash
-# Submit as in S-09 and note the reference on the confirmation, then find it in the public register:
-ref="<registration-reference-from-the-confirmation>"
-curl -fsS "http://localhost:8140/openbaar/register?q=$ref" | jq
-# → [ { "id": "<zaak-uuid>", "status": "INGEDIEND", "reference": "<same-ref-as-confirmation>" } ]
-```
-
-> The openbaar register's "Referentie" column and its search now use this reference — the exact value
-> the citizen saw on submit. Asserted end-to-end by the Playwright happy path.

infra/docker-compose.yml

@@ -396,9 +396,6 @@ services:
     image: register-referentie/event-subscriber:dev
     environment:
       ConnectionStrings__Projection: Host=projection-db;Database=projection;Username=projection;Password=projection
-      # The subscriber enriches the projection with each zaak's reference (identificatie) by asking
-      # the ACL — the only code allowed to read ZGW (§8.1, #78).
-      Acl__BaseUrl: http://acl:8080/
       # The bearer Open Notificaties must present on the abonnement callback. NRC's
       # registration probe expects a 401 without it (ADR-0007). Dev-only token.
       EventSubscriber__Webhook__AuthToken: ${NOTIFICATION_WEBHOOK_TOKEN:-Bearer big-reference-notifications}
@@ -413,8 +410,6 @@ services:
     depends_on:
       projection-db:
         condition: service_healthy
-      acl:
-        condition: service_healthy
     networks: [cg]
 
   # The read side of the projection. Shares Projection.ReadModel, so build context is root.

libs/api-client/src/lib/generated/bff-api.ts

@@ -27,8 +27,6 @@ import {
 export interface OpenbaarEntry {
   id: string;
   status: string;
-  /** @nullable */
-  reference: string | null;
 }
 
 export interface SubmitAccepted {

services/acl/Acl.Api/Program.cs

@@ -20,7 +20,7 @@ app.MapGet("/health", () => "Healthy");
 // The ACL's single operation, exposed as a service endpoint.
 app.MapPost("/zaken", async (OpenZaakRequest body, AclService acl, CancellationToken ct) =>
 {
-    var zaakUrl = await acl.OpenZaakAsync(new DomainRegistration(body.Bsn, body.Reference), ct);
+    var zaakUrl = await acl.OpenZaakAsync(new DomainRegistration(body.Bsn), ct);
     return Results.Ok(new { zaakUrl = zaakUrl.ToString() });
 });
 
@@ -32,20 +32,10 @@ app.MapPost("/statussen", async (SetStatusRequest body, AclService acl, Cancella
     return Results.NoContent();
 });
 
-// Read a zaak's public-safe reference (its identificatie). The Event Subscriber calls this to enrich
-// the read projection without reading ZGW itself (§8.1, #78).
-app.MapPost("/zaken/reference", async (ZaakReferenceRequest body, AclService acl, CancellationToken ct) =>
-{
-    var reference = await acl.GetZaakReferenceAsync(new Uri(body.ZaakUrl), ct);
-    return Results.Ok(new { reference });
-});
-
 app.Run();
 
-public sealed record OpenZaakRequest(string Bsn, string Reference);
+public sealed record OpenZaakRequest(string Bsn);
 
 public sealed record SetStatusRequest(string ZaakUrl);
 
-public sealed record ZaakReferenceRequest(string ZaakUrl);
-
 public partial class Program;

services/acl/Acl.Application/AclService.cs

@@ -13,8 +13,7 @@ public sealed class AclService(IZaakGateway gateway, AclDefaults defaults, ICloc
             defaults.VerantwoordelijkeOrganisatie,
             defaults.Vertrouwelijkheidaanduiding,
             defaults.ZaaktypeUrl,
-            clock.Today,
+            clock.Today);
-            registration.Reference);
 
         return gateway.OpenZaakAsync(request, ct);
     }
@@ -29,12 +28,4 @@ public sealed class AclService(IZaakGateway gateway, AclDefaults defaults, ICloc
 
         return gateway.SetZaakToEindstatusAsync(zaakUrl, defaults.ZaaktypeUrl, clock.Today, ct);
     }
-
-    /// <summary>The zaak's reference (its ZGW identificatie), for the read projection (#78).</summary>
-    public Task<string> GetZaakReferenceAsync(Uri zaakUrl, CancellationToken ct = default)
-    {
-        ArgumentNullException.ThrowIfNull(zaakUrl);
-
-        return gateway.GetZaakIdentificatieAsync(zaakUrl, ct);
-    }
 }

services/acl/Acl.Application/DomainRegistration.cs

@@ -1,5 +1,4 @@
 namespace Acl.Application;
 
-/// <summary>Domain-language payload handed to the ACL. No ZGW concepts here. <see cref="Reference"/>
+/// <summary>Domain-language payload handed to the ACL. No ZGW concepts here.</summary>
-/// is the registration's own id; the ACL records it as the zaak identificatie (adr-proposal #78).</summary>
+public sealed record DomainRegistration(string Bsn);
-public sealed record DomainRegistration(string Bsn, string Reference);

services/acl/Acl.Application/IZaakGateway.cs

@@ -12,8 +12,4 @@ public interface IZaakGateway
     /// the catalogus and POSTs a status against the zaak, dated <paramref name="datumStatusGezet"/>.
     /// </summary>
     Task SetZaakToEindstatusAsync(Uri zaakUrl, Uri zaaktypeUrl, DateOnly datumStatusGezet, CancellationToken ct = default);
-
-    /// <summary>Read the zaak's <c>identificatie</c> — the public-safe reference the register shows.
-    /// The Event Subscriber calls this through the ACL rather than reading ZGW itself (§8.1, #78).</summary>
-    Task<string> GetZaakIdentificatieAsync(Uri zaakUrl, CancellationToken ct = default);
 }

services/acl/Acl.Application/ZaakRequest.cs

@@ -6,5 +6,4 @@ public sealed record ZaakRequest(
     string VerantwoordelijkeOrganisatie,
     string Vertrouwelijkheidaanduiding,
     Uri Zaaktype,
-    DateOnly Startdatum,
+    DateOnly Startdatum);
-    string Identificatie);

services/acl/Acl.Infrastructure/OpenZaakGateway.cs

@@ -20,8 +20,7 @@ public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) :
                 request.Zaaktype.ToString(),
                 request.VerantwoordelijkeOrganisatie,
                 request.Startdatum.ToString("yyyy-MM-dd"),
-                request.Vertrouwelijkheidaanduiding,
+                request.Vertrouwelijkheidaanduiding)),
-                request.Identificatie)),
         };
         message.Headers.Authorization =
             new AuthenticationHeaderValue("Bearer", ZgwToken.Mint(options.ClientId, options.Secret));
@@ -48,69 +47,40 @@ public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) :
         ArgumentNullException.ThrowIfNull(zaaktypeUrl);
 
         var eindstatus = await ResolveEindstatusAsync(zaaktypeUrl, ct);
-        var resultaattype = await ResolveResultaattypeAsync(zaaktypeUrl, ct);
 
-        // OpenZaak refuses to set a zaak's eindstatus unless the zaak has a resultaat
+        using var message = new HttpRequestMessage(
-        // ("resultaat-does-not-exist"), so record the resultaat first, then the status.
+            HttpMethod.Post, new Uri(options.BaseUrl, "/zaken/api/v1/statussen"))
-        await PostAsync("/zaken/api/v1/resultaten",
+        {
-            new ResultaatDto(zaakUrl.ToString(), resultaattype.ToString()), "Setting the zaak resultaat", ct);
+            Content = JsonContent.Create(new StatusDto(
-
+                zaakUrl.ToString(),
-        await PostAsync("/zaken/api/v1/statussen",
+                eindstatus.ToString(),
                 // datumStatusGezet is a ZGW date-time; set it at the start of the given day (UTC).
-            new StatusDto(zaakUrl.ToString(), eindstatus.ToString(),
+                datumStatusGezet.ToDateTime(TimeOnly.MinValue, DateTimeKind.Utc).ToString("yyyy-MM-ddTHH:mm:ssZ"))),
-                datumStatusGezet.ToDateTime(TimeOnly.MinValue, DateTimeKind.Utc).ToString("yyyy-MM-ddTHH:mm:ssZ")),
-            "Setting the zaak status", ct);
-    }
-
-    public async Task<string> GetZaakIdentificatieAsync(Uri zaakUrl, CancellationToken ct = default)
-    {
-        ArgumentNullException.ThrowIfNull(zaakUrl);
-
-        using var message = new HttpRequestMessage(HttpMethod.Get, zaakUrl);
-        message.Headers.Authorization =
-            new AuthenticationHeaderValue("Bearer", ZgwToken.Mint(options.ClientId, options.Secret));
-        // The zaak is a geo resource; the Zaken API requires the CRS header even on GET.
-        message.Headers.Add("Accept-Crs", "EPSG:4326");
-
-        using var response = await http.SendAsync(message, ct);
-        await EnsureSuccessAsync(response, "Reading the zaak", ct);
-
-        var zaak = await response.Content.ReadFromJsonAsync<ZaakReadDto>(ct)
-            ?? throw new InvalidOperationException("OpenZaak returned an empty zaak response");
-        return zaak.Identificatie;
-    }
-
-    // POSTs a non-geo ZGW resource (resultaat/status — no CRS headers). Buffers the body so uwsgi gets
-    // a Content-Length instead of a chunked body (as with zaak-create).
-    private async Task PostAsync(string path, object dto, string action, CancellationToken ct)
-    {
-        using var message = new HttpRequestMessage(HttpMethod.Post, new Uri(options.BaseUrl, path))
-        {
-            Content = JsonContent.Create(dto),
         };
         message.Headers.Authorization =
             new AuthenticationHeaderValue("Bearer", ZgwToken.Mint(options.ClientId, options.Secret));
+        // The status resource carries no geometry, so no CRS headers. As with zaak-create, buffer the
+        // body so uwsgi gets a Content-Length instead of a chunked body.
         await message.Content.LoadIntoBufferAsync(ct);
 
         using var response = await http.SendAsync(message, ct);
-        await EnsureSuccessAsync(response, action, ct);
+        response.EnsureSuccessStatusCode();
-    }
-
-    // EnsureSuccessStatusCode discards the response body; ZGW returns a JSON problem detail on 400 that
-    // is essential for diagnosing a rejected request, so surface it in the exception.
-    private static async Task EnsureSuccessAsync(HttpResponseMessage response, string action, CancellationToken ct)
-    {
-        if (response.IsSuccessStatusCode)
-            return;
-
-        var body = await response.Content.ReadAsStringAsync(ct);
-        throw new HttpRequestException($"{action} failed: {(int)response.StatusCode} {response.ReasonPhrase}. {body}");
     }
 
     /// <summary>Resolve the zaaktype's eindstatus (the terminal statustype) from the catalogus.</summary>
     private async Task<Uri> ResolveEindstatusAsync(Uri zaaktypeUrl, CancellationToken ct)
     {
-        var page = await GetCatalogusAsync<StatustypePage>("statustypen", zaaktypeUrl, "statustypen", ct);
+        var query = new Uri(options.BaseUrl,
+            "/catalogi/api/v1/statustypen?status=alles&zaaktype=" + Uri.EscapeDataString(zaaktypeUrl.ToString()));
+        using var message = new HttpRequestMessage(HttpMethod.Get, query);
+        message.Headers.Authorization =
+            new AuthenticationHeaderValue("Bearer", ZgwToken.Mint(options.ClientId, options.Secret));
+
+        using var response = await http.SendAsync(message, ct);
+        response.EnsureSuccessStatusCode();
+
+        var page = await response.Content.ReadFromJsonAsync<StatustypePage>(ct)
+            ?? throw new InvalidOperationException("OpenZaak returned an empty statustypen response");
         var results = page.Results ?? [];
 
         // OpenZaak flags the terminal statustype (highest volgnummer) as isEindstatus; fall back to the
@@ -121,45 +91,16 @@ public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) :
         return new Uri(eindstatus.Url);
     }
 
-    /// <summary>Resolve the zaaktype's resultaattype from the catalogus (the seed defines one).</summary>
-    private async Task<Uri> ResolveResultaattypeAsync(Uri zaaktypeUrl, CancellationToken ct)
-    {
-        var page = await GetCatalogusAsync<ResultaattypePage>("resultaattypen", zaaktypeUrl, "resultaattypen", ct);
-        var resultaattype = (page.Results ?? []).FirstOrDefault()
-            ?? throw new InvalidOperationException($"No resultaattypen found for zaaktype {zaaktypeUrl}");
-        return new Uri(resultaattype.Url);
-    }
-
-    // GETs a catalogus collection filtered by zaaktype (status=alles includes concept + published).
-    private async Task<T> GetCatalogusAsync<T>(string resource, Uri zaaktypeUrl, string label, CancellationToken ct)
-    {
-        var query = new Uri(options.BaseUrl,
-            $"/catalogi/api/v1/{resource}?status=alles&zaaktype=" + Uri.EscapeDataString(zaaktypeUrl.ToString()));
-        using var message = new HttpRequestMessage(HttpMethod.Get, query);
-        message.Headers.Authorization =
-            new AuthenticationHeaderValue("Bearer", ZgwToken.Mint(options.ClientId, options.Secret));
-
-        using var response = await http.SendAsync(message, ct);
-        await EnsureSuccessAsync(response, $"Querying {label}", ct);
-
-        return await response.Content.ReadFromJsonAsync<T>(ct)
-            ?? throw new InvalidOperationException($"OpenZaak returned an empty {label} response");
-    }
-
     private sealed record ZaakDto(
         [property: JsonPropertyName("bronorganisatie")] string Bronorganisatie,
         [property: JsonPropertyName("zaaktype")] string Zaaktype,
         [property: JsonPropertyName("verantwoordelijkeOrganisatie")] string VerantwoordelijkeOrganisatie,
         [property: JsonPropertyName("startdatum")] string Startdatum,
-        [property: JsonPropertyName("vertrouwelijkheidaanduiding")] string Vertrouwelijkheidaanduiding,
+        [property: JsonPropertyName("vertrouwelijkheidaanduiding")] string Vertrouwelijkheidaanduiding);
-        [property: JsonPropertyName("identificatie")] string Identificatie);
 
     private sealed record ZaakCreatedDto(
         [property: JsonPropertyName("url")] string Url);
 
-    private sealed record ZaakReadDto(
-        [property: JsonPropertyName("identificatie")] string Identificatie);
-
     private sealed record StatusDto(
         [property: JsonPropertyName("zaak")] string Zaak,
         [property: JsonPropertyName("statustype")] string Statustype,
@@ -172,14 +113,4 @@ public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) :
         [property: JsonPropertyName("url")] string Url,
         [property: JsonPropertyName("volgnummer")] int Volgnummer,
         [property: JsonPropertyName("isEindstatus")] bool IsEindstatus);
-
-    private sealed record ResultaatDto(
-        [property: JsonPropertyName("zaak")] string Zaak,
-        [property: JsonPropertyName("resultaattype")] string Resultaattype);
-
-    private sealed record ResultaattypePage(
-        [property: JsonPropertyName("results")] IReadOnlyList<ResultaattypeDto>? Results);
-
-    private sealed record ResultaattypeDto(
-        [property: JsonPropertyName("url")] string Url);
 }

services/acl/Acl.IntegrationTests/OpenZaakGatewayIntegrationTests.cs

@@ -22,14 +22,12 @@ public sealed class OpenZaakGatewayIntegrationTests(OpenZaakFixture stack)
             "seed it with OZ_PUBLISH=1 (`make integration` does this).");
 
         var gateway = new OpenZaakGateway(stack.Http, stack.Options);
-        var reference = Guid.NewGuid().ToString(); // zaak identificatie must be unique per bronorganisatie
         var request = new ZaakRequest(
             Bronorganisatie: "517439943",
             VerantwoordelijkeOrganisatie: "517439943",
             Vertrouwelijkheidaanduiding: "openbaar",
             Zaaktype: zaaktype!,
-            Startdatum: DateOnly.FromDateTime(DateTime.UtcNow),
+            Startdatum: DateOnly.FromDateTime(DateTime.UtcNow));
-            Identificatie: reference);
 
         var zaakUrl = await gateway.OpenZaakAsync(request);
 
@@ -38,12 +36,11 @@ public sealed class OpenZaakGatewayIntegrationTests(OpenZaakFixture stack)
             new Uri(stack.BaseUrl, "/zaken/api/v1/zaken/").ToString(),
             zaakUrl.ToString());
 
-        // ...and that zaak is really persisted with the default-filled fields + the reference identificatie.
+        // ...and that zaak is really persisted with the default-filled fields.
         var zaak = await stack.GetZaakAsync(zaakUrl);
         Assert.Equal(zaaktype.ToString(), zaak.GetProperty("zaaktype").GetString());
         Assert.Equal("517439943", zaak.GetProperty("bronorganisatie").GetString());
         Assert.Equal("openbaar", zaak.GetProperty("vertrouwelijkheidaanduiding").GetString());
-        Assert.Equal(reference, zaak.GetProperty("identificatie").GetString());
     }
 
     [Fact]
@@ -60,8 +57,7 @@ public sealed class OpenZaakGatewayIntegrationTests(OpenZaakFixture stack)
             VerantwoordelijkeOrganisatie: "517439943",
             Vertrouwelijkheidaanduiding: "openbaar",
             Zaaktype: zaaktype!,
-            Startdatum: DateOnly.FromDateTime(DateTime.UtcNow),
+            Startdatum: DateOnly.FromDateTime(DateTime.UtcNow)));
-            Identificatie: Guid.NewGuid().ToString()));
 
         await gateway.SetZaakToEindstatusAsync(zaakUrl, zaaktype!, DateOnly.FromDateTime(DateTime.UtcNow));
 

services/acl/Acl.Tests/AclServiceTests.cs

@@ -22,14 +22,6 @@ public class AclServiceTests
             Approved = (zaakUrl, zaaktypeUrl, datumStatusGezet);
             return Task.CompletedTask;
         }
-
-        public Uri? ReadReferenceFor;
-
-        public Task<string> GetZaakIdentificatieAsync(Uri zaakUrl, CancellationToken ct = default)
-        {
-            ReadReferenceFor = zaakUrl;
-            return Task.FromResult("REG-FROM-ZAAK");
-        }
     }
 
     private static AclDefaults Defaults() => new()
@@ -58,7 +50,7 @@ public class AclServiceTests
         };
         var service = new AclService(gateway, defaults, new FixedClock(new DateOnly(2026, 6, 4)));
 
-        var url = await service.OpenZaakAsync(new DomainRegistration("123456782", "reg-77"));
+        var url = await service.OpenZaakAsync(new DomainRegistration("123456782"));
 
         Assert.Equal(gateway.Result, url);
         var req = Assert.IsType<ZaakRequest>(gateway.Captured);
@@ -67,8 +59,6 @@ public class AclServiceTests
         Assert.Equal("openbaar", req.Vertrouwelijkheidaanduiding);
         Assert.Equal(defaults.ZaaktypeUrl, req.Zaaktype);
         Assert.Equal(new DateOnly(2026, 6, 4), req.Startdatum);
-        // The registration reference becomes the zaak identificatie (#78).
-        Assert.Equal("reg-77", req.Identificatie);
     }
 
     [Fact]
@@ -113,27 +103,4 @@ public class AclServiceTests
         await Assert.ThrowsAsync<ArgumentNullException>(() => service.ApproveZaakAsync(null!));
         Assert.Null(gateway.Approved);
     }
-
-    [Fact]
-    public async Task Reading_a_zaak_reference_returns_the_zaaks_identificatie()
-    {
-        var gateway = new FakeGateway();
-        var service = new AclService(gateway, Defaults(), new FixedClock(new DateOnly(2026, 6, 4)));
-        var zaak = new Uri("http://openzaak/zaken/api/v1/zaken/abc");
-
-        var reference = await service.GetZaakReferenceAsync(zaak);
-
-        Assert.Equal("REG-FROM-ZAAK", reference);
-        Assert.Equal(zaak, gateway.ReadReferenceFor);
-    }
-
-    [Fact]
-    public async Task Reading_a_null_zaak_reference_is_rejected()
-    {
-        var gateway = new FakeGateway();
-        var service = new AclService(gateway, Defaults(), new FixedClock(new DateOnly(2026, 6, 4)));
-
-        await Assert.ThrowsAsync<ArgumentNullException>(() => service.GetZaakReferenceAsync(null!));
-        Assert.Null(gateway.ReadReferenceFor);
-    }
 }

services/acl/Acl.Tests/OpenZaakGatewayTests.cs

@@ -22,7 +22,7 @@ public class OpenZaakGatewayTests
 
     private static ZaakRequest SampleRequest() => new(
         "517439943", "517439943", "openbaar",
-        new("http://openzaak/catalogi/api/v1/zaaktypen/big"), new DateOnly(2026, 6, 4), "REG-REF-1");
+        new("http://openzaak/catalogi/api/v1/zaaktypen/big"), new DateOnly(2026, 6, 4));
 
     private static StubHandler Created(out RequestCapture capture)
     {
@@ -67,8 +67,6 @@ public class OpenZaakGatewayTests
         Assert.Contains("\"vertrouwelijkheidaanduiding\":\"openbaar\"", capture.Body);
         Assert.Contains("\"startdatum\":\"2026-06-04\"", capture.Body);
         Assert.Contains("\"zaaktype\":\"http://openzaak/catalogi/api/v1/zaaktypen/big\"", capture.Body);
-        // The registration reference is set as the zaak identificatie (#78).
-        Assert.Contains("\"identificatie\":\"REG-REF-1\"", capture.Body);
     }
 
     [Fact]
@@ -133,9 +131,8 @@ public class OpenZaakGatewayTests
                 Content = new StringContent("null", Encoding.UTF8, "application/json"),
             }));
 
-        var ex = await Assert.ThrowsAsync<InvalidOperationException>(
+        await Assert.ThrowsAsync<InvalidOperationException>(
             () => Gateway(handler).OpenZaakAsync(SampleRequest()));
-        Assert.Contains("empty zaak response", ex.Message);
     }
 
     [Fact]
@@ -147,284 +144,6 @@ public class OpenZaakGatewayTests
             () => Gateway(handler).OpenZaakAsync(null!));
     }
 
-    // --- SetZaakToEindstatusAsync (approval / S-09b) ---
-
-    private const string ZaakUrl = "http://openzaak/zaken/api/v1/zaken/xyz";
-    private static readonly Uri Zaaktype = new("http://openzaak/catalogi/api/v1/zaaktypen/big");
-
-    private sealed class Recorder
-    {
-        public List<HttpRequestMessage> Requests { get; } = [];
-        public List<string?> Bodies { get; } = [];
-        public List<long?> ContentLengths { get; } = [];
-
-        public int IndexOf(string pathContains) =>
-            Requests.FindIndex(r => r.RequestUri!.ToString().Contains(pathContains));
-
-        // The (body, content-length, request) of the single request whose URL contains the segment.
-        public (string? Body, long? Length, HttpRequestMessage Request) Sent(string pathContains)
-        {
-            var i = IndexOf(pathContains);
-            return (Bodies[i], ContentLengths[i], Requests[i]);
-        }
-    }
-
-    // Per-route response config for the four calls the approval makes.
-    private sealed class OzRoutes
-    {
-        public string StatustypenJson { get; init; } = StatustypenPage(withEindstatusFlag: true);
-        public string ResultaattypenJson { get; init; } = """{"results":[{"url":"http://openzaak/catalogi/api/v1/resultaattypen/1"}]}""";
-        public HttpStatusCode StatustypenStatus { get; init; } = HttpStatusCode.OK;
-        public HttpStatusCode ResultaattypenStatus { get; init; } = HttpStatusCode.OK;
-        public HttpStatusCode ResultaatPostStatus { get; init; } = HttpStatusCode.Created;
-        public HttpStatusCode StatusPostStatus { get; init; } = HttpStatusCode.Created;
-    }
-
-    // Routes the approval's four calls by URL: GET /statustypen, GET /resultaattypen (catalogus),
-    // then POST /resultaten and POST /statussen (zaken).
-    private static StubHandler ApprovalStub(Recorder rec, OzRoutes routes) => new(async req =>
-    {
-        rec.Requests.Add(req);
-        // Capture the length BEFORE reading the body (ReadAsStringAsync buffers as a side effect).
-        rec.ContentLengths.Add(req.Content?.Headers.ContentLength);
-        rec.Bodies.Add(req.Content is null ? null : await req.Content.ReadAsStringAsync());
-
-        var url = req.RequestUri!.ToString();
-        if (req.Method == HttpMethod.Get && url.Contains("/statustypen"))
-            return Json(routes.StatustypenStatus, routes.StatustypenJson);
-        if (req.Method == HttpMethod.Get && url.Contains("/resultaattypen"))
-            return Json(routes.ResultaattypenStatus, routes.ResultaattypenJson);
-        if (url.Contains("/resultaten"))
-            return Json(routes.ResultaatPostStatus, """{"url":"http://openzaak/zaken/api/v1/resultaten/new"}""");
-        return Json(routes.StatusPostStatus, """{"url":"http://openzaak/zaken/api/v1/statussen/new"}""");
-    });
-
-    private static HttpResponseMessage Json(HttpStatusCode status, string body) =>
-        new(status) { Content = new StringContent(body, Encoding.UTF8, "application/json") };
-
-    // Two statustypen; the eindstatus is flagged on the *lower* volgnummer so the tests prove the
-    // isEindstatus flag is preferred over "highest volgnummer", not coincidentally equal to it.
-    private static string StatustypenPage(bool withEindstatusFlag) => JsonSerializer.Serialize(new
-    {
-        results = new object[]
-        {
-            new { url = "http://openzaak/catalogi/api/v1/statustypen/1", volgnummer = 1, isEindstatus = withEindstatusFlag },
-            new { url = "http://openzaak/catalogi/api/v1/statustypen/2", volgnummer = 2, isEindstatus = false },
-        },
-    });
-
-    [Fact]
-    public async Task Approving_sets_a_resultaat_then_posts_the_flagged_eindstatus_against_the_zaak()
-    {
-        var rec = new Recorder();
-
-        await Gateway(ApprovalStub(rec, new OzRoutes()))
-            .SetZaakToEindstatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4));
-
-        Assert.Equal(4, rec.Requests.Count);
-
-        // Both catalogus queries filter by the zaaktype and carry the bearer.
-        var statustypenGet = rec.Sent("/statustypen").Request;
-        Assert.Equal(HttpMethod.Get, statustypenGet.Method);
-        Assert.Contains(Uri.EscapeDataString(Zaaktype.ToString()), statustypenGet.RequestUri!.ToString());
-        Assert.Equal("Bearer", statustypenGet.Headers.Authorization!.Scheme);
-        Assert.Contains(Uri.EscapeDataString(Zaaktype.ToString()), rec.Sent("/resultaattypen").Request.RequestUri!.ToString());
-
-        // OpenZaak requires a resultaat before the eindstatus, so /resultaten precedes /statussen.
-        Assert.True(rec.IndexOf("/resultaten") < rec.IndexOf("/statussen"));
-
-        var resultaat = rec.Sent("/resultaten");
-        Assert.Equal("http://openzaak/zaken/api/v1/resultaten", resultaat.Request.RequestUri!.ToString());
-        Assert.Equal("Bearer", resultaat.Request.Headers.Authorization!.Scheme);
-        Assert.Contains("\"zaak\":\"" + ZaakUrl + "\"", resultaat.Body);
-        Assert.Contains("\"resultaattype\":\"http://openzaak/catalogi/api/v1/resultaattypen/1\"", resultaat.Body);
-        Assert.True(resultaat.Length > 0);
-
-        var status = rec.Sent("/statussen");
-        Assert.Equal("http://openzaak/zaken/api/v1/statussen", status.Request.RequestUri!.ToString());
-        Assert.Equal("Bearer", status.Request.Headers.Authorization!.Scheme);
-        Assert.Contains("\"zaak\":\"" + ZaakUrl + "\"", status.Body);
-        // The isEindstatus-flagged statustype (/1) is chosen — even though /2 has a higher volgnummer.
-        Assert.Contains("\"statustype\":\"http://openzaak/catalogi/api/v1/statustypen/1\"", status.Body);
-        Assert.Contains("\"datumStatusGezet\":\"2026-06-04T00:00:00Z\"", status.Body);
-        // Bodies are buffered (Content-Length set), so uwsgi doesn't get a chunked body.
-        Assert.True(status.Length > 0);
-    }
-
-    [Fact]
-    public async Task Approving_falls_back_to_the_highest_volgnummer_when_no_eindstatus_is_flagged()
-    {
-        var rec = new Recorder();
-
-        await Gateway(ApprovalStub(rec, new OzRoutes { StatustypenJson = StatustypenPage(withEindstatusFlag: false) }))
-            .SetZaakToEindstatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4));
-
-        // No isEindstatus flag → the highest volgnummer (/2) is chosen.
-        Assert.Contains("\"statustype\":\"http://openzaak/catalogi/api/v1/statustypen/2\"", rec.Sent("/statussen").Body);
-    }
-
-    [Fact]
-    public async Task Approving_throws_when_the_zaaktype_has_no_statustypen()
-    {
-        var rec = new Recorder();
-
-        // A page with no `results` property (Results is null) — the eindstatus cannot be resolved.
-        var ex = await Assert.ThrowsAsync<InvalidOperationException>(() =>
-            Gateway(ApprovalStub(rec, new OzRoutes { StatustypenJson = "{}" }))
-                .SetZaakToEindstatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4)));
-
-        Assert.Contains("No statustypen found", ex.Message);
-        // It never posts anything when it cannot resolve the eindstatus.
-        Assert.Single(rec.Requests);
-    }
-
-    [Fact]
-    public async Task Approving_throws_when_the_statustypen_response_is_empty()
-    {
-        var rec = new Recorder();
-
-        var ex = await Assert.ThrowsAsync<InvalidOperationException>(() =>
-            Gateway(ApprovalStub(rec, new OzRoutes { StatustypenJson = "null" }))
-                .SetZaakToEindstatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4)));
-
-        Assert.Contains("empty statustypen", ex.Message);
-        Assert.Single(rec.Requests);
-    }
-
-    [Fact]
-    public async Task Approving_throws_when_the_statustypen_query_fails()
-    {
-        var rec = new Recorder();
-
-        var ex = await Assert.ThrowsAsync<HttpRequestException>(() =>
-            Gateway(ApprovalStub(rec, new OzRoutes { StatustypenStatus = HttpStatusCode.InternalServerError }))
-                .SetZaakToEindstatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4)));
-
-        Assert.Contains("Querying statustypen", ex.Message);
-    }
-
-    [Fact]
-    public async Task Approving_throws_when_the_resultaattypen_query_fails()
-    {
-        var rec = new Recorder();
-
-        var ex = await Assert.ThrowsAsync<HttpRequestException>(() =>
-            Gateway(ApprovalStub(rec, new OzRoutes { ResultaattypenStatus = HttpStatusCode.InternalServerError }))
-                .SetZaakToEindstatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4)));
-
-        Assert.Contains("Querying resultaattypen", ex.Message);
-        Assert.Equal(-1, rec.IndexOf("/resultaten"));
-    }
-
-    [Fact]
-    public async Task Approving_throws_when_the_zaaktype_has_no_resultaattype()
-    {
-        var rec = new Recorder();
-
-        var ex = await Assert.ThrowsAsync<InvalidOperationException>(() =>
-            Gateway(ApprovalStub(rec, new OzRoutes { ResultaattypenJson = "{}" }))
-                .SetZaakToEindstatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4)));
-
-        Assert.Contains("No resultaattypen found", ex.Message);
-        // Resolved the eindstatus + queried resultaattypen, but posted nothing.
-        Assert.Equal(-1, rec.IndexOf("/resultaten"));
-        Assert.Equal(-1, rec.IndexOf("/statussen"));
-    }
-
-    [Fact]
-    public async Task Approving_throws_when_posting_the_resultaat_fails()
-    {
-        var rec = new Recorder();
-
-        var ex = await Assert.ThrowsAsync<HttpRequestException>(() =>
-            Gateway(ApprovalStub(rec, new OzRoutes { ResultaatPostStatus = HttpStatusCode.BadRequest }))
-                .SetZaakToEindstatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4)));
-
-        Assert.Contains("Setting the zaak resultaat", ex.Message);
-        // The status is never posted if the resultaat could not be recorded.
-        Assert.Equal(-1, rec.IndexOf("/statussen"));
-    }
-
-    [Fact]
-    public async Task Approving_throws_when_posting_the_status_fails()
-    {
-        var rec = new Recorder();
-
-        var ex = await Assert.ThrowsAsync<HttpRequestException>(() =>
-            Gateway(ApprovalStub(rec, new OzRoutes { StatusPostStatus = HttpStatusCode.BadRequest }))
-                .SetZaakToEindstatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4)));
-
-        Assert.Contains("Setting the zaak status", ex.Message);
-        // It got as far as the resultaat + the status POST (4 calls) before failing.
-        Assert.Equal(4, rec.Requests.Count);
-    }
-
-    [Fact]
-    public async Task Reading_a_zaak_returns_its_identificatie_with_bearer_and_crs()
-    {
-        RequestCapture? capture = null;
-        var handler = new StubHandler(req =>
-        {
-            capture = new RequestCapture { Seen = req };
-            return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
-            {
-                Content = JsonContent.Create(new { identificatie = "REG-XYZ", url = ZaakUrl }),
-            });
-        });
-
-        var reference = await Gateway(handler).GetZaakIdentificatieAsync(new Uri(ZaakUrl));
-
-        Assert.Equal("REG-XYZ", reference);
-        Assert.Equal(HttpMethod.Get, capture!.Seen!.Method);
-        Assert.Equal(ZaakUrl, capture.Seen.RequestUri!.ToString());
-        Assert.Equal("Bearer", capture.Seen.Headers.Authorization!.Scheme);
-        Assert.Equal("EPSG:4326", Assert.Single(capture.Seen.Headers.GetValues("Accept-Crs")));
-    }
-
-    [Fact]
-    public async Task Reading_a_zaak_throws_when_openzaak_rejects_it()
-    {
-        var handler = new StubHandler(_ =>
-            Task.FromResult(new HttpResponseMessage(HttpStatusCode.NotFound) { Content = new StringContent("nope") }));
-
-        var ex = await Assert.ThrowsAsync<HttpRequestException>(
-            () => Gateway(handler).GetZaakIdentificatieAsync(new Uri(ZaakUrl)));
-        Assert.Contains("Reading the zaak", ex.Message);
-    }
-
-    [Fact]
-    public async Task Reading_a_zaak_throws_when_openzaak_returns_an_empty_body()
-    {
-        var handler = new StubHandler(_ =>
-            Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
-            {
-                Content = new StringContent("null", System.Text.Encoding.UTF8, "application/json"),
-            }));
-
-        var ex = await Assert.ThrowsAsync<InvalidOperationException>(
-            () => Gateway(handler).GetZaakIdentificatieAsync(new Uri(ZaakUrl)));
-        Assert.Contains("empty zaak response", ex.Message);
-    }
-
-    [Fact]
-    public async Task Reading_a_null_zaak_is_rejected()
-    {
-        var handler = new StubHandler(_ => throw new InvalidOperationException("should not be sent"));
-
-        await Assert.ThrowsAsync<ArgumentNullException>(() => Gateway(handler).GetZaakIdentificatieAsync(null!));
-    }
-
-    [Fact]
-    public async Task Approving_rejects_a_null_zaak_or_zaaktype()
-    {
-        var handler = new StubHandler(_ => throw new InvalidOperationException("should not be sent"));
-
-        await Assert.ThrowsAsync<ArgumentNullException>(() =>
-            Gateway(handler).SetZaakToEindstatusAsync(null!, Zaaktype, new DateOnly(2026, 6, 4)));
-        await Assert.ThrowsAsync<ArgumentNullException>(() =>
-            Gateway(handler).SetZaakToEindstatusAsync(new Uri(ZaakUrl), null!, new DateOnly(2026, 6, 4)));
-    }
-
     // ZGW tokens are base64url with padding stripped (ZgwToken.B64Url); restore it to decode.
     private static string DecodeSegment(string segment)
     {

services/bff/Bff.Api/DownstreamClients.cs

@@ -6,12 +6,11 @@ namespace Bff.Api;
 public sealed record SubmitAccepted(string RegistrationId, string Status);
 
 /// <summary>A projection row as the projection-api serves it. <c>Bsn</c>/<c>NaamPlaceholder</c> are
-/// read but never surfaced by the openbaar endpoint (public-safe filtering, ADR-0010/S-09).
+/// read but never surfaced by the openbaar endpoint (public-safe filtering, ADR-0010/S-09).</summary>
-/// <c>Reference</c> is the public-safe citizen reference (the zaak identificatie, #78).</summary>
+public sealed record ProjectionEntry(string Id, string Status, string? Bsn, string? NaamPlaceholder);
-public sealed record ProjectionEntry(string Id, string Status, string? Reference, string? Bsn, string? NaamPlaceholder);
 
 /// <summary>A public-safe openbaar register row — only non-sensitive fields leave the BFF.</summary>
-public sealed record OpenbaarEntry(string Id, string Status, string? Reference);
+public sealed record OpenbaarEntry(string Id, string Status);
 
 /// <summary>Port to the Domain Service (§8.3: the BFF is the portals' only backend; it fans out).</summary>
 public interface IDomainClient

services/bff/Bff.Api/OpenbaarProjection.cs

@@ -11,10 +11,8 @@ public static class OpenbaarProjection
     {
         var filtered = string.IsNullOrWhiteSpace(q)
             ? entries
-            : entries.Where(e =>
+            : entries.Where(e => e.Id.Contains(q, StringComparison.OrdinalIgnoreCase));
-                e.Id.Contains(q, StringComparison.OrdinalIgnoreCase) ||
-                (e.Reference?.Contains(q, StringComparison.OrdinalIgnoreCase) ?? false));
 
-        return [.. filtered.Select(e => new OpenbaarEntry(e.Id, e.Status, e.Reference))];
+        return [.. filtered.Select(e => new OpenbaarEntry(e.Id, e.Status))];
     }
 }

services/bff/Bff.Tests/OpenbaarEndpointTests.cs

@@ -10,7 +10,7 @@ public class OpenbaarEndpointTests
     public async Task Serves_public_safe_rows_anonymously()
     {
         using var factory = new BffFactory();
-        factory.Projection.Entries.Add(new ProjectionEntry("abc-111", "INGEDIEND", "REG-abc", "123456782", "Jan"));
+        factory.Projection.Entries.Add(new ProjectionEntry("abc-111", "INGEDIEND", "123456782", "Jan"));
 
         // No Authorization header — the openbaar register is a public lookup (ADR-0010/S-09).
         var response = await factory.CreateClient().GetAsync("/openbaar/register");
@@ -19,9 +19,7 @@ public class OpenbaarEndpointTests
         var body = await response.Content.ReadAsStringAsync();
         Assert.Contains("abc-111", body);
         Assert.Contains("INGEDIEND", body);
-        // The public reference is surfaced (matches the submit confirmation, #78)...
+        // The bsn must never appear in a public response.
-        Assert.Contains("REG-abc", body);
-        // ...but the bsn must never appear in a public response.
         Assert.DoesNotContain("123456782", body);
     }
 
@@ -29,8 +27,8 @@ public class OpenbaarEndpointTests
     public async Task Filters_by_the_query_parameter()
     {
         using var factory = new BffFactory();
-        factory.Projection.Entries.Add(new ProjectionEntry("abc-111", "INGEDIEND", "REG-abc", null, null));
+        factory.Projection.Entries.Add(new ProjectionEntry("abc-111", "INGEDIEND", null, null));
-        factory.Projection.Entries.Add(new ProjectionEntry("def-222", "INGEDIEND", "REG-def", null, null));
+        factory.Projection.Entries.Add(new ProjectionEntry("def-222", "INGEDIEND", null, null));
 
         var rows = await factory.CreateClient()
             .GetFromJsonAsync<List<OpenbaarEntry>>("/openbaar/register?q=abc");

services/bff/Bff.Tests/OpenbaarProjectionTests.cs

@@ -6,8 +6,8 @@ public class OpenbaarProjectionTests
 {
     private static readonly ProjectionEntry[] Sample =
     [
-        new("abc-111", "INGEDIEND", Reference: "REG-A", Bsn: "123456782", NaamPlaceholder: "Jan"),
+        new("abc-111", "INGEDIEND", "123456782", "Jan"),
-        new("def-222", "INGESCHREVEN", Reference: "REG-B", Bsn: "987654321", NaamPlaceholder: "Piet"),
+        new("def-222", "INGEDIEND", "987654321", "Piet"),
     ];
 
     [Fact]
@@ -18,47 +18,31 @@ public class OpenbaarProjectionTests
         Assert.Equal(2, view.Count);
         Assert.Equal("abc-111", view[0].Id);
         Assert.Equal("INGEDIEND", view[0].Status);
-        // The public reference (zaak identificatie) is surfaced so it matches the submit confirmation (#78).
-        Assert.Equal("REG-A", view[0].Reference);
     }
 
     [Fact]
-    public void Public_view_exposes_only_id_status_and_reference()
+    public void Public_view_exposes_only_id_and_status()
     {
-        // OpenbaarEntry structurally carries only public-safe fields — bsn/naam can never leak.
+        // OpenbaarEntry structurally carries only Id + Status — bsn/naam can never leak.
         var props = typeof(OpenbaarEntry).GetProperties().Select(p => p.Name).ToArray();
-        Assert.Equal(["Id", "Status", "Reference"], props);
+        Assert.Equal(["Id", "Status"], props);
     }
 
     [Theory]
-    [InlineData("abc", 1)]   // by id
+    [InlineData("abc", 1)]
-    [InlineData("ABC", 1)]   // by id, case-insensitive
+    [InlineData("ABC", 1)]
-    [InlineData("def", 1)]   // by id
+    [InlineData("2", 1)]
-    [InlineData("zzz", 0)]   // no match
+    [InlineData("zzz", 0)]
     public void Filters_by_id_containing_the_query_case_insensitively(string q, int expected)
-        => Assert.Equal(expected, OpenbaarProjection.PublicView(Sample, q).Count);
+    {
+        var view = OpenbaarProjection.PublicView(Sample, q);
 
-    [Theory]
+        Assert.Equal(expected, view.Count);
-    [InlineData("REG-A", 1)] // by reference — the citizen's confirmation reference
+    }
-    [InlineData("reg-a", 1)] // by reference, case-insensitive
-    [InlineData("REG", 2)]   // both share the prefix
-    public void Filters_by_reference_containing_the_query_case_insensitively(string q, int expected)
-        => Assert.Equal(expected, OpenbaarProjection.PublicView(Sample, q).Count);
 
     [Fact]
     public void Blank_query_is_treated_as_no_filter()
     {
         Assert.Equal(2, OpenbaarProjection.PublicView(Sample, "   ").Count);
     }
-
-    [Fact]
-    public void A_row_without_a_reference_never_matches_a_query()
-    {
-        // Older rows can have a null reference (the column is additive, #78/ADR-0012). A search must
-        // simply not match them — it must not throw and must not treat "no reference" as a match.
-        var entries = new[] { new ProjectionEntry("xyz-999", "INGEDIEND", Reference: null, Bsn: null, NaamPlaceholder: null) };
-
-        Assert.Empty(OpenbaarProjection.PublicView(entries, "REG"));
-        Assert.Equal("xyz-999", Assert.Single(OpenbaarProjection.PublicView(entries, "xyz")).Id);
-    }
 }

services/bff/openapi.json

@@ -67,8 +67,7 @@
       "OpenbaarEntry": {
         "required": [
           "id",
-          "status",
+          "status"
-          "reference"
         ],
         "type": "object",
         "properties": {
@@ -77,12 +76,6 @@
           },
           "status": {
             "type": "string"
-          },
-          "reference": {
-            "type": [
-              "null",
-              "string"
-            ]
           }
         }
       },

services/domain/Big.Api/Program.cs

@@ -24,7 +24,6 @@ builder.Services.AddHttpClient<IAclClient, AclHttpClient>();
 
 builder.Services.AddScoped<SubmitRegistration>();
 builder.Services.AddScoped<ApproveRegistration>();
-builder.Services.AddScoped<BeoordeelRegistratie>();
 builder.Services.AddScoped<OpenZaakWorker>();
 builder.Services.AddScoped<OpenZaakJobProcessor>();
 
@@ -56,22 +55,6 @@ app.MapPost("/registrations/{id}/approve", async (string id, ApproveRegistration
     return Results.NoContent();
 });
 
-// The behandelaar's beoordeling (S-12): decide a registration goedkeuren (→ INGESCHREVEN, sets the
-// zaak's final status via the ACL) or afwijzen (→ AFGEWEZEN). Idempotent. This is the domain contract
-// the behandel-portal's decision reaches through the BFF; it supersedes the temporary /approve above,
-// which is retired once the portal lands.
-app.MapPost("/registrations/{id}/decide", async (string id, DecideRequest body, BeoordeelRegistratie beoordeel, CancellationToken ct) =>
-{
-    if (!Guid.TryParse(id, out var guid))
-        return Results.NotFound();
-
-    if (!Enum.TryParse<BeoordelingsBesluit>(body.Besluit, ignoreCase: true, out var besluit))
-        return Results.BadRequest(new { error = $"Unknown besluit '{body.Besluit}'. Expected 'goedkeuren' or 'afwijzen'." });
-
-    await beoordeel.HandleAsync(new BeoordeelRegistratieCommand(new RegistrationId(guid), besluit), ct);
-    return Results.NoContent();
-});
-
 // Read a registration. Its zaak URL appears once the worker has opened the zaak (eventually).
 app.MapGet("/registrations/{id}", async (string id, IRegistrationStore store, CancellationToken ct) =>
 {
@@ -89,8 +72,6 @@ await app.RunAsync();
 
 public sealed record SubmitRegistrationRequest(string Bsn);
 
-public sealed record DecideRequest(string Besluit);
-
 public sealed record RegistrationResponse(string RegistrationId, string Status, string? ZaakUrl);
 
 public partial class Program;

services/domain/Big.Application/BeoordeelRegistratie.cs

@@ -1,57 +0,0 @@
-using Big.Domain;
-
-namespace Big.Application;
-
-/// <summary>A behandelaar's beoordeling outcome, in domain language.</summary>
-public enum BeoordelingsBesluit
-{
-    /// <summary>Approve — enter the registration in the register.</summary>
-    Goedkeuren,
-
-    /// <summary>Reject — turn the registration down.</summary>
-    Afwijzen,
-}
-
-/// <summary>A behandelaar's decision on a registration.</summary>
-public sealed record BeoordeelRegistratieCommand(RegistrationId RegistrationId, BeoordelingsBesluit Besluit);
-
-/// <summary>
-/// The beoordeling use case (S-12): apply a behandelaar's decision to a registration.
-/// <see cref="BeoordelingsBesluit.Goedkeuren"/> sets the zaak's final status via the ACL (§8.1) and
-/// advances the aggregate to INGESCHREVEN; <see cref="BeoordelingsBesluit.Afwijzen"/> advances it to
-/// AFGEWEZEN in the domain (propagating a rejection to the zaak, so the openbaar projection reflects
-/// it, is a later sub-slice of S-12). Both decisions are idempotent — a repeated or redelivered
-/// decision that matches the current terminal state is a no-op, so the ACL is not called twice.
-/// </summary>
-public sealed class BeoordeelRegistratie(IRegistrationStore store, IAclClient acl)
-{
-    public async Task HandleAsync(BeoordeelRegistratieCommand command, CancellationToken ct = default)
-    {
-        ArgumentNullException.ThrowIfNull(command);
-
-        var registration = await store.GetAsync(command.RegistrationId, ct)
-            ?? throw new InvalidOperationException($"No registration {command.RegistrationId} to decide.");
-
-        switch (command.Besluit)
-        {
-            case BeoordelingsBesluit.Goedkeuren:
-                // A repeated approval is a no-op: don't set the zaak status a second time.
-                if (registration.Status == RegistrationStatus.Ingeschreven)
-                    return;
-                if (registration.ZaakUrl is null)
-                    throw new InvalidOperationException(
-                        $"Registration {command.RegistrationId} has no zaak yet; it cannot be approved.");
-                await acl.ApproveZaakAsync(registration.ZaakUrl, ct);
-                registration.Approve();
-                break;
-
-            case BeoordelingsBesluit.Afwijzen:
-                if (registration.Status == RegistrationStatus.Afgewezen)
-                    return;
-                registration.Reject();
-                break;
-        }
-
-        await store.SaveAsync(registration, ct);
-    }
-}

services/domain/Big.Application/OpenZaakWorker.cs

@@ -28,7 +28,7 @@ public sealed class OpenZaakWorker(IRegistrationStore store, IAclClient acl)
         if (registration.ZaakUrl is not null)
             return registration.ZaakUrl;
 
-        var zaakUrl = await acl.OpenZaakAsync(registration.Bsn, registration.Id.ToString(), ct);
+        var zaakUrl = await acl.OpenZaakAsync(registration.Bsn, ct);
         registration.AttachZaak(zaakUrl);
         await store.SaveAsync(registration, ct);
         return zaakUrl;

services/domain/Big.Application/Ports.cs

@@ -24,10 +24,7 @@ public interface IWorkflowClient
 /// </summary>
 public interface IAclClient
 {
-    /// <summary>Open a zaak for the registration. <paramref name="reference"/> is the registration's
+    Task<Uri> OpenZaakAsync(string bsn, CancellationToken ct = default);
-    /// own reference (its id); the ACL records it as the zaak's identificatie so the openbaar register
-    /// can show the same reference the zorgprofessional was given (S-09b follow-up, adr-proposal #78).</summary>
-    Task<Uri> OpenZaakAsync(string bsn, string reference, CancellationToken ct = default);
 
     /// <summary>
     /// Record the approval on the given zaak. The ACL translates this to the ZGW concept — setting

services/domain/Big.Domain/Registration.cs

@@ -66,28 +66,10 @@ public sealed class Registration
     }
 
     /// <summary>
-    /// A behandelaar picks the registration up for beoordeling. Advances
+    /// Approve the registration — the behandelaar's decision to enter it in the register. Advances
-    /// <see cref="RegistrationStatus.Ingediend"/> → <see cref="RegistrationStatus.InBehandeling"/>.
+    /// <see cref="RegistrationStatus.Ingediend"/> → <see cref="RegistrationStatus.Ingeschreven"/>.
-    /// Re-taking one already <see cref="RegistrationStatus.InBehandeling"/> is a no-op (the same or
+    /// Requires an opened zaak (the approval sets that zaak's status via the ACL), and only a
-    /// another behandelaar re-opens it); a decided registration can no longer be taken into behandeling.
+    /// submitted registration can be approved: re-approving is rejected as an invalid transition.
-    /// </summary>
-    public void TakeIntoBehandeling()
-    {
-        if (Status == RegistrationStatus.InBehandeling)
-            return;
-
-        if (Status != RegistrationStatus.Ingediend)
-            throw new InvalidOperationException(
-                $"Registration {Id} is {Status}; only an INGEDIEND registration can be taken into behandeling.");
-
-        Status = RegistrationStatus.InBehandeling;
-    }
-
-    /// <summary>
-    /// Approve the registration — the behandelaar's decision to enter it in the register. Advances a
-    /// submitted or in-behandeling registration to <see cref="RegistrationStatus.Ingeschreven"/>.
-    /// Requires an opened zaak (the approval sets that zaak's status via the ACL); a registration that
-    /// has already been decided cannot be approved again.
     /// </summary>
     public void Approve()
     {
@@ -95,27 +77,10 @@ public sealed class Registration
             throw new InvalidOperationException(
                 $"Registration {Id} has no zaak yet; it cannot be approved before its zaak is opened.");
 
-        RequireOpenForDecision(nameof(Approve));
+        if (Status != RegistrationStatus.Ingediend)
+            throw new InvalidOperationException(
+                $"Registration {Id} is {Status}; only an INGEDIEND registration can be approved.");
+
         Status = RegistrationStatus.Ingeschreven;
     }
-
-    /// <summary>
-    /// Reject the registration — the behandelaar's decision not to enter it in the register. Advances a
-    /// submitted or in-behandeling registration to <see cref="RegistrationStatus.Afgewezen"/>. Unlike
-    /// approval this needs no zaak: a registration can be rejected before or after its zaak is opened.
-    /// A registration that has already been decided cannot be rejected again.
-    /// </summary>
-    public void Reject()
-    {
-        RequireOpenForDecision(nameof(Reject));
-        Status = RegistrationStatus.Afgewezen;
-    }
-
-    // A decision is only valid while the registration is still open (INGEDIEND or IN_BEHANDELING).
-    private void RequireOpenForDecision(string decision)
-    {
-        if (Status is not (RegistrationStatus.Ingediend or RegistrationStatus.InBehandeling))
-            throw new InvalidOperationException(
-                $"Registration {Id} is {Status}; only an INGEDIEND or IN_BEHANDELING registration can be decided ({decision}).");
-    }
 }

services/domain/Big.Domain/RegistrationStatus.cs

@@ -1,20 +1,13 @@
 namespace Big.Domain;
 
-/// <summary>The lifecycle states a <see cref="Registration"/> moves through. Submission starts in
+/// <summary>The lifecycle states a <see cref="Registration"/> moves through. The walking
-/// <see cref="Ingediend"/>; a behandelaar takes it <see cref="InBehandeling"/> and decides it into one
+/// skeleton knows <see cref="Ingediend"/> and the terminal <see cref="Ingeschreven"/>; withdrawal,
-/// of the terminal states <see cref="Ingeschreven"/> (approved) or <see cref="Afgewezen"/> (rejected).
+/// beoordeling and herregistratie states arrive in their own slices (Iteration 2+).</summary>
-/// Withdrawal and herregistratie states arrive in their own slices (S-11+).</summary>
 public enum RegistrationStatus
 {
     /// <summary>Submitted by the zorgprofessional; the registratie process has been started.</summary>
     Ingediend,
 
-    /// <summary>Picked up by a behandelaar for beoordeling (S-12).</summary>
+    /// <summary>Approved: entered in the register. Terminal in the walking skeleton (S-09b).</summary>
-    InBehandeling,
-
-    /// <summary>Approved: entered in the register. Terminal.</summary>
     Ingeschreven,
-
-    /// <summary>Rejected by the behandelaar. Terminal.</summary>
-    Afgewezen,
 }

services/domain/Big.Infrastructure/AclHttpClient.cs

@@ -11,10 +11,10 @@ namespace Big.Infrastructure;
 /// </summary>
 public sealed class AclHttpClient(HttpClient http, AclOptions options) : IAclClient
 {
-    public async Task<Uri> OpenZaakAsync(string bsn, string reference, CancellationToken ct = default)
+    public async Task<Uri> OpenZaakAsync(string bsn, CancellationToken ct = default)
     {
         using var response = await http.PostAsJsonAsync(
-            new Uri(options.BaseUrl, "zaken"), new OpenZaakRequest(bsn, reference), ct);
+            new Uri(options.BaseUrl, "zaken"), new OpenZaakRequest(bsn), ct);
         response.EnsureSuccessStatusCode();
 
         var opened = await response.Content.ReadFromJsonAsync<OpenZaakResponse>(ct)
@@ -31,9 +31,7 @@ public sealed class AclHttpClient(HttpClient http, AclOptions options) : IAclCli
         response.EnsureSuccessStatusCode();
     }
 
-    private sealed record OpenZaakRequest(
+    private sealed record OpenZaakRequest([property: JsonPropertyName("bsn")] string Bsn);
-        [property: JsonPropertyName("bsn")] string Bsn,
-        [property: JsonPropertyName("reference")] string Reference);
 
     private sealed record OpenZaakResponse([property: JsonPropertyName("zaakUrl")] string ZaakUrl);
 

services/domain/Big.Tests/AclHttpClientTests.cs

@@ -15,13 +15,12 @@ public class AclHttpClientTests
         var client = Client(capture.Responds(HttpStatusCode.OK,
             """{"zaakUrl":"http://openzaak/zaken/api/v1/zaken/abc"}"""));
 
-        var url = await client.OpenZaakAsync("123456782", "reg-42");
+        var url = await client.OpenZaakAsync("123456782");
 
         Assert.Equal("http://openzaak/zaken/api/v1/zaken/abc", url.ToString());
         Assert.Equal(HttpMethod.Post, capture.Seen!.Method);
         Assert.Equal("http://acl/zaken", capture.Seen.RequestUri!.ToString());
         Assert.Contains("\"bsn\":\"123456782\"", capture.Body);
-        Assert.Contains("\"reference\":\"reg-42\"", capture.Body);
     }
 
     [Fact]
@@ -30,7 +29,7 @@ public class AclHttpClientTests
         var capture = new RequestCapture();
         var client = Client(capture.Responds(HttpStatusCode.BadGateway));
 
-        await Assert.ThrowsAsync<HttpRequestException>(() => client.OpenZaakAsync("123456782", "reg-1"));
+        await Assert.ThrowsAsync<HttpRequestException>(() => client.OpenZaakAsync("123456782"));
     }
 
     [Fact]
@@ -39,7 +38,7 @@ public class AclHttpClientTests
         var capture = new RequestCapture();
         var client = Client(capture.Responds(HttpStatusCode.OK, "null"));
 
-        var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => client.OpenZaakAsync("123456782", "reg-1"));
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => client.OpenZaakAsync("123456782"));
         Assert.Contains("empty", ex.Message, StringComparison.OrdinalIgnoreCase);
     }
 
@@ -65,14 +64,4 @@ public class AclHttpClientTests
         await Assert.ThrowsAsync<HttpRequestException>(
             () => client.ApproveZaakAsync(new Uri("http://openzaak/zaken/api/v1/zaken/abc")));
     }
-
-    [Fact]
-    public async Task Approve_rejects_a_null_zaak_url_without_sending_a_request()
-    {
-        var capture = new RequestCapture();
-        var client = Client(capture.Responds(HttpStatusCode.NoContent));
-
-        await Assert.ThrowsAsync<ArgumentNullException>(() => client.ApproveZaakAsync(null!));
-        Assert.Null(capture.Seen);
-    }
 }

services/domain/Big.Tests/ApproveRegistrationTests.cs

@@ -27,19 +27,6 @@ public class ApproveRegistrationTests
         Assert.Equal(RegistrationStatus.Ingeschreven, saved!.Status);
         Assert.Equal(FakeAclClient.DefaultZaakUrl, acl.ApprovedZaakUrl);
         Assert.Equal(1, acl.ApproveCallCount);
-        // The approved aggregate is persisted (not just mutated in memory).
-        Assert.Equal(1, store.SaveCount);
-    }
-
-    [Fact]
-    public async Task Rejects_a_null_command_without_touching_the_store_or_acl()
-    {
-        var store = new FakeRegistrationStore();
-        var acl = new FakeAclClient();
-        var handler = new ApproveRegistration(store, acl);
-
-        await Assert.ThrowsAsync<ArgumentNullException>(() => handler.HandleAsync(null!));
-        Assert.Equal(0, acl.ApproveCallCount);
     }
 
     [Fact]
@@ -49,9 +36,8 @@ public class ApproveRegistrationTests
         var acl = new FakeAclClient();
         var handler = new ApproveRegistration(store, acl);
 
-        var ex = await Assert.ThrowsAsync<InvalidOperationException>(
+        await Assert.ThrowsAsync<InvalidOperationException>(
             () => handler.HandleAsync(new ApproveRegistrationCommand(RegistrationId.New())));
-        Assert.Contains("No registration", ex.Message);
         Assert.Equal(0, acl.ApproveCallCount);
     }
 
@@ -64,9 +50,8 @@ public class ApproveRegistrationTests
         store.Seed(registration);
         var handler = new ApproveRegistration(store, acl);
 
-        var ex = await Assert.ThrowsAsync<InvalidOperationException>(
+        await Assert.ThrowsAsync<InvalidOperationException>(
             () => handler.HandleAsync(new ApproveRegistrationCommand(registration.Id)));
-        Assert.Contains("no zaak", ex.Message);
         Assert.Equal(0, acl.ApproveCallCount);
     }
 

services/domain/Big.Tests/BeoordeelRegistratieTests.cs

@@ -1,142 +0,0 @@
-using Big.Application;
-using Big.Domain;
-
-namespace Big.Tests;
-
-/// <summary>
-/// The beoordeling use case (S-12): a behandelaar's decision on a registration. Goedkeuren sets the
-/// zaak's final status via the ACL (§8.1) and marks the aggregate INGESCHREVEN; Afwijzen marks it
-/// AFGEWEZEN in the domain (propagating a rejection to the zaak is a later sub-slice). Both are
-/// idempotent so a repeated or redelivered decision is a no-op.
-/// </summary>
-public class BeoordeelRegistratieTests
-{
-    private static Registration WithZaak(string bsn = "123456782")
-    {
-        var registration = Registration.Submit(bsn);
-        registration.AttachZaak(FakeAclClient.DefaultZaakUrl);
-        return registration;
-    }
-
-    [Fact]
-    public async Task Goedkeuren_sets_the_zaak_status_via_the_acl_and_marks_the_registration_ingeschreven()
-    {
-        var store = new FakeRegistrationStore();
-        var acl = new FakeAclClient();
-        var registration = WithZaak();
-        store.Seed(registration);
-        var handler = new BeoordeelRegistratie(store, acl);
-
-        await handler.HandleAsync(new BeoordeelRegistratieCommand(registration.Id, BeoordelingsBesluit.Goedkeuren));
-
-        var saved = await store.GetAsync(registration.Id);
-        Assert.Equal(RegistrationStatus.Ingeschreven, saved!.Status);
-        Assert.Equal(FakeAclClient.DefaultZaakUrl, acl.ApprovedZaakUrl);
-        Assert.Equal(1, acl.ApproveCallCount);
-        Assert.Equal(1, store.SaveCount);
-    }
-
-    [Fact]
-    public async Task Afwijzen_marks_the_registration_afgewezen_without_calling_the_acl()
-    {
-        var store = new FakeRegistrationStore();
-        var acl = new FakeAclClient();
-        var registration = WithZaak();
-        store.Seed(registration);
-        var handler = new BeoordeelRegistratie(store, acl);
-
-        await handler.HandleAsync(new BeoordeelRegistratieCommand(registration.Id, BeoordelingsBesluit.Afwijzen));
-
-        var saved = await store.GetAsync(registration.Id);
-        Assert.Equal(RegistrationStatus.Afgewezen, saved!.Status);
-        Assert.Equal(0, acl.ApproveCallCount);
-        Assert.Equal(1, store.SaveCount);
-    }
-
-    [Fact]
-    public async Task Goedkeuren_an_in_behandeling_registration_marks_it_ingeschreven()
-    {
-        var store = new FakeRegistrationStore();
-        var acl = new FakeAclClient();
-        var registration = WithZaak();
-        registration.TakeIntoBehandeling();
-        store.Seed(registration);
-        var handler = new BeoordeelRegistratie(store, acl);
-
-        await handler.HandleAsync(new BeoordeelRegistratieCommand(registration.Id, BeoordelingsBesluit.Goedkeuren));
-
-        Assert.Equal(RegistrationStatus.Ingeschreven, (await store.GetAsync(registration.Id))!.Status);
-    }
-
-    [Fact]
-    public async Task Rejects_a_null_command_without_touching_the_store_or_acl()
-    {
-        var store = new FakeRegistrationStore();
-        var acl = new FakeAclClient();
-        var handler = new BeoordeelRegistratie(store, acl);
-
-        await Assert.ThrowsAsync<ArgumentNullException>(() => handler.HandleAsync(null!));
-        Assert.Equal(0, acl.ApproveCallCount);
-        Assert.Equal(0, store.SaveCount);
-    }
-
-    [Fact]
-    public async Task Deciding_an_unknown_registration_throws_and_does_not_call_the_acl()
-    {
-        var store = new FakeRegistrationStore();
-        var acl = new FakeAclClient();
-        var handler = new BeoordeelRegistratie(store, acl);
-
-        var ex = await Assert.ThrowsAsync<InvalidOperationException>(() =>
-            handler.HandleAsync(new BeoordeelRegistratieCommand(RegistrationId.New(), BeoordelingsBesluit.Goedkeuren)));
-        Assert.Contains("No registration", ex.Message);
-        Assert.Equal(0, acl.ApproveCallCount);
-    }
-
-    [Fact]
-    public async Task Goedkeuren_before_the_zaak_is_opened_throws_without_calling_the_acl()
-    {
-        var store = new FakeRegistrationStore();
-        var acl = new FakeAclClient();
-        var registration = Registration.Submit("123456782"); // no zaak yet
-        store.Seed(registration);
-        var handler = new BeoordeelRegistratie(store, acl);
-
-        var ex = await Assert.ThrowsAsync<InvalidOperationException>(() =>
-            handler.HandleAsync(new BeoordeelRegistratieCommand(registration.Id, BeoordelingsBesluit.Goedkeuren)));
-        Assert.Contains("no zaak", ex.Message);
-        Assert.Equal(0, acl.ApproveCallCount);
-    }
-
-    [Fact]
-    public async Task Re_goedkeuren_an_already_ingeschreven_registration_is_idempotent()
-    {
-        var store = new FakeRegistrationStore();
-        var acl = new FakeAclClient();
-        var registration = WithZaak();
-        store.Seed(registration);
-        var handler = new BeoordeelRegistratie(store, acl);
-
-        await handler.HandleAsync(new BeoordeelRegistratieCommand(registration.Id, BeoordelingsBesluit.Goedkeuren));
-        await handler.HandleAsync(new BeoordeelRegistratieCommand(registration.Id, BeoordelingsBesluit.Goedkeuren));
-
-        Assert.Equal(1, acl.ApproveCallCount);
-        Assert.Equal(RegistrationStatus.Ingeschreven, (await store.GetAsync(registration.Id))!.Status);
-    }
-
-    [Fact]
-    public async Task Re_afwijzen_an_already_afgewezen_registration_is_idempotent()
-    {
-        var store = new FakeRegistrationStore();
-        var acl = new FakeAclClient();
-        var registration = WithZaak();
-        store.Seed(registration);
-        var handler = new BeoordeelRegistratie(store, acl);
-
-        await handler.HandleAsync(new BeoordeelRegistratieCommand(registration.Id, BeoordelingsBesluit.Afwijzen));
-        await handler.HandleAsync(new BeoordeelRegistratieCommand(registration.Id, BeoordelingsBesluit.Afwijzen));
-
-        Assert.Equal(1, store.SaveCount);
-        Assert.Equal(RegistrationStatus.Afgewezen, (await store.GetAsync(registration.Id))!.Status);
-    }
-}

services/domain/Big.Tests/Fakes.cs

@@ -50,17 +50,15 @@ internal sealed class FakeAclClient(Uri? zaakUrl = null) : IAclClient
     private readonly Uri _zaakUrl = zaakUrl ?? DefaultZaakUrl;
 
     public string? OpenedForBsn { get; private set; }
-    public string? OpenedWithReference { get; private set; }
     public int CallCount { get; private set; }
 
     public Uri? ApprovedZaakUrl { get; private set; }
     public int ApproveCallCount { get; private set; }
 
-    public Task<Uri> OpenZaakAsync(string bsn, string reference, CancellationToken ct = default)
+    public Task<Uri> OpenZaakAsync(string bsn, CancellationToken ct = default)
     {
         CallCount++;
         OpenedForBsn = bsn;
-        OpenedWithReference = reference;
         return Task.FromResult(_zaakUrl);
     }
 

services/domain/Big.Tests/OpenZaakWorkerTests.cs

@@ -25,9 +25,6 @@ public class OpenZaakWorkerTests
 
         Assert.Equal(FakeAclClient.DefaultZaakUrl, zaakUrl);
         Assert.Equal("123456782", acl.OpenedForBsn);
-        // The registration's own id is handed to the ACL as the zaak reference (identificatie),
-        // so the openbaar register can show the reference the zorgprofessional received (#78).
-        Assert.Equal(registration.Id.ToString(), acl.OpenedWithReference);
         var saved = await store.GetAsync(registration.Id);
         Assert.Equal(FakeAclClient.DefaultZaakUrl, saved!.ZaakUrl);
         Assert.Equal(1, store.SaveCount);

services/domain/Big.Tests/RegistrationTests.cs

@@ -117,104 +117,7 @@ public class RegistrationTests
         registration.AttachZaak(new Uri("http://openzaak/zaken/api/v1/zaken/abc"));
         registration.Approve();
 
-        var ex = Assert.Throws<InvalidOperationException>(() => registration.Approve());
+        Assert.Throws<InvalidOperationException>(() => registration.Approve());
-        Assert.Contains("only an INGEDIEND", ex.Message);
         Assert.Equal(RegistrationStatus.Ingeschreven, registration.Status);
     }
-
-    [Fact]
-    public void Taking_a_registration_into_behandeling_moves_it_to_in_behandeling()
-    {
-        var registration = Registration.Submit("123456782");
-
-        registration.TakeIntoBehandeling();
-
-        Assert.Equal(RegistrationStatus.InBehandeling, registration.Status);
-    }
-
-    [Fact]
-    public void Re_taking_an_in_behandeling_registration_is_idempotent()
-    {
-        var registration = Registration.Submit("123456782");
-        registration.TakeIntoBehandeling();
-
-        registration.TakeIntoBehandeling();
-
-        Assert.Equal(RegistrationStatus.InBehandeling, registration.Status);
-    }
-
-    [Fact]
-    public void Taking_a_decided_registration_into_behandeling_is_rejected()
-    {
-        var registration = Registration.Submit("123456782");
-        registration.AttachZaak(new Uri("http://openzaak/zaken/api/v1/zaken/abc"));
-        registration.Approve();
-
-        var ex = Assert.Throws<InvalidOperationException>(() => registration.TakeIntoBehandeling());
-        Assert.Contains("only an INGEDIEND", ex.Message);
-        Assert.Equal(RegistrationStatus.Ingeschreven, registration.Status);
-    }
-
-    [Fact]
-    public void Approving_an_in_behandeling_registration_with_a_zaak_sets_it_ingeschreven()
-    {
-        var registration = Registration.Submit("123456782");
-        registration.AttachZaak(new Uri("http://openzaak/zaken/api/v1/zaken/abc"));
-        registration.TakeIntoBehandeling();
-
-        registration.Approve();
-
-        Assert.Equal(RegistrationStatus.Ingeschreven, registration.Status);
-    }
-
-    [Fact]
-    public void Rejecting_a_registration_sets_it_afgewezen()
-    {
-        var registration = Registration.Submit("123456782");
-
-        registration.Reject();
-
-        Assert.Equal(RegistrationStatus.Afgewezen, registration.Status);
-    }
-
-    [Fact]
-    public void Rejecting_needs_no_zaak()
-    {
-        // A registration can be turned down before its zaak is ever opened, so Reject must not require one.
-        var registration = Registration.Submit("123456782");
-
-        registration.Reject();
-
-        Assert.Equal(RegistrationStatus.Afgewezen, registration.Status);
-        Assert.Null(registration.ZaakUrl);
-    }
-
-    [Fact]
-    public void Rejecting_an_in_behandeling_registration_sets_it_afgewezen()
-    {
-        var registration = Registration.Submit("123456782");
-        registration.TakeIntoBehandeling();
-
-        registration.Reject();
-
-        Assert.Equal(RegistrationStatus.Afgewezen, registration.Status);
-    }
-
-    [Fact]
-    public void Deciding_an_already_decided_registration_is_rejected()
-    {
-        var registration = Registration.Submit("123456782");
-        registration.Reject();
-
-        var approveEx = Assert.Throws<InvalidOperationException>(() =>
-        {
-            registration.AttachZaak(new Uri("http://openzaak/zaken/api/v1/zaken/abc"));
-            registration.Approve();
-        });
-        Assert.Contains("IN_BEHANDELING", approveEx.Message);
-
-        var rejectEx = Assert.Throws<InvalidOperationException>(() => registration.Reject());
-        Assert.Contains("Afgewezen", rejectEx.Message);
-        Assert.Equal(RegistrationStatus.Afgewezen, registration.Status);
-    }
 }

services/event-subscriber/EventSubscriber.Api/AclHttpClient.cs

@@ -1,30 +0,0 @@
-using System.Net.Http.Json;
-using System.Text.Json.Serialization;
-using EventSubscriber.Application;
-
-namespace EventSubscriber.Api;
-
-/// <summary>
-/// HTTP client to the ACL service. The subscriber enriches the projection with the zaak's reference
-/// (identificatie) by asking the ACL — the only code that may read ZGW (§8.1) — rather than reading
-/// OpenZaak itself (adr-proposal #78).
-/// </summary>
-public sealed class AclHttpClient(HttpClient http) : IAclClient
-{
-    public async Task<string> GetZaakReferenceAsync(Uri zaakUrl, CancellationToken ct = default)
-    {
-        ArgumentNullException.ThrowIfNull(zaakUrl);
-
-        using var response = await http.PostAsJsonAsync(
-            new Uri(http.BaseAddress!, "zaken/reference"), new ReferenceRequest(zaakUrl.ToString()), ct);
-        response.EnsureSuccessStatusCode();
-
-        var body = await response.Content.ReadFromJsonAsync<ReferenceResponse>(ct)
-            ?? throw new InvalidOperationException("The ACL returned an empty reference response.");
-        return body.Reference;
-    }
-
-    private sealed record ReferenceRequest([property: JsonPropertyName("zaakUrl")] string ZaakUrl);
-
-    private sealed record ReferenceResponse([property: JsonPropertyName("reference")] string Reference);
-}

services/event-subscriber/EventSubscriber.Api/Program.cs

@@ -11,15 +11,9 @@ var connectionString = builder.Configuration.GetConnectionString("Projection")
 // this value (ADR-0007), so the webhook enforces it.
 var webhookToken = builder.Configuration["EventSubscriber:Webhook:AuthToken"]
     ?? throw new InvalidOperationException("Missing configuration 'EventSubscriber:Webhook:AuthToken'");
-// The ACL is the only code that may read ZGW (§8.1); the subscriber enriches the projection with the
-// zaak reference through it (adr-proposal #78).
-var aclBaseUrl = builder.Configuration["Acl:BaseUrl"]
-    ?? throw new InvalidOperationException("Missing configuration 'Acl:BaseUrl'");
 
 builder.Services.AddProjectionReadModel(connectionString);
 builder.Services.AddProjectionWriteSide();
-builder.Services.AddHttpClient<EventSubscriber.Application.IAclClient, EventSubscriber.Api.AclHttpClient>(
-    c => c.BaseAddress = new Uri(aclBaseUrl));
 
 var app = builder.Build();
 

services/event-subscriber/EventSubscriber.Application/Notification.cs

@@ -24,12 +24,10 @@ public sealed record Notification(
     public bool IsZaakStatusSet =>
         Kanaal == "zaken" && Resource == "status" && Actie == "create";
 
-    /// <summary>The zaak URL this notification concerns — <c>hoofdObject</c> (the zaak) for a status
+    /// <summary>The zaak UUID used as the projection key. For a status notification the resource URL is
-    /// notification, else the resource URL (which, for a zaak-create, is the zaak).</summary>
+    /// the status, so the zaak comes from <c>hoofdObject</c> (which, for a zaak-create, equals the
-    public Uri ZaakUrl => HoofdObject ?? ResourceUrl;
+    /// resource URL) — see the NRC payload note.</summary>
-
+    public string ZaakId => (HoofdObject ?? ResourceUrl).Segments[^1].Trim('/');
-    /// <summary>The zaak UUID used as the projection key — the trailing segment of <see cref="ZaakUrl"/>.</summary>
-    public string ZaakId => ZaakUrl.Segments[^1].Trim('/');
 
     /// <summary>
     /// A deterministic dedup key. Open Notificaties carries no notification id and may

services/event-subscriber/EventSubscriber.Application/NotificationProjector.cs

@@ -5,19 +5,17 @@ namespace EventSubscriber.Application;
 /// out-of-order deliveries (CLAUDE.md §8.6): the notification log dedups, and the projection
 /// upsert is idempotent on the zaak id. Rebuilds the projection by replaying the log.
 /// </summary>
-public sealed class NotificationProjector(INotificationLog log, IProjectionStore store, IAclClient acl)
+public sealed class NotificationProjector(INotificationLog log, IProjectionStore store)
 {
     /// <summary>Handle one inbound notification. Reacts to a zaak being created (INGEDIEND) and a
-    /// status being set (INGESCHREVEN); ignores everything else. Enriches the row with the zaak's
+    /// status being set (INGESCHREVEN); ignores everything else.</summary>
-    /// reference via the ACL (§8.1) and records it so a rebuild needs no ZGW access (#78).</summary>
     public async Task HandleAsync(Notification notification, CancellationToken ct = default)
     {
         if (!notification.IsZaakCreated && !notification.IsZaakStatusSet)
             return;
 
-        var reference = await acl.GetZaakReferenceAsync(notification.ZaakUrl, ct);
         var recorded = new RecordedNotification(
-            notification.IdempotencyKey, notification.Actie, notification.ZaakId, notification.Resource, reference);
+            notification.IdempotencyKey, notification.Actie, notification.ZaakId, notification.Resource);
 
         // Atomic record-or-skip: a duplicate (or concurrent) delivery is recognised and dropped
         // before it touches the projection, so the projection stays a faithful derived artefact.
@@ -38,8 +36,7 @@ public sealed class NotificationProjector(INotificationLog log, IProjectionStore
     /// <summary>The projection row for an accepted notification: a status-set maps to INGESCHREVEN,
     /// a zaak-create to INGEDIEND. bsn/naam are deferred (ADR-0008).</summary>
     private static RegisterEntry ToEntry(RecordedNotification recorded)
-        => new(
+        => new(recorded.ZaakId, recorded.Resource == "status"
-            recorded.ZaakId,
+            ? RegistrationStatus.Ingeschreven
-            recorded.Resource == "status" ? RegistrationStatus.Ingeschreven : RegistrationStatus.Ingediend,
+            : RegistrationStatus.Ingediend);
-            Reference: recorded.Reference);
 }

services/event-subscriber/EventSubscriber.Application/Ports.cs

@@ -20,20 +20,9 @@ public interface INotificationLog
 }
 
 /// <summary>A notification that has been accepted, retaining what a rebuild needs to recompute its
-/// projection row — the ZGW <c>resource</c> (zaak-create → INGEDIEND vs status-set → INGESCHREVEN) and
+/// projection row — including the ZGW <c>resource</c>, which distinguishes a zaak-create (INGEDIEND)
-/// the zaak <c>reference</c> (identificatie), so a rebuild reproduces the row without re-reading ZGW (#78).</summary>
+/// from a status-set (INGESCHREVEN) so a rebuild reproduces the right status.</summary>
-public sealed record RecordedNotification(string Key, string Actie, string ZaakId, string Resource, string? Reference);
+public sealed record RecordedNotification(string Key, string Actie, string ZaakId, string Resource);
-
-/// <summary>
-/// Port to the Anti-Corruption Layer. The subscriber enriches the projection with the zaak's
-/// public-safe reference (its identificatie) by asking the ACL — the only code that may read ZGW
-/// (§8.1) — rather than reading OpenZaak itself (adr-proposal #78).
-/// </summary>
-public interface IAclClient
-{
-    /// <summary>The zaak's reference (identificatie) for the read projection.</summary>
-    Task<string> GetZaakReferenceAsync(Uri zaakUrl, CancellationToken ct = default);
-}
 
 /// <summary>The read projection store. Owned by the projection bounded context (ADR-0008); the
 /// subscriber writes to it and the projection-api reads it.</summary>

services/event-subscriber/EventSubscriber.Application/RegisterEntry.cs

@@ -9,7 +9,6 @@ namespace EventSubscriber.Application;
 public sealed record RegisterEntry(
     string Id,
     string Status,
-    string? Reference = null,
     string? Bsn = null,
     string? NaamPlaceholder = null);
 

services/event-subscriber/EventSubscriber.Tests/AclHttpClientTests.cs

@@ -1,86 +0,0 @@
-using System.Net;
-using System.Text;
-using EventSubscriber.Api;
-
-namespace EventSubscriber.Tests;
-
-/// <summary>
-/// Unit tests for the subscriber's ACL client, which reads a zaak's reference (identificatie) through
-/// the ACL — the only code allowed to talk to ZGW (§8.1, #78). Uses a scripted message handler so no
-/// real ACL is required.
-/// </summary>
-public class AclHttpClientTests
-{
-    private static AclHttpClient Client(StubHandler handler) =>
-        new(new HttpClient(handler) { BaseAddress = new Uri("http://acl/") });
-
-    [Fact]
-    public async Task Reads_a_zaak_reference_by_posting_the_zaak_url_and_returns_it()
-    {
-        var capture = new RequestCapture();
-        var client = Client(capture.Responds(HttpStatusCode.OK, """{"reference":"REG-42"}"""));
-
-        var reference = await client.GetZaakReferenceAsync(new Uri("http://openzaak/zaken/api/v1/zaken/abc"));
-
-        Assert.Equal("REG-42", reference);
-        Assert.Equal(HttpMethod.Post, capture.Seen!.Method);
-        Assert.Equal("http://acl/zaken/reference", capture.Seen.RequestUri!.ToString());
-        Assert.Contains("\"zaakUrl\":\"http://openzaak/zaken/api/v1/zaken/abc\"", capture.Body);
-    }
-
-    [Fact]
-    public async Task Throws_when_the_acl_rejects_the_request()
-    {
-        var capture = new RequestCapture();
-        var client = Client(capture.Responds(HttpStatusCode.BadGateway));
-
-        await Assert.ThrowsAsync<HttpRequestException>(
-            () => client.GetZaakReferenceAsync(new Uri("http://openzaak/zaken/api/v1/zaken/abc")));
-    }
-
-    [Fact]
-    public async Task Throws_when_the_acl_returns_an_empty_body()
-    {
-        var capture = new RequestCapture();
-        var client = Client(capture.Responds(HttpStatusCode.OK, "null"));
-
-        var ex = await Assert.ThrowsAsync<InvalidOperationException>(
-            () => client.GetZaakReferenceAsync(new Uri("http://openzaak/zaken/api/v1/zaken/abc")));
-        Assert.Contains("empty", ex.Message, StringComparison.OrdinalIgnoreCase);
-    }
-
-    [Fact]
-    public async Task Rejects_a_null_zaak_url_without_sending_a_request()
-    {
-        var capture = new RequestCapture();
-        var client = Client(capture.Responds(HttpStatusCode.OK, """{"reference":"REG-1"}"""));
-
-        await Assert.ThrowsAsync<ArgumentNullException>(() => client.GetZaakReferenceAsync(null!));
-        Assert.Null(capture.Seen);
-    }
-}
-
-/// <summary>A test double for <see cref="HttpMessageHandler"/> that records the last request and
-/// returns a scripted response — mirrors the ACL/domain gateway tests.</summary>
-internal sealed class StubHandler(Func<HttpRequestMessage, Task<HttpResponseMessage>> onSend) : HttpMessageHandler
-{
-    protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken ct)
-        => onSend(request);
-}
-
-/// <summary>Captures the request a client sent, including the (buffered) body.</summary>
-internal sealed class RequestCapture
-{
-    public HttpRequestMessage? Seen { get; private set; }
-    public string? Body { get; private set; }
-
-    public StubHandler Responds(HttpStatusCode status, string? json = null) => new(async req =>
-    {
-        Seen = req;
-        Body = req.Content is null ? null : await req.Content.ReadAsStringAsync();
-        var response = new HttpResponseMessage(status);
-        if (json is not null)
-            response.Content = new StringContent(json, Encoding.UTF8, "application/json");
-        return response;
-    });
-}

services/event-subscriber/EventSubscriber.Tests/EventSubscriber.Tests.csproj

@@ -19,7 +19,6 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\EventSubscriber.Api\EventSubscriber.Api.csproj" />
     <ProjectReference Include="..\EventSubscriber.Application\EventSubscriber.Application.csproj" />
   </ItemGroup>
 

services/event-subscriber/EventSubscriber.Tests/InMemoryStores.cs

@@ -5,19 +5,6 @@ namespace EventSubscriber.Tests;
 /// <summary>In-memory stand-ins for the projection store and notification log, so the
 /// projector's behaviour is exercised without Postgres (hand-written stubs, the repo's
 /// convention — no mocking library).</summary>
-/// <summary>A fake ACL client that returns a fixed reference derived from the zaak, and records
-/// how many times it was called (to prove a rebuild does not re-read via the ACL).</summary>
-internal sealed class FakeAclClient : IAclClient
-{
-    public int CallCount { get; private set; }
-
-    public Task<string> GetZaakReferenceAsync(Uri zaakUrl, CancellationToken ct = default)
-    {
-        CallCount++;
-        return Task.FromResult("REG-" + zaakUrl.Segments[^1].Trim('/'));
-    }
-}
-
 internal sealed class InMemoryNotificationLog : INotificationLog
 {
     private readonly Dictionary<string, RecordedNotification> _byKey = [];

services/event-subscriber/EventSubscriber.Tests/NotificationProjectorTests.cs

@@ -12,9 +12,8 @@ public sealed class NotificationProjectorTests
 
     private readonly InMemoryNotificationLog _log = new();
     private readonly InMemoryProjectionStore _store = new();
-    private readonly FakeAclClient _acl = new();
 
-    private NotificationProjector Projector() => new(_log, _store, _acl);
+    private NotificationProjector Projector() => new(_log, _store);
 
     private static Notification ZaakCreated(string url = ZaakUrl)
         => new("zaken", "zaak", "create", new Uri(url));
@@ -31,23 +30,6 @@ public sealed class NotificationProjectorTests
         var entry = Assert.Single(await _store.AllAsync());
         Assert.Equal("11111111-1111-1111-1111-111111111111", entry.Id);
         Assert.Equal(RegistrationStatus.Ingediend, entry.Status);
-        // Enriched with the zaak's reference (identificatie), fetched via the ACL (#78).
-        Assert.Equal("REG-11111111-1111-1111-1111-111111111111", entry.Reference);
-    }
-
-    [Fact]
-    public async Task rebuild_reproduces_the_reference_without_re_reading_via_the_acl()
-    {
-        var projector = Projector();
-        await projector.HandleAsync(ZaakCreated());
-        var callsAfterProjection = _acl.CallCount;
-
-        await projector.RebuildAsync();
-
-        var entry = Assert.Single(await _store.AllAsync());
-        Assert.Equal("REG-11111111-1111-1111-1111-111111111111", entry.Reference);
-        // Rebuild replays the log (which stored the reference) — no extra ACL calls (#78, ADR-0008).
-        Assert.Equal(callsAfterProjection, _acl.CallCount);
     }
 
     [Fact]

services/projection-api/Projection.ReadModel/EfNotificationLog.cs

@@ -16,7 +16,6 @@ public sealed class EfNotificationLog(ProjectionDbContext db) : INotificationLog
             Actie = notification.Actie,
             ZaakId = notification.ZaakId,
             Resource = notification.Resource,
-            Reference = notification.Reference,
             ReceivedAt = DateTimeOffset.UtcNow,
         });
 
@@ -36,6 +35,6 @@ public sealed class EfNotificationLog(ProjectionDbContext db) : INotificationLog
     public async Task<IReadOnlyList<RecordedNotification>> AllAsync(CancellationToken ct = default)
         => await db.ProcessedNotifications
             .OrderBy(r => r.ReceivedAt)
-            .Select(r => new RecordedNotification(r.Key, r.Actie, r.ZaakId, r.Resource, r.Reference))
+            .Select(r => new RecordedNotification(r.Key, r.Actie, r.ZaakId, r.Resource))
             .ToListAsync(ct);
 }

services/projection-api/Projection.ReadModel/EfProjectionStore.cs

@@ -15,7 +15,6 @@ public sealed class EfProjectionStore(ProjectionDbContext db) : IProjectionStore
             {
                 Id = entry.Id,
                 Status = entry.Status,
-                Reference = entry.Reference,
                 Bsn = entry.Bsn,
                 NaamPlaceholder = entry.NaamPlaceholder,
             });
@@ -23,7 +22,6 @@ public sealed class EfProjectionStore(ProjectionDbContext db) : IProjectionStore
         else
         {
             row.Status = entry.Status;
-            row.Reference = entry.Reference;
             row.Bsn = entry.Bsn;
             row.NaamPlaceholder = entry.NaamPlaceholder;
         }
@@ -37,6 +35,6 @@ public sealed class EfProjectionStore(ProjectionDbContext db) : IProjectionStore
     public async Task<IReadOnlyList<RegisterEntry>> AllAsync(CancellationToken ct = default)
         => await db.RegisterEntries
             .OrderBy(r => r.Id)
-            .Select(r => new RegisterEntry(r.Id, r.Status, Reference: r.Reference, Bsn: r.Bsn, NaamPlaceholder: r.NaamPlaceholder))
+            .Select(r => new RegisterEntry(r.Id, r.Status, r.Bsn, r.NaamPlaceholder))
             .ToListAsync(ct);
 }

services/projection-api/Projection.ReadModel/Migrations/20260714101642_AddReferenceColumns.Designer.cs

@@ -1,92 +0,0 @@
-// <auto-generated />
-using System;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Migrations;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-using Projection.ReadModel;
-
-#nullable disable
-
-namespace Projection.ReadModel.Migrations
-{
-    [DbContext(typeof(ProjectionDbContext))]
-    [Migration("20260714101642_AddReferenceColumns")]
-    partial class AddReferenceColumns
-    {
-        /// <inheritdoc />
-        protected override void BuildTargetModel(ModelBuilder modelBuilder)
-        {
-#pragma warning disable 612, 618
-            modelBuilder
-                .HasAnnotation("ProductVersion", "10.0.0")
-                .HasAnnotation("Relational:MaxIdentifierLength", 63);
-
-            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
-
-            modelBuilder.Entity("Projection.ReadModel.ProcessedNotificationRow", b =>
-                {
-                    b.Property<string>("Key")
-                        .HasColumnType("text")
-                        .HasColumnName("key");
-
-                    b.Property<string>("Actie")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("actie");
-
-                    b.Property<DateTimeOffset>("ReceivedAt")
-                        .HasColumnType("timestamp with time zone")
-                        .HasColumnName("received_at");
-
-                    b.Property<string>("Reference")
-                        .HasColumnType("text")
-                        .HasColumnName("reference");
-
-                    b.Property<string>("Resource")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("resource");
-
-                    b.Property<string>("ZaakId")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("zaak_id");
-
-                    b.HasKey("Key");
-
-                    b.ToTable("processed_notifications", (string)null);
-                });
-
-            modelBuilder.Entity("Projection.ReadModel.RegisterEntryRow", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("text")
-                        .HasColumnName("id");
-
-                    b.Property<string>("Bsn")
-                        .HasColumnType("text")
-                        .HasColumnName("bsn");
-
-                    b.Property<string>("NaamPlaceholder")
-                        .HasColumnType("text")
-                        .HasColumnName("naam_placeholder");
-
-                    b.Property<string>("Reference")
-                        .HasColumnType("text")
-                        .HasColumnName("reference");
-
-                    b.Property<string>("Status")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("status");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("register_projection", (string)null);
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

services/projection-api/Projection.ReadModel/Migrations/20260714101642_AddReferenceColumns.cs

@@ -1,38 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace Projection.ReadModel.Migrations
-{
-    /// <inheritdoc />
-    public partial class AddReferenceColumns : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.AddColumn<string>(
-                name: "reference",
-                table: "register_projection",
-                type: "text",
-                nullable: true);
-
-            migrationBuilder.AddColumn<string>(
-                name: "reference",
-                table: "processed_notifications",
-                type: "text",
-                nullable: true);
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropColumn(
-                name: "reference",
-                table: "register_projection");
-
-            migrationBuilder.DropColumn(
-                name: "reference",
-                table: "processed_notifications");
-        }
-    }
-}

services/projection-api/Projection.ReadModel/Migrations/ProjectionDbContextModelSnapshot.cs

@@ -37,10 +37,6 @@ namespace Projection.ReadModel.Migrations
                         .HasColumnType("timestamp with time zone")
                         .HasColumnName("received_at");
 
-                    b.Property<string>("Reference")
-                        .HasColumnType("text")
-                        .HasColumnName("reference");
-
                     b.Property<string>("Resource")
                         .IsRequired()
                         .HasColumnType("text")
@@ -70,10 +66,6 @@ namespace Projection.ReadModel.Migrations
                         .HasColumnType("text")
                         .HasColumnName("naam_placeholder");
 
-                    b.Property<string>("Reference")
-                        .HasColumnType("text")
-                        .HasColumnName("reference");
-
                     b.Property<string>("Status")
                         .IsRequired()
                         .HasColumnType("text")

services/projection-api/Projection.ReadModel/ProjectionDbContext.cs

@@ -24,7 +24,6 @@ public sealed class ProjectionDbContext(DbContextOptions<ProjectionDbContext> op
             e.HasKey(r => r.Id);
             e.Property(r => r.Id).HasColumnName("id");
             e.Property(r => r.Status).HasColumnName("status").IsRequired();
-            e.Property(r => r.Reference).HasColumnName("reference");
             e.Property(r => r.Bsn).HasColumnName("bsn");
             e.Property(r => r.NaamPlaceholder).HasColumnName("naam_placeholder");
         });
@@ -37,7 +36,6 @@ public sealed class ProjectionDbContext(DbContextOptions<ProjectionDbContext> op
             e.Property(r => r.Actie).HasColumnName("actie").IsRequired();
             e.Property(r => r.ZaakId).HasColumnName("zaak_id").IsRequired();
             e.Property(r => r.Resource).HasColumnName("resource").IsRequired();
-            e.Property(r => r.Reference).HasColumnName("reference");
             e.Property(r => r.ReceivedAt).HasColumnName("received_at");
         });
     }
@@ -48,10 +46,6 @@ public sealed class RegisterEntryRow
 {
     public required string Id { get; set; }
     public required string Status { get; set; }
-
-    /// <summary>The citizen-facing reference (the zaak's identificatie) — matches the submit confirmation (#78).</summary>
-    public string? Reference { get; set; }
-
     public string? Bsn { get; set; }
     public string? NaamPlaceholder { get; set; }
 }
@@ -67,8 +61,5 @@ public sealed class ProcessedNotificationRow
     /// the right status without reading OpenZaak (S-09b).</summary>
     public required string Resource { get; set; }
 
-    /// <summary>The zaak reference (identificatie), retained so a rebuild reprojects it without the ACL (#78).</summary>
-    public string? Reference { get; set; }
-
     public DateTimeOffset ReceivedAt { get; set; }
 }

services/projection-api/Projection.ReadModel/ServiceCollectionExtensions.cs

@@ -19,46 +19,12 @@ public static class ServiceCollectionExtensions
         return services;
     }
 
-    // A fixed application-scoped key for the migration advisory lock (any stable 64-bit constant).
-    private const long MigrationAdvisoryLockKey = 727501;
-
     /// <summary>Apply any pending EF migrations. Called once on service start so a fresh stack
-    /// reaches a usable schema without a manual migration step (DoD: compose up reaches green).
+    /// reaches a usable schema without a manual migration step (DoD: compose up reaches green).</summary>
-    ///
-    /// The Event Subscriber and the projection-api share this DB and both migrate on start. EF's
-    /// migrations-history lock is released between individual migrations, so with more than one pending
-    /// migration two migrators can interleave and one re-applies a migration the other just did
-    /// ("column already exists"). Hold a Postgres session <c>pg_advisory_lock</c> across the whole
-    /// sequence so it runs exactly once; the second migrator then finds nothing pending.</summary>
     public static async Task MigrateProjectionAsync(this IServiceProvider services, CancellationToken ct = default)
     {
         await using var scope = services.CreateAsyncScope();
         var db = scope.ServiceProvider.GetRequiredService<ProjectionDbContext>();
-        var connection = db.Database.GetDbConnection();
-
-        await connection.OpenAsync(ct);
-        try
-        {
-            await ExecuteAsync(connection, $"SELECT pg_advisory_lock({MigrationAdvisoryLockKey})", ct);
-            try
-            {
         await db.Database.MigrateAsync(ct);
     }
-            finally
-            {
-                await ExecuteAsync(connection, $"SELECT pg_advisory_unlock({MigrationAdvisoryLockKey})", ct);
-            }
-        }
-        finally
-        {
-            await connection.CloseAsync();
-        }
-    }
-
-    private static async Task ExecuteAsync(System.Data.Common.DbConnection connection, string sql, CancellationToken ct)
-    {
-        await using var command = connection.CreateCommand();
-        command.CommandText = sql;
-        await command.ExecuteNonQueryAsync(ct);
-    }
 }

services/projection-api/ProjectionApi.Api/Program.cs

@@ -10,9 +10,8 @@ builder.Services.AddProjectionReadModel(connectionString);
 
 var app = builder.Build();
 
-// Ensure the schema exists before serving reads. The Event Subscriber migrates this shared DB too;
+// Ensure the schema exists before serving reads. EF serialises concurrent migrators via the
-// MigrateProjectionAsync serialises concurrent migrators with a session advisory lock so the whole
+// migrations-history lock, so it is safe that the Event Subscriber migrates too.
-// migration sequence runs exactly once (see ServiceCollectionExtensions).
 await app.Services.MigrateProjectionAsync();
 
 app.MapGet("/health", () => "Healthy");
@@ -23,7 +22,7 @@ app.MapGet("/register", async (ProjectionDbContext db, CancellationToken ct) =>
 {
     var rows = await db.RegisterEntries
         .OrderBy(r => r.Id)
-        .Select(r => new RegisterEntryDto(r.Id, r.Status, r.Reference, r.Bsn, r.NaamPlaceholder))
+        .Select(r => new RegisterEntryDto(r.Id, r.Status, r.Bsn, r.NaamPlaceholder))
         .ToListAsync(ct);
     return Results.Ok(rows);
 });
@@ -32,13 +31,13 @@ app.MapGet("/register/{id}", async (string id, ProjectionDbContext db, Cancellat
 {
     var row = await db.RegisterEntries
         .Where(r => r.Id == id)
-        .Select(r => new RegisterEntryDto(r.Id, r.Status, r.Reference, r.Bsn, r.NaamPlaceholder))
+        .Select(r => new RegisterEntryDto(r.Id, r.Status, r.Bsn, r.NaamPlaceholder))
         .SingleOrDefaultAsync(ct);
     return row is null ? Results.NotFound() : Results.Ok(row);
 });
 
 await app.RunAsync();
 
-public sealed record RegisterEntryDto(string Id, string Status, string? Reference, string? Bsn, string? NaamPlaceholder);
+public sealed record RegisterEntryDto(string Id, string Status, string? Bsn, string? NaamPlaceholder);
 
 public partial class Program;

tests/acceptance/Features/EenRegistratieBeoordelen.feature

@@ -1,24 +0,0 @@
-# language: en
-# Drives S-12 (#13). A behandelaar picks up a submitted registration for beoordeling and decides it:
-# goedkeuren enters it in the register (INGESCHREVEN, the zaak's final status set via the ACL, §8.1),
-# afwijzen turns it down (AFGEWEZEN). This scenario exercises the use cases against in-memory
-# stand-ins for the ACL and the store; real Flowable user-task claim/complete arrives in a later
-# sub-slice and is verified live.
-Feature: Een registratie beoordelen
-  Als behandelaar wil ik een ingediende registratie beoordelen
-  zodat deze wordt ingeschreven of afgewezen.
-
-  Scenario: Goedkeuren schrijft de registratie in via de ACL
-    Given a submitted registration with an opened zaak
-    When the behandelaar takes it into behandeling
-    Then the registration has status "INBEHANDELING"
-    When the behandelaar decides "goedkeuren"
-    Then the registration has status "INGESCHREVEN"
-    And the zaak's final status is set via the ACL
-
-  Scenario: Afwijzen wijst de registratie af zonder de ACL
-    Given a submitted registration with an opened zaak
-    When the behandelaar takes it into behandeling
-    And the behandelaar decides "afwijzen"
-    Then the registration has status "AFGEWEZEN"
-    And the ACL is not asked to set the zaak status

tests/acceptance/Steps/BffToegangSteps.cs

@@ -31,7 +31,7 @@ public sealed class BffToegangSteps : IDisposable
     [Given("the projection contains a zaak \"(.*)\" for BSN \"(.*)\"")]
     public void GivenTheProjectionContains(string zaakId, string bsn)
     {
-        _host.Projection.Entries.Add(new ProjectionEntry(zaakId, "INGEDIEND", "REG-" + zaakId, bsn, null));
+        _host.Projection.Entries.Add(new ProjectionEntry(zaakId, "INGEDIEND", bsn, null));
         _client = _host.CreateClient();
     }
 

tests/acceptance/Steps/EenRegistratieBeoordelenSteps.cs

@@ -1,58 +0,0 @@
-using Acceptance.Support;
-using Big.Application;
-using Big.Domain;
-using Reqnroll;
-using Xunit;
-
-namespace Acceptance.Steps;
-
-/// <summary>Bindings for <c>EenRegistratieBeoordelen.feature</c> (S-12). Drives the TakeIntoBehandeling
-/// transition and the BeoordeelRegistratie use case against in-memory ports; one instance per scenario.
-/// Scoped to this feature so its "the registration has status" step does not clash with the identically
-/// phrased (but differently-asserting) step in <see cref="RegistratieIndienenSteps"/>.</summary>
-[Binding]
-[Scope(Feature = "Een registratie beoordelen")]
-public sealed class EenRegistratieBeoordelenSteps
-{
-    private readonly InMemoryAclClient _acl = new();
-    private readonly InMemoryRegistrationStore _store = new();
-    private RegistrationId _id;
-
-    [Given("a submitted registration with an opened zaak")]
-    public async Task GivenASubmittedRegistrationWithAnOpenedZaak()
-    {
-        var registration = Registration.Submit("123456782");
-        registration.AttachZaak(InMemoryAclClient.OpenedZaakUrl);
-        await _store.SaveAsync(registration);
-        _id = registration.Id;
-    }
-
-    [When("the behandelaar takes it into behandeling")]
-    public async Task WhenTheBehandelaarTakesItIntoBehandeling()
-    {
-        var registration = await _store.GetAsync(_id);
-        registration!.TakeIntoBehandeling();
-        await _store.SaveAsync(registration);
-    }
-
-    [When("the behandelaar decides \"(.*)\"")]
-    public async Task WhenTheBehandelaarDecides(string besluit)
-        => await new BeoordeelRegistratie(_store, _acl).HandleAsync(
-            new BeoordeelRegistratieCommand(_id, Enum.Parse<BeoordelingsBesluit>(besluit, ignoreCase: true)));
-
-    [Then("the registration has status \"(.*)\"")]
-    public async Task ThenTheRegistrationHasStatus(string expected)
-    {
-        var registration = await _store.GetAsync(_id);
-        Assert.NotNull(registration);
-        Assert.Equal(expected, registration.Status.ToString().ToUpperInvariant());
-    }
-
-    [Then("the zaak's final status is set via the ACL")]
-    public void ThenTheZaakFinalStatusIsSetViaTheAcl()
-        => Assert.Equal(InMemoryAclClient.OpenedZaakUrl, _acl.ApprovedZaakUrl);
-
-    [Then("the ACL is not asked to set the zaak status")]
-    public void ThenTheAclIsNotAskedToSetTheZaakStatus()
-        => Assert.Null(_acl.ApprovedZaakUrl);
-}

tests/acceptance/Steps/EenZaakOpenenSteps.cs

@@ -18,7 +18,7 @@ public sealed class EenZaakOpenenSteps
 
     [Given("a domain registration for BSN \"(.*)\"")]
     public void GivenADomainRegistrationForBsn(string bsn)
-        => _registration = new DomainRegistration(bsn, "ACC-REF-1");
+        => _registration = new DomainRegistration(bsn);
 
     [Given("the ACL is configured with these defaults:")]
     public void GivenTheAclIsConfiguredWithTheseDefaults(DataTable defaults)

tests/acceptance/Steps/RegisterProjectieBijwerkenSteps.cs

@@ -17,8 +17,7 @@ public sealed class RegisterProjectieBijwerkenSteps
     private readonly NotificationProjector _projector;
     private Notification? _notification;
 
-    public RegisterProjectieBijwerkenSteps()
+    public RegisterProjectieBijwerkenSteps() => _projector = new NotificationProjector(_log, _store);
-        => _projector = new NotificationProjector(_log, _store, new InMemoryAclReferenceClient());
 
     [Given("a zaak is created in OpenZaak with id \"(.*)\"")]
     public void GivenAZaakIsCreatedInOpenZaakWithId(string id)

tests/acceptance/Support/InMemoryDomainPorts.cs

@@ -26,13 +26,11 @@ public sealed class InMemoryAclClient : IAclClient
     public static readonly Uri OpenedZaakUrl = new("http://openzaak/zaken/api/v1/zaken/acc-zaak");
 
     public string? OpenedForBsn { get; private set; }
-    public string? OpenedWithReference { get; private set; }
     public Uri? ApprovedZaakUrl { get; private set; }
 
-    public Task<Uri> OpenZaakAsync(string bsn, string reference, CancellationToken ct = default)
+    public Task<Uri> OpenZaakAsync(string bsn, CancellationToken ct = default)
     {
         OpenedForBsn = bsn;
-        OpenedWithReference = reference;
         return Task.FromResult(OpenedZaakUrl);
     }
 

tests/acceptance/Support/InMemoryProjectionStores.cs

@@ -38,11 +38,3 @@ public sealed class InMemoryProjectionStore : IProjectionStore
     public IReadOnlyList<RegisterEntry> RowsFor(string id)
         => [.. _byId.Values.Where(e => e.Id == id)];
 }
-
-/// <summary>A fake ACL client for the projection acceptance scenario: returns a reference derived
-/// from the zaak, so the projector can enrich rows without a running ACL (#78).</summary>
-public sealed class InMemoryAclReferenceClient : IAclClient
-{
-    public Task<string> GetZaakReferenceAsync(Uri zaakUrl, CancellationToken ct = default)
-        => Task.FromResult("REG-" + zaakUrl.Segments[^1].Trim('/'));
-}

tests/acceptance/Support/InMemoryZaakGateway.cs

@@ -24,7 +24,4 @@ public sealed class InMemoryZaakGateway : IZaakGateway
         Approved = (zaakUrl, zaaktypeUrl, datumStatusGezet);
         return Task.CompletedTask;
     }
-
-    public Task<string> GetZaakIdentificatieAsync(Uri zaakUrl, CancellationToken ct = default)
-        => Task.FromResult("ACC-REF-1");
 }

tests/e2e/registration.spec.ts

@@ -26,22 +26,15 @@ test('DigiD login → submit → public INGEDIEND → approve → public INGESCH
 
   // The openbaar register (anonymous, its own origin) shows the submitted entry once the projection
   // catches up. The projection updates asynchronously (NRC → event-subscriber), and the register loads
-  // on open, so reload until *this* submission's row appears. We poll on the reference cell (not a
+  // on open, so reload until a submitted (INGEDIEND) row appears.
-  // generic INGEDIEND cell): the shared verify stack already holds INGEDIEND rows from earlier checks,
-  // so a status-only poll would short-circuit on a stale row before our row is projected.
   await page.goto('http://openbaar/');
   await expect(page.getByRole('heading', { name: /Openbaar BIG-register/i })).toBeVisible();
-
-  // #78: the reference shown in the public register must be the exact one the citizen saw on the
-  // submit confirmation — no mismatch between the two portals.
   await expect
     .poll(async () => {
       await page.reload();
-      return page.getByRole('cell', { name: reference }).count();
+      return page.getByRole('cell', { name: 'INGEDIEND' }).count();
     }, { timeout: 30_000, intervals: [1_000, 2_000, 3_000, 5_000] })
     .toBeGreaterThan(0);
-  await expect(page.getByRole('row', { name: reference }).getByRole('cell', { name: 'INGEDIEND' }))
-    .toBeVisible();
 
   // Approve via the temporary admin endpoint (reached directly on the compose network, as a
   // behandelaar would until the behandel-portal exists — S-12). The zaak is opened off the request
@@ -56,12 +49,11 @@ test('DigiD login → submit → public INGEDIEND → approve → public INGESCH
   const approve = await request.post(`http://domain:8080/registrations/${reference}/approve`);
   expect(approve.status()).toBe(204);
 
-  // The approval flows back to the projection; the openbaar register now shows *our* row (matched by
+  // The approval flows back to the projection; the openbaar register now shows it as INGESCHREVEN.
-  // its reference) as INGESCHREVEN.
   await expect
     .poll(async () => {
       await page.reload();
-      return page.getByRole('row', { name: reference }).getByRole('cell', { name: 'INGESCHREVEN' }).count();
+      return page.getByRole('cell', { name: 'INGESCHREVEN' }).count();
     }, { timeout: 30_000, intervals: [1_000, 2_000, 3_000, 5_000] })
     .toBeGreaterThan(0);
 });