fix(infra): deploy diploma-eligibility DMN via dmn-api, not a process .bar (refs #14)

flowable-rest does not cascade a .dmn bundled inside a process .bar into the
DMN engine: the resource is stored but no decision is created, so the DMN
service task fails at runtime with FlowableObjectNotFoundException. Deploy the
DMN to the DMN engine via /dmn-api/dmn-repository/deployments and the BPMN to
the process engine separately; the service task resolves the decision across
deployments by key (verified live: Buitenlands->CBGV_ADVIES, Binnenlands->DIRECT).

Also move the DMN's doc comment inside <definitions>: Flowable's DMN XML
converter rejects a comment between the <?xml?> declaration and the root element
(XMLStreamReader not in START_DOCUMENT/START_ELEMENT state), unlike its BPMN one.

seed-config.sh now seeds both raw workflow files instead of building a .bar.

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

BACKLOG.md

@@ -199,25 +199,9 @@ _Split from the original S-09 — scoped to the portal only; the approval flow i
 
 ### S-10 · Document upload + boundary timer for document timeout (Flow 2)
 
-Split (issue #11 closed) into two independently-demoable slices per §13 — the original spanned six net-new surfaces including a new ZGW boundary:
+**Outcome:** BPMN extended with a "wacht op documenten" user task with a 30-day boundary timer. Self-service portal supports diploma upload. On timeout the case is cancelled.
 
-#### S-10a · Document-wait task + 30-day timeout cancellation + provision trigger — #102
-
-**Outcome:** BPMN gains a `WachtOpDocumenten` user task with a 30-day (P30D) interrupting boundary timer. On timeout the case is cancelled — the timer runs to a dedicated cancel end-event and the domain aggregate moves to a new terminal status `Verlopen` via an external-worker (mirrors S-14 escalation / S-11 withdrawal). "Documents received" is wired end-to-end (domain endpoint + BFF + a "Documenten aanleveren" button on the self-service page) so the walking-skeleton e2e stays green — but the document is **not yet stored** in ZGW; that is S-10b.
-
-**Acceptance:** BDD both branches (documents-in-time vs timeout-cancel); live timer-fire via the management-API "move" idiom; the registration e2e provides documents before the behandelaar step.
-
-#### S-10b · Real diploma upload stored via the ACL Documenten API — #103
-
-**Outcome:** the self-service "Documenten aanleveren" action becomes a real file upload; the file (base64-encoded end-to-end) is stored in the ZGW Documenten (DRC) API as an `enkelvoudiginformatieobject` and related to the zaak, with all document calls routed through the ACL (§8.1, ADR-0018). Builds on the S-10a trigger/wait. Depends on #102.
-
-**Acceptance:** ACL Documenten gateway integration test (real OpenZaak); Playwright e2e uploads a real PDF.
-
-#### S-10c · Close the ZGW zaak on document-timeout expiry — #106
-
-**Outcome:** when the 30-day term lapses (S-10a `RegistratieVerlopen`), the ZGW zaak is set to a distinct non-terminal `Geannuleerd` status + `Vervallen` resultaat (not just the domain aggregate → `Verlopen`), resolved by name in the ACL. Adds the cancellation statustype/resultaattype to the seed + an ACL `CancelZaakAsync`/`POST /annuleringen` + expiry-worker wiring. Carved from S-10b (ADR-0017/0018/0019). Depends on #103.
-
-**Acceptance:** ACL↔OpenZaak integration test (cancellation records `Geannuleerd` + a resultaat, live); the domain verify script fires the P30D timer and asserts the zaak reaches `Geannuleerd` end-to-end; BDD asserts the zaak is cancelled on timeout but untouched when documents arrive in time.
+**Acceptance:** BDD scenarios for both branches; integration tests for the timer firing.
 
 ### S-11 · Withdrawal (Flow 3)
 
@@ -239,12 +223,6 @@ Split (issue #11 closed) into two independently-demoable slices per §13 — the
 
 **Outcome:** Boundary timer on beoordeling user task — 14 days. On timeout, reassigns to a teamlead role.
 
-### S-26 · Self-service — resume an existing registration after refresh — #111
-
-**Outcome:** a signed-in zorgprofessional who reloads the self-service portal (or returns later) gets back to their in-flight registration and its actions (Documenten aanleveren, Trek aanvraag in), instead of a blank submit form with the reference lost. Today all post-submit state lives in in-memory signals, the reference is not in the URL, and there is no self-service read endpoint — so a reload strands the registration. Adds an owner-scoped (DigiD bsn) `GET /self-service/registrations` on the BFF/domain and a load-on-init/route restore in the portal.
-
-**Acceptance:** BDD — resume after refresh shows the existing registration; lookup is owner-scoped (never another citizen's); a user with no in-flight registration still sees the submit form. Playwright e2e reloads mid-flow and asserts the actions remain reachable.
-
 ---
 
 ## Iteration 3 — Maintenance portal and observability *(milestone: `Iteration 3 — Beheer & Observability`)*

apps/self-service/src/app/registration/registration-page.html

@@ -11,33 +11,6 @@
         <p utrecht-paragraph role="status">
           Uw registratie is ontvangen. Referentie: {{ reference() }}.
         </p>
-        @if (documentsProvided()) {
-          <p utrecht-paragraph role="status">Uw documenten zijn aangeleverd.</p>
-        } @else {
-          @if (provideDocumentsFailed()) {
-            <p utrecht-paragraph role="alert">
-              Het aanleveren van uw documenten is niet gelukt. Probeer het opnieuw.
-            </p>
-          }
-          <p utrecht-paragraph>Lever uw diploma aan (PDF).</p>
-          <label utrecht-form-label for="diploma">Diploma</label>
-          <input
-            id="diploma"
-            type="file"
-            accept="application/pdf"
-            [disabled]="providingDocuments()"
-            (change)="onFileSelected($event)"
-          />
-          <button
-            utrecht-button
-            appearance="primary-action-button"
-            type="button"
-            [disabled]="providingDocuments() || !selectedFile()"
-            (click)="provideDocuments()"
-          >
-            Documenten aanleveren
-          </button>
-        }
         @if (withdrawFailed()) {
           <p utrecht-paragraph role="alert">
             Het intrekken van uw registratie is niet gelukt. Probeer het opnieuw.

apps/self-service/src/app/registration/registration-page.spec.ts

@@ -20,12 +20,10 @@ class FakeAuth extends AuthService {
 function providers(
   post = vi.fn().mockReturnValue(of({ registrationId: 'reg-9', status: 'Ingediend' })),
   withdraw = vi.fn().mockReturnValue(of(undefined)),
-  provideDocuments = vi.fn().mockReturnValue(of(undefined)),
 ) {
   return {
     post,
     withdraw,
-    provideDocuments,
     providers: [
       { provide: AuthService, useClass: FakeAuth },
       {
@@ -33,7 +31,6 @@ function providers(
         useValue: {
           postSelfServiceRegistrations: post,
           postSelfServiceRegistrationsIdWithdraw: withdraw,
-          postSelfServiceRegistrationsIdDocuments: provideDocuments,
         },
       },
     ],
@@ -83,46 +80,6 @@ describe('RegistrationPage', () => {
     expect(await screen.findByText(/ingetrokken/i)).toBeTruthy();
   });
 
-  // A small PDF file the citizen "uploads"; the component base64-encodes it client-side.
-  const diploma = () => new File([new Uint8Array([1, 2, 3])], 'diploma.pdf', { type: 'application/pdf' });
-
-  it('uploads a chosen diploma after submitting, and doing so confirms', async () => {
-    const { provideDocuments, providers: p } = providers();
-    await render(RegistrationPage, { providers: p });
-
-    fireEvent.click(screen.getByRole('button', { name: /indienen/i }));
-    await screen.findByText(/ontvangen/i);
-
-    // Choose the file, then upload it.
-    fireEvent.change(screen.getByLabelText(/diploma/i), { target: { files: [diploma()] } });
-    fireEvent.click(await screen.findByRole('button', { name: /documenten aanleveren/i }));
-
-    // The upload is keyed by the reference and carries the base64 file + its name; the page confirms.
-    expect(await screen.findByText(/documenten.*aangeleverd/i)).toBeTruthy();
-    expect(provideDocuments).toHaveBeenCalledWith(
-      'reg-9',
-      expect.objectContaining({ fileName: 'diploma.pdf', contentType: 'application/pdf', contentBase64: expect.any(String) }),
-    );
-  });
-
-  it('surfaces a diploma-upload failure and keeps the action available', async () => {
-    const { providers: p } = providers(
-      vi.fn().mockReturnValue(of({ registrationId: 'reg-9', status: 'Ingediend' })),
-      vi.fn().mockReturnValue(of(undefined)),
-      vi.fn().mockReturnValue(throwError(() => new Error('documents rejected'))),
-    );
-    await render(RegistrationPage, { providers: p });
-
-    fireEvent.click(screen.getByRole('button', { name: /indienen/i }));
-    await screen.findByText(/ontvangen/i);
-    fireEvent.change(screen.getByLabelText(/diploma/i), { target: { files: [diploma()] } });
-    fireEvent.click(await screen.findByRole('button', { name: /documenten aanleveren/i }));
-
-    expect(await screen.findByRole('alert')).toBeTruthy();
-    expect(screen.queryByText(/aangeleverd/i)).toBeNull();
-    expect(screen.getByRole('button', { name: /documenten aanleveren/i })).toBeTruthy();
-  });
-
   it('surfaces a withdraw failure and keeps the action available', async () => {
     const { providers: p } = providers(
       vi.fn().mockReturnValue(of({ registrationId: 'reg-9', status: 'Ingediend' })),

apps/self-service/src/app/registration/registration-page.ts

@@ -26,10 +26,6 @@ export class RegistrationPage {
   protected readonly withdrawing = signal(false);
   protected readonly withdrawn = signal(false);
   protected readonly withdrawFailed = signal(false);
-  protected readonly providingDocuments = signal(false);
-  protected readonly documentsProvided = signal(false);
-  protected readonly provideDocumentsFailed = signal(false);
-  protected readonly selectedFile = signal<File | undefined>(undefined);
 
   submit(): void {
     this.submitting.set(true);
@@ -48,46 +44,6 @@ export class RegistrationPage {
     });
   }
 
-  onFileSelected(event: Event): void {
-    const input = event.target as HTMLInputElement;
-    this.selectedFile.set(input.files?.[0] ?? undefined);
-  }
-
-  async provideDocuments(): Promise<void> {
-    const reference = this.reference();
-    const file = this.selectedFile();
-    if (!reference || !file) {
-      return;
-    }
-    this.providingDocuments.set(true);
-    this.provideDocumentsFailed.set(false);
-    let contentBase64: string;
-    try {
-      contentBase64 = await readAsBase64(file);
-    } catch {
-      this.provideDocumentsFailed.set(true);
-      this.providingDocuments.set(false);
-      return;
-    }
-    this.bff
-      .postSelfServiceRegistrationsIdDocuments(reference, {
-        contentBase64,
-        fileName: file.name,
-        contentType: file.type || 'application/pdf',
-      })
-      .subscribe({
-        next: () => {
-          this.documentsProvided.set(true);
-          this.providingDocuments.set(false);
-        },
-        // Surface the failure instead of swallowing it: keep the action so the user can retry.
-        error: () => {
-          this.provideDocumentsFailed.set(true);
-          this.providingDocuments.set(false);
-        },
-      });
-  }
-
   withdraw(): void {
     const reference = this.reference();
     if (!reference) {
@@ -108,13 +64,3 @@ export class RegistrationPage {
     });
   }
 }
-
-/** Read a file's bytes as a base64 string (without the `data:...;base64,` prefix). */
-function readAsBase64(file: File): Promise<string> {
-  return new Promise<string>((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onload = () => resolve(((reader.result as string) ?? '').split(',', 2)[1] ?? '');
-    reader.onerror = () => reject(reader.error ?? new Error('Could not read the file.'));
-    reader.readAsDataURL(file);
-  });
-}

docs/architecture/adr-0017-document-wait-timeout-cancellation.md

@@ -1,90 +0,0 @@
-# ADR-0017: A document-wait task with a 30-day interrupting timer cancels the registration
-
-- **Status:** Accepted
-- **Date:** 2026-07-20
-- **Deciders:** Respellion engineering
-- **Relates to:** S-10a (#102); proposal #104; split from S-10 (#11). Builds on ADR-0009 (external-task
-  worker / Workflow Client), ADR-0014 (withdrawal cancels the process), ADR-0015 (beoordeling
-  escalation — the boundary-timer + external-worker pattern), ADR-0016 (diploma-eligibility DMN).
-
-## Context
-
-Flow 2 (PRD §5) requires the citizen to supply documents (their diploma) after submitting. The
-registratie process must park waiting for those documents and, if they do not arrive within 30 days,
-cancel the case. S-10 was split (§13): **S-10a** is this workflow/timeout spine (backend only);
-**S-10b** wires the actual upload (portal → BFF → domain → ACL → Documenten API) that completes the
-wait. This ADR records the spine: where the wait sits, how the timeout cancels, and how the domain
-aggregate stays in sync.
-
-## Decision
-
-**A `WachtOpDocumenten` user task is inserted immediately after `OpenZaakAanmaken`, carrying an
-`cancelActivity="true"` (interrupting) `P30D` boundary timer. "Documents received" completes the task
-and the process continues into the diploma-eligibility routing; on timeout the timer cancels the task,
-runs a `RegistratieVerlopen` external-worker task, and ends the process at `endVerlopen`. A domain
-worker expires the correlated aggregate to a new terminal status `Verlopen`.**
-
-- **Where the wait sits.** Right after the zaak is opened, before the diploma-eligibility DMN: the zaak
-  exists, then the process waits for documents; on receipt it continues to the DMN routing → Beoordelen
-  (ADR-0016). The wait gates the whole assessment, so it precedes the routing rather than sitting
-  between the gateway and Beoordelen.
-- **Interrupting timer, mirroring the existing constructs.** Unlike the S-14 escalation timer
-  (non-interrupting — the Beoordelen task stays open), this timer is interrupting: when it fires the
-  wait token is consumed and the case is cancelled, like the S-11 withdrawal boundary (ADR-0014). The
-  timeout branch runs a `RegistratieVerlopen` external-worker task (topic mirrors
-  `OpenZaakAanmaken`/`BeoordelingEscaleren`) → `endVerlopen`.
-- **The domain stays authoritative.** The `RegistratieVerlopen` job carries the `registrationId`; the
-  `RegistratieVerlopenProcessor` drains it and the `ExpireRegistrationWorker` loads the aggregate and
-  calls `Registration.Expire()`, moving it to the new terminal status `Verlopen`. This keeps the
-  aggregate — which the projection/openbaar view reads — the source of truth, exactly as escalation and
-  withdrawal do. Idempotent per §8.6: a redelivered job whose aggregate is already `Verlopen` completes
-  without persisting again; an unknown registration throws so the job is redelivered.
-- **Documents-in-time transition.** `IWorkflowClient.CompleteDocumentWaitAsync(processInstanceId)`
-  completes the `WachtOpDocumenten` task (the Workflow Client remains the only code that talks to
-  Flowable, §8.2). It is best-effort — a no-op if the instance already left the wait (continued, or
-  timed out). The trigger is wired end-to-end in S-10a: a `ProvideDocuments` application use case behind
-  an owner-scoped domain endpoint `POST /registrations/{id}/documents`, a BFF passthrough
-  `POST /self-service/registrations/{id}/documents` (bsn from the DigiD token), and a "Documenten
-  aanleveren" action on the self-service page — so the walking-skeleton e2e stays green (a registration
-  can still reach the behandelaar). **S-10b replaces the stub trigger with a real file upload stored in
-  the ZGW Documenten (DRC) API via the ACL**; the completion of the wait is unchanged.
-  - *Why the trigger lives here, not in S-10b:* inserting the `WachtOpDocumenten` gate without any way
-    to pass it breaks the submit→beoordeling e2e (a merge gate). Splitting "gate" from "means to pass
-    the gate" across slices would leave `main` red, so S-10a owns both; S-10b is purely the ZGW storage
-    behind the same action.
-
-## Consequences
-
-**Positive**
-
-- The wait/timeout is a first-class workflow construct that reuses the boundary-timer + external-worker
-  pattern already proven by S-14, so the domain change is small and additive: one terminal status, one
-  worker trio (worker + processor + pump), one Workflow Client method.
-- §8 stays clean: the Workflow Client is still the only Flowable caller, and no new ZGW boundary is
-  introduced in S-10a.
-- The timeout is verified live (verify-domain fires the P30D timer via the management-API "move" idiom
-  and asserts the domain reaches `Verlopen`), consistent with ADR-0009/0014/0015.
-
-**Negative / costs**
-
-- Every registration now parks at `WachtOpDocumenten` before Beoordelen, so the other flows must supply
-  documents first: the live-check blocks (S-11/S-12b/S-13/S-14) complete the task via Flowable, and the
-  registration e2e clicks "Documenten aanleveren". A small, explicit step, but it touches every path
-  through the process.
-- On expiry S-10a cancels the *process* and marks the aggregate `Verlopen` but does **not** set the ZGW
-  *zaak* to a cancellation status — that needs a new ACL method + statustype seeding, which overlaps
-  S-10b's ACL/infra work. Deferred to S-10b (or a follow-up); noted here as the S-10a/S-10b boundary.
-- Withdrawing while parked at `WachtOpDocumenten` marks the aggregate `Ingetrokken` but does not cancel
-  the process (the withdrawal message boundary is on `Beoordelen`); the timeout worker tolerates this
-  by no-op'ing on an already-resolved aggregate. Extending withdrawal to the wait state is a follow-up.
-
-## Alternatives considered
-
-- **Pure-BPMN cancellation (timer → end event, no worker).** Rejected: the domain aggregate would then
-  be out of sync with the cancelled process, and the openbaar/projection view reads the aggregate's
-  status — the case would still look open.
-- **Wait task between the gateway and Beoordelen.** Rejected: documents gate the whole assessment
-  (including the CBGV-advies routing), so the wait belongs before the DMN, not after it.
-- **A dedicated timeout status per branch vs. reusing an open-state guard.** `Expire()` reuses the same
-  `RequireOpenForDecision` guard as withdrawal/decision, so only an `INGEDIEND`/`IN_BEHANDELING`
-  registration can lapse and the terminal states stay mutually exclusive — no new guard logic.

docs/architecture/adr-0018-diploma-upload-via-acl-documenten.md

@@ -1,74 +0,0 @@
-# ADR-0018: Diploma upload is stored in the ZGW Documenten API, fronted by the ACL
-
-- **Status:** Accepted
-- **Date:** 2026-07-20
-- **Deciders:** Respellion engineering
-- **Relates to:** S-10b (#103); proposal #107. Builds on ADR-0001 (ACL is the only ZGW caller),
-  ADR-0003 (ACL default-fill), ADR-0017 (document-wait + provision trigger). Carves the zaak-close on
-  expiry to #106 (S-10c).
-
-## Context
-
-S-10a wired the "documenten aanleveren" trigger (portal → BFF → domain → complete the WachtOpDocumenten
-wait) with the file itself stubbed. S-10b makes the upload real: the diploma must be **stored in the
-ZGW Documenten (DRC) API** and related to the zaak. §8.1 makes the ACL the only code that talks to ZGW.
-The DRC API is served by the same OpenZaak container as the Zaken/Catalogi APIs.
-
-## Decision
-
-**The ACL fronts the Documenten API: it creates an `enkelvoudiginformatieobject` and relates it to the
-zaak. The file travels base64-encoded in JSON across every hop (the portal encodes it client-side); a
-"Diploma" `informatieobjecttype` is seeded in the catalogus and injected into the ACL like the
-zaaktype.**
-
-- **ACL gateway.** `OpenZaakGateway.StoreDocumentAsync` POSTs the `enkelvoudiginformatieobject`
-  (`/documenten/api/v1/enkelvoudiginformatieobjecten`, base64 `inhoud`, `bestandsomvang`,
-  `status=definitief`) then relates it to the zaak (`/zaken/api/v1/zaakinformatieobjecten`), reusing the
-  established gateway patterns (ZGW Bearer JWT, buffered non-chunked body for uwsgi, **no CRS headers** —
-  the Documenten API is not geo, unlike zaak-create). `AclService.StoreDiplomaAsync` default-fills the
-  ZGW-mandatory fields (informatieobjecttype, bronorganisatie, vertrouwelijkheidaanduiding, `taal=nld`,
-  creatiedatum); the domain hands over only the zaak, the bytes, and the file's name/type. No new ZGW
-  scopes were needed — the seed applicatie holds `heeft_alle_autorisaties`.
-- **The file travels as base64 JSON end-to-end.** The portal reads the chosen file client-side
-  (`FileReader`) and posts `{ contentBase64, fileName, contentType }` as JSON to the BFF; the BFF
-  forwards it to the domain, and the domain to the ACL, all as JSON. This deviates from proposal #107's
-  "multipart on the portal→BFF hop": base64 JSON keeps **one** contract shape across all four services
-  (no `IFormFile`/antiforgery plumbing, no multipart in the generated client), and a diploma is a small
-  placeholder PDF, so the ~33% base64 overhead is immaterial. The ACL turns the base64 back into the
-  ZGW `inhoud`.
-- **Storing precedes completing the wait.** `ProvideDocuments` (from S-10a) now stores the diploma via
-  the ACL — once the zaak is opened — and then completes the `WachtOpDocumenten` task, so a registration
-  reaches beoordeling only after its diploma is stored. Both steps stay best-effort about missing
-  preconditions (no zaak yet → skip storage; no process yet → skip completion), mirroring withdrawal.
-- **Catalogus.** `seed_catalogus.py` (OZ_PUBLISH) creates a "Diploma" `informatieobjecttype`, relates it
-  to the zaaktype (`zaaktype-informatieobjecttypen`, while both concept), publishes both, and prints
-  `INFORMATIEOBJECTTYPE_URL`; verify-domain injects it as `Acl__Defaults__InformatieobjecttypeUrl`
-  (a zeros-uuid placeholder otherwise, so the ACL still boots).
-
-## Consequences
-
-**Positive**
-
-- §8.1 stays intact: the ACL is still the only ZGW caller; the portal only talks to the BFF; the domain
-  only crosses the ACL boundary. Adding a document was almost entirely additive (one gateway method, one
-  default, one seed block).
-- One JSON contract shape across portal/BFF/domain/ACL keeps the generated client and the service
-  contracts uniform; the upload is exercised live (ACL integration test against real OpenZaak; the
-  Playwright journey uploads a real PDF).
-
-**Negative / costs**
-
-- Base64 inflates the payload ~33% and holds the whole file in memory at each hop — fine for a small
-  diploma, but not a pattern to reuse for large documents without streaming/multipart.
-- The zaak is **not** set to a cancellation status when the 30-day term lapses — carved to #106 (S-10c),
-  which adds the cancellation statustype/resultaattype + ACL method + expiry-worker wiring.
-- Providing documents before the zaak is opened silently skips storage (best-effort); the e2e/live flow
-  avoids this by uploading only after the openbaar register shows the zaak (INGEDIEND).
-
-## Alternatives considered
-
-- **Multipart on the portal→BFF hop** (proposal #107). Rejected: it splits the transport into two shapes
-  (multipart then JSON), needs `IFormFile` + antiforgery handling and a multipart method in the generated
-  client, for no benefit at diploma size.
-- **The domain talks to the Documenten API directly.** Rejected outright: violates §8.1 (only the ACL
-  talks to ZGW).

docs/architecture/adr-0019-zaak-cancellation-on-timeout.md

@@ -1,81 +0,0 @@
-# ADR-0019: A timed-out zaak is cancelled with a distinct status + resultaat, resolved by name
-
-- **Status:** Accepted
-- **Date:** 2026-07-21
-- **Deciders:** Respellion engineering
-- **Relates to:** S-10c (#106). Completes the S-10a/S-10b boundary noted in ADR-0017 (§Consequences) and
-  reuses the ACL close-zaak machinery from S-09b (approval) and the Documenten work in ADR-0018.
-
-## Context
-
-ADR-0017 (S-10a) cancels the *process* and marks the domain aggregate `Verlopen` when the 30-day
-document term lapses, but explicitly deferred setting the ZGW **zaak** to a cancellation status. Left
-open, a timed-out zaak stays open in OpenZaak while the register shows the registration as lapsed — the
-two diverge. S-10c closes that gap: on expiry the domain must also cancel the zaak through the ACL
-(§8.1, the only code that talks to ZGW).
-
-The non-obvious part is *how to represent "cancelled" in ZGW* alongside the existing "approved" close.
-The approval path (S-09b) sets the zaak's **eindstatus** (the terminal statustype) plus a resultaat. In
-ZGW a zaaktype has exactly one eindstatus — the highest-`volgnummer` statustype — and setting it is what
-closes the zaak (`einddatum`). A second *terminal* status would collide with that single-eindstatus rule.
-
-## Decision
-
-**Model cancellation as a distinct, non-terminal `Geannuleerd` statustype plus a distinct `Vervallen`
-resultaat, and resolve both the approval and cancellation statustype/resultaat by their omschrijving
-(name) rather than by position or the eindstatus flag alone.**
-
-- **Seed.** `Geannuleerd` is seeded at `volgnummer` 2 — between `Ontvangen` (1) and the `Afgehandeld`
-  eindstatus (3) — so it is a *non-terminal* status and never displaces the eindstatus the approval path
-  resolves. A second resultaattype `Vervallen` (archiefnominatie `vernietigen`) is seeded beside the
-  approval `Geregistreerd` (`blijvend_bewaren`); both draw their `selectielijstklasse` from the
-  zaaktype's single `selectielijstProcestype` so they validate on publish.
-- **The ACL owns the mapping.** `OpenZaakGateway.SetZaakToCancellationStatusAsync` resolves `Geannuleerd`
-  + `Vervallen` by omschrijving and POSTs the resultaat then the status (OpenZaak requires a resultaat
-  before a closing/terminal status), mirroring `SetZaakToEindstatusAsync`. Exposed as
-  `AclService.CancelZaakAsync` behind the ACL endpoint `POST /annuleringen`. The omschrijvingen live as
-  constants in the gateway — the ACL, not the domain, knows which ZGW status means what (§8.1).
-- **Approval now resolves its resultaat by name too.** With two resultaattypen present, taking the first
-  is ambiguous (the Zaken API does not guarantee order), so the approval path resolves `Geregistreerd`
-  by omschrijving. Its statustype resolution is unchanged (still the eindstatus).
-- **Domain wiring.** The `ExpireRegistrationWorker` calls `IAclClient.CancelZaakAsync(zaakUrl)` **before**
-  advancing the aggregate to `Verlopen` (ACL-first, mirroring approval): if the ACL call fails the job is
-  redelivered (§8.6) rather than leaving the aggregate `Verlopen` with an open zaak. The existing
-  open-state guard stops a redelivered job from cancelling twice (a second resultaat would be a 400); a
-  registration that lapsed before its zaak was opened has nothing to cancel.
-
-## Consequences
-
-**Positive**
-
-- The domain aggregate and the ZGW zaak no longer diverge on timeout — both reflect the cancellation.
-- Reuses the approval close machinery (resultaat-then-status, ACL endpoint shape, ACL-first ordering), so
-  the change is additive and §8 stays clean (only the ACL talks to ZGW).
-- Verified at two levels: an ACL↔OpenZaak integration test asserts the live zaak reaches `Geannuleerd`
-  with a resultaat, and the domain verify script fires the real P30D timer and confirms the zaak is
-  cancelled end-to-end.
-
-**Negative / costs**
-
-- `Geannuleerd` is non-terminal, so the cancelled zaak's `einddatum` is not set — it carries a
-  cancellation status + resultaat but is not formally "closed" in ZGW. Accepted: the register reads the
-  domain aggregate's status, and a single eindstatus per zaaktype is a ZGW constraint we chose not to
-  fight. Formally closing a cancelled zaak (a second eindstatus, or reusing `Afgehandeld` with a
-  `Vervallen` resultaat) is a possible follow-up.
-- The ACL couples to the seeded omschrijvingen (`Geregistreerd`/`Geannuleerd`/`Vervallen`) by string
-  constants. This mirrors the existing implicit coupling to the catalogus (zaaktype URL, eindstatus) and
-  is documented in the gateway.
-- Renumbering `Afgehandeld` from `volgnummer` 2 to 3 means a *stale* local catalogus must have its
-  OpenZaak volumes reset for the change to take effect; CI reseeds a fresh catalogus each run.
-
-## Alternatives considered
-
-- **Shared eindstatus, distinct resultaat only** (reuse `Afgehandeld`, distinguish approval vs
-  cancellation purely by the resultaat). ZGW-idiomatic and would set `einddatum` on cancellation too, but
-  the register would show no visibly distinct cancellation *status*. Rejected in favour of the issue's
-  explicit "distinct statustype + resultaattype" outcome, which makes the cancellation legible in ZGW.
-- **A second terminal (eindstatus) `Geannuleerd`.** Rejected: ZGW allows only one eindstatus per
-  zaaktype (highest volgnummer); a second terminal status would either not close the zaak or collide with
-  the approval eindstatus resolution.
-- **Passing the target omschrijvingen from the domain.** Rejected: which ZGW status means "cancelled" is
-  ZGW vocabulary the ACL owns (§8.1); the domain says only "cancel this zaak".

docs/demo-script.md

@@ -361,8 +361,7 @@ DOM=http://localhost:8080   # domain service
 curl -s -i -X POST "$DOM/registrations" -H 'Content-Type: application/json' \
   -d '{"bsn":"123456782","diplomaOrigin":"Buitenlands"}' | grep -i '^location:'
 #
-# 2. Once the zaak is opened, the process first parks at WachtOpDocumenten (S-10a); complete that task
-#    (documents received) — then it parks at the CBGV-advies task (NOT Beoordelen). In Flowable:
+# 2. Once the zaak is opened, the process parks at the CBGV-advies task (NOT Beoordelen). In Flowable:
 FL=http://localhost:8090/flowable-rest/service
 curl -s -u rest-admin:test -X POST "$FL/query/tasks" -H 'Content-Type: application/json' \
   -d '{"processDefinitionKey":"registratie","taskDefinitionKey":"CBGVAdvies"}' | python3 -m json.tool
@@ -383,102 +382,3 @@ domestic: `Beoordelen` directly (§8.2, ADR-0016).
 > The domestic/foreign paths are covered by the `Een diploma op herkomst routeren` acceptance
 > scenarios and unit tests (the origin is carried into the process); the DMN decision and the
 > foreign→CBGV routing are asserted live by the verify-domain check.
-
-## S-10a — Document wait + 30-day timeout cancels the registration (#102, ADR-0017)
-
-After the zaak is opened the registratie process parks at a **WachtOpDocumenten** user task, waiting
-for the citizen's documents (their diploma). Two things can happen:
-
-- **Documents arrive in time** → the task completes and the process continues to the diploma-eligibility
-  routing (S-13) → beoordeling.
-- **30 days pass with no documents** → an interrupting `P30D` boundary timer cancels the wait, runs the
-  `RegistratieVerlopen` external task, and the domain expires the registration to the terminal status
-  **VERLOPEN** (the case is cancelled).
-
-The "documents received" trigger is wired end-to-end in S-10a: the self-service page shows a
-**"Documenten aanleveren"** button after submit (portal → BFF → domain → completes the wait). S-10b
-turns that into a real file upload stored in the ZGW Documenten API via the ACL. The timeout branch is
-demonstrated by firing the 30-day timer early via the management API.
-
-```bash
-DOM=http://localhost:8080                      # domain service
-FL=http://localhost:8090/flowable-rest/service # flowable-rest
-
-# 1. Submit a registration; once the zaak is opened it parks at WachtOpDocumenten:
-curl -s -i -X POST "$DOM/registrations" -H 'Content-Type: application/json' \
-  -d '{"bsn":"123456782"}' | grep -i '^location:'          # note the /registrations/<id> reference
-WQ='{"processDefinitionKey":"registratie","taskDefinitionKey":"WachtOpDocumenten"}'
-
-# 2a. Documents-in-time: complete the WachtOpDocumenten task → the process advances to beoordeling.
-TID=$(curl -s -u rest-admin:test -X POST "$FL/query/tasks" -H 'Content-Type: application/json' \
-  -d "$WQ" | python3 -c 'import sys,json;print(json.load(sys.stdin)["data"][0]["id"])')
-curl -s -u rest-admin:test -X POST "$FL/runtime/tasks/$TID" \
-  -H 'Content-Type: application/json' -d '{"action":"complete"}'
-
-# 2b. Timeout: instead of completing it, fire the 30-day timer early via the management API. Find the
-#     instance's timer job, "move" it to executable; the async executor fires the interrupting event.
-PID=$(curl -s -u rest-admin:test -X POST "$FL/query/tasks" -H 'Content-Type: application/json' \
-  -d "$WQ" | python3 -c 'import sys,json;print(json.load(sys.stdin)["data"][0]["processInstanceId"])')
-JID=$(curl -s -u rest-admin:test "$FL/management/timer-jobs?processInstanceId=$PID" \
-  | python3 -c 'import sys,json;print(json.load(sys.stdin)["data"][0]["id"])')
-curl -s -u rest-admin:test -X POST "$FL/management/timer-jobs/$JID" \
-  -H 'Content-Type: application/json' -d '{"action":"move"}'
-#     The RegistratieVerlopen worker then expires the aggregate — read it back as VERLOPEN:
-curl -s "$DOM/registrations/<id>"   # → {"status":"Verlopen", ...}
-```
-
-**The path:** registratie process parks at `WachtOpDocumenten` → documents received completes it (→
-routing → `Beoordelen`), OR the `P30D` interrupting timer fires → `RegistratieVerlopen` external task
-→ domain worker expires the aggregate to `Verlopen` → `endVerlopen` (§8.2, ADR-0017).
-
-> Both branches are covered by the `Een documenttermijn laten verlopen` acceptance scenarios (worker +
-> aggregate) and unit tests; the wait completion and the 30-day timer firing are asserted live by the
-> verify-domain check.
-
-## S-10b — Diploma upload stored in the ZGW Documenten API (#103, ADR-0018)
-
-The self-service "Documenten aanleveren" action (S-10a) is now a **real file upload**: after submitting,
-the citizen picks a PDF and uploads it. The portal base64-encodes the file client-side and posts it to
-the BFF; the BFF forwards it to the domain, which stores it via the **ACL** as a ZGW
-`enkelvoudiginformatieobject` in the **Documenten (DRC) API** and relates it to the zaak — then completes
-the `WachtOpDocumenten` wait so beoordeling can proceed. Per §8.1 only the ACL talks to ZGW.
-
-```bash
-make up
-# 1. Log in as jan-burger / test123, submit, then — once the openbaar register shows the row —
-#    choose a PDF under "Documenten aanleveren" and upload it. The page confirms "aangeleverd".
-open http://localhost:8140
-#
-# 2. Automated: the walking-skeleton e2e now uploads a real PDF before the behandelaar approves.
-make verify-e2e
-#
-# 3. The ACL integration test proves the document is really created in the Documenten API and
-#    related to the zaak (against a live OpenZaak):
-make verify-acl        # → "Storing a diploma creates a real informatieobject related to the zaak"
-```
-
-**The path:** portal (base64) → BFF `POST /self-service/registrations/{id}/documents` → domain
-`ProvideDocuments` → ACL `POST /documenten` → ZGW `enkelvoudiginformatieobjecten` +
-`zaakinformatieobjecten`; the wait is then completed and the case advances to Beoordelen (§8.1, ADR-0018).
-
-## S-10c — the ZGW zaak is cancelled when the document term lapses (#106)
-
-When the 30-day document term lapses (S-10a), the domain no longer only marks the aggregate `Verlopen` —
-it now also cancels the **ZGW zaak** through the ACL, so OpenZaak and the register agree. The zaak is set
-to a distinct, non-terminal **`Geannuleerd`** status with a **`Vervallen`** resultaat (as opposed to the
-approval `Afgehandeld` + `Geregistreerd`), resolved by name in the ACL (§8.1, ADR-0019).
-
-```bash
-# 1. The ACL integration test proves cancellation records the Geannuleerd status + a resultaat
-#    against a live OpenZaak:
-make verify-acl        # → "Cancelling a zaak records the geannuleerd status and a resultaat"
-#
-# 2. End-to-end: the domain check submits a registration, fires its 30-day timer early, and asserts
-#    the timeout worker both expires the registration (VERLOPEN) and cancels its zaak (Geannuleerd):
-make verify-domain     # → "the timed-out registration's zaak was cancelled to Geannuleerd in OpenZaak"
-```
-
-**The path:** Flowable P30D timer → `RegistratieVerlopen` job → domain `ExpireRegistrationWorker` → ACL
-`POST /annuleringen` → ZGW `resultaten` + `statussen` (Geannuleerd); the aggregate then moves to
-`Verlopen`. The ACL cancels the zaak **before** the aggregate is expired, so a failed ZGW call leaves the
-job for redelivery rather than diverging the two (ADR-0019).

infra/docker-compose.yml

@@ -306,9 +306,6 @@ services:
       Acl__Defaults__Vertrouwelijkheidaanduiding: openbaar
       # Override with the real zaaktype URL after running seed_catalogus.py.
       Acl__Defaults__ZaaktypeUrl: ${ACL_ZAAKTYPE_URL:-http://openzaak:8000/catalogi/api/v1/zaaktypen/00000000-0000-0000-0000-000000000000}
-      # The informatieobjecttype a diploma is filed under (S-10b). Placeholder until seed_catalogus.py
-      # (OZ_PUBLISH=1) reports the real URL, which verify-domain injects like the zaaktype URL.
-      Acl__Defaults__InformatieobjecttypeUrl: ${ACL_INFORMATIEOBJECTTYPE_URL:-http://openzaak:8000/catalogi/api/v1/informatieobjecttypen/00000000-0000-0000-0000-000000000000}
     ports:
       - "8100:8080"
     healthcheck:

infra/openzaak/seed_catalogus.py

@@ -10,7 +10,7 @@ Creates (if absent):
 Auth uses the JWT client provisioned by setup_configuration (see ADR-0002).
 Stdlib only — no pip deps. Re-running is safe (matches existing by identifier).
 """
-import base64, hashlib, hmac, json, os, sys, time, urllib.error, urllib.parse, urllib.request
+import base64, hashlib, hmac, json, os, sys, time, urllib.error, urllib.request
 
 BASE = os.environ.get("OZ_BASE", "http://localhost:8000")
 CLIENT_ID = os.environ.get("OZ_CLIENT_ID", "big-reference-seed")
@@ -77,12 +77,8 @@ def publish_zaaktype(zt):
     Selectielijst `selectielijstklasse` whose procestype matches the zaaktype's
     `selectielijstProcestype`, plus a `resultaattypeomschrijving`.
     """
-    # Ontvangen (begin) → Afgehandeld (eind, highest volgnummer). "Geannuleerd" (S-10c) sits between
-    # them: a non-terminal status the document-timeout branch sets, so it never displaces the Afgehandeld
-    # eindstatus the approval path resolves. Keyed by volgnummer on a fresh catalogus (CI reseeds); a
-    # stale local stack must reset its OpenZaak volumes for the renumbering to take effect.
     have_st = {s.get("volgnummer") for s in find(f"/statustypen?zaaktype={zt['url']}&status=alles")}
-    for volgnummer, omschrijving in [(1, "Ontvangen"), (2, "Geannuleerd"), (3, "Afgehandeld")]:
+    for volgnummer, omschrijving in [(1, "Ontvangen"), (2, "Afgehandeld")]:
         if volgnummer not in have_st:
             st, body = api("POST", "/statustypen", {
                 "omschrijving": omschrijving, "zaaktype": zt["url"], "volgnummer": volgnummer})
@@ -99,42 +95,25 @@ def publish_zaaktype(zt):
             sys.exit(f"create roltype -> {st}: {json.dumps(body, indent=2)}")
         print("create roltype Aanvrager")
 
-    # Two resultaattypen, keyed by omschrijving so each is created independently (idempotent):
-    #   "Geregistreerd" — the approval outcome (S-09b)
-    #   "Vervallen"     — the document-timeout cancellation outcome (S-10c)
-    # Both selectielijstklassen must share the zaaktype's selectielijstProcestype, so pick two
-    # Selectielijst resultaten from a single procestype and set that procestype on the zaaktype.
-    have_rt = {r.get("omschrijving") for r in find(f"/resultaattypen?zaaktype={zt['url']}&status=alles")}
-    wanted = [("Geregistreerd", "blijvend_bewaren"), ("Vervallen", "vernietigen")]
-    if all(naam in have_rt for naam, _ in wanted):
-        print("skip   resultaattypen Geregistreerd + Vervallen")
+    if find(f"/resultaattypen?zaaktype={zt['url']}&status=alles"):
+        print("skip   resultaattype Geregistreerd")
     else:
-        # Anchor on the procestype of an arbitrary resultaat, then fetch that procestype's resultaten so
-        # both klassen validate against the zaaktype's selectielijstProcestype.
-        procestype = selectielijst("/resultaten?pageSize=1")["results"][0]["procesType"]
-        resultaten = selectielijst(f"/resultaten?procesType={urllib.parse.quote(procestype, safe='')}")["results"]
-        if len(resultaten) < len(wanted):
-            sys.exit(f"selectielijst procestype has too few resultaten ({len(resultaten)}) for {len(wanted)} resultaattypen")
+        resultaat = selectielijst("/resultaten?pageSize=1")["results"][0]
         omschrijvingen = selectielijst("/resultaattypeomschrijvingen")
-        oms_list = omschrijvingen if isinstance(omschrijvingen, list) else omschrijvingen["results"]
-
-        st, body = api("PATCH", zt["url"], {"selectielijstProcestype": procestype})
+        oms = (omschrijvingen if isinstance(omschrijvingen, list) else omschrijvingen["results"])[0]["url"]
+        # The selectielijstklasse and the zaaktype must share a procestype.
+        st, body = api("PATCH", zt["url"], {"selectielijstProcestype": resultaat["procesType"]})
         if st != 200:
             sys.exit(f"set procestype -> {st}: {json.dumps(body, indent=2)}")
-
-        for i, (naam, archiefnominatie) in enumerate(wanted):
-            if naam in have_rt:
-                print(f"skip   resultaattype {naam}")
-                continue
-            st, body = api("POST", "/resultaattypen", {
-                "zaaktype": zt["url"], "omschrijving": naam,
-                "resultaattypeomschrijving": oms_list[i]["url"], "selectielijstklasse": resultaten[i]["url"],
-                "archiefnominatie": archiefnominatie,
-                "brondatumArchiefprocedure": {"afleidingswijze": "afgehandeld"},
-            })
-            if st != 201:
-                sys.exit(f"create resultaattype {naam} -> {st}: {json.dumps(body, indent=2)}")
-            print(f"create resultaattype {naam}")
+        st, body = api("POST", "/resultaattypen", {
+            "zaaktype": zt["url"], "omschrijving": "Geregistreerd",
+            "resultaattypeomschrijving": oms, "selectielijstklasse": resultaat["url"],
+            "archiefnominatie": "blijvend_bewaren",
+            "brondatumArchiefprocedure": {"afleidingswijze": "afgehandeld"},
+        })
+        if st != 201:
+            sys.exit(f"create resultaattype -> {st}: {json.dumps(body, indent=2)}")
+        print("create resultaattype Geregistreerd")
 
     if zt.get("concept", True):
         st, body = api("POST", f"{zt['url']}/publish")
@@ -145,58 +124,6 @@ def publish_zaaktype(zt):
         print("skip   publish (already published)")
 
 
-def seed_informatieobjecttype(cat, zt):
-    """Create the "Diploma" informatieobjecttype and relate it to the zaaktype (both idempotent).
-
-    A diploma uploaded in S-10b is filed under this informatieobjecttype; OpenZaak only accepts a
-    document (and its zaak relation) once the informatieobjecttype is published AND allowed for the
-    zaak's zaaktype (a zaaktype-informatieobjecttype relation). Both the relation and this call must run
-    while the zaaktype is still a concept, so seed this *before* publishing the zaaktype. Returns the
-    informatieobjecttype dict.
-    """
-    iots = [i for i in find(f"/informatieobjecttypen?catalogus={cat['url']}&status=alles")
-            if i.get("omschrijving") == "Diploma"]
-    if iots:
-        iot = iots[0]
-        print(f"skip   informatieobjecttype Diploma ({iot['url']}) concept={iot.get('concept')}")
-    else:
-        st, iot = api("POST", "/informatieobjecttypen", {
-            "catalogus": cat["url"],
-            "omschrijving": "Diploma",
-            "vertrouwelijkheidaanduiding": "openbaar",
-            "informatieobjectcategorie": "diploma",
-            "beginGeldigheid": "2026-01-01",
-        })
-        if st != 201:
-            sys.exit(f"create informatieobjecttype -> {st}: {json.dumps(iot, indent=2)}")
-        print(f"create informatieobjecttype Diploma ({iot['url']})")
-
-    # Relate it to the zaaktype (must be done while both are concept).
-    relations = find(f"/zaaktype-informatieobjecttypen?zaaktype={zt['url']}&status=alles")
-    if any(r.get("informatieobjecttype") == iot["url"] for r in relations):
-        print("skip   zaaktype-informatieobjecttype Diploma")
-    else:
-        st, body = api("POST", "/zaaktype-informatieobjecttypen", {
-            "zaaktype": zt["url"], "informatieobjecttype": iot["url"],
-            "volgnummer": 1, "richting": "inkomend"})
-        if st != 201:
-            sys.exit(f"relate zaaktype-informatieobjecttype -> {st}: {json.dumps(body, indent=2)}")
-        print("create zaaktype-informatieobjecttype Diploma")
-
-    return iot
-
-
-def publish_informatieobjecttype(iot):
-    """Publish the informatieobjecttype (idempotent) so documents may reference it."""
-    if iot.get("concept", True):
-        st, body = api("POST", f"{iot['url']}/publish")
-        if st != 200:
-            sys.exit(f"publish informatieobjecttype -> {st}: {json.dumps(body, indent=2)}")
-        print(f"publish informatieobjecttype Diploma ({iot['url']})")
-    else:
-        print("skip   publish informatieobjecttype (already published)")
-
-
 def main():
     # 1. Catalogus
     existing = [c for c in find(f"/catalogussen?domein=BIG") if c.get("domein") == "BIG"]
@@ -271,16 +198,10 @@ def main():
     # schema-mandatory" zaaktype S-01 asks for (ADR-0002). Set OZ_PUBLISH=1 to add
     # those relations and publish — needed so a real zaak POST is accepted, which
     # the ACL integration test (S-04a, #46) exercises. See ADR-0006.
-    iot = None
     if PUBLISH:
         # Re-fetch: the bsn-eigenschap branch above may hold a stale concept flag.
         zt = next(z for z in find(f"/zaaktypen?catalogus={cat['url']}&status=alles")
                   if z.get("identificatie") == "BIG-REGISTRATIE")
-        # Seed + relate the Diploma informatieobjecttype (S-10b) while the zaaktype is still concept,
-        # then publish both. Publish the informatieobjecttype before the zaaktype so the zaaktype's
-        # relations reference a published type.
-        iot = seed_informatieobjecttype(cat, zt)
-        publish_informatieobjecttype(iot)
         publish_zaaktype(zt)
 
     # 5. Verify the JWT client can list the zaaktype (concepts included).
@@ -293,10 +214,6 @@ def main():
     # zaaktype URL to configure the ACL's default-fill (ADR-0003/0009).
     zt_url = next(z["url"] for z in zaaktypen if z.get("identificatie") == "BIG-REGISTRATIE")
     print(f"ZAAKTYPE_URL {zt_url}")
-    # Machine-readable informatieobjecttype URL (S-10b) so callers can configure the ACL's document
-    # default-fill. Only emitted when publishing — a concept informatieobjecttype can't back a document.
-    if iot is not None:
-        print(f"INFORMATIEOBJECTTYPE_URL {iot['url']}")
     print(f"OK — BIG catalogus seeded (BIG-REGISTRATIE {state} + bsn eigenschap)")
 
 

infra/run-domain-check.sh

@@ -33,18 +33,13 @@ echo ">> openzaak=$oz_ip domain=$dom_ip network=$net"
 echo ">> seeding a published BIG zaaktype (idempotent) and capturing its URL"
 sid="$(docker create --network "$net" -e "OZ_BASE=$oz_base" -e OZ_PUBLISH=1 python:3-slim python /seed.py)"
 docker cp "$here/openzaak/seed_catalogus.py" "$sid:/seed.py" >/dev/null
-seed_out="$(docker start -a "$sid")"
-zt_url="$(printf '%s\n' "$seed_out" | sed -n 's/^ZAAKTYPE_URL //p' | head -1)"
-iot_url="$(printf '%s\n' "$seed_out" | sed -n 's/^INFORMATIEOBJECTTYPE_URL //p' | head -1)"
+zt_url="$(docker start -a "$sid" | sed -n 's/^ZAAKTYPE_URL //p' | head -1)"
 docker rm -f "$sid" >/dev/null
 [ -n "$zt_url" ] || { echo "ERROR: seed did not report a ZAAKTYPE_URL" >&2; exit 1; }
-[ -n "$iot_url" ] || { echo "ERROR: seed did not report an INFORMATIEOBJECTTYPE_URL" >&2; exit 1; }
 echo ">> zaaktype: $zt_url"
-echo ">> informatieobjecttype: $iot_url"
 
-echo ">> recreating the acl service pointed at the seeded zaaktype + informatieobjecttype (host-consistent)"
-ACL_ZAAKTYPE_URL="$zt_url" ACL_INFORMATIEOBJECTTYPE_URL="$iot_url" ACL_OPENZAAK_BASEURL="$oz_base/" \
-  docker compose -f "$compose" up -d acl
+echo ">> recreating the acl service pointed at the seeded zaaktype (host-consistent)"
+ACL_ZAAKTYPE_URL="$zt_url" ACL_OPENZAAK_BASEURL="$oz_base/" docker compose -f "$compose" up -d acl
 WAIT_TIMEOUT="${WAIT_TIMEOUT:-120}" bash "$here/wait-healthy.sh" acl
 
 echo ">> submitting a registration to the domain"
@@ -98,27 +93,6 @@ print(next((t['id'] for t in (d.get('data') or [])
 
 flcurl() { docker run --rm --network "$net" curlimages/curl:latest -fsS -u rest-admin:test "$@"; }
 query='{"processDefinitionKey":"registratie","taskDefinitionKey":"Beoordelen","includeProcessVariables":true}'
-wacht_query='{"processDefinitionKey":"registratie","taskDefinitionKey":"WachtOpDocumenten","includeProcessVariables":true}'
-
-# S-10a: every registration now parks at WachtOpDocumenten first (interrupting P30D timer). Completing
-# that task stands in for the citizen's document upload (wired for real in S-10b), letting the process
-# advance to the diploma routing / Beoordelen so the checks below still hold. The 30-day timeout branch
-# is exercised separately at the end.
-complete_wacht() {  # reg_id
-  local rid="$1" wid="" r
-  for _ in $(seq 1 30); do
-    r="$(flcurl -X POST "$fl_base/query/tasks" -H 'Content-Type: application/json' -d "$wacht_query" 2>/dev/null || true)"
-    wid="$(printf '%s' "$r" | task_for_reg "$rid")"
-    [ -n "$wid" ] && break
-    sleep 2
-  done
-  [ -n "$wid" ] || { echo "FAIL — no WachtOpDocumenten task appeared for $rid" >&2; docker logs "$dom" 2>&1 | tail -15 >&2; exit 1; }
-  flcurl -X POST "$fl_base/runtime/tasks/$wid" -H 'Content-Type: application/json' -d '{"action":"complete"}' >/dev/null
-  echo ">> completed WachtOpDocumenten for $rid (documents received)"
-}
-
-echo ">> completing WachtOpDocumenten so the process advances (documents received)"
-complete_wacht "$reg_id"
 
 echo ">> polling Flowable for the Beoordelen user task (werkbak)"
 task_id=""
@@ -156,7 +130,6 @@ loc2="$(docker run --rm --network "$net" curlimages/curl:latest \
 [ -n "$loc2" ] || { echo "FAIL — second POST /registrations returned no Location" >&2; exit 1; }
 reg_id2="${loc2##*/}"
 echo ">> second registration $reg_id2"
-complete_wacht "$reg_id2"
 
 echo ">> polling Flowable for its Beoordelen task"
 task_id2=""
@@ -198,7 +171,6 @@ locf="$(docker run --rm --network "$net" curlimages/curl:latest \
 [ -n "$locf" ] || { echo "FAIL — foreign POST /registrations returned no Location" >&2; exit 1; }
 reg_idf="${locf##*/}"
 echo ">> foreign registration $reg_idf"
-complete_wacht "$reg_idf"
 
 echo ">> polling Flowable for its CBGV-advies task (foreign diplomas route here first)"
 cbgv_task=""
@@ -269,8 +241,6 @@ except Exception:
     d={}
 print(((d.get('data') or [{}])[0]).get('id',''))"; }
 
-complete_wacht "$reg_id3"
-
 echo ">> polling Flowable for its Beoordelen task"
 task_id3=""; pid3=""
 for _ in $(seq 1 30); do
@@ -308,94 +278,4 @@ for _ in $(seq 1 30); do
 done
 [ -n "$escalated" ] || { echo "FAIL — Beoordelen task not reassigned to teamlead (candidate groups: '$groups')" >&2; docker logs "$dom" 2>&1 | tail -15 >&2; exit 1; }
 echo "OK — the 14-day timer escalated the still-open Beoordelen task to the teamlead"
-
-# ── S-10a/S-10c: document timeout. A registration parks at WachtOpDocumenten and — unlike every block
-# above — its documents never arrive. We fire its 30-day boundary timer early via the management API;
-# the INTERRUPTING timer cancels the wait and routes a token to the RegistratieVerlopen external task.
-# The domain's timeout worker acquires it, cancels the ZGW zaak via the ACL (S-10c), and expires the
-# registration to VERLOPEN (ADR-0017). ─────────────────────────────────────────────────────────────
-echo ">> submitting a registration to let its document term lapse"
-locv="$(docker run --rm --network "$net" curlimages/curl:latest \
-  -fsS -D - -o /dev/null -X POST "http://$dom_ip:8080/registrations" \
-  -H 'Content-Type: application/json' -d '{"bsn":"123456782"}' \
-  | sed -n 's/\r$//; s/^[Ll]ocation: //p' | head -1)"
-[ -n "$locv" ] || { echo "FAIL — timeout POST /registrations returned no Location" >&2; exit 1; }
-reg_idv="${locv##*/}"
-echo ">> timeout registration $reg_idv"
-
-echo ">> polling Flowable for its WachtOpDocumenten task"
-wacht_id=""; pidv=""
-for _ in $(seq 1 30); do
-  resp="$(flcurl -X POST "$fl_base/query/tasks" -H 'Content-Type: application/json' -d "$wacht_query" 2>/dev/null || true)"
-  read -r wacht_id pidv <<<"$(printf '%s' "$resp" | task_and_pid_for_reg "$reg_idv")"
-  [ -n "$wacht_id" ] && break
-  sleep 2
-done
-[ -n "$wacht_id" ] || { echo "FAIL — no WachtOpDocumenten task appeared for $reg_idv" >&2; docker logs "$dom" 2>&1 | tail -15 >&2; exit 1; }
-echo ">> WachtOpDocumenten task $wacht_id (instance $pidv) is waiting for documents"
-
-echo ">> firing the 30-day document timer early via the management API"
-timer_idv="$(flcurl "$fl_base/management/timer-jobs?processInstanceId=$pidv" | first_job_id)"
-[ -n "$timer_idv" ] || { echo "FAIL — no timer job found for instance $pidv" >&2; exit 1; }
-# Move the timer job to an executable async job; the async executor fires the interrupting boundary
-# event. It may run before we look, so executing it explicitly is a best-effort nudge (as for S-14).
-flcurl -X POST "$fl_base/management/timer-jobs/$timer_idv" -H 'Content-Type: application/json' -d '{"action":"move"}' >/dev/null
-async_idv="$(flcurl "$fl_base/management/jobs?processInstanceId=$pidv" 2>/dev/null | first_job_id || true)"
-if [ -n "$async_idv" ]; then
-  flcurl -X POST "$fl_base/management/jobs/$async_idv" -H 'Content-Type: application/json' -d '{"action":"execute"}' >/dev/null 2>&1 || true
-fi
-echo ">> timer fired; the RegistratieVerlopen token is parked for the domain worker"
-
-echo ">> polling the domain until the timeout worker expires the registration to VERLOPEN"
-verlopen=""
-for _ in $(seq 1 30); do
-  body="$(docker run --rm --network "$net" curlimages/curl:latest -fsS "http://$dom_ip:8080$locv" 2>/dev/null || true)"
-  printf '%s' "$body" | grep -qi 'verlopen' && { verlopen=1; break; }
-  sleep 2
-done
-[ -n "$verlopen" ] || { echo "FAIL — registration $reg_idv not VERLOPEN after the document timer fired (body: $body)" >&2; docker logs "$dom" 2>&1 | tail -15 >&2; exit 1; }
-echo "OK — the 30-day document timer expired the registration to VERLOPEN"
-
-# S-10c: the worker cancels the ZGW zaak (ACL-first, before it expires the aggregate), so a VERLOPEN
-# registration must carry a zaak whose current status is "Geannuleerd". Read it back from OpenZaak with
-# a ZGW token minted like the seed's client (the same client OpenZaak trusts for this stack).
-zaak_url_v="$(printf '%s' "$body" | grep -oiE 'http://[^"]*/zaken/api/v1/zaken/[a-f0-9-]+' | head -1)"
-[ -n "$zaak_url_v" ] || { echo "FAIL — VERLOPEN registration $reg_idv exposes no zaak URL (body: $body)" >&2; exit 1; }
-echo ">> confirming the zaak $zaak_url_v reached the Geannuleerd status in OpenZaak"
-
-read_zaak_status() {
-  # -i so the heredoc reaches `python -` on the container's stdin (without it the script is empty).
-  docker run --rm -i --network "$net" \
-    -e OZ_CLIENT_ID="${OZ_CLIENT_ID:-big-reference-seed}" \
-    -e OZ_SECRET="${OZ_SECRET:-insecure-dev-secret-change-me}" \
-    python:3-slim python - "$1" <<'PY'
-import base64, hashlib, hmac, json, os, sys, time, urllib.request
-cid, sec = os.environ["OZ_CLIENT_ID"], os.environ["OZ_SECRET"]
-b64 = lambda b: base64.urlsafe_b64encode(b).rstrip(b"=")
-def token():
-    hdr = {"alg": "HS256", "typ": "JWT"}
-    pl = {"iss": cid, "iat": int(time.time()), "client_id": cid, "user_id": "verify", "user_representation": "verify"}
-    seg = b64(json.dumps(hdr, separators=(",", ":")).encode()) + b"." + b64(json.dumps(pl, separators=(",", ":")).encode())
-    return (seg + b"." + b64(hmac.new(sec.encode(), seg, hashlib.sha256).digest())).decode()
-def get(url):
-    req = urllib.request.Request(url, headers={
-        "Authorization": "Bearer " + token(), "Accept": "application/json", "Accept-Crs": "EPSG:4326"})
-    with urllib.request.urlopen(req, timeout=30) as r:
-        return json.loads(r.read())
-zaak = get(sys.argv[1])
-status_url = zaak.get("status")
-if not status_url:
-    print(""); sys.exit(0)
-print(get(get(status_url)["statustype"]).get("omschrijving", ""))
-PY
-}
-
-geannuleerd=""
-for _ in $(seq 1 15); do
-  oms="$(read_zaak_status "$zaak_url_v" 2>/dev/null | tr -d '\r' || true)"
-  [ "$oms" = "Geannuleerd" ] && { geannuleerd=1; break; }
-  sleep 2
-done
-[ -n "$geannuleerd" ] || { echo "FAIL — zaak $zaak_url_v not Geannuleerd after timeout (current status omschrijving: '$oms')" >&2; docker logs "$dom" 2>&1 | tail -15 >&2; exit 1; }
-echo "OK — the timed-out registration's zaak was cancelled to Geannuleerd in OpenZaak"
 exit 0

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

@@ -35,14 +35,6 @@ export interface OpenbaarEntry {
   reference: string | null;
 }
 
-export interface ProvideDocumentsRequest {
-  contentBase64: string;
-  /** @nullable */
-  fileName?: string | null;
-  /** @nullable */
-  contentType?: string | null;
-}
-
 export interface SubmitAccepted {
   registrationId: string;
   status: string;
@@ -234,44 +226,6 @@ export class BffApiV1Service {
     );
   }
 
- postSelfServiceRegistrationsIdDocuments<TData = void>(id: string,
-    provideDocumentsRequest: ProvideDocumentsRequest, options?: HttpClientBodyOptions): Observable<TData>;
- postSelfServiceRegistrationsIdDocuments<TData = void>(id: string,
-    provideDocumentsRequest: ProvideDocumentsRequest, options?: HttpClientEventOptions): Observable<HttpEvent<TData>>;
- postSelfServiceRegistrationsIdDocuments<TData = void>(id: string,
-    provideDocumentsRequest: ProvideDocumentsRequest, options?: HttpClientResponseOptions): Observable<AngularHttpResponse<TData>>;
-  postSelfServiceRegistrationsIdDocuments<TData = void>(
-    id: string,
-    provideDocumentsRequest: ProvideDocumentsRequest, options?: HttpClientObserveOptions): Observable<TData | HttpEvent<TData> | AngularHttpResponse<TData>> {
-    if (options?.observe === 'events') {
-      return this.http.post<TData>(
-      `/self-service/registrations/${id}/documents`,
-      provideDocumentsRequest,{
-        ...(options as Omit<NonNullable<typeof options>, 'observe'>),
-        observe: 'events',
-      }
-    );
-    }
-
-    if (options?.observe === 'response') {
-      return this.http.post<TData>(
-      `/self-service/registrations/${id}/documents`,
-      provideDocumentsRequest,{
-        ...(options as Omit<NonNullable<typeof options>, 'observe'>),
-        observe: 'response',
-      }
-    );
-    }
-
-    return this.http.post<TData>(
-      `/self-service/registrations/${id}/documents`,
-      provideDocumentsRequest,{
-        ...(options as Omit<NonNullable<typeof options>, 'observe'>),
-        observe: 'body',
-      }
-    );
-  }
-
  getOpenbaarRegister<TData = OpenbaarEntry[]>(params?: GetOpenbaarRegisterParams, options?: HttpClientBodyOptions): Observable<TData>;
  getOpenbaarRegister<TData = OpenbaarEntry[]>(params?: GetOpenbaarRegisterParams, options?: HttpClientEventOptions): Observable<HttpEvent<TData>>;
  getOpenbaarRegister<TData = OpenbaarEntry[]>(params?: GetOpenbaarRegisterParams, options?: HttpClientResponseOptions): Observable<AngularHttpResponse<TData>>;

services/acl/Acl.Api/Program.cs

@@ -32,14 +32,6 @@ app.MapPost("/statussen", async (SetStatusRequest body, AclService acl, Cancella
     return Results.NoContent();
 });
 
-// Cancel a zaak on document-timeout expiry (S-10c): set it to its zaaktype's cancellation statustype
-// + resultaat. The domain hands over only the zaak URL; the ACL owns the ZGW resolution (§8.1).
-app.MapPost("/annuleringen", async (CancelZaakRequest body, AclService acl, CancellationToken ct) =>
-{
-    await acl.CancelZaakAsync(new Uri(body.ZaakUrl), ct);
-    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) =>
@@ -48,25 +40,12 @@ app.MapPost("/zaken/reference", async (ZaakReferenceRequest body, AclService acl
     return Results.Ok(new { reference });
 });
 
-// Store an uploaded diploma against a zaak (S-10b): the domain sends the file as base64; the ACL
-// creates the ZGW enkelvoudiginformatieobject and relates it to the zaak (§8.1). Returns its URL.
-app.MapPost("/documenten", async (StoreDocumentRequest body, AclService acl, CancellationToken ct) =>
-{
-    var url = await acl.StoreDiplomaAsync(
-        new Uri(body.ZaakUrl), Convert.FromBase64String(body.ContentBase64), body.FileName, body.ContentType, ct);
-    return Results.Ok(new { informatieobjectUrl = url.ToString() });
-});
-
 app.Run();
 
 public sealed record OpenZaakRequest(string Bsn, string Reference);
 
 public sealed record SetStatusRequest(string ZaakUrl);
 
-public sealed record CancelZaakRequest(string ZaakUrl);
-
 public sealed record ZaakReferenceRequest(string ZaakUrl);
 
-public sealed record StoreDocumentRequest(string ZaakUrl, string ContentBase64, string FileName, string ContentType);
-
 public partial class Program;

services/acl/Acl.Application/AclDefaults.cs

@@ -7,8 +7,4 @@ public sealed class AclDefaults
     public required string VerantwoordelijkeOrganisatie { get; init; }
     public required string Vertrouwelijkheidaanduiding { get; init; }
     public required Uri ZaaktypeUrl { get; init; }
-
-    /// <summary>The informatieobjecttype an uploaded diploma is filed under (S-10b). Seeded in the
-    /// catalogus and injected like <see cref="ZaaktypeUrl"/>.</summary>
-    public required Uri InformatieobjecttypeUrl { get; init; }
 }

services/acl/Acl.Application/AclService.cs

@@ -30,18 +30,6 @@ public sealed class AclService(IZaakGateway gateway, AclDefaults defaults, ICloc
         return gateway.SetZaakToEindstatusAsync(zaakUrl, defaults.ZaaktypeUrl, clock.Today, ct);
     }
 
-    /// <summary>
-    /// Cancel a zaak on document-timeout expiry (S-10c): set it to the configured BIG zaaktype's
-    /// cancellation statustype + resultaat. The domain hands over only the zaak URL; the ACL owns which
-    /// statustype/resultaat means "cancelled" (§8.1).
-    /// </summary>
-    public Task CancelZaakAsync(Uri zaakUrl, CancellationToken ct = default)
-    {
-        ArgumentNullException.ThrowIfNull(zaakUrl);
-
-        return gateway.SetZaakToCancellationStatusAsync(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)
     {
@@ -49,33 +37,4 @@ public sealed class AclService(IZaakGateway gateway, AclDefaults defaults, ICloc
 
         return gateway.GetZaakIdentificatieAsync(zaakUrl, ct);
     }
-
-    /// <summary>
-    /// Store an uploaded diploma against the zaak (S-10b): default-fill the ZGW-mandatory document
-    /// fields (informatieobjecttype, bronorganisatie, vertrouwelijkheidaanduiding, taal, creatiedatum)
-    /// and hand the file to the gateway, which creates the informatieobject and relates it to the zaak.
-    /// The domain supplies only the zaak, the bytes, and the file's name/type (§8.1).
-    /// </summary>
-    public Task<Uri> StoreDiplomaAsync(Uri zaakUrl, byte[] content, string fileName, string contentType, CancellationToken ct = default)
-    {
-        ArgumentNullException.ThrowIfNull(zaakUrl);
-        ArgumentNullException.ThrowIfNull(content);
-        ArgumentException.ThrowIfNullOrWhiteSpace(fileName);
-        ArgumentException.ThrowIfNullOrWhiteSpace(contentType);
-
-        var request = new DocumentRequest(
-            defaults.Bronorganisatie,
-            defaults.InformatieobjecttypeUrl,
-            defaults.Vertrouwelijkheidaanduiding,
-            zaakUrl,
-            clock.Today,
-            Titel: "Diploma",
-            Auteur: "zorgprofessional",
-            Taal: "nld",
-            Bestandsnaam: fileName,
-            Formaat: contentType,
-            Inhoud: content);
-
-        return gateway.StoreDocumentAsync(request, ct);
-    }
 }

services/acl/Acl.Application/DocumentRequest.cs

@@ -1,17 +0,0 @@
-namespace Acl.Application;
-
-/// <summary>The fully default-filled diploma document the gateway will create in the ZGW Documenten
-/// API and relate to the zaak (S-10b). <see cref="Inhoud"/> is the raw file content; the gateway
-/// base64-encodes it into the ZGW <c>inhoud</c> field.</summary>
-public sealed record DocumentRequest(
-    string Bronorganisatie,
-    Uri Informatieobjecttype,
-    string Vertrouwelijkheidaanduiding,
-    Uri Zaak,
-    DateOnly Creatiedatum,
-    string Titel,
-    string Auteur,
-    string Taal,
-    string Bestandsnaam,
-    string Formaat,
-    byte[] Inhoud);

services/acl/Acl.Application/IZaakGateway.cs

@@ -13,23 +13,7 @@ public interface IZaakGateway
     /// </summary>
     Task SetZaakToEindstatusAsync(Uri zaakUrl, Uri zaaktypeUrl, DateOnly datumStatusGezet, CancellationToken ct = default);
 
-    /// <summary>
-    /// Set the given zaak to the <em>cancellation</em> statustype ("Geannuleerd") and record the
-    /// matching cancellation resultaat ("Vervallen") — the ZGW translation of "the 30-day document term
-    /// lapsed" (S-10c). Distinct from <see cref="SetZaakToEindstatusAsync"/> (approval): the gateway
-    /// resolves both the cancellation statustype and resultaattype from the catalogus by their
-    /// omschrijving, POSTs the resultaat then the status, dated <paramref name="datumStatusGezet"/>.
-    /// </summary>
-    Task SetZaakToCancellationStatusAsync(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);
-
-    /// <summary>
-    /// Store a diploma document (S-10b): create an <c>enkelvoudiginformatieobject</c> in the ZGW
-    /// Documenten API and relate it to the zaak via a <c>zaakinformatieobject</c>. Returns the URL of
-    /// the created informatieobject.
-    /// </summary>
-    Task<Uri> StoreDocumentAsync(DocumentRequest request, CancellationToken ct = default);
 }

services/acl/Acl.Infrastructure/OpenZaakGateway.cs

@@ -8,12 +8,6 @@ namespace Acl.Infrastructure;
 /// <summary>The only code that talks to OpenZaak's Zaken API (ADR-0001).</summary>
 public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) : IZaakGateway
 {
-    // The ACL owns which ZGW statustype/resultaat carries each domain outcome (§8.1). These
-    // omschrijvingen match the seeded BIG catalogus (infra/openzaak/seed_catalogus.py).
-    private const string GeregistreerdResultaat = "Geregistreerd";   // approval outcome
-    private const string GeannuleerdStatus = "Geannuleerd";          // document-timeout cancellation status (S-10c)
-    private const string VervallenResultaat = "Vervallen";           // document-timeout cancellation outcome (S-10c)
-
     public async Task<Uri> OpenZaakAsync(ZaakRequest request, CancellationToken ct = default)
     {
         ArgumentNullException.ThrowIfNull(request);
@@ -54,9 +48,7 @@ public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) :
         ArgumentNullException.ThrowIfNull(zaaktypeUrl);
 
         var eindstatus = await ResolveEindstatusAsync(zaaktypeUrl, ct);
-        // Resolve the approval resultaat by name: once S-10c adds the Vervallen resultaattype, taking
-        // the first would be ambiguous (the Zaken API does not guarantee order).
-        var resultaattype = await ResolveResultaattypeByOmschrijvingAsync(zaaktypeUrl, GeregistreerdResultaat, ct);
+        var resultaattype = await ResolveResultaattypeAsync(zaaktypeUrl, ct);
 
         // OpenZaak refuses to set a zaak's eindstatus unless the zaak has a resultaat
         // ("resultaat-does-not-exist"), so record the resultaat first, then the status.
@@ -70,27 +62,6 @@ public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) :
             "Setting the zaak status", ct);
     }
 
-    public async Task SetZaakToCancellationStatusAsync(Uri zaakUrl, Uri zaaktypeUrl, DateOnly datumStatusGezet, CancellationToken ct = default)
-    {
-        ArgumentNullException.ThrowIfNull(zaakUrl);
-        ArgumentNullException.ThrowIfNull(zaaktypeUrl);
-
-        // Distinct from approval: resolve the cancellation statustype + resultaat by name (Geannuleerd
-        // is a non-terminal statustype, so it is never the eindstatus the approval path resolves).
-        var cancellationStatus = await ResolveStatustypeByOmschrijvingAsync(zaaktypeUrl, GeannuleerdStatus, ct);
-        var cancellationResultaat = await ResolveResultaattypeByOmschrijvingAsync(zaaktypeUrl, VervallenResultaat, ct);
-
-        // As with approval, OpenZaak wants the resultaat recorded before the status.
-        await PostAsync("/zaken/api/v1/resultaten",
-            new ResultaatDto(zaakUrl.ToString(), cancellationResultaat.ToString()),
-            "Setting the zaak cancellation resultaat", ct);
-
-        await PostAsync("/zaken/api/v1/statussen",
-            new StatusDto(zaakUrl.ToString(), cancellationStatus.ToString(),
-                datumStatusGezet.ToDateTime(TimeOnly.MinValue, DateTimeKind.Utc).ToString("yyyy-MM-ddTHH:mm:ssZ")),
-            "Setting the zaak cancellation status", ct);
-    }
-
     public async Task<string> GetZaakIdentificatieAsync(Uri zaakUrl, CancellationToken ct = default)
     {
         ArgumentNullException.ThrowIfNull(zaakUrl);
@@ -109,39 +80,6 @@ public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) :
         return zaak.Identificatie;
     }
 
-    public async Task<Uri> StoreDocumentAsync(DocumentRequest request, CancellationToken ct = default)
-    {
-        ArgumentNullException.ThrowIfNull(request);
-
-        // 1. Create the enkelvoudiginformatieobject in the Documenten API (not a geo API — no CRS).
-        var created = await PostForUrlAsync(
-            "/documenten/api/v1/enkelvoudiginformatieobjecten",
-            new EnkelvoudigInformatieobjectDto(
-                request.Bronorganisatie,
-                request.Creatiedatum.ToString("yyyy-MM-dd"),
-                request.Titel,
-                request.Auteur,
-                request.Taal,
-                request.Informatieobjecttype.ToString(),
-                Convert.ToBase64String(request.Inhoud),
-                request.Bestandsnaam,
-                request.Inhoud.Length,
-                request.Vertrouwelijkheidaanduiding,
-                request.Formaat,
-                "definitief",
-                // No usage-rights restrictions apply. Left null, OpenZaak rejects closing the related
-                // zaak with "indicatiegebruiksrecht-unset"; false records the deliberate "none" answer.
-                false),
-            "Creating the informatieobject", ct);
-
-        // 2. Relate it to the zaak (Zaken API — no CRS).
-        await PostAsync("/zaken/api/v1/zaakinformatieobjecten",
-            new ZaakInformatieobjectDto(request.Zaak.ToString(), created.ToString()),
-            "Relating the informatieobject to the zaak", ct);
-
-        return created;
-    }
-
     // 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)
@@ -158,26 +96,6 @@ public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) :
         await EnsureSuccessAsync(response, action, ct);
     }
 
-    // POSTs a non-geo ZGW resource and returns the created resource's URL (as PostAsync, but reads back
-    // the `url` of the created object). Buffers the body so uwsgi gets a Content-Length.
-    private async Task<Uri> PostForUrlAsync(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));
-        await message.Content.LoadIntoBufferAsync(ct);
-
-        using var response = await http.SendAsync(message, ct);
-        await EnsureSuccessAsync(response, action, ct);
-
-        var created = await response.Content.ReadFromJsonAsync<CreatedDto>(ct)
-            ?? throw new InvalidOperationException($"OpenZaak returned an empty response for {action}");
-        return new Uri(created.Url);
-    }
-
     // 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)
@@ -203,23 +121,13 @@ public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) :
         return new Uri(eindstatus.Url);
     }
 
-    /// <summary>Resolve a specific statustype from the catalogus by its omschrijving (e.g. "Geannuleerd").</summary>
-    private async Task<Uri> ResolveStatustypeByOmschrijvingAsync(Uri zaaktypeUrl, string omschrijving, CancellationToken ct)
-    {
-        var page = await GetCatalogusAsync<StatustypePage>("statustypen", zaaktypeUrl, "statustypen", ct);
-        var match = (page.Results ?? []).FirstOrDefault(s => s.Omschrijving == omschrijving)
-            ?? throw new InvalidOperationException($"No '{omschrijving}' statustype found for zaaktype {zaaktypeUrl}");
-        return new Uri(match.Url);
-    }
-
-    /// <summary>Resolve a specific resultaattype from the catalogus by its omschrijving (the seed defines
-    /// "Geregistreerd" for approval and "Vervallen" for a document-timeout cancellation).</summary>
-    private async Task<Uri> ResolveResultaattypeByOmschrijvingAsync(Uri zaaktypeUrl, string omschrijving, CancellationToken ct)
+    /// <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 match = (page.Results ?? []).FirstOrDefault(r => r.Omschrijving == omschrijving)
-            ?? throw new InvalidOperationException($"No '{omschrijving}' resultaattype found for zaaktype {zaaktypeUrl}");
-        return new Uri(match.Url);
+        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).
@@ -263,8 +171,7 @@ public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) :
     private sealed record StatustypeDto(
         [property: JsonPropertyName("url")] string Url,
         [property: JsonPropertyName("volgnummer")] int Volgnummer,
-        [property: JsonPropertyName("isEindstatus")] bool IsEindstatus,
-        [property: JsonPropertyName("omschrijving")] string? Omschrijving);
+        [property: JsonPropertyName("isEindstatus")] bool IsEindstatus);
 
     private sealed record ResultaatDto(
         [property: JsonPropertyName("zaak")] string Zaak,
@@ -274,28 +181,5 @@ public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) :
         [property: JsonPropertyName("results")] IReadOnlyList<ResultaattypeDto>? Results);
 
     private sealed record ResultaattypeDto(
-        [property: JsonPropertyName("url")] string Url,
-        [property: JsonPropertyName("omschrijving")] string? Omschrijving);
-
-    private sealed record CreatedDto(
         [property: JsonPropertyName("url")] string Url);
-
-    private sealed record EnkelvoudigInformatieobjectDto(
-        [property: JsonPropertyName("bronorganisatie")] string Bronorganisatie,
-        [property: JsonPropertyName("creatiedatum")] string Creatiedatum,
-        [property: JsonPropertyName("titel")] string Titel,
-        [property: JsonPropertyName("auteur")] string Auteur,
-        [property: JsonPropertyName("taal")] string Taal,
-        [property: JsonPropertyName("informatieobjecttype")] string Informatieobjecttype,
-        [property: JsonPropertyName("inhoud")] string Inhoud,
-        [property: JsonPropertyName("bestandsnaam")] string Bestandsnaam,
-        [property: JsonPropertyName("bestandsomvang")] int Bestandsomvang,
-        [property: JsonPropertyName("vertrouwelijkheidaanduiding")] string Vertrouwelijkheidaanduiding,
-        [property: JsonPropertyName("formaat")] string Formaat,
-        [property: JsonPropertyName("status")] string Status,
-        [property: JsonPropertyName("indicatieGebruiksrecht")] bool IndicatieGebruiksrecht);
-
-    private sealed record ZaakInformatieobjectDto(
-        [property: JsonPropertyName("zaak")] string Zaak,
-        [property: JsonPropertyName("informatieobject")] string Informatieobject);
 }

services/acl/Acl.IntegrationTests/OpenZaakFixture.cs

@@ -77,18 +77,6 @@ public sealed class OpenZaakFixture : IDisposable
         return JsonDocument.Parse(json).RootElement.Clone();
     }
 
-    /// <summary>The URL of the published "Diploma" informatieobjecttype (S-10b), or null when the
-    /// stack has not been seeded with OZ_PUBLISH=1. `status=definitief` returns published types only.</summary>
-    public async Task<Uri?> FindPublishedDiplomaInformatieobjecttypeAsync(CancellationToken ct = default)
-    {
-        var query = new Uri(BaseUrl, "/catalogi/api/v1/informatieobjecttypen?status=definitief");
-        var page = await GetJsonAsync(query, ct);
-        foreach (var iot in page.GetProperty("results").EnumerateArray())
-            if (iot.TryGetProperty("omschrijving", out var o) && o.GetString() == "Diploma")
-                return new Uri(iot.GetProperty("url").GetString()!);
-        return null;
-    }
-
     /// <summary>The zaaktype's eindstatus (terminal statustype) URL — the one an approval sets.</summary>
     public async Task<Uri> FindEindstatustypeAsync(Uri zaaktypeUrl, CancellationToken ct = default)
     {
@@ -114,19 +102,6 @@ public sealed class OpenZaakFixture : IDisposable
         return fallback ?? throw new InvalidOperationException($"No statustypen for zaaktype {zaaktypeUrl}");
     }
 
-    /// <summary>Resolve a statustype by its omschrijving (e.g. the S-10c "Geannuleerd" cancellation status).</summary>
-    public async Task<Uri> FindStatustypeByOmschrijvingAsync(Uri zaaktypeUrl, string omschrijving, CancellationToken ct = default)
-    {
-        var query = new Uri(BaseUrl,
-            "/catalogi/api/v1/statustypen?status=alles&zaaktype=" + Uri.EscapeDataString(zaaktypeUrl.ToString()));
-        var page = await GetJsonAsync(query, ct);
-        foreach (var st in page.GetProperty("results").EnumerateArray())
-            if (st.TryGetProperty("omschrijving", out var o) && o.GetString() == omschrijving)
-                return new Uri(st.GetProperty("url").GetString()!);
-
-        throw new InvalidOperationException($"No '{omschrijving}' statustype for zaaktype {zaaktypeUrl}");
-    }
-
     // A ZGW (vng-api-common) HS256 JWT, mirroring the seed's client. Minted here
     // rather than reusing Acl.Infrastructure's internal minter to keep that internal.
     private string MintToken()

services/acl/Acl.IntegrationTests/OpenZaakGatewayIntegrationTests.cs

@@ -74,91 +74,4 @@ public sealed class OpenZaakGatewayIntegrationTests(OpenZaakFixture stack)
         var eindstatustype = await stack.FindEindstatustypeAsync(zaaktype!);
         Assert.Equal(eindstatustype.ToString(), status.GetProperty("statustype").GetString());
     }
-
-    [Fact]
-    public async Task Cancelling_a_zaak_records_the_geannuleerd_status_and_a_resultaat()
-    {
-        var zaaktype = await stack.FindPublishedBigZaaktypeAsync();
-        Assert.True(zaaktype is not null,
-            "No published BIG-REGISTRATIE zaaktype found in OpenZaak — bring the stack up and " +
-            "seed it with OZ_PUBLISH=1 (`make integration` does this).");
-
-        var gateway = new OpenZaakGateway(stack.Http, stack.Options);
-        var zaakUrl = await gateway.OpenZaakAsync(new ZaakRequest(
-            Bronorganisatie: "517439943",
-            VerantwoordelijkeOrganisatie: "517439943",
-            Vertrouwelijkheidaanduiding: "openbaar",
-            Zaaktype: zaaktype!,
-            Startdatum: DateOnly.FromDateTime(DateTime.UtcNow),
-            Identificatie: Guid.NewGuid().ToString()));
-
-        await gateway.SetZaakToCancellationStatusAsync(zaakUrl, zaaktype!, DateOnly.FromDateTime(DateTime.UtcNow));
-
-        // The zaak's current status is the Geannuleerd statustype — distinct from the approval eindstatus.
-        var zaak = await stack.GetZaakAsync(zaakUrl);
-        var statusUrl = zaak.GetProperty("status").GetString();
-        Assert.False(string.IsNullOrEmpty(statusUrl), "the cancelled zaak has no current status");
-
-        var status = await stack.GetJsonAsync(new Uri(statusUrl!));
-        var geannuleerd = await stack.FindStatustypeByOmschrijvingAsync(zaaktype!, "Geannuleerd");
-        Assert.Equal(geannuleerd.ToString(), status.GetProperty("statustype").GetString());
-
-        // ...and a resultaat is recorded (OpenZaak requires it before a closing/terminal status).
-        Assert.False(string.IsNullOrEmpty(zaak.GetProperty("resultaat").GetString()),
-            "the cancelled zaak has no resultaat");
-    }
-
-    [Fact]
-    public async Task Storing_a_diploma_creates_a_real_informatieobject_related_to_the_zaak()
-    {
-        var zaaktype = await stack.FindPublishedBigZaaktypeAsync();
-        Assert.True(zaaktype is not null,
-            "No published BIG-REGISTRATIE zaaktype found — seed the stack with OZ_PUBLISH=1.");
-        var informatieobjecttype = await stack.FindPublishedDiplomaInformatieobjecttypeAsync();
-        Assert.True(informatieobjecttype is not null,
-            "No published Diploma informatieobjecttype found — seed the stack with OZ_PUBLISH=1.");
-
-        var gateway = new OpenZaakGateway(stack.Http, stack.Options);
-        var zaakUrl = await gateway.OpenZaakAsync(new ZaakRequest(
-            Bronorganisatie: "517439943",
-            VerantwoordelijkeOrganisatie: "517439943",
-            Vertrouwelijkheidaanduiding: "openbaar",
-            Zaaktype: zaaktype!,
-            Startdatum: DateOnly.FromDateTime(DateTime.UtcNow),
-            Identificatie: Guid.NewGuid().ToString()));
-
-        var content = System.Text.Encoding.UTF8.GetBytes("%PDF-1.4 synthetic diploma\n");
-        var documentUrl = await gateway.StoreDocumentAsync(new DocumentRequest(
-            Bronorganisatie: "517439943",
-            Informatieobjecttype: informatieobjecttype!,
-            Vertrouwelijkheidaanduiding: "openbaar",
-            Zaak: zaakUrl,
-            Creatiedatum: DateOnly.FromDateTime(DateTime.UtcNow),
-            Titel: "Diploma",
-            Auteur: "zorgprofessional",
-            Taal: "nld",
-            Bestandsnaam: "diploma.pdf",
-            Formaat: "application/pdf",
-            Inhoud: content));
-
-        // The gateway returns the canonical informatieobject URL...
-        Assert.StartsWith(
-            new Uri(stack.BaseUrl, "/documenten/api/v1/enkelvoudiginformatieobjecten/").ToString(),
-            documentUrl.ToString());
-
-        // ...the document is really persisted with the default-filled fields...
-        var doc = await stack.GetJsonAsync(documentUrl);
-        Assert.Equal("diploma.pdf", doc.GetProperty("bestandsnaam").GetString());
-        Assert.Equal(informatieobjecttype.ToString(), doc.GetProperty("informatieobjecttype").GetString());
-        Assert.Equal(content.Length, doc.GetProperty("bestandsomvang").GetInt32());
-        // indicatieGebruiksrecht is recorded as "no restrictions"; left null, OpenZaak would refuse to
-        // close the zaak this document is related to (the S-10b regression that broke the e2e flow).
-        Assert.False(doc.GetProperty("indicatieGebruiksrecht").GetBoolean());
-
-        // ...and it is related to the zaak (a zaakinformatieobject links the two).
-        var relations = await stack.GetJsonAsync(new Uri(stack.BaseUrl,
-            "/zaken/api/v1/zaakinformatieobjecten?informatieobject=" + Uri.EscapeDataString(documentUrl.ToString())));
-        Assert.Contains(relations.EnumerateArray(),
-            r => r.GetProperty("zaak").GetString() == zaakUrl.ToString());
-    }
 }

services/acl/Acl.Tests/AclServiceTests.cs

@@ -23,14 +23,6 @@ public class AclServiceTests
             return Task.CompletedTask;
         }
 
-        public (Uri Zaak, Uri Zaaktype, DateOnly Datum)? Cancelled;
-
-        public Task SetZaakToCancellationStatusAsync(Uri zaakUrl, Uri zaaktypeUrl, DateOnly datumStatusGezet, CancellationToken ct = default)
-        {
-            Cancelled = (zaakUrl, zaaktypeUrl, datumStatusGezet);
-            return Task.CompletedTask;
-        }
-
         public Uri? ReadReferenceFor;
 
         public Task<string> GetZaakIdentificatieAsync(Uri zaakUrl, CancellationToken ct = default)
@@ -38,15 +30,6 @@ public class AclServiceTests
             ReadReferenceFor = zaakUrl;
             return Task.FromResult("REG-FROM-ZAAK");
         }
-
-        public DocumentRequest? StoredDocument;
-        public Uri DocumentResult { get; } = new("http://openzaak/documenten/api/v1/enkelvoudiginformatieobjecten/doc-1");
-
-        public Task<Uri> StoreDocumentAsync(DocumentRequest request, CancellationToken ct = default)
-        {
-            StoredDocument = request;
-            return Task.FromResult(DocumentResult);
-        }
     }
 
     private static AclDefaults Defaults() => new()
@@ -55,7 +38,6 @@ public class AclServiceTests
         VerantwoordelijkeOrganisatie = "517439943",
         Vertrouwelijkheidaanduiding = "openbaar",
         ZaaktypeUrl = new("http://openzaak/catalogi/api/v1/zaaktypen/big"),
-        InformatieobjecttypeUrl = new("http://openzaak/catalogi/api/v1/informatieobjecttypen/dip"),
     };
 
     private sealed class FixedClock(DateOnly today) : IClock
@@ -73,7 +55,6 @@ public class AclServiceTests
             VerantwoordelijkeOrganisatie = "517439943",
             Vertrouwelijkheidaanduiding = "openbaar",
             ZaaktypeUrl = new("http://openzaak/catalogi/api/v1/zaaktypen/big"),
-            InformatieobjecttypeUrl = new("http://openzaak/catalogi/api/v1/informatieobjecttypen/dip"),
         };
         var service = new AclService(gateway, defaults, new FixedClock(new DateOnly(2026, 6, 4)));
 
@@ -100,7 +81,6 @@ public class AclServiceTests
             VerantwoordelijkeOrganisatie = "517439943",
             Vertrouwelijkheidaanduiding = "openbaar",
             ZaaktypeUrl = new("http://openzaak/catalogi/api/v1/zaaktypen/big"),
-            InformatieobjecttypeUrl = new("http://openzaak/catalogi/api/v1/informatieobjecttypen/dip"),
         };
         var service = new AclService(gateway, defaults, new FixedClock(new DateOnly(2026, 6, 4)));
 
@@ -134,69 +114,6 @@ public class AclServiceTests
         Assert.Null(gateway.Approved);
     }
 
-    [Fact]
-    public async Task Cancelling_a_zaak_sets_it_to_the_cancellation_status_dated_today()
-    {
-        var gateway = new FakeGateway();
-        var defaults = Defaults();
-        var service = new AclService(gateway, defaults, new FixedClock(new DateOnly(2026, 6, 4)));
-        var zaak = new Uri("http://openzaak/zaken/api/v1/zaken/abc");
-
-        await service.CancelZaakAsync(zaak);
-
-        Assert.NotNull(gateway.Cancelled);
-        Assert.Equal(zaak, gateway.Cancelled!.Value.Zaak);
-        Assert.Equal(defaults.ZaaktypeUrl, gateway.Cancelled.Value.Zaaktype);
-        Assert.Equal(new DateOnly(2026, 6, 4), gateway.Cancelled.Value.Datum);
-        // Cancellation must not touch the approval path.
-        Assert.Null(gateway.Approved);
-    }
-
-    [Fact]
-    public async Task Cancelling_a_null_zaak_is_rejected_without_touching_the_gateway()
-    {
-        var gateway = new FakeGateway();
-        var service = new AclService(gateway, Defaults(), new FixedClock(new DateOnly(2026, 6, 4)));
-
-        await Assert.ThrowsAsync<ArgumentNullException>(() => service.CancelZaakAsync(null!));
-        Assert.Null(gateway.Cancelled);
-    }
-
-    [Fact]
-    public async Task Storing_a_diploma_default_fills_the_document_fields_and_returns_its_url()
-    {
-        var gateway = new FakeGateway();
-        var defaults = Defaults();
-        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 url = await service.StoreDiplomaAsync(zaak, [1, 2, 3], "diploma.pdf", "application/pdf");
-
-        Assert.Equal(gateway.DocumentResult, url);
-        var req = gateway.StoredDocument!;
-        Assert.Equal(zaak, req.Zaak);
-        Assert.Equal(defaults.InformatieobjecttypeUrl, req.Informatieobjecttype);
-        Assert.Equal("517439943", req.Bronorganisatie);
-        Assert.Equal("openbaar", req.Vertrouwelijkheidaanduiding);
-        Assert.Equal(new DateOnly(2026, 6, 4), req.Creatiedatum);
-        Assert.Equal("nld", req.Taal);
-        Assert.Equal("diploma.pdf", req.Bestandsnaam);
-        Assert.Equal("application/pdf", req.Formaat);
-        Assert.Equal(new byte[] { 1, 2, 3 }, req.Inhoud);
-    }
-
-    [Fact]
-    public async Task Storing_a_diploma_rejects_null_or_blank_arguments()
-    {
-        var service = new AclService(new FakeGateway(), Defaults(), new FixedClock(new DateOnly(2026, 6, 4)));
-        var zaak = new Uri("http://openzaak/zaken/api/v1/zaken/abc");
-
-        await Assert.ThrowsAsync<ArgumentNullException>(() => service.StoreDiplomaAsync(null!, [1], "d.pdf", "application/pdf"));
-        await Assert.ThrowsAsync<ArgumentNullException>(() => service.StoreDiplomaAsync(zaak, null!, "d.pdf", "application/pdf"));
-        await Assert.ThrowsAnyAsync<ArgumentException>(() => service.StoreDiplomaAsync(zaak, [1], " ", "application/pdf"));
-        await Assert.ThrowsAnyAsync<ArgumentException>(() => service.StoreDiplomaAsync(zaak, [1], "d.pdf", " "));
-    }
-
     [Fact]
     public async Task Reading_a_zaak_reference_returns_the_zaaks_identificatie()
     {

services/acl/Acl.Tests/OpenZaakGatewayTests.cs

@@ -173,8 +173,7 @@ public class OpenZaakGatewayTests
     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","omschrijving":"Geregistreerd"}]}""";
+        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;
@@ -252,138 +251,6 @@ public class OpenZaakGatewayTests
         Assert.True(status.Length > 0);
     }
 
-    [Fact]
-    public async Task Approving_selects_the_geregistreerd_resultaat_by_name_when_several_exist()
-    {
-        // Once S-10c adds a second resultaattype (Vervallen), picking the first is ambiguous — the
-        // Zaken API does not guarantee order. Approval must resolve its resultaat by omschrijving.
-        var rec = new Recorder();
-        var twoResultaattypen = """
-            {"results":[
-              {"url":"http://openzaak/catalogi/api/v1/resultaattypen/vervallen","omschrijving":"Vervallen"},
-              {"url":"http://openzaak/catalogi/api/v1/resultaattypen/geregistreerd","omschrijving":"Geregistreerd"}
-            ]}
-            """;
-
-        await Gateway(ApprovalStub(rec, new OzRoutes { ResultaattypenJson = twoResultaattypen }))
-            .SetZaakToEindstatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4));
-
-        Assert.Contains("\"resultaattype\":\"http://openzaak/catalogi/api/v1/resultaattypen/geregistreerd\"",
-            rec.Sent("/resultaten").Body);
-    }
-
-    // --- SetZaakToCancellationStatusAsync (document-timeout cancellation / S-10c) ---
-
-    // A catalogus with the three statustypen S-10c seeds (Geannuleerd is non-terminal, below the
-    // Afgehandeld eindstatus) and both resultaattypen. Cancellation must resolve "Geannuleerd" and
-    // "Vervallen" by omschrijving, never the approval pair.
-    private const string CancellationStatustypenJson = """
-        {"results":[
-          {"url":"http://openzaak/catalogi/api/v1/statustypen/ontvangen","volgnummer":1,"omschrijving":"Ontvangen","isEindstatus":false},
-          {"url":"http://openzaak/catalogi/api/v1/statustypen/geannuleerd","volgnummer":2,"omschrijving":"Geannuleerd","isEindstatus":false},
-          {"url":"http://openzaak/catalogi/api/v1/statustypen/afgehandeld","volgnummer":3,"omschrijving":"Afgehandeld","isEindstatus":true}
-        ]}
-        """;
-
-    private const string CancellationResultaattypenJson = """
-        {"results":[
-          {"url":"http://openzaak/catalogi/api/v1/resultaattypen/geregistreerd","omschrijving":"Geregistreerd"},
-          {"url":"http://openzaak/catalogi/api/v1/resultaattypen/vervallen","omschrijving":"Vervallen"}
-        ]}
-        """;
-
-    [Fact]
-    public async Task Cancelling_records_the_vervallen_resultaat_then_the_geannuleerd_status_against_the_zaak()
-    {
-        var rec = new Recorder();
-
-        await Gateway(ApprovalStub(rec, new OzRoutes
-        {
-            StatustypenJson = CancellationStatustypenJson,
-            ResultaattypenJson = CancellationResultaattypenJson,
-        })).SetZaakToCancellationStatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4));
-
-        // Resultaat precedes status (OpenZaak requires a resultaat before a closing/terminal status).
-        Assert.True(rec.IndexOf("/resultaten") < rec.IndexOf("/statussen"));
-
-        var resultaat = rec.Sent("/resultaten");
-        Assert.Contains("\"zaak\":\"" + ZaakUrl + "\"", resultaat.Body);
-        // The cancellation resultaat (Vervallen) is chosen by name — not the approval one (Geregistreerd).
-        Assert.Contains("\"resultaattype\":\"http://openzaak/catalogi/api/v1/resultaattypen/vervallen\"", resultaat.Body);
-
-        var status = rec.Sent("/statussen");
-        Assert.Contains("\"zaak\":\"" + ZaakUrl + "\"", status.Body);
-        // The Geannuleerd statustype is chosen by name — not the Afgehandeld eindstatus (approval).
-        Assert.Contains("\"statustype\":\"http://openzaak/catalogi/api/v1/statustypen/geannuleerd\"", status.Body);
-        Assert.Contains("\"datumStatusGezet\":\"2026-06-04T00:00:00Z\"", status.Body);
-    }
-
-    [Fact]
-    public async Task Cancelling_throws_when_the_zaaktype_has_no_geannuleerd_statustype()
-    {
-        var rec = new Recorder();
-
-        var ex = await Assert.ThrowsAsync<InvalidOperationException>(() =>
-            Gateway(ApprovalStub(rec, new OzRoutes
-            {
-                // Only the approval statustypen — no "Geannuleerd".
-                StatustypenJson = StatustypenPage(withEindstatusFlag: true),
-                ResultaattypenJson = CancellationResultaattypenJson,
-            })).SetZaakToCancellationStatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4)));
-
-        Assert.Contains("Geannuleerd", ex.Message);
-    }
-
-    [Fact]
-    public async Task Cancelling_rejects_a_null_zaak_without_calling_openzaak()
-    {
-        var handler = new StubHandler(_ => throw new InvalidOperationException("should not be sent"));
-        await Assert.ThrowsAsync<ArgumentNullException>(() =>
-            Gateway(handler).SetZaakToCancellationStatusAsync(null!, Zaaktype, new DateOnly(2026, 6, 4)));
-    }
-
-    [Fact]
-    public async Task Cancelling_rejects_a_null_zaaktype_without_calling_openzaak()
-    {
-        var handler = new StubHandler(_ => throw new InvalidOperationException("should not be sent"));
-        await Assert.ThrowsAsync<ArgumentNullException>(() =>
-            Gateway(handler).SetZaakToCancellationStatusAsync(new Uri(ZaakUrl), null!, new DateOnly(2026, 6, 4)));
-    }
-
-    [Fact]
-    public async Task Cancelling_surfaces_the_failure_when_recording_the_resultaat_is_rejected()
-    {
-        var rec = new Recorder();
-
-        var ex = await Assert.ThrowsAsync<HttpRequestException>(() =>
-            Gateway(ApprovalStub(rec, new OzRoutes
-            {
-                StatustypenJson = CancellationStatustypenJson,
-                ResultaattypenJson = CancellationResultaattypenJson,
-                ResultaatPostStatus = HttpStatusCode.BadRequest,
-            })).SetZaakToCancellationStatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4)));
-
-        Assert.Contains("cancellation resultaat", ex.Message);
-        // It fails on the resultaat, before it ever posts the status.
-        Assert.Equal(-1, rec.IndexOf("/statussen"));
-    }
-
-    [Fact]
-    public async Task Cancelling_surfaces_the_failure_when_recording_the_status_is_rejected()
-    {
-        var rec = new Recorder();
-
-        var ex = await Assert.ThrowsAsync<HttpRequestException>(() =>
-            Gateway(ApprovalStub(rec, new OzRoutes
-            {
-                StatustypenJson = CancellationStatustypenJson,
-                ResultaattypenJson = CancellationResultaattypenJson,
-                StatusPostStatus = HttpStatusCode.BadRequest,
-            })).SetZaakToCancellationStatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4)));
-
-        Assert.Contains("cancellation status", ex.Message);
-    }
-
     [Fact]
     public async Task Approving_falls_back_to_the_highest_volgnummer_when_no_eindstatus_is_flagged()
     {
@@ -458,7 +325,7 @@ public class OpenZaakGatewayTests
             Gateway(ApprovalStub(rec, new OzRoutes { ResultaattypenJson = "{}" }))
                 .SetZaakToEindstatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4)));
 
-        Assert.Contains("'Geregistreerd' resultaattype", ex.Message);
+        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"));
@@ -565,114 +432,4 @@ public class OpenZaakGatewayTests
         b64 = (b64.Length % 4) switch { 2 => b64 + "==", 3 => b64 + "=", _ => b64 };
         return Encoding.UTF8.GetString(Convert.FromBase64String(b64));
     }
-
-    // --- StoreDocumentAsync (diploma upload / S-10b) ---
-
-    private static readonly Uri Informatieobjecttype =
-        new("http://openzaak/catalogi/api/v1/informatieobjecttypen/dip");
-
-    private static DocumentRequest SampleDocument(byte[]? inhoud = null) => new(
-        Bronorganisatie: "517439943",
-        Informatieobjecttype: Informatieobjecttype,
-        Vertrouwelijkheidaanduiding: "openbaar",
-        Zaak: new Uri(ZaakUrl),
-        Creatiedatum: new DateOnly(2026, 6, 4),
-        Titel: "Diploma",
-        Auteur: "zorgprofessional",
-        Taal: "nld",
-        Bestandsnaam: "diploma.pdf",
-        Formaat: "application/pdf",
-        Inhoud: inhoud ?? [1, 2, 3, 4]);
-
-    // Routes the two document calls: POST /enkelvoudiginformatieobjecten (documenten) then
-    // POST /zaakinformatieobjecten (zaken).
-    private static StubHandler DocumentStub(Recorder rec) => new(async req =>
-    {
-        rec.Requests.Add(req);
-        rec.ContentLengths.Add(req.Content?.Headers.ContentLength);
-        rec.Bodies.Add(req.Content is null ? null : await req.Content.ReadAsStringAsync());
-
-        return req.RequestUri!.ToString().Contains("/enkelvoudiginformatieobjecten")
-            ? Json(HttpStatusCode.Created, """{"url":"http://openzaak/documenten/api/v1/enkelvoudiginformatieobjecten/doc-1"}""")
-            : Json(HttpStatusCode.Created, """{"url":"http://openzaak/zaken/api/v1/zaakinformatieobjecten/rel-1"}""");
-    });
-
-    [Fact]
-    public async Task Storing_a_document_creates_the_informatieobject_then_relates_it_to_the_zaak()
-    {
-        var rec = new Recorder();
-
-        var url = await Gateway(DocumentStub(rec)).StoreDocumentAsync(SampleDocument([10, 20, 30]));
-
-        Assert.Equal("http://openzaak/documenten/api/v1/enkelvoudiginformatieobjecten/doc-1", url.ToString());
-
-        // 1. Create the enkelvoudiginformatieobject in the Documenten API.
-        var create = rec.Sent("/enkelvoudiginformatieobjecten");
-        Assert.Equal(HttpMethod.Post, create.Request.Method);
-        Assert.Equal("http://openzaak/documenten/api/v1/enkelvoudiginformatieobjecten",
-            create.Request.RequestUri!.ToString());
-        Assert.Equal("Bearer", create.Request.Headers.Authorization!.Scheme);
-        Assert.Contains("\"bronorganisatie\":\"517439943\"", create.Body);
-        Assert.Contains("\"informatieobjecttype\":\"http://openzaak/catalogi/api/v1/informatieobjecttypen/dip\"", create.Body);
-        Assert.Contains("\"creatiedatum\":\"2026-06-04\"", create.Body);
-        Assert.Contains("\"titel\":\"Diploma\"", create.Body);
-        Assert.Contains("\"auteur\":\"zorgprofessional\"", create.Body);
-        Assert.Contains("\"taal\":\"nld\"", create.Body);
-        Assert.Contains("\"bestandsnaam\":\"diploma.pdf\"", create.Body);
-        Assert.Contains("\"formaat\":\"application/pdf\"", create.Body);
-        Assert.Contains("\"vertrouwelijkheidaanduiding\":\"openbaar\"", create.Body);
-        Assert.Contains("\"status\":\"definitief\"", create.Body);
-        // indicatieGebruiksrecht must be set explicitly (false = no usage restrictions); left null,
-        // OpenZaak refuses to close the zaak this document is related to ("indicatiegebruiksrecht-unset").
-        Assert.Contains("\"indicatieGebruiksrecht\":false", create.Body);
-        // The file content is base64-encoded into `inhoud`, with its byte length in `bestandsomvang`.
-        Assert.Contains($"\"inhoud\":\"{Convert.ToBase64String([10, 20, 30])}\"", create.Body);
-        Assert.Contains("\"bestandsomvang\":3", create.Body);
-
-        // 2. Relate that informatieobject to the zaak (Zaken API — no CRS).
-        var relate = rec.Sent("/zaakinformatieobjecten");
-        Assert.Equal(HttpMethod.Post, relate.Request.Method);
-        Assert.Equal("http://openzaak/zaken/api/v1/zaakinformatieobjecten",
-            relate.Request.RequestUri!.ToString());
-        Assert.Contains($"\"zaak\":\"{ZaakUrl}\"", relate.Body);
-        Assert.Contains("\"informatieobject\":\"http://openzaak/documenten/api/v1/enkelvoudiginformatieobjecten/doc-1\"", relate.Body);
-    }
-
-    [Fact]
-    public async Task Storing_a_document_buffers_the_body_and_sends_no_crs_headers()
-    {
-        // uwsgi rejects a chunked body (Content-Length must be present); the Documenten API is not a
-        // geo API, so no CRS headers (unlike the Zaken zaak-create).
-        var rec = new Recorder();
-
-        await Gateway(DocumentStub(rec)).StoreDocumentAsync(SampleDocument());
-
-        var create = rec.Sent("/enkelvoudiginformatieobjecten");
-        Assert.NotNull(create.Length);
-        Assert.True(create.Length > 0);
-        Assert.False(create.Request.Headers.Contains("Accept-Crs"));
-        Assert.False(create.Request.Content!.Headers.Contains("Content-Crs"));
-    }
-
-    [Fact]
-    public async Task Storing_a_document_surfaces_an_openzaak_rejection()
-    {
-        var handler = new StubHandler(_ =>
-            Task.FromResult(new HttpResponseMessage(HttpStatusCode.BadRequest)
-            {
-                Content = new StringContent("""{"detail":"bad"}""", Encoding.UTF8, "application/json"),
-            }));
-
-        var ex = await Assert.ThrowsAsync<HttpRequestException>(
-            () => Gateway(handler).StoreDocumentAsync(SampleDocument()));
-        Assert.Contains("bad", ex.Message);
-    }
-
-    [Fact]
-    public async Task Storing_a_document_rejects_a_null_request()
-    {
-        var handler = new StubHandler(_ => throw new InvalidOperationException("should not be sent"));
-
-        await Assert.ThrowsAsync<ArgumentNullException>(() => Gateway(handler).StoreDocumentAsync(null!));
-    }
 }

services/bff/Bff.Api/DownstreamClients.cs

@@ -27,12 +27,6 @@ public interface IDomainClient
     /// unknown or not the caller's (404), so the BFF can relay a 404 rather than a 500.</summary>
     Task<bool> WithdrawRegistrationAsync(string registrationId, string bsn, CancellationToken ct = default);
 
-    /// <summary>Provide (upload) the diploma the caller's own registration is waiting for ("documenten
-    /// aanleveren"). The file is carried base64-encoded. Owner-scoped by <paramref name="bsn"/>. Returns
-    /// <c>false</c> when the domain reports the registration is unknown or not the caller's (404).</summary>
-    Task<bool> ProvideDocumentsAsync(
-        string registrationId, string bsn, string contentBase64, string? fileName, string? contentType, CancellationToken ct = default);
-
     /// <summary>The behandelaar's werkbak — registrations awaiting beoordeling.</summary>
     Task<IReadOnlyList<WerkbakItem>> GetWerkbakAsync(CancellationToken ct = default);
 
@@ -69,19 +63,6 @@ public sealed class DomainClient(HttpClient http) : IDomainClient
         return true;
     }
 
-    public async Task<bool> ProvideDocumentsAsync(
-        string registrationId, string bsn, string contentBase64, string? fileName, string? contentType, CancellationToken ct = default)
-    {
-        using var response = await http.PostAsJsonAsync(
-            $"registrations/{registrationId}/documents",
-            new { bsn, contentBase64, fileName, contentType }, ct);
-        // The domain 404s an unknown or not-owned registration; relay that rather than fail hard.
-        if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
-            return false;
-        response.EnsureSuccessStatusCode();
-        return true;
-    }
-
     public async Task<IReadOnlyList<WerkbakItem>> GetWerkbakAsync(CancellationToken ct = default)
         => await http.GetFromJsonAsync<List<WerkbakItem>>("behandel/werkbak", ct) ?? [];
 

services/bff/Bff.Api/Program.cs

@@ -104,28 +104,6 @@ app.MapPost("/self-service/registrations/{id}/withdraw", async (string id, Claim
     .Produces(StatusCodes.Status401Unauthorized)
     .Produces(StatusCodes.Status404NotFound);
 
-// Self-service provide-documents (S-10a): the signed-in zorgprofessional supplies the documents their
-// registration is waiting for ("documenten aanleveren"). The bsn comes from the DigiD token and is
-// forwarded to the domain, which owner-scopes the action and completes the WachtOpDocumenten task; a
-// registration that is unknown or not the caller's comes back 404. The real file upload + ZGW storage
-// is S-10b — this is the trigger that unblocks the process.
-app.MapPost("/self-service/registrations/{id}/documents", async (string id, ProvideDocumentsRequest body, ClaimsPrincipal user, IDomainClient domain, CancellationToken ct) =>
-{
-    var bsn = user.FindFirstValue("bsn");
-    if (string.IsNullOrWhiteSpace(bsn))
-        return Results.BadRequest("The token carries no bsn claim.");
-    if (string.IsNullOrWhiteSpace(body?.ContentBase64))
-        return Results.BadRequest("A document is required.");
-
-    var provided = await domain.ProvideDocumentsAsync(id, bsn, body.ContentBase64, body.FileName, body.ContentType, ct);
-    return provided ? Results.NoContent() : Results.NotFound();
-})
-    .RequireAuthorization()
-    .Produces(StatusCodes.Status204NoContent)
-    .Produces(StatusCodes.Status400BadRequest)
-    .Produces(StatusCodes.Status401Unauthorized)
-    .Produces(StatusCodes.Status404NotFound);
-
 // Openbaar register: an anonymous public lookup that exposes only public-safe fields (S-09).
 app.MapGet("/openbaar/register", async (string? q, IProjectionClient projection, CancellationToken ct) =>
 {
@@ -165,10 +143,6 @@ app.Run();
 /// <summary>The behandelaar's decision on a registration.</summary>
 public sealed record DecideRequest(string Besluit);
 
-/// <summary>A diploma upload from the self-service portal — the file base64-encoded client-side, with
-/// its name and MIME type. The bsn is taken from the DigiD token, not this body.</summary>
-public sealed record ProvideDocumentsRequest(string ContentBase64, string? FileName = null, string? ContentType = null);
-
 // Behandel (medewerker-realm) authentication + authorization wiring (ADR-0013).
 internal static class BehandelAuth
 {

services/bff/Bff.Tests/BffFactory.cs

@@ -94,18 +94,6 @@ internal sealed class FakeDomainClient : IDomainClient
         return Task.FromResult(WithdrawSucceeds);
     }
 
-    public (string RegistrationId, string Bsn, string ContentBase64, string? FileName, string? ContentType)? DocumentsProvidedFor { get; private set; }
-
-    /// <summary>Whether the fake domain reports the provide-documents as done (true → 204) or
-    /// not-found/not-owned (false → 404). Tests set this to exercise the relay.</summary>
-    public bool ProvideDocumentsSucceeds { get; set; } = true;
-
-    public Task<bool> ProvideDocumentsAsync(string registrationId, string bsn, string contentBase64, string? fileName, string? contentType, CancellationToken ct = default)
-    {
-        DocumentsProvidedFor = (registrationId, bsn, contentBase64, fileName, contentType);
-        return Task.FromResult(ProvideDocumentsSucceeds);
-    }
-
     public (string RegistrationId, string Besluit)? Decided { get; private set; }
 
     public Task<IReadOnlyList<WerkbakItem>> GetWerkbakAsync(CancellationToken ct = default)

services/bff/Bff.Tests/SelfServiceEndpointTests.cs

@@ -112,61 +112,5 @@ public class SelfServiceEndpointTests
         Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
     }
 
-    private static HttpRequestMessage ProvideDocuments(string? bearer, string id = "reg-123")
-    {
-        var request = new HttpRequestMessage(HttpMethod.Post, $"/self-service/registrations/{id}/documents")
-        {
-            // The portal base64-encodes the file client-side and posts it as JSON (S-10b); the bsn is
-            // never in the body — it comes from the DigiD token.
-            Content = JsonContent.Create(new
-            {
-                contentBase64 = Convert.ToBase64String([1, 2, 3]),
-                fileName = "diploma.pdf",
-                contentType = "application/pdf",
-            }),
-        };
-        if (bearer is not null)
-            request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", bearer);
-        return request;
-    }
-
-    [Fact]
-    public async Task Rejects_providing_documents_without_a_token()
-    {
-        using var factory = new BffFactory();
-
-        var response = await factory.CreateClient().SendAsync(ProvideDocuments(bearer: null));
-
-        Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
-        Assert.Null(factory.Domain.DocumentsProvidedFor);
-    }
-
-    [Fact]
-    public async Task Provides_documents_for_the_callers_registration_forwarding_id_bsn_and_file()
-    {
-        using var factory = new BffFactory();
-
-        var response = await factory.CreateClient().SendAsync(ProvideDocuments(TestTokens.Valid("123456782"), "reg-9"));
-
-        Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
-        var provided = factory.Domain.DocumentsProvidedFor;
-        Assert.NotNull(provided);
-        Assert.Equal("reg-9", provided!.Value.RegistrationId);
-        Assert.Equal("123456782", provided.Value.Bsn);
-        Assert.Equal(Convert.ToBase64String([1, 2, 3]), provided.Value.ContentBase64);
-        Assert.Equal("diploma.pdf", provided.Value.FileName);
-    }
-
-    [Fact]
-    public async Task Relays_not_found_providing_documents_for_an_unknown_or_not_owned_registration()
-    {
-        using var factory = new BffFactory();
-        factory.Domain.ProvideDocumentsSucceeds = false;
-
-        var response = await factory.CreateClient().SendAsync(ProvideDocuments(TestTokens.Valid("123456782")));
-
-        Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
-    }
-
     private sealed record SubmitAcceptedDto(string RegistrationId, string Status);
 }

services/bff/openapi.json

@@ -61,47 +61,6 @@
         }
       }
     },
-    "/self-service/registrations/{id}/documents": {
-      "post": {
-        "tags": [
-          "Bff.Api"
-        ],
-        "parameters": [
-          {
-            "name": "id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string"
-            }
-          }
-        ],
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/ProvideDocumentsRequest"
-              }
-            }
-          },
-          "required": true
-        },
-        "responses": {
-          "204": {
-            "description": "No Content"
-          },
-          "400": {
-            "description": "Bad Request"
-          },
-          "401": {
-            "description": "Unauthorized"
-          },
-          "404": {
-            "description": "Not Found"
-          }
-        }
-      }
-    },
     "/openbaar/register": {
       "get": {
         "tags": [
@@ -238,29 +197,6 @@
           }
         }
       },
-      "ProvideDocumentsRequest": {
-        "required": [
-          "contentBase64"
-        ],
-        "type": "object",
-        "properties": {
-          "contentBase64": {
-            "type": "string"
-          },
-          "fileName": {
-            "type": [
-              "null",
-              "string"
-            ]
-          },
-          "contentType": {
-            "type": [
-              "null",
-              "string"
-            ]
-          }
-        }
-      },
       "SubmitAccepted": {
         "required": [
           "registrationId",

services/domain/Big.Api/Program.cs

@@ -22,29 +22,22 @@ builder.Services.AddTransient<IWorkflowClient>(sp => sp.GetRequiredService<Flowa
 builder.Services.AddTransient<IExternalWorkerClient>(sp => sp.GetRequiredService<FlowableWorkflowClient>());
 builder.Services.AddTransient<IUserTaskClient>(sp => sp.GetRequiredService<FlowableWorkflowClient>());
 builder.Services.AddTransient<IBeoordelingEscalatieClient>(sp => sp.GetRequiredService<FlowableWorkflowClient>());
-builder.Services.AddTransient<IRegistratieVerlopenClient>(sp => sp.GetRequiredService<FlowableWorkflowClient>());
 builder.Services.AddHttpClient<IAclClient, AclHttpClient>();
 
 builder.Services.AddScoped<SubmitRegistration>();
 builder.Services.AddScoped<ApproveRegistration>();
 builder.Services.AddScoped<BeoordeelRegistratie>();
 builder.Services.AddScoped<WithdrawRegistration>();
-builder.Services.AddScoped<ProvideDocuments>();
 builder.Services.AddScoped<Werkbak>();
 builder.Services.AddScoped<OpenZaakWorker>();
 builder.Services.AddScoped<OpenZaakJobProcessor>();
 builder.Services.AddScoped<BeoordelingEscalatieProcessor>();
-builder.Services.AddScoped<ExpireRegistrationWorker>();
-builder.Services.AddScoped<RegistratieVerlopenProcessor>();
 
 // The hosted external-task job worker polls Flowable and drives OpenZaakAanmaken to completion.
 builder.Services.AddHostedService<OpenZaakJobPump>();
 // The escalation worker polls the BeoordelingEscaleren jobs the 14-day timer parks and reassigns
 // each overdue beoordeling to the teamlead (S-14).
 builder.Services.AddHostedService<BeoordelingEscalatiePump>();
-// The document-timeout worker polls the RegistratieVerlopen jobs the 30-day timer on WachtOpDocumenten
-// parks and expires each lapsed registration to VERLOPEN (S-10a, ADR-0017).
-builder.Services.AddHostedService<RegistratieVerlopenPump>();
 
 var app = builder.Build();
 
@@ -108,32 +101,6 @@ app.MapPost("/registrations/{id}/withdraw", async (string id, WithdrawRequest bo
     return outcome == WithdrawOutcome.Withdrawn ? Results.NoContent() : Results.NotFound();
 });
 
-// Provide documents (S-10a): the zorgprofessional supplies the documents their registration is parked
-// waiting for, completing the WachtOpDocumenten task so the process advances to beoordeling (ADR-0017).
-// Owner-scoped by the caller's bsn (the BFF forwards it from the DigiD token); unknown or not-the-
-// caller's is 404 (indistinguishable). Idempotent — completing an already-left wait is a no-op. The
-// real file upload + ZGW storage is S-10b; this endpoint is the trigger that unblocks the process.
-app.MapPost("/registrations/{id}/documents", async (string id, ProvideDocumentsRequest body, ProvideDocuments provide, CancellationToken ct) =>
-{
-    if (!Guid.TryParse(id, out var guid))
-        return Results.NotFound();
-
-    if (string.IsNullOrWhiteSpace(body?.Bsn))
-        return Results.BadRequest(new { error = "A bsn is required to provide documents." });
-    if (string.IsNullOrWhiteSpace(body.ContentBase64))
-        return Results.BadRequest(new { error = "A document is required." });
-
-    byte[] content;
-    try { content = Convert.FromBase64String(body.ContentBase64); }
-    catch (FormatException) { return Results.BadRequest(new { error = "The document content is not valid base64." }); }
-
-    var command = new ProvideDocumentsCommand(
-        new RegistrationId(guid), body.Bsn, content,
-        body.FileName ?? "diploma.pdf", body.ContentType ?? "application/pdf");
-    var outcome = await provide.HandleAsync(command, ct);
-    return outcome == ProvideDocumentsOutcome.Accepted ? Results.NoContent() : Results.NotFound();
-});
-
 // The behandelaar's werkbak (S-12): the registrations awaiting beoordeling, read from the open
 // Beoordelen user tasks (§8.2) and enriched with bsn + status. The BFF proxies this behind
 // medewerker-realm + behandelaar-role authorization; the domain trusts its callers (§8.3).
@@ -161,8 +128,6 @@ public sealed record DecideRequest(string Besluit);
 
 public sealed record WithdrawRequest(string Bsn);
 
-public sealed record ProvideDocumentsRequest(string Bsn, string ContentBase64, string? FileName = null, string? ContentType = null);
-
 public sealed record RegistrationResponse(string RegistrationId, string Status, string? ZaakUrl);
 
 public partial class Program;

services/domain/Big.Application/ExpireRegistrationWorker.cs

@@ -1,45 +0,0 @@
-using Big.Domain;
-
-namespace Big.Application;
-
-/// <summary>
-/// Handles one acquired <c>RegistratieVerlopen</c> external-worker job (S-10a, ADR-0017): load the
-/// registration the job correlates to and expire it to VERLOPEN — the 30-day document-wait timer fired
-/// before the documents arrived, so the case is cancelled. Pure application logic over ports; it knows
-/// nothing of Flowable. The polling loop that feeds it jobs lives in Infrastructure. Mirrors
-/// <see cref="OpenZaakWorker"/>.
-/// </summary>
-public sealed class ExpireRegistrationWorker(IRegistrationStore store, IAclClient acl)
-{
-    /// <summary>
-    /// Process the job. Idempotent and tolerant of races (§8.6, at-least-once delivery): a job whose
-    /// registration is already resolved — a redelivered expiry (VERLOPEN), or one withdrawn/decided
-    /// while it waited (INGETROKKEN/INGESCHREVEN/AFGEWEZEN) — is a no-op, so the job still completes
-    /// rather than throwing into a redelivery loop. Only a still-open registration is expired. An
-    /// unknown registration is an error: it throws, leaving the job un-completed for Flowable to redeliver.
-    /// </summary>
-    public async Task HandleAsync(RegistratieVerlopenJob job, CancellationToken ct = default)
-    {
-        ArgumentNullException.ThrowIfNull(job);
-
-        var registration = await store.GetAsync(job.RegistrationId, ct)
-            ?? throw new InvalidOperationException(
-                $"No registration {job.RegistrationId} for RegistratieVerlopen job {job.JobId}.");
-
-        // Only a still-open registration lapses; an already-resolved one (expired, or withdrawn/decided
-        // while it waited) is left untouched so the job can complete without violating the aggregate.
-        if (registration.Status is not (RegistrationStatus.Ingediend or RegistrationStatus.InBehandeling))
-            return;
-
-        // Cancel the ZGW zaak before advancing the aggregate (mirrors the approval path): if the ACL
-        // call fails it throws, the aggregate stays open, and the job is redelivered (§8.6) — rather
-        // than leaving the aggregate VERLOPEN while the zaak stays open. The status guard above stops a
-        // redelivered job from cancelling the zaak twice (a second resultaat would be a 400). A
-        // registration expired before its zaak was opened has nothing to cancel.
-        if (registration.ZaakUrl is not null)
-            await acl.CancelZaakAsync(registration.ZaakUrl, ct);
-
-        registration.Expire();
-        await store.SaveAsync(registration, ct);
-    }
-}

services/domain/Big.Application/Ports.cs

@@ -25,14 +25,6 @@ public interface IWorkflowClient
     /// ended, or not yet parked) it is a no-op; the aggregate is INGETROKKEN regardless.
     /// </summary>
     Task WithdrawProcessAsync(string processInstanceId, CancellationToken ct = default);
-
-    /// <summary>
-    /// Signal that the required documents have arrived (S-10a): complete the <c>WachtOpDocumenten</c>
-    /// user task in the instance so the process leaves the 30-day wait state and continues to
-    /// beoordeling (ADR-0017). Best-effort — if the instance is not parked at that task (already
-    /// continued, or timed out) it is a no-op. The upload trigger that calls this is wired in S-10b.
-    /// </summary>
-    Task CompleteDocumentWaitAsync(string processInstanceId, CancellationToken ct = default);
 }
 
 /// <summary>
@@ -52,19 +44,6 @@ public interface IAclClient
     /// the zaak's final status — which OpenZaak notifies over NRC; the domain never names statustypen.
     /// </summary>
     Task ApproveZaakAsync(Uri zaakUrl, CancellationToken ct = default);
-
-    /// <summary>
-    /// Store an uploaded diploma against the zaak (S-10b). The domain hands over the zaak, the raw file
-    /// bytes, and the file's name/type; the ACL creates the ZGW informatieobject and relates it to the
-    /// zaak (§8.1). Returns the stored document's URL.
-    /// </summary>
-    Task<Uri> StoreDiplomaAsync(Uri zaakUrl, byte[] content, string fileName, string contentType, CancellationToken ct = default);
-
-    /// <summary>
-    /// Cancel the zaak on document-timeout expiry (S-10c): the 30-day document term lapsed, so the ACL
-    /// translates this to the ZGW cancellation status/resultaat. The domain never names statustypen.
-    /// </summary>
-    Task CancelZaakAsync(Uri zaakUrl, CancellationToken ct = default);
 }
 
 /// <summary>
@@ -116,11 +95,3 @@ public sealed record OpenZaakJob(string JobId, RegistrationId RegistrationId);
 /// once the 14-day boundary timer fires (ADR-0015).
 /// </summary>
 public sealed record EscalatieJob(string JobId, string ProcessInstanceId);
-
-/// <summary>
-/// An acquired <c>RegistratieVerlopen</c> job (S-10a): the Flowable job id and the registration id it
-/// carries as a process variable. The 30-day boundary timer on <c>WachtOpDocumenten</c> spawns it when
-/// the required documents were not supplied in time; expiring the correlated registration to VERLOPEN
-/// cancels the case (ADR-0017).
-/// </summary>
-public sealed record RegistratieVerlopenJob(string JobId, RegistrationId RegistrationId);

services/domain/Big.Application/ProvideDocuments.cs

@@ -1,54 +0,0 @@
-using Big.Domain;
-
-namespace Big.Application;
-
-/// <summary>A zorgprofessional's upload of the diploma their registration is waiting for ("documenten
-/// aanleveren"). <paramref name="Bsn"/> is the authenticated caller (from the DigiD token, forwarded by
-/// the BFF): only the registration's own bsn may provide its documents. <paramref name="Content"/> is
-/// the raw file, with its <paramref name="FileName"/> and <paramref name="ContentType"/>.</summary>
-public sealed record ProvideDocumentsCommand(
-    RegistrationId RegistrationId, string Bsn, byte[] Content, string FileName, string ContentType);
-
-/// <summary>The outcome of a provide-documents request.</summary>
-public enum ProvideDocumentsOutcome
-{
-    /// <summary>The documents were accepted; the process's document wait was completed (if any).</summary>
-    Accepted,
-
-    /// <summary>No registration with that id belongs to the caller — unknown, or owned by someone else
-    /// (the two are deliberately indistinguishable, so the endpoint reveals neither).</summary>
-    NotFound,
-}
-
-/// <summary>
-/// The provide-documents use case (S-10a/S-10b): a zorgprofessional uploads the diploma their
-/// registration is parked waiting for. The document is stored in ZGW via the ACL (§8.1), then the
-/// WachtOpDocumenten task is completed so the registratie process leaves the 30-day wait and continues
-/// to beoordeling (ADR-0017). Owner-scoped by bsn. Both steps are best-effort about missing preconditions
-/// (mirroring <see cref="WithdrawRegistration"/>): storage needs an opened zaak, and completion needs a
-/// running process — a request that arrives before either still stands, storing/completing what it can.
-/// </summary>
-public sealed class ProvideDocuments(IRegistrationStore store, IWorkflowClient workflow, IAclClient acl)
-{
-    public async Task<ProvideDocumentsOutcome> HandleAsync(ProvideDocumentsCommand command, CancellationToken ct = default)
-    {
-        ArgumentNullException.ThrowIfNull(command);
-
-        var registration = await store.GetAsync(command.RegistrationId, ct);
-
-        // Unknown, or not the caller's registration: report NotFound either way (don't reveal which).
-        if (registration is null || registration.Bsn != command.Bsn)
-            return ProvideDocumentsOutcome.NotFound;
-
-        // Store the diploma against the zaak (once it is opened) — the ACL is the only ZGW caller (§8.1).
-        if (registration.ZaakUrl is not null)
-            await acl.StoreDiplomaAsync(
-                registration.ZaakUrl, command.Content, command.FileName, command.ContentType, ct);
-
-        // Complete the document wait (if a process is running) so beoordeling can proceed.
-        if (registration.ProcessInstanceId is not null)
-            await workflow.CompleteDocumentWaitAsync(registration.ProcessInstanceId, ct);
-
-        return ProvideDocumentsOutcome.Accepted;
-    }
-}

services/domain/Big.Domain/Registration.cs

@@ -133,24 +133,8 @@ public sealed class Registration
         Status = RegistrationStatus.Ingetrokken;
     }
 
-    /// <summary>
-    /// Expire the registration — the 30-day document-wait timer fired before the required documents
-    /// were supplied, so the registratie process cancels the case (S-10a). Allowed while it is still
-    /// open (INGEDIEND or IN_BEHANDELING) and needs no zaak; a decided (INGESCHREVEN/AFGEWEZEN) or
-    /// withdrawn (INGETROKKEN) registration can no longer expire. Re-expiring one already
-    /// <see cref="RegistrationStatus.Verlopen"/> is a no-op — the worker job may be redelivered (§8.6).
-    /// </summary>
-    public void Expire()
-    {
-        if (Status == RegistrationStatus.Verlopen)
-            return;
-
-        RequireOpenForDecision(nameof(Expire));
-        Status = RegistrationStatus.Verlopen;
-    }
-
-    // A decision (or withdrawal, or expiry) is only valid while the registration is still open
-    // (INGEDIEND or IN_BEHANDELING).
+    // A decision (or withdrawal) 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))

services/domain/Big.Domain/RegistrationStatus.cs

@@ -21,8 +21,4 @@ public enum RegistrationStatus
 
     /// <summary>Withdrawn by the zorgprofessional before a decision (S-11). Terminal.</summary>
     Ingetrokken,
-
-    /// <summary>Lapsed: the required documents were not supplied within the 30-day window, so the
-    /// registratie process cancelled the case (S-10a). Terminal.</summary>
-    Verlopen,
 }

services/domain/Big.Infrastructure/AclHttpClient.cs

@@ -31,32 +31,6 @@ public sealed class AclHttpClient(HttpClient http, AclOptions options) : IAclCli
         response.EnsureSuccessStatusCode();
     }
 
-    public async Task CancelZaakAsync(Uri zaakUrl, CancellationToken ct = default)
-    {
-        ArgumentNullException.ThrowIfNull(zaakUrl);
-
-        using var response = await http.PostAsJsonAsync(
-            new Uri(options.BaseUrl, "annuleringen"), new CancelZaakRequest(zaakUrl.ToString()), ct);
-        response.EnsureSuccessStatusCode();
-    }
-
-    public async Task<Uri> StoreDiplomaAsync(Uri zaakUrl, byte[] content, string fileName, string contentType, CancellationToken ct = default)
-    {
-        ArgumentNullException.ThrowIfNull(zaakUrl);
-        ArgumentNullException.ThrowIfNull(content);
-
-        // The file crosses this boundary base64-encoded in JSON — the domain and ACL contracts are
-        // JSON, and a diploma is small (S-10b, ADR). The ACL turns it into a ZGW informatieobject.
-        using var response = await http.PostAsJsonAsync(
-            new Uri(options.BaseUrl, "documenten"),
-            new StoreDocumentRequest(zaakUrl.ToString(), Convert.ToBase64String(content), fileName, contentType), ct);
-        response.EnsureSuccessStatusCode();
-
-        var stored = await response.Content.ReadFromJsonAsync<StoreDocumentResponse>(ct)
-            ?? throw new InvalidOperationException("The ACL returned an empty document response.");
-        return new Uri(stored.InformatieobjectUrl);
-    }
-
     private sealed record OpenZaakRequest(
         [property: JsonPropertyName("bsn")] string Bsn,
         [property: JsonPropertyName("reference")] string Reference);
@@ -64,15 +38,4 @@ public sealed class AclHttpClient(HttpClient http, AclOptions options) : IAclCli
     private sealed record OpenZaakResponse([property: JsonPropertyName("zaakUrl")] string ZaakUrl);
 
     private sealed record SetStatusRequest([property: JsonPropertyName("zaakUrl")] string ZaakUrl);
-
-    private sealed record CancelZaakRequest([property: JsonPropertyName("zaakUrl")] string ZaakUrl);
-
-    private sealed record StoreDocumentRequest(
-        [property: JsonPropertyName("zaakUrl")] string ZaakUrl,
-        [property: JsonPropertyName("contentBase64")] string ContentBase64,
-        [property: JsonPropertyName("fileName")] string FileName,
-        [property: JsonPropertyName("contentType")] string ContentType);
-
-    private sealed record StoreDocumentResponse(
-        [property: JsonPropertyName("informatieobjectUrl")] string InformatieobjectUrl);
 }

services/domain/Big.Infrastructure/FlowableWorkflowClient.cs

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

services/domain/Big.Infrastructure/IExternalWorkerClient.cs

@@ -36,19 +36,3 @@ public interface IBeoordelingEscalatieClient
     /// <summary>Complete an acquired escalation job so its token reaches the escalation end event.</summary>
     Task CompleteBeoordelingEscalatieJobAsync(string jobId, CancellationToken ct = default);
 }
-
-/// <summary>
-/// The document-timeout side of the Workflow Client (S-10a): the <c>RegistratieVerlopen</c>
-/// external-worker jobs parked by the 30-day boundary timer on <c>WachtOpDocumenten</c>. Kept separate
-/// from the other worker ports (interface segregation) so neither the OpenZaak nor escalation worker
-/// sees expiry. Implemented by <see cref="FlowableWorkflowClient"/> — the only code that talks to
-/// Flowable (§8.2, ADR-0017).
-/// </summary>
-public interface IRegistratieVerlopenClient
-{
-    /// <summary>Acquire and lock up to <paramref name="maxJobs"/> <c>RegistratieVerlopen</c> jobs.</summary>
-    Task<IReadOnlyList<RegistratieVerlopenJob>> AcquireRegistratieVerlopenJobsAsync(int maxJobs, CancellationToken ct = default);
-
-    /// <summary>Complete an acquired expiry job so its token reaches the <c>endVerlopen</c> end event.</summary>
-    Task CompleteRegistratieVerlopenJobAsync(string jobId, CancellationToken ct = default);
-}

services/domain/Big.Infrastructure/RegistratieVerlopenProcessor.cs

@@ -1,41 +0,0 @@
-using Big.Application;
-using Microsoft.Extensions.Logging;
-
-namespace Big.Infrastructure;
-
-/// <summary>
-/// One poll tick of the document-timeout worker (S-10a, ADR-0017): acquire the parked
-/// <c>RegistratieVerlopen</c> jobs — the tokens the 30-day boundary timer on <c>WachtOpDocumenten</c>
-/// spawns — expire each correlated registration via the <see cref="ExpireRegistrationWorker"/>, and
-/// complete the job so its token reaches <c>endVerlopen</c>. A job that fails is logged and left
-/// un-completed so Flowable redelivers it (§8.6). Split out from the hosted pump so the
-/// acquire→expire→complete logic is unit-testable without a running host. Mirrors
-/// <see cref="OpenZaakJobProcessor"/> and <see cref="BeoordelingEscalatieProcessor"/>.
-/// </summary>
-public sealed class RegistratieVerlopenProcessor(
-    IRegistratieVerlopenClient client,
-    ExpireRegistrationWorker worker,
-    ILogger<RegistratieVerlopenProcessor> logger)
-{
-    /// <summary>Acquire and process up to <paramref name="maxJobs"/> jobs. Returns the number acquired.</summary>
-    public async Task<int> PumpOnceAsync(int maxJobs, CancellationToken ct = default)
-    {
-        var jobs = await client.AcquireRegistratieVerlopenJobsAsync(maxJobs, ct);
-
-        foreach (var job in jobs)
-        {
-            try
-            {
-                await worker.HandleAsync(job, ct);
-                await client.CompleteRegistratieVerlopenJobAsync(job.JobId, ct);
-            }
-            catch (Exception ex)
-            {
-                // Leave the job un-completed: its lock expires and Flowable redelivers it (§8.6).
-                logger.LogError(ex, "RegistratieVerlopen job {JobId} failed; leaving it for redelivery.", job.JobId);
-            }
-        }
-
-        return jobs.Count;
-    }
-}

services/domain/Big.Infrastructure/RegistratieVerlopenPump.cs

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

services/domain/Big.Tests/ExpireRegistrationWorkerTests.cs

@@ -1,110 +0,0 @@
-using Big.Application;
-using Big.Domain;
-
-namespace Big.Tests;
-
-// S-10a (#102): the application handler behind the RegistratieVerlopen external-worker job. The 30-day
-// document-wait timer fired, so the correlated registration is expired to VERLOPEN. Mirrors
-// OpenZaakWorker — pure application logic over ports, idempotent under at-least-once delivery (§8.6).
-public class ExpireRegistrationWorkerTests
-{
-    private const string Bsn = "123456782";
-
-    // By the time the 30-day document timer fires, the zaak was opened long ago (OpenZaakAanmaken runs
-    // early in the flow), so a timed-out registration carries a zaak the worker can cancel.
-    private static Registration Submitted(string processInstanceId = "proc-1", Uri? zaakUrl = null)
-    {
-        var registration = Registration.Submit(Bsn);
-        registration.RecordProcessStarted(processInstanceId);
-        registration.AttachZaak(zaakUrl ?? FakeAclClient.DefaultZaakUrl);
-        return registration;
-    }
-
-    [Fact]
-    public async Task Expires_the_registration_the_job_correlates_to()
-    {
-        var store = new FakeRegistrationStore();
-        var registration = Submitted();
-        store.Seed(registration);
-
-        await new ExpireRegistrationWorker(store, new FakeAclClient()).HandleAsync(
-            new RegistratieVerlopenJob("job-7", registration.Id));
-
-        var saved = await store.GetAsync(registration.Id);
-        Assert.Equal(RegistrationStatus.Verlopen, saved!.Status);
-        Assert.Equal(1, store.SaveCount);
-    }
-
-    [Fact]
-    public async Task Cancels_the_zaak_via_the_acl_when_expiring_a_still_open_registration()
-    {
-        // S-10c: expiring the aggregate is not enough — the ZGW zaak must also be set to its
-        // cancellation status, which the ACL owns (§8.1). The worker hands the ACL the zaak URL.
-        var store = new FakeRegistrationStore();
-        var zaak = new Uri("http://openzaak/zaken/api/v1/zaken/timed-out");
-        var registration = Submitted(zaakUrl: zaak);
-        store.Seed(registration);
-        var acl = new FakeAclClient();
-
-        await new ExpireRegistrationWorker(store, acl).HandleAsync(
-            new RegistratieVerlopenJob("job-7", registration.Id));
-
-        Assert.Equal(1, acl.CancelCallCount);
-        Assert.Equal(zaak, acl.CancelledZaakUrl);
-    }
-
-    [Fact]
-    public async Task An_already_verlopen_registration_is_not_persisted_again_and_the_zaak_is_not_recancelled()
-    {
-        // A redelivered job (§8.6) finds the aggregate already VERLOPEN: a no-op, not saved again — and
-        // the ACL is not asked to cancel the zaak a second time (posting a second resultaat would 400).
-        var store = new FakeRegistrationStore();
-        var registration = Submitted();
-        registration.Expire();
-        store.Seed(registration);
-        var acl = new FakeAclClient();
-
-        await new ExpireRegistrationWorker(store, acl).HandleAsync(
-            new RegistratieVerlopenJob("job-7", registration.Id));
-
-        Assert.Equal(0, store.SaveCount);
-        Assert.Equal(0, acl.CancelCallCount);
-        Assert.Equal(RegistrationStatus.Verlopen, (await store.GetAsync(registration.Id))!.Status);
-    }
-
-    [Fact]
-    public async Task An_already_resolved_registration_is_left_alone_and_the_zaak_is_not_cancelled()
-    {
-        // Race with S-11: the citizen withdrew while parked at WachtOpDocumenten, so the aggregate is
-        // already terminal (INGETROKKEN) when the timer's job arrives. Expiring it would violate the
-        // aggregate's invariant; the worker must instead no-op (and let the job complete), not throw
-        // into a redelivery loop — and it must not cancel the zaak of a registration it didn't expire.
-        var store = new FakeRegistrationStore();
-        var registration = Submitted();
-        registration.Withdraw();
-        store.Seed(registration);
-        var acl = new FakeAclClient();
-
-        await new ExpireRegistrationWorker(store, acl).HandleAsync(
-            new RegistratieVerlopenJob("job-7", registration.Id));
-
-        Assert.Equal(0, store.SaveCount);
-        Assert.Equal(0, acl.CancelCallCount);
-        Assert.Equal(RegistrationStatus.Ingetrokken, (await store.GetAsync(registration.Id))!.Status);
-    }
-
-    [Fact]
-    public async Task An_unknown_registration_throws_so_the_job_is_redelivered()
-    {
-        var store = new FakeRegistrationStore();
-
-        await Assert.ThrowsAsync<InvalidOperationException>(() =>
-            new ExpireRegistrationWorker(store, new FakeAclClient()).HandleAsync(
-                new RegistratieVerlopenJob("job-7", RegistrationId.New())));
-    }
-
-    [Fact]
-    public async Task Rejects_a_null_job()
-        => await Assert.ThrowsAsync<ArgumentNullException>(() =>
-            new ExpireRegistrationWorker(new FakeRegistrationStore(), new FakeAclClient()).HandleAsync(null!));
-}

services/domain/Big.Tests/Fakes.cs

@@ -34,7 +34,6 @@ internal sealed class FakeWorkflowClient(string processInstanceId = "proc-1", Ac
     public RegistrationId? StartedFor { get; private set; }
     public DiplomaOrigin? StartedWithOrigin { get; private set; }
     public string? WithdrawnProcessInstanceId { get; private set; }
-    public string? CompletedDocumentWaitFor { get; private set; }
 
     public Task<string> StartRegistrationProcessAsync(
         RegistrationId registrationId, DiplomaOrigin diplomaOrigin, CancellationToken ct = default)
@@ -50,12 +49,6 @@ internal sealed class FakeWorkflowClient(string processInstanceId = "proc-1", Ac
         WithdrawnProcessInstanceId = processInstanceId;
         return Task.CompletedTask;
     }
-
-    public Task CompleteDocumentWaitAsync(string processInstanceId, CancellationToken ct = default)
-    {
-        CompletedDocumentWaitFor = processInstanceId;
-        return Task.CompletedTask;
-    }
 }
 
 /// <summary>A fake user-task client for the werkbak/decision use cases: returns a scripted set of
@@ -110,23 +103,4 @@ internal sealed class FakeAclClient(Uri? zaakUrl = null) : IAclClient
         ApprovedZaakUrl = zaakUrl;
         return Task.CompletedTask;
     }
-
-    public (Uri ZaakUrl, byte[] Content, string FileName, string ContentType)? StoredDiploma { get; private set; }
-    public static readonly Uri DefaultDocumentUrl = new("http://openzaak/documenten/api/v1/enkelvoudiginformatieobjecten/doc");
-
-    public Task<Uri> StoreDiplomaAsync(Uri zaakUrl, byte[] content, string fileName, string contentType, CancellationToken ct = default)
-    {
-        StoredDiploma = (zaakUrl, content, fileName, contentType);
-        return Task.FromResult(DefaultDocumentUrl);
-    }
-
-    public Uri? CancelledZaakUrl { get; private set; }
-    public int CancelCallCount { get; private set; }
-
-    public Task CancelZaakAsync(Uri zaakUrl, CancellationToken ct = default)
-    {
-        CancelCallCount++;
-        CancelledZaakUrl = zaakUrl;
-        return Task.CompletedTask;
-    }
 }

services/domain/Big.Tests/FlowableWorkflowClientTests.cs

@@ -426,106 +426,4 @@ public class FlowableWorkflowClientTests
             capture.Seen.RequestUri!.ToString());
         Assert.Contains("\"workerId\":\"worker-x\"", capture.Body);
     }
-
-    // ── S-10a (#102): document-wait timeout → RegistratieVerlopen (ADR-0017) ──────────────────────
-    // A 30-day interrupting boundary timer on WachtOpDocumenten spawns a RegistratieVerlopen
-    // external-worker job carrying the registration id; the worker expires the registration and
-    // completes the job. Separately, "documents received" completes the WachtOpDocumenten user task.
-
-    [Fact]
-    public async Task Acquire_verlopen_jobs_posts_the_topic_and_parses_jobs_with_their_registration_id()
-    {
-        var rid = RegistrationId.New();
-        var capture = new RequestCapture();
-        var client = Client(capture.Responds(HttpStatusCode.OK,
-            $$"""[{"id":"job-9","variables":[{"name":"registrationId","type":"string","value":"{{rid}}"}]}]"""));
-
-        var jobs = await client.AcquireRegistratieVerlopenJobsAsync(3);
-
-        var job = Assert.Single(jobs);
-        Assert.Equal("job-9", job.JobId);
-        Assert.Equal(rid, job.RegistrationId);
-        Assert.Equal("http://flowable/flowable-rest/external-job-api/acquire/jobs",
-            capture.Seen!.RequestUri!.ToString());
-        Assert.Contains("\"topic\":\"RegistratieVerlopen\"", capture.Body);
-        Assert.Contains("\"numberOfTasks\":3", capture.Body);
-        Assert.Contains("\"workerId\":\"worker-x\"", capture.Body);
-    }
-
-    [Theory]
-    [InlineData("[]")]
-    [InlineData("null")]
-    public async Task Acquire_verlopen_jobs_returns_empty_when_none_are_parked(string body)
-    {
-        var capture = new RequestCapture();
-        var client = Client(capture.Responds(HttpStatusCode.OK, body));
-
-        Assert.Empty(await client.AcquireRegistratieVerlopenJobsAsync(1));
-        Assert.NotNull(capture.Seen);
-    }
-
-    [Fact]
-    public async Task Complete_verlopen_job_posts_to_the_job_complete_endpoint()
-    {
-        var capture = new RequestCapture();
-        var client = Client(capture.Responds(HttpStatusCode.NoContent));
-
-        await client.CompleteRegistratieVerlopenJobAsync("job-9");
-
-        Assert.Equal(HttpMethod.Post, capture.Seen!.Method);
-        Assert.Equal("http://flowable/flowable-rest/external-job-api/acquire/jobs/job-9/complete",
-            capture.Seen.RequestUri!.ToString());
-        Assert.Contains("\"workerId\":\"worker-x\"", capture.Body);
-    }
-
-    [Fact]
-    public async Task Provide_documents_completes_the_wacht_op_documenten_task_in_the_instance()
-    {
-        var requests = new List<(HttpMethod Method, string Url, string? Body)>();
-        var client = Client(new StubHandler(async req =>
-        {
-            requests.Add((req.Method, req.RequestUri!.ToString(),
-                req.Content is null ? null : await req.Content.ReadAsStringAsync()));
-            return req.RequestUri!.AbsoluteUri.EndsWith("service/query/tasks")
-                ? new HttpResponseMessage(HttpStatusCode.OK)
-                {
-                    Content = new StringContent("""{"data":[{"id":"task-3"}],"total":1}""",
-                        Encoding.UTF8, "application/json"),
-                }
-                : new HttpResponseMessage(HttpStatusCode.OK);
-        }));
-
-        await client.CompleteDocumentWaitAsync("pi-1");
-
-        // 1. Find the still-open WachtOpDocumenten task in this process instance.
-        var query = requests.Single(r => r.Url.EndsWith("service/query/tasks"));
-        Assert.Equal(HttpMethod.Post, query.Method);
-        Assert.Contains("\"processInstanceId\":\"pi-1\"", query.Body);
-        Assert.Contains("\"taskDefinitionKey\":\"WachtOpDocumenten\"", query.Body);
-        // 2. Complete that task so the process leaves the wait state.
-        var complete = requests.Single(r => r.Url.EndsWith("service/runtime/tasks/task-3"));
-        Assert.Equal(HttpMethod.Post, complete.Method);
-        Assert.Contains("\"action\":\"complete\"", complete.Body);
-    }
-
-    [Fact]
-    public async Task Provide_documents_is_a_no_op_when_the_wait_task_is_no_longer_open()
-    {
-        // The process already left WachtOpDocumenten (e.g. timed out): nothing to complete, no throw.
-        var methods = new List<HttpMethod>();
-        var client = Client(new StubHandler(req =>
-        {
-            methods.Add(req.Method);
-            return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
-            {
-                Content = new StringContent("""{"data":[],"total":0}""", Encoding.UTF8, "application/json"),
-            });
-        }));
-
-        await client.CompleteDocumentWaitAsync("pi-1");
-
-        // Only the query ran; no task-completion POST followed.
-        Assert.DoesNotContain(methods, m => m == HttpMethod.Put || m == HttpMethod.Delete);
-        Assert.Single(methods);
-    }
 }

services/domain/Big.Tests/ProvideDocumentsTests.cs

@@ -1,96 +0,0 @@
-using Big.Application;
-using Big.Domain;
-
-namespace Big.Tests;
-
-// S-10a/S-10b (#102/#103): the "documents received" use case. A zorgprofessional supplies the diploma
-// their registration is waiting for; the handler stores it in ZGW via the ACL and completes the
-// WachtOpDocumenten task via the Workflow Client so the process continues to beoordeling. Owner-scoped
-// by the caller's bsn, like WithdrawRegistration.
-public class ProvideDocumentsTests
-{
-    private const string Bsn = "123456782";
-    private static readonly Uri Zaak = new("http://openzaak/zaken/api/v1/zaken/abc");
-
-    private static Registration Submitted(string processInstanceId = "proc-1")
-    {
-        var registration = Registration.Submit(Bsn);
-        registration.RecordProcessStarted(processInstanceId);
-        registration.AttachZaak(Zaak);
-        return registration;
-    }
-
-    private static ProvideDocumentsCommand Command(RegistrationId id, string bsn = Bsn) =>
-        new(id, bsn, [1, 2, 3], "diploma.pdf", "application/pdf");
-
-    [Fact]
-    public async Task Providing_documents_stores_the_diploma_and_completes_the_wait()
-    {
-        var store = new FakeRegistrationStore();
-        var registration = Submitted("proc-42");
-        store.Seed(registration);
-        var workflow = new FakeWorkflowClient();
-        var acl = new FakeAclClient();
-        var handler = new ProvideDocuments(store, workflow, acl);
-
-        var outcome = await handler.HandleAsync(Command(registration.Id));
-
-        Assert.Equal(ProvideDocumentsOutcome.Accepted, outcome);
-        // Stored against the registration's zaak, carrying the uploaded bytes + file metadata.
-        Assert.Equal((Zaak, new byte[] { 1, 2, 3 }, "diploma.pdf", "application/pdf"), acl.StoredDiploma);
-        // …and the wait is completed so beoordeling can proceed.
-        Assert.Equal("proc-42", workflow.CompletedDocumentWaitFor);
-    }
-
-    [Fact]
-    public async Task A_different_bsn_cannot_provide_documents()
-    {
-        // Owner-scoping: another bsn is told NotFound; nothing is stored or completed.
-        var store = new FakeRegistrationStore();
-        var registration = Submitted();
-        store.Seed(registration);
-        var workflow = new FakeWorkflowClient();
-        var acl = new FakeAclClient();
-        var handler = new ProvideDocuments(store, workflow, acl);
-
-        var outcome = await handler.HandleAsync(Command(registration.Id, bsn: "999999990"));
-
-        Assert.Equal(ProvideDocumentsOutcome.NotFound, outcome);
-        Assert.Null(acl.StoredDiploma);
-        Assert.Null(workflow.CompletedDocumentWaitFor);
-    }
-
-    [Fact]
-    public async Task Providing_for_an_unknown_registration_is_not_found()
-    {
-        var store = new FakeRegistrationStore();
-        var handler = new ProvideDocuments(store, new FakeWorkflowClient(), new FakeAclClient());
-
-        Assert.Equal(ProvideDocumentsOutcome.NotFound, await handler.HandleAsync(Command(RegistrationId.New())));
-    }
-
-    [Fact]
-    public async Task Providing_before_a_zaak_is_opened_does_not_store_but_still_completes_the_wait()
-    {
-        // No zaak yet → nothing to file the document against, but the request still stands (best-effort,
-        // mirroring WithdrawRegistration). The wait is completed if a process is running.
-        var store = new FakeRegistrationStore();
-        var registration = Registration.Submit(Bsn);
-        registration.RecordProcessStarted("proc-9"); // process started, but no zaak attached
-        store.Seed(registration);
-        var workflow = new FakeWorkflowClient();
-        var acl = new FakeAclClient();
-        var handler = new ProvideDocuments(store, workflow, acl);
-
-        var outcome = await handler.HandleAsync(Command(registration.Id));
-
-        Assert.Equal(ProvideDocumentsOutcome.Accepted, outcome);
-        Assert.Null(acl.StoredDiploma);
-        Assert.Equal("proc-9", workflow.CompletedDocumentWaitFor);
-    }
-
-    [Fact]
-    public async Task Rejects_a_null_command()
-        => await Assert.ThrowsAsync<ArgumentNullException>(() =>
-            new ProvideDocuments(new FakeRegistrationStore(), new FakeWorkflowClient(), new FakeAclClient()).HandleAsync(null!));
-}

services/domain/Big.Tests/RegistratieVerlopenProcessorTests.cs

@@ -1,79 +0,0 @@
-using Big.Application;
-using Big.Infrastructure;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Logging.Abstractions;
-
-namespace Big.Tests;
-
-// S-10a (#102): the document-timeout drain loop. Mirrors BeoordelingEscalatieProcessor — acquire the
-// parked RegistratieVerlopen jobs (the tokens the 30-day boundary timer on WachtOpDocumenten spawns),
-// expire each correlated registration via the ExpireRegistrationWorker, then complete the job. A job
-// whose expiry fails is logged and left un-completed for Flowable to redeliver (§8.6).
-public class RegistratieVerlopenProcessorTests
-{
-    /// <summary>A fake client scripting the jobs to acquire and recording completions.</summary>
-    private sealed class FakeVerlopenClient(params RegistratieVerlopenJob[] jobs) : IRegistratieVerlopenClient
-    {
-        public int AcquireCount { get; private set; }
-        public List<string> Completed { get; } = [];
-
-        public Task<IReadOnlyList<RegistratieVerlopenJob>> AcquireRegistratieVerlopenJobsAsync(int maxJobs, CancellationToken ct = default)
-        {
-            AcquireCount++;
-            return Task.FromResult<IReadOnlyList<RegistratieVerlopenJob>>(jobs.Take(maxJobs).ToList());
-        }
-
-        public Task CompleteRegistratieVerlopenJobAsync(string jobId, CancellationToken ct = default)
-        {
-            Completed.Add(jobId);
-            return Task.CompletedTask;
-        }
-    }
-
-    private static ExpireRegistrationWorker Worker(FakeRegistrationStore store) => new(store, new FakeAclClient());
-
-    [Fact]
-    public async Task Acquires_a_job_expires_the_registration_and_completes_the_job()
-    {
-        var store = new FakeRegistrationStore();
-        var registration = Domain.Registration.Submit("123456782");
-        store.Seed(registration);
-        var client = new FakeVerlopenClient(new RegistratieVerlopenJob("job-9", registration.Id));
-
-        var acquired = await new RegistratieVerlopenProcessor(
-            client, Worker(store), NullLogger<RegistratieVerlopenProcessor>.Instance).PumpOnceAsync(5);
-
-        Assert.Equal(1, acquired);
-        Assert.Equal(Domain.RegistrationStatus.Verlopen, (await store.GetAsync(registration.Id))!.Status);
-        Assert.Equal("job-9", Assert.Single(client.Completed));
-    }
-
-    [Fact]
-    public async Task A_failing_expiry_is_left_uncompleted_for_flowable_to_redeliver()
-    {
-        // Unknown registration → the worker throws → the job is left for redelivery, error logged.
-        var store = new FakeRegistrationStore();
-        var client = new FakeVerlopenClient(new RegistratieVerlopenJob("job-9", Domain.RegistrationId.New()));
-        var logger = new CapturingLogger<RegistratieVerlopenProcessor>();
-
-        var acquired = await new RegistratieVerlopenProcessor(client, Worker(store), logger).PumpOnceAsync(5);
-
-        Assert.Equal(1, acquired);
-        Assert.Empty(client.Completed);
-        var error = Assert.Single(logger.Entries, e => e.Level == LogLevel.Error);
-        Assert.Contains("job-9", error.Message);
-    }
-
-    [Fact]
-    public async Task Does_nothing_but_poll_when_there_are_no_jobs()
-    {
-        var client = new FakeVerlopenClient();
-
-        var acquired = await new RegistratieVerlopenProcessor(
-            client, Worker(new FakeRegistrationStore()), NullLogger<RegistratieVerlopenProcessor>.Instance).PumpOnceAsync(5);
-
-        Assert.Equal(0, acquired);
-        Assert.Equal(1, client.AcquireCount);
-        Assert.Empty(client.Completed);
-    }
-}

services/domain/Big.Tests/RegistrationTests.cs

@@ -294,63 +294,4 @@ public class RegistrationTests
         Assert.Contains("only an INGEDIEND", ex.Message);
         Assert.Equal(RegistrationStatus.Afgewezen, registration.Status);
     }
-
-    [Fact]
-    public void Expiring_an_ingediend_registration_sets_it_verlopen()
-    {
-        // The 30-day document-wait timer fired before the documents arrived (S-10a): the case is
-        // cancelled and the aggregate becomes terminal VERLOPEN.
-        var registration = Registration.Submit("123456782");
-
-        registration.Expire();
-
-        Assert.Equal(RegistrationStatus.Verlopen, registration.Status);
-    }
-
-    [Fact]
-    public void Expiring_needs_no_zaak()
-    {
-        // The timer fires on a purely time-based boundary; expiry does not depend on the zaak.
-        var registration = Registration.Submit("123456782");
-
-        registration.Expire();
-
-        Assert.Equal(RegistrationStatus.Verlopen, registration.Status);
-        Assert.Null(registration.ZaakUrl);
-    }
-
-    [Fact]
-    public void Re_expiring_an_already_verlopen_registration_is_idempotent()
-    {
-        // The RegistratieVerlopen worker job may be redelivered (§8.6); re-expiring is a no-op.
-        var registration = Registration.Submit("123456782");
-        registration.Expire();
-
-        registration.Expire();
-
-        Assert.Equal(RegistrationStatus.Verlopen, registration.Status);
-    }
-
-    [Fact]
-    public void Expiring_an_approved_registration_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.Expire());
-        Assert.Contains("only an INGEDIEND", ex.Message);
-        Assert.Equal(RegistrationStatus.Ingeschreven, registration.Status);
-    }
-
-    [Fact]
-    public void Expiring_a_withdrawn_registration_is_rejected()
-    {
-        var registration = Registration.Submit("123456782");
-        registration.Withdraw();
-
-        var ex = Assert.Throws<InvalidOperationException>(() => registration.Expire());
-        Assert.Contains("only an INGEDIEND", ex.Message);
-        Assert.Equal(RegistrationStatus.Ingetrokken, registration.Status);
-    }
 }

services/domain/stryker-config.json

@@ -5,8 +5,7 @@
     "reporters": ["progress", "html"],
     "mutate": [
       "!**/OpenZaakJobPump.cs",
-      "!**/BeoordelingEscalatiePump.cs",
-      "!**/RegistratieVerlopenPump.cs"
+      "!**/BeoordelingEscalatiePump.cs"
     ],
     "thresholds": {
       "high": 95,

tests/acceptance/Features/EenDocumentTermijnVerlopen.feature

@@ -1,25 +0,0 @@
-# language: en
-# Drives S-10a (#102). After the zaak is opened the process parks at WachtOpDocumenten with an
-# INTERRUPTING 30-day boundary timer. If the documents do not arrive in time the timer cancels the
-# task and parks a RegistratieVerlopen job (ADR-0017) which the timeout worker drains, expiring the
-# registration to VERLOPEN. Documents received before the timer fires close the wait, so no expiry
-# happens. This scenario exercises the timeout worker against an in-memory Flowable stand-in; the timer
-# firing live is verify-domain.
-Feature: Een documenttermijn laten verlopen
-  Als registerbeheerder wil ik dat een aanvraag waarvoor de documenten niet binnen 30 dagen binnen zijn
-  automatisch vervalt zodat onvolledige aanvragen niet blijven liggen.
-
-  Scenario: Zonder documenten binnen 30 dagen vervalt de registratie
-    Given a registration parked at the WachtOpDocumenten task
-    When the 30-day document timer fires
-    And the document-timeout worker runs
-    Then the registration is verlopen
-    And the zaak is cancelled in ZGW
-
-  Scenario: Tijdig aangeleverde documenten laten de registratie niet vervallen
-    Given a registration parked at the WachtOpDocumenten task
-    When the documents arrive before the timer fires
-    And the 30-day document timer fires
-    And the document-timeout worker runs
-    Then the registration is not verlopen
-    And the zaak is not cancelled in ZGW

tests/acceptance/Steps/EenDocumentTermijnVerlopenSteps.cs

@@ -1,64 +0,0 @@
-using Acceptance.Support;
-using Big.Application;
-using Big.Domain;
-using Big.Infrastructure;
-using Microsoft.Extensions.Logging.Abstractions;
-using Reqnroll;
-using Xunit;
-
-namespace Acceptance.Steps;
-
-/// <summary>Bindings for <c>EenDocumentTermijnVerlopen.feature</c> (S-10a). Drives the timeout worker
-/// (<see cref="RegistratieVerlopenProcessor"/> over the <see cref="ExpireRegistrationWorker"/>) against
-/// an in-memory Flowable stand-in and a shared registration store; one instance per scenario. The
-/// interrupting 30-day timer either cancels the wait and expires the registration, or — if the
-/// documents arrived first — never fires; the scenario asserts on the aggregate's status.</summary>
-[Binding]
-[Scope(Feature = "Een documenttermijn laten verlopen")]
-public sealed class EenDocumentTermijnVerlopenSteps
-{
-    private static readonly Uri ZaakUrl = new("http://openzaak/zaken/api/v1/zaken/acc-timeout");
-
-    private readonly InMemoryDocumentTimeoutClient _flowable = new();
-    private readonly Support.InMemoryRegistrationStore _store = new();
-    private readonly InMemoryAclClient _acl = new();
-    private Registration _registration = null!;
-    private string _processInstanceId = "";
-
-    [Given("a registration parked at the WachtOpDocumenten task")]
-    public async Task GivenARegistrationParkedAtWachtOpDocumenten()
-    {
-        _registration = Registration.Submit("123456782");
-        // By the time it parks at WachtOpDocumenten its zaak has been opened (OpenZaakAanmaken runs
-        // earlier), so a timeout has a zaak to cancel.
-        _registration.AttachZaak(ZaakUrl);
-        await _store.SaveAsync(_registration);
-        _processInstanceId = _flowable.ParkWaitingForDocuments(_registration.Id);
-    }
-
-    [When("the 30-day document timer fires")]
-    public void WhenTheDocumentTimerFires() => _flowable.FireDocumentTimer(_processInstanceId);
-
-    [When("the documents arrive before the timer fires")]
-    public void WhenTheDocumentsArriveBeforeTheTimer() => _flowable.ReceiveDocuments(_processInstanceId);
-
-    [When("the document-timeout worker runs")]
-    public async Task WhenTheTimeoutWorkerRuns()
-        => await new RegistratieVerlopenProcessor(
-            _flowable, new ExpireRegistrationWorker(_store, _acl),
-            NullLogger<RegistratieVerlopenProcessor>.Instance).PumpOnceAsync(5);
-
-    [Then("the registration is verlopen")]
-    public async Task ThenTheRegistrationIsVerlopen()
-        => Assert.Equal(RegistrationStatus.Verlopen, (await _store.GetAsync(_registration.Id))!.Status);
-
-    [Then("the registration is not verlopen")]
-    public async Task ThenTheRegistrationIsNotVerlopen()
-        => Assert.Equal(RegistrationStatus.Ingediend, (await _store.GetAsync(_registration.Id))!.Status);
-
-    [Then("the zaak is cancelled in ZGW")]
-    public void ThenTheZaakIsCancelled() => Assert.Equal(ZaakUrl, _acl.CancelledZaakUrl);
-
-    [Then("the zaak is not cancelled in ZGW")]
-    public void ThenTheZaakIsNotCancelled() => Assert.Null(_acl.CancelledZaakUrl);
-}

tests/acceptance/Steps/EenZaakOpenenSteps.cs

@@ -30,7 +30,6 @@ public sealed class EenZaakOpenenSteps
             VerantwoordelijkeOrganisatie = values["verantwoordelijkeOrganisatie"],
             Vertrouwelijkheidaanduiding = values["vertrouwelijkheidaanduiding"],
             ZaaktypeUrl = new Uri(values["zaaktype"]),
-            InformatieobjecttypeUrl = new Uri("http://openzaak/catalogi/api/v1/informatieobjecttypen/dip"),
         };
     }
 

tests/acceptance/Support/BffAcceptanceHost.cs

@@ -72,10 +72,6 @@ public sealed class CapturingDomainClient : IDomainClient
     public Task<bool> WithdrawRegistrationAsync(string registrationId, string bsn, CancellationToken ct = default)
         => Task.FromResult(true);
 
-    public Task<bool> ProvideDocumentsAsync(
-        string registrationId, string bsn, string contentBase64, string? fileName, string? contentType, CancellationToken ct = default)
-        => Task.FromResult(true);
-
     public Task<IReadOnlyList<WerkbakItem>> GetWerkbakAsync(CancellationToken ct = default)
         => Task.FromResult<IReadOnlyList<WerkbakItem>>([]);
 

tests/acceptance/Support/InMemoryDomainPorts.cs

@@ -14,7 +14,6 @@ public sealed class InMemoryWorkflowClient : IWorkflowClient
     public RegistrationId? StartedFor { get; private set; }
     public DiplomaOrigin? StartedWithOrigin { get; private set; }
     public string? WithdrawnProcessInstanceId { get; private set; }
-    public string? CompletedDocumentWaitFor { get; private set; }
 
     public Task<string> StartRegistrationProcessAsync(
         RegistrationId registrationId, DiplomaOrigin diplomaOrigin, CancellationToken ct = default)
@@ -29,12 +28,6 @@ public sealed class InMemoryWorkflowClient : IWorkflowClient
         WithdrawnProcessInstanceId = processInstanceId;
         return Task.CompletedTask;
     }
-
-    public Task CompleteDocumentWaitAsync(string processInstanceId, CancellationToken ct = default)
-    {
-        CompletedDocumentWaitFor = processInstanceId;
-        return Task.CompletedTask;
-    }
 }
 
 /// <summary>An in-memory ACL stand-in: records the bsn it opened a zaak for and returns a fixed URL,
@@ -59,22 +52,6 @@ public sealed class InMemoryAclClient : IAclClient
         ApprovedZaakUrl = zaakUrl;
         return Task.CompletedTask;
     }
-
-    public Uri? CancelledZaakUrl { get; private set; }
-
-    public Task CancelZaakAsync(Uri zaakUrl, CancellationToken ct = default)
-    {
-        CancelledZaakUrl = zaakUrl;
-        return Task.CompletedTask;
-    }
-
-    public (Uri ZaakUrl, string FileName)? StoredDiploma { get; private set; }
-
-    public Task<Uri> StoreDiplomaAsync(Uri zaakUrl, byte[] content, string fileName, string contentType, CancellationToken ct = default)
-    {
-        StoredDiploma = (zaakUrl, fileName);
-        return Task.FromResult(new Uri("http://openzaak/documenten/api/v1/enkelvoudiginformatieobjecten/acc-doc"));
-    }
 }
 
 /// <summary>An in-memory user-task client for the beoordeling acceptance scenario: it holds one open
@@ -153,57 +130,6 @@ public sealed class InMemoryEscalatieClient : IBeoordelingEscalatieClient
     }
 }
 
-/// <summary>An in-memory Flowable stand-in for the document-timeout scenario (S-10a): it models one
-/// WachtOpDocumenten wait per process instance — whether it is still open and the registration it
-/// correlates to — and the RegistratieVerlopen jobs the interrupting 30-day boundary timer parks. It
-/// drives the timeout worker's behaviour without a running Flowable; the timer firing live is the
-/// verify-domain check.</summary>
-public sealed class InMemoryDocumentTimeoutClient : IRegistratieVerlopenClient
-{
-    private sealed class Wait
-    {
-        public required RegistrationId RegistrationId { get; init; }
-        public bool IsWaiting { get; set; } = true;
-    }
-
-    private readonly Dictionary<string, Wait> _waits = [];
-    private readonly List<RegistratieVerlopenJob> _parked = [];
-    private int _seq;
-
-    /// <summary>A registration parks at WachtOpDocumenten, waiting for the citizen's documents.</summary>
-    public string ParkWaitingForDocuments(RegistrationId registrationId)
-    {
-        var pid = $"pi-{++_seq}";
-        _waits[pid] = new Wait { RegistrationId = registrationId };
-        return pid;
-    }
-
-    /// <summary>The documents arrive before the timer fires: the wait task closes, so the interrupting
-    /// timer no longer fires (mirrors the Workflow Client completing WachtOpDocumenten).</summary>
-    public void ReceiveDocuments(string processInstanceId) => _waits[processInstanceId].IsWaiting = false;
-
-    /// <summary>The 30-day interrupting boundary timer fires: if still waiting, it cancels the wait and
-    /// parks a RegistratieVerlopen job carrying the correlated registration id. A no-op if the documents
-    /// already arrived (the wait/timer race, §8.6).</summary>
-    public void FireDocumentTimer(string processInstanceId)
-    {
-        var wait = _waits[processInstanceId];
-        if (!wait.IsWaiting)
-            return;
-        wait.IsWaiting = false;
-        _parked.Add(new RegistratieVerlopenJob($"job-{++_seq}", wait.RegistrationId));
-    }
-
-    public Task<IReadOnlyList<RegistratieVerlopenJob>> AcquireRegistratieVerlopenJobsAsync(int maxJobs, CancellationToken ct = default)
-        => Task.FromResult<IReadOnlyList<RegistratieVerlopenJob>>(_parked.Take(maxJobs).ToList());
-
-    public Task CompleteRegistratieVerlopenJobAsync(string jobId, CancellationToken ct = default)
-    {
-        _parked.RemoveAll(j => j.JobId == jobId);
-        return Task.CompletedTask;
-    }
-}
-
 /// <summary>An in-memory registration store for the domain acceptance scenario.</summary>
 public sealed class InMemoryRegistrationStore : IRegistrationStore
 {

tests/acceptance/Support/InMemoryZaakGateway.cs

@@ -12,7 +12,6 @@ public sealed class InMemoryZaakGateway : IZaakGateway
 
     public ZaakRequest? Captured { get; private set; }
     public (Uri Zaak, Uri Zaaktype, DateOnly Datum)? Approved { get; private set; }
-    public (Uri Zaak, Uri Zaaktype, DateOnly Datum)? Cancelled { get; private set; }
 
     public Task<Uri> OpenZaakAsync(ZaakRequest request, CancellationToken ct = default)
     {
@@ -26,15 +25,6 @@ public sealed class InMemoryZaakGateway : IZaakGateway
         return Task.CompletedTask;
     }
 
-    public Task SetZaakToCancellationStatusAsync(Uri zaakUrl, Uri zaaktypeUrl, DateOnly datumStatusGezet, CancellationToken ct = default)
-    {
-        Cancelled = (zaakUrl, zaaktypeUrl, datumStatusGezet);
-        return Task.CompletedTask;
-    }
-
     public Task<string> GetZaakIdentificatieAsync(Uri zaakUrl, CancellationToken ct = default)
         => Task.FromResult("ACC-REF-1");
-
-    public Task<Uri> StoreDocumentAsync(DocumentRequest request, CancellationToken ct = default)
-        => Task.FromResult(new Uri("http://openzaak/documenten/api/v1/enkelvoudiginformatieobjecten/acc-doc"));
 }

tests/e2e/playwright.config.ts

@@ -12,12 +12,6 @@ export default defineConfig({
   timeout: 90_000,
   expect: { timeout: 15_000 },
   retries: 1,
-  // Run the specs serially. Each spec drives a full `channel: 'chromium'` browser, and the e2e
-  // shares an 8 GB runner with the entire compose stack (OpenZaak, NRC, Keycloak, Flowable, 4×
-  // Postgres, every service + 3 portals). Two parallel browsers exhaust memory and the renderer is
-  // OOM-killed mid-action ("Page crashed") — fixing the flakiness at its source rather than leaning
-  // on `retries` (CLAUDE.md §15). Only two long-running happy-path specs, so serial costs little.
-  workers: 1,
   reporter: [['list']],
   use: {
     baseURL,
@@ -32,13 +26,7 @@ export default defineConfig({
     // headless), not Playwright's default headless-shell, so pin `channel: 'chromium'`.
     channel: 'chromium',
     launchOptions: {
-      args: [
-        `--unsafely-treat-insecure-origin-as-secure=${baseURL},${behandelURL}`,
-        // Write Chromium's shared memory to /tmp instead of the container's small /dev/shm, so a
-        // large DOM/heap can't crash the renderer on the memory-constrained runner (belt-and-braces
-        // alongside the single worker above).
-        '--disable-dev-shm-usage',
-      ],
+      args: [`--unsafely-treat-insecure-origin-as-secure=${baseURL},${behandelURL}`],
     },
   },
   projects: [{ name: 'chromium', use: { ...devices['Desktop Chrome'] } }],

tests/e2e/registration.spec.ts

@@ -1,15 +1,11 @@
 import { expect, test } from '@playwright/test';
 
-// Walking-skeleton happy path (S-08d + S-09 + S-09b + S-12 + S-10a): a zorgprofessional logs in via
-// mock DigiD and submits through the self-service portal → BFF → domain; the entry appears in the
-// openbaar register as INGEDIEND; the citizen supplies the documents the process is waiting for
-// (S-10a); a behandelaar then logs in to the behandel portal, finds the registration in the werkbak,
-// and approves it (goedkeuren); the decision completes the Flowable Beoordelen task and flows via the
-// ACL → NRC → event-subscriber → projection, and the openbaar register shows INGESCHREVEN.
-test('DigiD submit → public INGEDIEND → documenten → behandelaar goedkeurt → public INGESCHREVEN', async ({
-  page,
-  context,
-}) => {
+// Walking-skeleton happy path (S-08d + S-09 + S-09b + S-12): a zorgprofessional logs in via mock
+// DigiD and submits through the self-service portal → BFF → domain; the entry appears in the openbaar
+// register as INGEDIEND; a behandelaar then logs in to the behandel portal, finds the registration in
+// the werkbak, and approves it (goedkeuren); the decision completes the Flowable Beoordelen task and
+// flows via the ACL → NRC → event-subscriber → projection, and the openbaar register shows INGESCHREVEN.
+test('DigiD submit → public INGEDIEND → behandelaar goedkeurt → public INGESCHREVEN', async ({ page }) => {
   // Visiting the guarded page redirects to the Keycloak (mock DigiD) login.
   await page.goto('/');
 
@@ -30,58 +26,42 @@ test('DigiD submit → public INGEDIEND → documenten → behandelaar goedkeurt
   expect(reference, 'the confirmation shows a registration reference').toBeTruthy();
 
   // The openbaar register (anonymous, its own origin) shows the submitted entry once the projection
-  // catches up. We check it on a SEPARATE page so the self-service tab keeps its (in-memory) submitted
-  // state — the "Documenten aanleveren" action below acts on that same session. The projection updates
-  // asynchronously (NRC → event-subscriber), so reload until *this* submission's row appears. We poll
-  // on the reference cell (not a 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.
-  const staff = await context.newPage();
-  await staff.goto('http://openbaar/');
-  await expect(staff.getByRole('heading', { name: /Openbaar BIG-register/i })).toBeVisible();
+  // 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
+  // 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 staff.reload();
-      return staff.getByRole('cell', { name: reference }).count();
+      await page.reload();
+      return page.getByRole('cell', { name: reference }).count();
     }, { timeout: 30_000, intervals: [1_000, 2_000, 3_000, 5_000] })
     .toBeGreaterThan(0);
-  await expect(staff.getByRole('row', { name: reference }).getByRole('cell', { name: 'INGEDIEND' }))
+  await expect(page.getByRole('row', { name: reference }).getByRole('cell', { name: 'INGEDIEND' }))
     .toBeVisible();
 
-  // Provide the documents the registration is waiting for (S-10a), on the still-open self-service tab.
-  // The process parks at WachtOpDocumenten only after the zaak is opened; the INGEDIEND row above proves
-  // the zaak exists — so the OpenZaak worker has completed and the process is now at the wait — which is
-  // why we supply the documents here rather than right after submit, when the trigger would race the
-  // wait and no-op. (S-10b turns this into a real file upload; here it is the trigger that unblocks
-  // beoordeling.)
-  await page.setInputFiles('#diploma', {
-    name: 'diploma.pdf',
-    mimeType: 'application/pdf',
-    buffer: Buffer.from('%PDF-1.4 synthetic diploma\n'),
-  });
-  await page.getByRole('button', { name: /documenten aanleveren/i }).click();
-  await expect(page.getByText(/documenten zijn aangeleverd/i)).toBeVisible();
+  // A behandelaar picks the registration up in the behandel-portal werkbak and approves it
+  // (goedkeuren) — the S-12 flow that replaces the temporary admin endpoint. Navigating here switches
+  // to the medewerker realm (a different Keycloak realm than the citizen's digid session).
+  await page.goto('http://behandel/');
+  await page.locator('#username').fill('merel-behandelaar');
+  await page.locator('#password').fill('test123');
+  await page.locator('#kc-login').click();
 
-  // A behandelaar picks the registration up in the behandel-portal werkbak and approves it (goedkeuren)
-  // — the S-12 flow that replaces the temporary admin endpoint. The staff tab switches to the
-  // medewerker realm (a different Keycloak realm than the citizen's digid session).
-  await staff.goto('http://behandel/');
-  await staff.locator('#username').fill('merel-behandelaar');
-  await staff.locator('#password').fill('test123');
-  await staff.locator('#kc-login').click();
+  await expect(page.getByRole('heading', { name: /Werkbak/i })).toBeVisible();
 
-  await expect(staff.getByRole('heading', { name: /Werkbak/i })).toBeVisible();
-
-  // The registration reaches the Beoordelen user task only after its documents are provided (above), so
+  // The registration parks at the Beoordelen user task only after the worker has opened its zaak, so
   // it appears in the werkbak asynchronously — reload until this reference's row shows up. Target the
   // decide button by reference (not a generic "Goedkeuren"): the shared verify stack holds other open
   // tasks, so a positional match could act on someone else's registration.
-  const goedkeuren = staff.getByRole('button', { name: `Goedkeuren ${reference}` });
+  const goedkeuren = page.getByRole('button', { name: `Goedkeuren ${reference}` });
   await expect
     .poll(async () => {
-      await staff.reload();
+      await page.reload();
       return goedkeuren.count();
     }, { timeout: 30_000, intervals: [1_000, 2_000, 3_000, 5_000] })
     .toBeGreaterThan(0);
@@ -89,7 +69,7 @@ test('DigiD submit → public INGEDIEND → documenten → behandelaar goedkeurt
   // Click and wait for the decide POST to finish (204) BEFORE leaving the page. `click()` only
   // dispatches the request; navigating away immediately cancels it in flight (nginx logs a 499) and
   // the decision never reaches the domain — so the registration would stay INGEDIEND.
-  const decided = staff.waitForResponse(
+  const decided = page.waitForResponse(
     (r) =>
       r.url().includes(`/behandel/registrations/${reference}/decide`) &&
       r.request().method() === 'POST',
@@ -99,11 +79,11 @@ test('DigiD submit → public INGEDIEND → documenten → behandelaar goedkeurt
 
   // The approval flows back to the projection; back on the openbaar register *our* row (matched by
   // its reference) now shows INGESCHREVEN.
-  await staff.goto('http://openbaar/');
+  await page.goto('http://openbaar/');
   await expect
     .poll(async () => {
-      await staff.reload();
-      return staff.getByRole('row', { name: reference }).getByRole('cell', { name: 'INGESCHREVEN' }).count();
+      await page.reload();
+      return page.getByRole('row', { name: reference }).getByRole('cell', { name: 'INGESCHREVEN' }).count();
     }, { timeout: 30_000, intervals: [1_000, 2_000, 3_000, 5_000] })
     .toBeGreaterThan(0);
 });

workflows/registratie.bpmn

@@ -22,16 +22,10 @@
        (BeoordelingEscaleren); the Workflow Client reassigns the still-open Beoordelen task from the
        behandelaar group to teamlead (ADR-0015). The Beoordelen task stays open throughout — the timer
        only changes who may claim it.
-       S-13 adds diploma-eligibility routing: between the document wait and Beoordelen a DMN service
+       S-13 adds diploma-eligibility routing: between OpenZaakAanmaken and Beoordelen a DMN service
        task (flowable:type="dmn") evaluates the `diploma-eligibility` decision on the diplomaOrigin
        start variable; an exclusive gateway routes a foreign diploma through the CBGV-advies user task
-       before Beoordelen, a domestic one straight there (ADR-0016).
-       S-10a adds the document wait: right after the zaak is opened the process parks at a
-       WachtOpDocumenten user task with an INTERRUPTING P30D boundary timer. "Documents received"
-       (the S-10b upload, via the Workflow Client) completes the task and the process continues to the
-       diploma routing; if the 30 days lapse first the timer cancels the task and runs the
-       RegistratieVerlopen external-worker task, whose worker expires the registration to VERLOPEN,
-       ending the process as "verlopen" (ADR-0017). -->
+       before Beoordelen, a domestic one straight there (ADR-0016). -->
   <message id="Message_Ingetrokken" name="RegistratieIngetrokken"/>
 
   <process id="registratie" name="Registratie ontvangen" isExecutable="true">
@@ -44,32 +38,7 @@
                  flowable:type="external-worker"
                  flowable:topic="OpenZaakAanmaken"/>
 
-    <sequenceFlow id="flow2" sourceRef="OpenZaakAanmaken" targetRef="WachtOpDocumenten"/>
-
-    <!-- S-10a: wait for the citizen's documents (diploma). The process parks here; "documents received"
-         (the S-10b upload path) completes the task via the Workflow Client. An INTERRUPTING P30D
-         boundary timer cancels the case if the documents never arrive (ADR-0017). -->
-    <userTask id="WachtOpDocumenten" name="Wacht op documenten"/>
-
-    <sequenceFlow id="flow2doc" sourceRef="WachtOpDocumenten" targetRef="DiplomaEligibiliteit"/>
-
-    <boundaryEvent id="DocumentenTimer" attachedToRef="WachtOpDocumenten" cancelActivity="true">
-      <timerEventDefinition>
-        <timeDuration>P30D</timeDuration>
-      </timerEventDefinition>
-    </boundaryEvent>
-
-    <sequenceFlow id="flow7" sourceRef="DocumentenTimer" targetRef="RegistratieVerlopen"/>
-
-    <!-- On timeout: an external-worker task the Workflow Client picks up to expire the registration to
-         VERLOPEN (S-10a). Its topic mirrors OpenZaakAanmaken/BeoordelingEscaleren. -->
-    <serviceTask id="RegistratieVerlopen" name="Registratie laten verlopen"
-                 flowable:type="external-worker"
-                 flowable:topic="RegistratieVerlopen"/>
-
-    <sequenceFlow id="flow8" sourceRef="RegistratieVerlopen" targetRef="endVerlopen"/>
-
-    <endEvent id="endVerlopen" name="Registratie verlopen"/>
+    <sequenceFlow id="flow2" sourceRef="OpenZaakAanmaken" targetRef="DiplomaEligibiliteit"/>
 
     <!-- S-13: evaluate the diploma-eligibility DMN inline (ADR-0016). A Flowable DMN service task
          (flowable:type="dmn" — NOT a businessRuleTask, whose default implementation is the legacy
@@ -145,47 +114,35 @@
       <bpmndi:BPMNShape id="s_task" bpmnElement="OpenZaakAanmaken">
         <omgdc:Bounds x="180" y="85" width="120" height="60"/>
       </bpmndi:BPMNShape>
-      <bpmndi:BPMNShape id="s_wacht" bpmnElement="WachtOpDocumenten">
-        <omgdc:Bounds x="340" y="85" width="120" height="60"/>
-      </bpmndi:BPMNShape>
-      <bpmndi:BPMNShape id="s_documentenTimer" bpmnElement="DocumentenTimer">
-        <omgdc:Bounds x="385" y="130" width="30" height="30"/>
-      </bpmndi:BPMNShape>
-      <bpmndi:BPMNShape id="s_verlopen" bpmnElement="RegistratieVerlopen">
-        <omgdc:Bounds x="340" y="220" width="120" height="60"/>
-      </bpmndi:BPMNShape>
-      <bpmndi:BPMNShape id="s_endVerlopen" bpmnElement="endVerlopen">
-        <omgdc:Bounds x="510" y="235" width="30" height="30"/>
-      </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="s_dmn" bpmnElement="DiplomaEligibiliteit">
-        <omgdc:Bounds x="510" y="85" width="120" height="60"/>
+        <omgdc:Bounds x="350" y="85" width="120" height="60"/>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="s_route" bpmnElement="RouteOpDiploma" isMarkerVisible="true">
-        <omgdc:Bounds x="680" y="90" width="40" height="40"/>
+        <omgdc:Bounds x="520" y="90" width="40" height="40"/>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="s_cbgv" bpmnElement="CBGVAdvies">
-        <omgdc:Bounds x="660" y="200" width="120" height="60"/>
+        <omgdc:Bounds x="500" y="200" width="120" height="60"/>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="s_beoordelen" bpmnElement="Beoordelen">
-        <omgdc:Bounds x="790" y="85" width="120" height="60"/>
+        <omgdc:Bounds x="630" y="85" width="120" height="60"/>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="s_end" bpmnElement="end">
-        <omgdc:Bounds x="970" y="100" width="30" height="30"/>
+        <omgdc:Bounds x="810" y="100" width="30" height="30"/>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="s_ingetrokken" bpmnElement="Ingetrokken">
-        <omgdc:Bounds x="850" y="135" width="30" height="30"/>
+        <omgdc:Bounds x="690" y="135" width="30" height="30"/>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="s_endIngetrokken" bpmnElement="endIngetrokken">
-        <omgdc:Bounds x="850" y="250" width="30" height="30"/>
+        <omgdc:Bounds x="690" y="250" width="30" height="30"/>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="s_escaleerTimer" bpmnElement="EscaleerTimer">
-        <omgdc:Bounds x="860" y="70" width="30" height="30"/>
+        <omgdc:Bounds x="700" y="70" width="30" height="30"/>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="s_escaleerBeoordeling" bpmnElement="EscaleerBeoordeling">
-        <omgdc:Bounds x="960" y="20" width="120" height="60"/>
+        <omgdc:Bounds x="800" y="20" width="120" height="60"/>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="s_endEscaleren" bpmnElement="endEscaleren">
-        <omgdc:Bounds x="1130" y="35" width="30" height="30"/>
+        <omgdc:Bounds x="970" y="35" width="30" height="30"/>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNEdge id="e_flow1" bpmnElement="flow1">
         <omgdi:waypoint x="130" y="115"/>
@@ -193,53 +150,41 @@
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="e_flow2" bpmnElement="flow2">
         <omgdi:waypoint x="300" y="115"/>
-        <omgdi:waypoint x="340" y="115"/>
-      </bpmndi:BPMNEdge>
-      <bpmndi:BPMNEdge id="e_flow2doc" bpmnElement="flow2doc">
-        <omgdi:waypoint x="460" y="115"/>
-        <omgdi:waypoint x="510" y="115"/>
-      </bpmndi:BPMNEdge>
-      <bpmndi:BPMNEdge id="e_flow7" bpmnElement="flow7">
-        <omgdi:waypoint x="400" y="160"/>
-        <omgdi:waypoint x="400" y="220"/>
-      </bpmndi:BPMNEdge>
-      <bpmndi:BPMNEdge id="e_flow8" bpmnElement="flow8">
-        <omgdi:waypoint x="460" y="250"/>
-        <omgdi:waypoint x="510" y="250"/>
+        <omgdi:waypoint x="350" y="115"/>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="e_flow2a" bpmnElement="flow2a">
-        <omgdi:waypoint x="630" y="115"/>
-        <omgdi:waypoint x="680" y="110"/>
+        <omgdi:waypoint x="470" y="115"/>
+        <omgdi:waypoint x="520" y="110"/>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="e_flowDirect" bpmnElement="flowDirect">
-        <omgdi:waypoint x="720" y="110"/>
-        <omgdi:waypoint x="790" y="115"/>
+        <omgdi:waypoint x="560" y="110"/>
+        <omgdi:waypoint x="630" y="115"/>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="e_flowCbgv" bpmnElement="flowCbgv">
-        <omgdi:waypoint x="700" y="130"/>
-        <omgdi:waypoint x="700" y="200"/>
+        <omgdi:waypoint x="540" y="130"/>
+        <omgdi:waypoint x="540" y="200"/>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="e_flowCbgvNaarBeoordelen" bpmnElement="flowCbgvNaarBeoordelen">
-        <omgdi:waypoint x="780" y="230"/>
-        <omgdi:waypoint x="820" y="230"/>
-        <omgdi:waypoint x="820" y="145"/>
+        <omgdi:waypoint x="620" y="230"/>
+        <omgdi:waypoint x="660" y="230"/>
+        <omgdi:waypoint x="660" y="145"/>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="e_flow3" bpmnElement="flow3">
-        <omgdi:waypoint x="910" y="115"/>
-        <omgdi:waypoint x="970" y="115"/>
+        <omgdi:waypoint x="750" y="115"/>
+        <omgdi:waypoint x="810" y="115"/>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="e_flow4" bpmnElement="flow4">
-        <omgdi:waypoint x="865" y="165"/>
-        <omgdi:waypoint x="865" y="250"/>
+        <omgdi:waypoint x="705" y="165"/>
+        <omgdi:waypoint x="705" y="250"/>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="e_flow5" bpmnElement="flow5">
-        <omgdi:waypoint x="875" y="70"/>
-        <omgdi:waypoint x="875" y="50"/>
-        <omgdi:waypoint x="960" y="50"/>
+        <omgdi:waypoint x="715" y="70"/>
+        <omgdi:waypoint x="715" y="50"/>
+        <omgdi:waypoint x="800" y="50"/>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="e_flow6" bpmnElement="flow6">
-        <omgdi:waypoint x="1080" y="50"/>
-        <omgdi:waypoint x="1130" y="50"/>
+        <omgdi:waypoint x="920" y="50"/>
+        <omgdi:waypoint x="970" y="50"/>
       </bpmndi:BPMNEdge>
     </bpmndi:BPMNPlane>
   </bpmndi:BPMNDiagram>