fix(acl): use camelCase indicatieGebruiksrecht so OpenZaak honours it (refs #103)

The ZGW Documenten API property is indicatieGebruiksrecht (camelCase); the
all-lowercase key was silently dropped on write (DRF camel-case mapping),
leaving the field null so the zaak still could not close. Correct the JSON
name on the DTO and both assertions to match the ZGW spec.

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

BACKLOG.md

@@ -199,9 +199,23 @@ _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)
 
-**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.
+Split (issue #11 closed) into two independently-demoable slices per §13 — the original spanned six net-new surfaces including a new ZGW boundary:
 
-**Acceptance:** BDD scenarios for both branches; integration tests for the timer firing.
+#### 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 cancellation status (not just the domain aggregate → `Verlopen`). Adds a cancellation statustype/resultaattype to the seed + an ACL method + expiry-worker wiring. Carved from S-10b (ADR-0017/0018). Depends on #103.
 
 ### S-11 · Withdrawal (Flow 3)
 

apps/behandel/Dockerfile

@@ -19,5 +19,9 @@ COPY --from=build /src/dist/apps/behandel/browser /usr/share/nginx/html
 # Compose-time OIDC config: the browser (Playwright, on the compose network) reaches Keycloak by
 # service name, so the token issuer matches the BFF's medewerker authority (host-consistent, ADR-0013).
 RUN printf '{ "authority": "http://keycloak:8080/realms/medewerker" }\n' > /usr/share/nginx/html/config.json
+# Make the reverse-proxy resolver engine-portable (Docker 127.0.0.11 vs podman aardvark); runs from
+# the nginx image's /docker-entrypoint.d before nginx starts.
+COPY apps/portal-nginx-resolver.sh /docker-entrypoint.d/40-resolver.sh
+RUN chmod +x /docker-entrypoint.d/40-resolver.sh
 
 EXPOSE 80

apps/openbaar/Dockerfile

@@ -17,5 +17,9 @@ FROM nginx:1.27-alpine AS runtime
 COPY apps/openbaar/nginx.conf /etc/nginx/conf.d/default.conf
 COPY --from=build /src/dist/apps/openbaar/browser /usr/share/nginx/html
 # No runtime config: the openbaar register is anonymous (no OIDC authority to inject).
+# Make the reverse-proxy resolver engine-portable (Docker 127.0.0.11 vs podman aardvark); runs from
+# the nginx image's /docker-entrypoint.d before nginx starts.
+COPY apps/portal-nginx-resolver.sh /docker-entrypoint.d/40-resolver.sh
+RUN chmod +x /docker-entrypoint.d/40-resolver.sh
 
 EXPOSE 80

apps/portal-nginx-resolver.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+# Point nginx's reverse-proxy `resolver` at THIS container's real DNS server.
+#
+# The portal nginx configs use a variable proxy_pass, which needs a `resolver` so the BFF hostname is
+# resolved at request time (nginx can start before the BFF is up). The config hardcodes Docker's
+# embedded DNS (127.0.0.11) — correct on Docker/Docker Desktop, but rootless podman uses a
+# network-specific address (aardvark, e.g. 10.89.0.1), so proxied calls 502 there. Read the actual
+# nameserver from /etc/resolv.conf and substitute it, so the reverse proxy works on any engine.
+#
+# Runs from the nginx image's /docker-entrypoint.d/ before nginx starts. On Docker the nameserver IS
+# 127.0.0.11, so the substitution is a no-op. Guarded (no `set -e`) so it's safe whether the nginx
+# entrypoint executes or sources it.
+ns="$(awk '/^nameserver/{print $2; exit}' /etc/resolv.conf 2>/dev/null)"
+if [ -n "$ns" ] && [ "$ns" != "127.0.0.11" ]; then
+  sed -i "s/resolver 127\.0\.0\.11/resolver $ns/" /etc/nginx/conf.d/default.conf 2>/dev/null || true
+  echo "portal-nginx-resolver: set resolver to $ns"
+fi

apps/self-service/Dockerfile

@@ -19,5 +19,9 @@ COPY --from=build /src/dist/apps/self-service/browser /usr/share/nginx/html
 # Compose-time OIDC config: the browser (Playwright, on the compose network) reaches Keycloak by
 # service name, so the token issuer matches the BFF's authority (host-consistent, ADR-0010).
 RUN printf '{ "authority": "http://keycloak:8080/realms/digid" }\n' > /usr/share/nginx/html/config.json
+# Make the reverse-proxy resolver engine-portable (Docker 127.0.0.11 vs podman aardvark); runs from
+# the nginx image's /docker-entrypoint.d before nginx starts.
+COPY apps/portal-nginx-resolver.sh /docker-entrypoint.d/40-resolver.sh
+RUN chmod +x /docker-entrypoint.d/40-resolver.sh
 
 EXPOSE 80

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

@@ -3,9 +3,56 @@
     <utrecht-heading-1>Zelfservice — BIG-registratie</utrecht-heading-1>
 
     @if (submitted()) {
-      <p utrecht-paragraph role="status">
-        Uw registratie is ontvangen. Referentie: {{ reference() }}.
-      </p>
+      @if (withdrawn()) {
+        <p utrecht-paragraph role="status">
+          Uw registratie met referentie {{ reference() }} is ingetrokken.
+        </p>
+      } @else {
+        <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.
+          </p>
+        }
+        <button
+          utrecht-button
+          appearance="secondary-action-button"
+          type="button"
+          [disabled]="withdrawing()"
+          (click)="withdraw()"
+        >
+          Trek aanvraag in
+        </button>
+      }
     } @else {
       <p utrecht-paragraph>U bent ingelogd met BSN {{ bsn() }}.</p>
       @if (failed()) {

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

@@ -17,12 +17,25 @@ class FakeAuth extends AuthService {
   }
 }
 
-function providers(post = vi.fn().mockReturnValue(of({ registrationId: 'reg-9', status: 'Ingediend' }))) {
+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 },
-      { provide: BffApiV1Service, useValue: { postSelfServiceRegistrations: post } },
+      {
+        provide: BffApiV1Service,
+        useValue: {
+          postSelfServiceRegistrations: post,
+          postSelfServiceRegistrationsIdWithdraw: withdraw,
+          postSelfServiceRegistrationsIdDocuments: provideDocuments,
+        },
+      },
     ],
   };
 }
@@ -56,6 +69,76 @@ describe('RegistrationPage', () => {
     expect(screen.getByRole('button', { name: /indienen/i })).toBeTruthy();
   });
 
+  it('offers to withdraw after submitting, and withdrawing confirms', async () => {
+    const { withdraw, providers: p } = providers();
+    await render(RegistrationPage, { providers: p });
+
+    fireEvent.click(screen.getByRole('button', { name: /indienen/i }));
+    await screen.findByText(/ontvangen/i);
+
+    fireEvent.click(await screen.findByRole('button', { name: /trek aanvraag in/i }));
+
+    // The withdrawal is keyed by the reference the submit returned, and the page confirms it.
+    expect(withdraw).toHaveBeenCalledWith('reg-9');
+    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' })),
+      vi.fn().mockReturnValue(throwError(() => new Error('withdraw rejected'))),
+    );
+    await render(RegistrationPage, { providers: p });
+
+    fireEvent.click(screen.getByRole('button', { name: /indienen/i }));
+    await screen.findByText(/ontvangen/i);
+    fireEvent.click(await screen.findByRole('button', { name: /trek aanvraag in/i }));
+
+    expect(await screen.findByRole('alert')).toBeTruthy();
+    expect(screen.queryByText(/is ingetrokken/i)).toBeNull();
+    expect(screen.getByRole('button', { name: /trek aanvraag in/i })).toBeTruthy();
+  });
+
   it('has no WCAG 2.1 AA violations on the submit page', async () => {
     // The portal is Dutch; the real index.html sets lang. Set it here so the document-level
     // html-has-lang rule reflects the app, not the bare jsdom document.

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

@@ -6,7 +6,8 @@ import { UtrechtComponentsModule } from 'ui';
 /**
  * The self-service submit page: a signed-in zorgprofessional confirms and submits their BIG
  * registration. The bsn comes from the DigiD token (not a form field), so this is a confirm-and-
- * submit flow that posts to the BFF and shows the returned reference (ADR-0010; S-08c).
+ * submit flow that posts to the BFF and shows the returned reference (ADR-0010; S-08c). After
+ * submitting they can withdraw it — "trek aanvraag in" — keyed by that reference (S-11c).
  */
 @Component({
   selector: 'app-registration-page',
@@ -22,6 +23,13 @@ export class RegistrationPage {
   protected readonly reference = signal<string | undefined>(undefined);
   protected readonly submitted = signal(false);
   protected readonly failed = signal(false);
+  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);
@@ -39,4 +47,74 @@ 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) {
+      return;
+    }
+    this.withdrawing.set(true);
+    this.withdrawFailed.set(false);
+    this.bff.postSelfServiceRegistrationsIdWithdraw(reference).subscribe({
+      next: () => {
+        this.withdrawn.set(true);
+        this.withdrawing.set(false);
+      },
+      // Surface the failure instead of swallowing it: keep the action so the user can retry.
+      error: () => {
+        this.withdrawFailed.set(true);
+        this.withdrawing.set(false);
+      },
+    });
+  }
+}
+
+/** 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-0014-withdrawal-cancels-the-process.md

@@ -0,0 +1,72 @@
+# ADR-0014: Withdrawal cancels the registratie process via a BPMN message event
+
+- **Status:** Accepted
+- **Date:** 2026-07-16
+- **Deciders:** Respellion engineering
+- **Relates to:** S-11 (#12); builds on ADR-0009 (external-task worker / Workflow Client), ADR-0013
+  (behandel-portal wiring, the Beoordelen user task)
+
+## Context
+
+S-11 lets a zorgprofessional withdraw a still-open registration ("trek aanvraag in"). S-11a already
+advances the aggregate to INGETROKKEN (domain state). But the registratie process is still running in
+Flowable — parked at the `Beoordelen` user task — so without a second step the withdrawn registration
+would linger as work for a behandelaar. The withdrawal must also **cancel the running process**.
+
+Two questions shape this sub-slice.
+
+1. **How does the case get cancelled — in code, or in the BPMN model?**
+2. **How does a withdrawal correlate to the right running process instance?**
+
+## Decision
+
+**The BPMN models the cancellation as an interrupting message boundary event on the `Beoordelen`
+task; the Workflow Client correlates a `RegistratieIngetrokken` message to the task's execution.**
+
+- **Modelled in BPMN, not deleted from code.** The `Beoordelen` user task carries an interrupting
+  message boundary event (`RegistratieIngetrokken`) that routes to a dedicated "Registratie
+  ingetrokken" end event. The process's own model says *how* a withdrawal ends it — the Workflow
+  Client only delivers the message; it never reaches into Flowable to delete an instance. This keeps
+  the workflow's control flow in the workflow (§8.2) and leaves an audit trail in Flowable history
+  (the process ended via the ingetrokken path, not a raw delete).
+- **Correlated by the registration's own process instance.** The aggregate records its Flowable
+  process instance id at submit, so the `WithdrawRegistration` handler correlates directly by that
+  id — no task lookup. The Workflow Client asks Flowable for the execution **subscribed to** the
+  `RegistratieIngetrokken` message in that instance and delivers `messageEventReceived` to it.
+  Targeting the subscribed execution (not the user task's execution — a message boundary event's
+  subscription lives on its own execution) is what makes the correlation land.
+- **Best-effort, mirroring the beoordeling.** If no open `Beoordelen` task is found (the process has
+  not yet parked there — the `OpenZaakAanmaken` window — or has already ended), the withdrawal still
+  stands: the aggregate is INGETROKKEN and the werkbak filters it out regardless (S-11b). We complete
+  the domain transition first and cancel the workflow best-effort, exactly as `BeoordeelRegistratie`
+  completes its task best-effort.
+
+## Consequences
+
+**Positive**
+
+- The cancellation path is visible in `registratie.bpmn`; the Workflow Client stays the only code
+  that talks to Flowable and does not delete instances behind the model's back.
+- Reuses the existing task-query correlation — no new plumbing, no correlation store.
+- A withdrawn case leaves the werkbak (its `Beoordelen` task is cancelled), and the werkbak also
+  filters non-open registrations as a belt-and-braces for the brief window before cancellation lands.
+
+**Negative / costs**
+
+- A withdrawal raced ahead of the process reaching `Beoordelen` (during `OpenZaakAanmaken`, seconds)
+  finds no task to cancel, so that process instance runs on to `Beoordelen` and parks there with no
+  one to act on it (it is hidden from the werkbak by the status filter). Acceptable for this
+  reference at these volumes; a process-level interrupting event subprocess would close the gap and
+  is an additive follow-up if it matters.
+- The Flowable message-correlation REST shape is validated live (verify-stack), not in the
+  Workflow Client's unit tests, which stub the HTTP exchange and assert only the request shape
+  (consistent with ADR-0009).
+
+## Alternatives considered
+
+- **Delete the process instance from the Workflow Client** (`DELETE /runtime/process-instances/{id}`)
+  — rejected: it cancels the case but hides the reason from the BPMN model; the "why" lives in code,
+  not the process. The message event keeps the cancellation a first-class part of the workflow.
+- **Interrupting message event subprocess at process level** — more robust (correlates anytime,
+  closing the `OpenZaakAanmaken`-race gap), but a heavier BPMN construct; deferred as an additive
+  change if the race proves to matter.

docs/architecture/adr-0015-beoordeling-escalation.md

@@ -0,0 +1,77 @@
+# ADR-0015: Beoordeling escalation reassigns via an external-worker task
+
+- **Status:** Accepted
+- **Date:** 2026-07-17
+- **Deciders:** Respellion engineering
+- **Relates to:** S-14 (#15); proposal #98. Builds on ADR-0009 (external-task worker / Workflow
+  Client), ADR-0013 (behandel-portal wiring, the `Beoordelen` user task), ADR-0014 (the boundary-event
+  pattern on `Beoordelen`).
+
+## Context
+
+S-14 escalates a beoordeling that a behandelaar does not pick up in time: after 14 days the case must
+move to the `teamlead` role (PRD §5, flow 5). The `Beoordelen` user task already exists, claimable by
+the `behandelaar` candidate group; the teamlead role is seeded in the medewerker realm.
+
+Two forces shape this.
+
+1. **The task must stay open.** Escalation changes *who may claim* an unclaimed beoordeling, not the
+   work itself — so the timer must be **non-interrupting**: the `Beoordelen` task keeps running while
+   escalation happens alongside it.
+2. **Reassigning an open task's candidate group needs code.** Flowable cannot rewrite the candidate
+   groups of an already-open user task from BPMN XML alone — that requires either a Java delegate/listener
+   embedded in the engine, or an out-of-process actor driving the REST API. The repository has held a
+   "stock Flowable image, no custom jars; the Workflow Client is the only code that talks to Flowable
+   (§8.2)" posture since ADR-0009.
+
+## Decision
+
+**A non-interrupting `P14D` boundary timer on `Beoordelen` fires an external-worker task
+(`BeoordelingEscaleren`); the Workflow Client reassigns the still-open `Beoordelen` task from the
+behandelaar group to teamlead.**
+
+- **Modelled in BPMN, driven by an external worker.** The timer routes a parallel token to an
+  `external-worker` service task on the `BeoordelingEscaleren` topic, ending at a dedicated "Beoordeling
+  geëscaleerd" end event. The model owns *when* escalation happens; the Workflow Client — the only code
+  that talks to Flowable (§8.2) — owns *how* the reassignment is applied, exactly as `OpenZaakAanmaken`
+  delegates the ZGW call (ADR-0009). No custom code runs inside Flowable.
+- **Reassignment is a candidate-group swap.** The escalation worker finds the still-open `Beoordelen`
+  task in the escalating instance (task query by `processInstanceId` + `taskDefinitionKey`), adds
+  `teamlead` as a candidate group via the task identity links, then removes `behandelaar`. The task now
+  belongs to the teamlead; its history and variables are untouched.
+- **Best-effort, mirroring beoordeling and withdrawal.** If the task is no longer open — the behandelaar
+  completed it in the window before the timer fired — the reassignment is a no-op. A failed reassignment
+  leaves the escalation job un-completed so Flowable redelivers it (§8.6), consistent with the
+  `OpenZaakAanmaken` worker.
+- **Segregated interface.** The escalation methods live on `IBeoordelingEscalatieClient`, separate from
+  the `OpenZaakAanmaken` worker's `IExternalWorkerClient`, so the OpenZaak worker never sees escalation
+  (interface segregation). Both are implemented by the one `FlowableWorkflowClient`.
+
+## Consequences
+
+**Positive**
+
+- The escalation trigger is visible in `registratie.bpmn`; Flowable stays a stock image, and the
+  Workflow Client remains the sole Flowable client (§8.2 upheld, not bent).
+- Reuses the external-worker mechanics (topic acquire/complete, hosted pump, per-tick scope,
+  redelivery-on-failure) wholesale — the new code is one client capability, one processor, one pump.
+- Escalation latency is bounded by the worker's poll interval (seconds) — negligible against a 14-day
+  timer.
+
+**Negative / costs**
+
+- Escalation is two REST hops (add teamlead, remove behandelaar) rather than one atomic update; between
+  them the task is briefly claimable by both groups. Harmless at these volumes, and the pair is idempotent
+  on redelivery.
+- The Flowable identity-link and management-job REST shapes are validated live (verify-domain fires the
+  timer early via the management API), not in the Workflow Client's unit tests, which stub the HTTP
+  exchange and assert only the request shape — consistent with ADR-0009 and ADR-0014.
+
+## Alternatives considered
+
+- **Flowable timer/task listener (Java delegate).** Reassign in-engine when the timer fires. Rejected:
+  it needs a custom jar in Flowable, breaking the stock-image, REST-only posture and adding a build/deploy
+  surface to the engine for no capability the external-worker route lacks.
+- **Interrupting timer that re-creates the task for teamlead.** Cancel `Beoordelen` and start a fresh
+  teamlead task. Rejected: it loses the task's identity/history and complicates correlation, where a
+  candidate-group swap on the same task expresses "the same work, now the teamlead's" directly.

docs/architecture/adr-0016-diploma-eligibility-dmn.md

@@ -0,0 +1,77 @@
+# ADR-0016: Diploma eligibility is a DMN evaluated inline as a BPMN DMN service task
+
+- **Status:** Accepted
+- **Date:** 2026-07-17
+- **Deciders:** Respellion engineering
+- **Relates to:** S-13 (#14); proposal #100. Builds on ADR-0009 (external-task worker / Workflow
+  Client), ADR-0014/0015 (the boundary-event and routing constructs on the registratie process).
+
+## Context
+
+S-13 adds flow 4: a foreign diploma must get an extra CBGV-advies assessment before beoordeling
+(PRD §5). The eligibility decision — domestic goes straight to beoordeling, foreign routes through
+CBGV-advies — needs a home. The Flowable REST app bundles a DMN engine, and the same
+`repository/deployments` machinery that deploys `registratie.bpmn` can deploy a `.dmn`. §8.2 makes
+the Workflow Client the only code that talks to Flowable; the PRD frames the workflow as "BPMN + DMN
+governing the registration workflow" (Flowable as a peer orchestration module).
+
+The issue's wording ("a DMN decision table evaluated by the Domain Service via Workflow Client")
+suggests the domain reaches into Flowable's DMN API to evaluate the decision and feeds the result
+back. That is one option; it is not the only one, and it is not the cleanest.
+
+## Decision
+
+**The diploma-eligibility DMN is deployed to Flowable and evaluated inline by the registratie process
+as a DMN service task (`flowable:type="dmn"`); an exclusive gateway routes on its output. The domain's
+only new job is to carry the diploma origin and pass it into the process as a start variable.**
+
+- **The decision lives in the workflow.** `workflows/diploma-eligibility.dmn` maps `diplomaOrigin`
+  → `route` (`Buitenlands` ⇒ `CBGV_ADVIES`, otherwise `DIRECT`). A DMN service task
+  (`flowable:type="dmn"`, `decisionTableReferenceKey=diploma-eligibility`) runs it between
+  `OpenZaakAanmaken` and `Beoordelen`, and an exclusive gateway sends `CBGV_ADVIES` through a new
+  `CBGVAdvies` user task before `Beoordelen`, `DIRECT` straight there. (A `businessRuleTask` would
+  bind Flowable's legacy Drools/KIE implementation, which `flowable-rest` does not bundle — its parse
+  handler throws `NoClassDefFoundError` at deploy time; the DMN service task is the supported route.)
+- **The domain carries the input, not the decision.** The `Registration` aggregate gains a
+  `DiplomaOrigin` (Binnenlands/Buitenlands); `SubmitRegistration` passes it to
+  `StartRegistrationProcessAsync`, which sets it as the `diplomaOrigin` start variable. The domain
+  never evaluates the DMN and never learns the route — that is the process's concern.
+- **Deployed as its own DMN-engine deployment, separate from the BPMN.** The DMN is version-controlled
+  in `workflows/` and `flowable-init` deploys it to the DMN engine via the `dmn-api`
+  (`/dmn-api/dmn-repository/deployments`), while `registratie.bpmn` goes to the process engine via
+  `/service/repository/deployments`. Two things were learned the hard way here (both cost a CI cycle):
+  (1) `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 service task fails at runtime with
+  `FlowableObjectNotFoundException: No decision found for key`; the DMN must go through `dmn-api`.
+  (2) Flowable's DMN XML converter rejects an XML comment placed between the `<?xml?>` declaration and
+  the root `<definitions>` element (`XMLStreamReader not in START_DOCUMENT or START_ELEMENT state`),
+  unlike its BPMN converter — so the DMN's documentation comment lives *inside* `<definitions>`.
+  With the decision present in the DMN repository, the process's DMN service task resolves it across
+  deployments by key (verified live), so no shared parent deployment id is needed.
+
+## Consequences
+
+**Positive**
+
+- The eligibility rule is a first-class, inspectable workflow artefact (matching the PRD's BPMN+DMN
+  framing); business users can read/adjust the decision table without touching domain code.
+- §8.2 stays clean: the Workflow Client remains the only code talking to Flowable, and the decision
+  runs inside the process the client already started — no domain→Flowable round-trip for a decision.
+- The domain change is minimal and additive: one value on the aggregate, one start variable.
+
+**Negative / costs**
+
+- Deviates from #14's literal "evaluated by the Domain Service via Workflow Client" wording (noted on
+  the issue). The outcome — DMN decides eligibility, foreign diplomas get the CBGV step — is unchanged.
+- The DMN and its service-task wiring are validated live (verify-domain drives a foreign
+  registration through CBGV-advies and a domestic one straight to beoordeling, exercising both
+  branches), not in unit tests — consistent with ADR-0009/0014/0015. The domain unit/acceptance tests
+  cover only that the origin is carried into the process.
+
+## Alternatives considered
+
+- **Domain evaluates the DMN via the Workflow Client** (the issue's wording). Rejected: it couples
+  the domain to Flowable for a decision and splits the routing across two places (domain computes,
+  BPMN branches), for no benefit over letting the engine that owns the process own the decision.
+- **Eligibility rules in domain C#.** Rejected: it moves a governable business decision out of the
+  DMN the PRD calls for, and hard-codes what the reference app is meant to demonstrate as data.

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

@@ -0,0 +1,90 @@
+# 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

@@ -0,0 +1,74 @@
+# 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/demo-script.md

@@ -275,3 +275,190 @@ ACL → NRC → event-subscriber → projection → openbaar register shows INGE
 > The full round-trip — DigiD submit → public INGEDIEND → behandelaar goedkeurt in the werkbak →
 > public INGESCHREVEN — is the Playwright happy path (`tests/e2e/registration.spec.ts`), which now
 > drives the behandel portal in place of the old admin endpoint.
+
+## S-11 — Withdrawal: "trek aanvraag in" (#12, ADR-0014)
+
+A zorgprofessional can withdraw their own still-open registration from the self-service portal. The
+withdrawal is owner-scoped (the BFF forwards the DigiD token's bsn; the domain only lets the owner
+withdraw) and cancels the running workflow via a BPMN message event, so the case leaves the
+behandelaar's werkbak.
+
+```text
+# 1. Log in and submit at the self-service portal (http://localhost:8140/, jan-burger / test123),
+#    note the "Referentie" on the confirmation.
+# 2. Click "Trek aanvraag in" → the page confirms the registration is ingetrokken.
+# 3. In the behandel werkbak (http://localhost:8142/, merel-behandelaar) the registration no longer
+#    appears — its Beoordelen task was cancelled.
+```
+
+**The path:** self-service → BFF `POST /self-service/registrations/{id}/withdraw` (DigiD, owner-scoped)
+→ domain sets INGETROKKEN + correlates the `RegistratieIngetrokken` message to the process → the
+interrupting boundary event ends it → the werkbak drops the case.
+
+> DigiD submit → trek aanvraag in → ingetrokken is the Playwright happy path
+> (`tests/e2e/withdrawal.spec.ts`); the owner-scoping + workflow cancellation are covered by the
+> `Een registratie intrekken` acceptance scenarios and the domain live check.
+
+## S-14 — Beoordeling escalation: 14 days unclaimed → teamlead (#15, ADR-0015)
+
+A beoordeling a behandelaar does not pick up within 14 days escalates to the teamlead. A
+non-interrupting boundary timer on the `Beoordelen` task fires a `BeoordelingEscaleren` external task;
+the domain's escalation worker reassigns the still-open task's candidate group from `behandelaar` to
+`teamlead`, so it moves from the behandelaar werkbak into the teamlead's. The `Beoordelen` task keeps
+its identity throughout — only who may claim it changes.
+
+The timer is 14 days, so the demo fires it early through Flowable's management API (exactly what the
+verify-domain check automates):
+
+```bash
+# 1. Submit at the self-service portal (http://localhost:8140/, jan-burger / test123). The case
+#    parks at Beoordelen, visible in the behandelaar werkbak (http://localhost:8142/, merel-behandelaar)
+#    but NOT claimed.
+#
+# 2. Find the parked instance and its Beoordelen task, then fire the boundary timer early:
+FL=http://localhost:8090/flowable-rest/service
+PID=$(curl -s -u rest-admin:test -X POST "$FL/query/tasks" -H 'Content-Type: application/json' \
+  -d '{"processDefinitionKey":"registratie","taskDefinitionKey":"Beoordelen"}' \
+  | python3 -c 'import sys,json;print(json.load(sys.stdin)["data"][0]["processInstanceId"])')
+TID=$(curl -s -u rest-admin:test -X POST "$FL/query/tasks" -H 'Content-Type: application/json' \
+  -d '{"processDefinitionKey":"registratie","taskDefinitionKey":"Beoordelen"}' \
+  | python3 -c 'import sys,json;print(json.load(sys.stdin)["data"][0]["id"])')
+TJ=$(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/$TJ" \
+  -H 'Content-Type: application/json' -d '{"action":"move"}'
+AJ=$(curl -s -u rest-admin:test "$FL/management/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/jobs/$AJ" \
+  -H 'Content-Type: application/json' -d '{"action":"execute"}'
+#
+# 3. Within a couple of poll cycles the task's candidate group flips to teamlead:
+curl -s -u rest-admin:test "$FL/runtime/tasks/$TID/identitylinks"   # → [{"group":"teamlead","type":"candidate"}]
+```
+
+**The path:** BPMN non-interrupting `P14D` boundary timer on `Beoordelen` → `BeoordelingEscaleren`
+external task → domain escalation worker (`BeoordelingEscalatiePump`) → Workflow Client swaps the task's
+candidate group behandelaar → teamlead (§8.2).
+
+> Both branches (escalate after 14 days; no-op when completed in time) are covered by the
+> `Een beoordeling escaleren` acceptance scenarios and the Workflow Client unit tests; the timer firing
+> and reassignment are asserted live by the verify-domain check.
+
+## S-13 — Diploma-eligibility: foreign diplomas route through CBGV-advies (#14, ADR-0016)
+
+A registration's diploma origin decides its route. A DMN service task in the registratie
+process evaluates the `diploma-eligibility` decision on the `diplomaOrigin` start variable: a
+**foreign** (Buitenlands) diploma is routed through an extra **CBGV-advies** user task before
+beoordeling; a **domestic** (Binnenlands) one goes straight to beoordeling. The decision lives in the
+DMN, not in code — a beheerder can read and adjust the decision table directly.
+
+The self-service portal's eIDAS→foreign wiring is a later slice; for now the origin is submitted to
+the domain directly, so the demo drives it through the domain endpoint:
+
+```bash
+# 1. Submit a foreign-diploma registration to the domain (note the returned Location/reference):
+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:
+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
+#
+# 3. Complete the CBGV-advies task; the case then advances to the regular Beoordelen task:
+TID=$(curl -s -u rest-admin:test -X POST "$FL/query/tasks" -H 'Content-Type: application/json' \
+  -d '{"processDefinitionKey":"registratie","taskDefinitionKey":"CBGVAdvies"}' \
+  | 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"}'
+# A domestic submission (default, or "Binnenlands") skips CBGV-advies and parks straight at Beoordelen.
+```
+
+**The path:** domain sets the `diplomaOrigin` start variable → registratie process DMN
+DMN service task sets `route` → exclusive gateway → foreign: `CBGVAdvies` user task → `Beoordelen`;
+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).
+
+> Setting the ZGW zaak to a cancellation status on 30-day expiry is a follow-up (S-10c, #106).

docs/frontend-decisions.md

@@ -151,3 +151,19 @@ frontend work is the medewerker realm auth and the werkbak/decide page. Wiring r
   to assert the medewerker token attaches to `/behandel/*` (and not to the anonymous openbaar call).
   The full DigiD-submit → behandel-decide → public INGESCHREVEN round-trip is the Playwright happy
   path.
+
+## Self-service withdrawal: "trek aanvraag in" (S-11c, #12)
+
+The submit confirmation grows a **"Trek aanvraag in"** action so a zorgprofessional can withdraw the
+registration they just submitted (`apps/self-service`, on the existing `RegistrationPage`).
+
+- **Keyed by the reference, owner-scoped at the BFF.** The button calls the generated
+  `postSelfServiceRegistrationsIdWithdraw(reference)` with the reference the submit returned. The
+  DigiD token (attached by the interceptor) carries the bsn the BFF forwards; the domain only lets
+  the owner withdraw (a mismatch is 404). No extra identity is entered in the UI.
+- **Same confirm-and-surface pattern as submit.** A secondary-action button; on success the page
+  switches to an ingetrokken confirmation; a failure is surfaced (`role="alert"`) and the action
+  stays available to retry — mirroring how submit handles its failure rather than swallowing it.
+- **Testing.** Component tests (`@testing-library/angular`, mocked BFF) cover the button appearing
+  after submit, the reference being passed, the ingetrokken confirmation, and the failure path; the
+  browser round-trip is `tests/e2e/withdrawal.spec.ts`.

infra/docker-compose.local.yml

@@ -17,7 +17,12 @@
 #
 # Port map (host):
 #   8000 OpenZaak · 8001 Open Notificaties · 8080 BFF · 8090 Flowable REST
-#   8100 ACL · 8180 Keycloak   (all admin: admin / admin — dev only)
+#   8100 ACL · 8130 Domain · 8180 Keycloak   (all admin: admin / admin — dev only)
+#   8140 self-service portal · 8141 openbaar register · 8142 behandel portal
+#
+# Portal OIDC on the HOST: browse the portals at their 8140/8141/8142 ports and log in via
+# Keycloak on localhost:8180 (KC_HOSTNAME below pins the issuer there; the BFF still validates
+# in-network via keycloak:8080). Test users are in docs/synthetic-data.md.
 
 services:
 
@@ -205,6 +210,12 @@ services:
       KEYCLOAK_ADMIN_PASSWORD: admin
       KC_HEALTH_ENABLED: "true"
       KC_HTTP_ENABLED: "true"
+      # Pin the frontend/issuer URL to the host-published address so a browser on the host and the
+      # tokens it gets both use localhost:8180. KC_HOSTNAME_BACKCHANNEL_DYNAMIC lets in-network
+      # callers (the BFF via keycloak:8080) still resolve token/jwks endpoints to their request host,
+      # so the BFF validates the localhost:8180 issuer while fetching keys over the compose network.
+      KC_HOSTNAME: http://localhost:8180
+      KC_HOSTNAME_BACKCHANNEL_DYNAMIC: "true"
     ports:
       - "8180:8080"
     volumes:
@@ -295,6 +306,14 @@ services:
       context: ../services/bff
       dockerfile: Dockerfile
     image: register-referentie/bff:dev
+    environment:
+      # Reach Keycloak over the compose network for metadata/keys; the discovered issuer is the
+      # host-pinned localhost:8180 (KC_HOSTNAME above), which is what browser tokens carry — so
+      # validation matches without the BFF ever needing to resolve localhost:8180 itself.
+      Keycloak__Authority: http://keycloak:8080/realms/digid
+      Keycloak__MedewerkerAuthority: http://keycloak:8080/realms/medewerker
+      Downstream__Domain__BaseUrl: http://domain:8080/
+      Downstream__Projection__BaseUrl: http://projection-api:8080/
     ports:
       - "8080:8080"
     healthcheck:
@@ -303,6 +322,39 @@ services:
       timeout: 3s
       retries: 5
       start_period: 10s
+    depends_on:
+      domain:
+        condition: service_healthy
+      projection-api:
+        condition: service_healthy
+      keycloak:
+        condition: service_started
+    networks: [cg]
+
+  # ── BIG Domain Service (S-05) ─────────────────────────────────────────────
+  domain:
+    build:
+      context: ../services/domain
+      dockerfile: Dockerfile
+    image: register-referentie/domain:dev
+    environment:
+      Flowable__BaseUrl: http://flowable-rest:8080/flowable-rest/
+      Flowable__Username: rest-admin
+      Flowable__Password: test
+      Acl__BaseUrl: http://acl:8080/
+    ports:
+      - "8130:8080"
+    healthcheck:
+      test: ["CMD", "curl", "-fsS", "http://localhost:8080/health"]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+      start_period: 10s
+    depends_on:
+      acl:
+        condition: service_healthy
+      flowable-init:
+        condition: service_completed_successfully
     networks: [cg]
 
   # ── Read projection (S-06) ────────────────────────────────────────────────
@@ -328,6 +380,10 @@ services:
     image: register-referentie/event-subscriber:dev
     environment:
       ConnectionStrings__Projection: Host=projection-db;Database=projection;Username=projection;Password=projection
+      # The subscriber enriches the projection with each zaak's reference by asking the ACL — the only
+      # code allowed to read ZGW (§8.1, #78). Required: startup throws without it (parity with the
+      # canonical compose).
+      Acl__BaseUrl: http://acl:8080/
       EventSubscriber__Webhook__AuthToken: ${NOTIFICATION_WEBHOOK_TOKEN:-Bearer big-reference-notifications}
     ports:
       - "8110:8080"
@@ -340,6 +396,8 @@ services:
     depends_on:
       projection-db:
         condition: service_healthy
+      acl:
+        condition: service_healthy
     networks: [cg]
 
   projection-api:
@@ -362,6 +420,73 @@ services:
         condition: service_healthy
     networks: [cg]
 
+  # ── Portals (S-08/S-09/S-12) ──────────────────────────────────────────────
+  # nginx serves each Angular app and reverse-proxies its endpoint group to the BFF (same-origin).
+  # The images bake config.json with the compose authority (keycloak:8080), which a HOST browser
+  # can't resolve — so here we bind-mount a config.json pointing at the host-published localhost:8180
+  # (matching KC_HOSTNAME). openbaar is anonymous and needs no config.
+  self-service:
+    build:
+      context: ..
+      dockerfile: apps/self-service/Dockerfile
+    image: register-referentie/self-service:dev
+    ports:
+      - "8140:80"
+    volumes:
+      - ./local-config/self-service.config.json:/usr/share/nginx/html/config.json:ro,z
+    healthcheck:
+      test: ["CMD-SHELL", "wget -q -O /dev/null http://127.0.0.1/ || exit 1"]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+      start_period: 10s
+    depends_on:
+      bff:
+        condition: service_healthy
+      keycloak:
+        condition: service_started
+    networks: [cg]
+
+  openbaar:
+    build:
+      context: ..
+      dockerfile: apps/openbaar/Dockerfile
+    image: register-referentie/openbaar:dev
+    ports:
+      - "8141:80"
+    healthcheck:
+      test: ["CMD-SHELL", "wget -q -O /dev/null http://127.0.0.1/ || exit 1"]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+      start_period: 10s
+    depends_on:
+      bff:
+        condition: service_healthy
+    networks: [cg]
+
+  behandel:
+    build:
+      context: ..
+      dockerfile: apps/behandel/Dockerfile
+    image: register-referentie/behandel:dev
+    ports:
+      - "8142:80"
+    volumes:
+      - ./local-config/behandel.config.json:/usr/share/nginx/html/config.json:ro,z
+    healthcheck:
+      test: ["CMD-SHELL", "wget -q -O /dev/null http://127.0.0.1/ || exit 1"]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+      start_period: 10s
+    depends_on:
+      bff:
+        condition: service_healthy
+      keycloak:
+        condition: service_started
+    networks: [cg]
+
 volumes:
   oz-db:
   nrc-db:

infra/docker-compose.yml

@@ -259,19 +259,30 @@ services:
   flowable-init:
     image: docker.io/curlimages/curl:latest
     restart: "no"
-    # registratie.bpmn is streamed into this external volume by infra/seed-config.sh.
+    # registratie.bpmn + diploma-eligibility.dmn are streamed into this external volume by
+    # infra/seed-config.sh.
     volumes:
       - fl-bpmn:/work:ro
     command:
       - sh
       - -c
       - |
-        base=http://flowable-rest:8080/flowable-rest/service/repository/deployments
-        until curl -sf -u rest-admin:test "$$base" >/dev/null 2>&1; do echo "waiting for flowable-rest..."; sleep 3; done
-        if curl -s -u rest-admin:test "$$base?name=registratie" | grep -q '"name":"registratie"'; then
-          echo "registratie already deployed; skip"
+        svc=http://flowable-rest:8080/flowable-rest/service/repository/deployments
+        dmn=http://flowable-rest:8080/flowable-rest/dmn-api/dmn-repository/deployments
+        until curl -sf -u rest-admin:test "$$svc" >/dev/null 2>&1; do echo "waiting for flowable-rest..."; sleep 3; done
+        # Deploy the DMN to the DMN engine and the BPMN to the process engine as SEPARATE deployments:
+        # flowable-rest does NOT cascade a .dmn bundled in a process .bar into the DMN engine, so the DMN
+        # must go via dmn-api. The process's DMN service task then resolves the decision across deployments
+        # by key (S-13, ADR-0016). Both steps are idempotent (skip if already deployed).
+        if curl -s -u rest-admin:test "$$dmn" | grep -q '"name":"diploma-eligibility.dmn"'; then
+          echo "diploma-eligibility DMN already deployed; skip"
         else
-          curl -sf -u rest-admin:test -F 'file=@/work/registratie.bpmn;filename=registratie.bpmn' "$$base" >/dev/null && echo "deployed registratie"
+          curl -sf -u rest-admin:test -F 'file=@/work/diploma-eligibility.dmn;filename=diploma-eligibility.dmn' "$$dmn" >/dev/null && echo "deployed diploma-eligibility DMN"
+        fi
+        if curl -s -u rest-admin:test "$$svc?name=registratie" | grep -q '"name":"registratie"'; then
+          echo "registratie BPMN already deployed; skip"
+        else
+          curl -sf -u rest-admin:test -F 'file=@/work/registratie.bpmn;filename=registratie.bpmn' "$$svc" >/dev/null && echo "deployed registratie BPMN"
         fi
     depends_on:
       flowable-rest:
@@ -295,6 +306,9 @@ 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/flowable/docker-compose.yml

@@ -35,24 +35,35 @@ services:
         condition: service_healthy
     networks: [cg]
 
-  # Deploys workflows/registratie.bpmn via the REST API once flowable-rest is up.
-  # Idempotent: skips if a deployment named "registratie" already exists.
+  # Deploys registratie.bpmn (process engine) and diploma-eligibility.dmn (DMN engine) via the REST
+  # API once flowable-rest is up. Idempotent: skips each if already deployed.
   flowable-init:
     image: docker.io/curlimages/curl:latest
     restart: "no"
-    # registratie.bpmn is streamed into this external volume by infra/seed-config.sh.
+    # registratie.bpmn + diploma-eligibility.dmn are streamed into this external volume by
+    # infra/seed-config.sh.
     volumes:
       - fl-bpmn:/work:ro
     command:
       - sh
       - -c
       - |
-        base=http://flowable-rest:8080/flowable-rest/service/repository/deployments
-        until curl -sf -u rest-admin:test "$$base" >/dev/null 2>&1; do echo "waiting for flowable-rest..."; sleep 3; done
-        if curl -s -u rest-admin:test "$$base?name=registratie" | grep -q '"name":"registratie"'; then
-          echo "registratie already deployed; skip"
+        svc=http://flowable-rest:8080/flowable-rest/service/repository/deployments
+        dmn=http://flowable-rest:8080/flowable-rest/dmn-api/dmn-repository/deployments
+        until curl -sf -u rest-admin:test "$$svc" >/dev/null 2>&1; do echo "waiting for flowable-rest..."; sleep 3; done
+        # Deploy the DMN to the DMN engine and the BPMN to the process engine as SEPARATE deployments:
+        # flowable-rest does NOT cascade a .dmn bundled in a process .bar into the DMN engine, so the DMN
+        # must go via dmn-api. The process's DMN service task then resolves the decision across deployments
+        # by key (S-13, ADR-0016). Both steps are idempotent (skip if already deployed).
+        if curl -s -u rest-admin:test "$$dmn" | grep -q '"name":"diploma-eligibility.dmn"'; then
+          echo "diploma-eligibility DMN already deployed; skip"
         else
-          curl -sf -u rest-admin:test -F 'file=@/work/registratie.bpmn;filename=registratie.bpmn' "$$base" >/dev/null && echo "deployed registratie"
+          curl -sf -u rest-admin:test -F 'file=@/work/diploma-eligibility.dmn;filename=diploma-eligibility.dmn' "$$dmn" >/dev/null && echo "deployed diploma-eligibility DMN"
+        fi
+        if curl -s -u rest-admin:test "$$svc?name=registratie" | grep -q '"name":"registratie"'; then
+          echo "registratie BPMN already deployed; skip"
+        else
+          curl -sf -u rest-admin:test -F 'file=@/work/registratie.bpmn;filename=registratie.bpmn' "$$svc" >/dev/null && echo "deployed registratie BPMN"
         fi
     depends_on:
       flowable-rest:

infra/local-config/behandel.config.json

@@ -0,0 +1,3 @@
+{
+  "authority": "http://localhost:8180/realms/medewerker"
+}

infra/local-config/self-service.config.json

@@ -0,0 +1,3 @@
+{
+  "authority": "http://localhost:8180/realms/digid"
+}

infra/openzaak/seed_catalogus.py

@@ -124,6 +124,58 @@ 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"]
@@ -198,10 +250,16 @@ 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).
@@ -214,6 +272,10 @@ 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,13 +33,18 @@ 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
-zt_url="$(docker start -a "$sid" | sed -n 's/^ZAAKTYPE_URL //p' | head -1)"
+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)"
 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 (host-consistent)"
-ACL_ZAAKTYPE_URL="$zt_url" ACL_OPENZAAK_BASEURL="$oz_base/" docker compose -f "$compose" up -d acl
+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
 WAIT_TIMEOUT="${WAIT_TIMEOUT:-120}" bash "$here/wait-healthy.sh" acl
 
 echo ">> submitting a registration to the domain"
@@ -79,9 +84,9 @@ fl="$(docker ps -q --filter 'name=flowable-rest' | head -1)"
 fl_base="http://$(ip "$fl"):8080/flowable-rest/service"
 reg_id="${loc##*/}"
 
-# Extracts the Beoordelen task id for our registration from a Flowable task-query response on stdin.
-# Tolerates an empty/non-JSON body (a transient failure during the poll) by printing nothing.
-task_for_reg() { REG_ID="$reg_id" python3 -c "import os,sys,json
+# Extracts the Beoordelen task id for a given registration from a Flowable task-query response on
+# stdin. Tolerates an empty/non-JSON body (a transient failure during the poll) by printing nothing.
+task_for_reg() { REG_ID="$1" python3 -c "import os,sys,json
 try:
     d=json.load(sys.stdin)
 except Exception:
@@ -93,12 +98,33 @@ 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=""
 for _ in $(seq 1 30); do
   resp="$(flcurl -X POST "$fl_base/query/tasks" -H 'Content-Type: application/json' -d "$query" 2>/dev/null || true)"
-  task_id="$(printf '%s' "$resp" | task_for_reg)"
+  task_id="$(printf '%s' "$resp" | task_for_reg "$reg_id")"
   [ -n "$task_id" ] && break
   sleep 2
 done
@@ -115,7 +141,217 @@ flcurl -X POST "$fl_base/runtime/tasks/$task_id" -H 'Content-Type: application/j
 
 echo ">> asserting the process finished (no Beoordelen task remains for the registration)"
 resp="$(flcurl -X POST "$fl_base/query/tasks" -H 'Content-Type: application/json' -d "$query")"
-still="$(printf '%s' "$resp" | task_for_reg)"
+still="$(printf '%s' "$resp" | task_for_reg "$reg_id")"
 [ -z "$still" ] || { echo "FAIL — Beoordelen task $still still active after completion" >&2; exit 1; }
 echo "OK — behandelaar claimed and completed the Beoordelen task; the registratie process finished"
+
+# ── S-11: withdrawal. A second registration parks at Beoordelen; the citizen withdraws it via the
+# domain, which delivers the RegistratieIngetrokken message to the task's execution, tripping the
+# BPMN boundary event so the process ends and the Beoordelen task disappears (ADR-0014). ────────────
+echo ">> submitting a second registration to withdraw"
+loc2="$(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 "$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=""
+for _ in $(seq 1 30); do
+  resp="$(flcurl -X POST "$fl_base/query/tasks" -H 'Content-Type: application/json' -d "$query" 2>/dev/null || true)"
+  task_id2="$(printf '%s' "$resp" | task_for_reg "$reg_id2")"
+  [ -n "$task_id2" ] && break
+  sleep 2
+done
+[ -n "$task_id2" ] || { echo "FAIL — no Beoordelen task appeared for registration $reg_id2" >&2; docker logs "$dom" 2>&1 | tail -15 >&2; exit 1; }
+echo ">> Beoordelen task $task_id2 is waiting; withdrawing the registration via the domain"
+
+# Owner-scoped: the withdraw carries the same bsn the registration was submitted with (S-11c).
+docker run --rm --network "$net" curlimages/curl:latest \
+  -fsS -X POST "http://$dom_ip:8080/registrations/$reg_id2/withdraw" \
+  -H 'Content-Type: application/json' -d '{"bsn":"123456782"}' >/dev/null
+
+echo ">> asserting the process was cancelled (no Beoordelen task remains for the registration)"
+gone=""
+for _ in $(seq 1 15); do
+  resp="$(flcurl -X POST "$fl_base/query/tasks" -H 'Content-Type: application/json' -d "$query" 2>/dev/null || true)"
+  still2="$(printf '%s' "$resp" | task_for_reg "$reg_id2")"
+  [ -z "$still2" ] && { gone=1; break; }
+  sleep 2
+done
+[ -n "$gone" ] || { echo "FAIL — Beoordelen task for $reg_id2 still active after withdrawal" >&2; docker logs "$dom" 2>&1 | tail -15 >&2; exit 1; }
+echo "OK — withdrawal cancelled the Beoordelen task; the registratie process ended (ingetrokken)"
+
+# ── S-13: diploma-eligibility routing. A registration with a FOREIGN diploma must route through the
+# extra CBGVAdvies user task before Beoordelen (the DMN service task sets route=CBGV_ADVIES and the
+# gateway branches, ADR-0016). The domestic DIRECT path is already proven by the first registration
+# above, which parked straight at Beoordelen. ──────────────────────────────────────────────────────
+cbgv_query='{"processDefinitionKey":"registratie","taskDefinitionKey":"CBGVAdvies","includeProcessVariables":true}'
+echo ">> submitting a registration with a foreign diploma"
+locf="$(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","diplomaOrigin":"Buitenlands"}' \
+  | sed -n 's/\r$//; s/^[Ll]ocation: //p' | head -1)"
+[ -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=""
+for _ in $(seq 1 30); do
+  resp="$(flcurl -X POST "$fl_base/query/tasks" -H 'Content-Type: application/json' -d "$cbgv_query" 2>/dev/null || true)"
+  cbgv_task="$(printf '%s' "$resp" | task_for_reg "$reg_idf")"
+  [ -n "$cbgv_task" ] && break
+  sleep 2
+done
+[ -n "$cbgv_task" ] || { echo "FAIL — no CBGVAdvies task appeared for the foreign registration $reg_idf" >&2; docker logs "$dom" 2>&1 | tail -15 >&2; exit 1; }
+echo ">> CBGVAdvies task $cbgv_task is waiting"
+
+echo ">> asserting it has NOT reached Beoordelen yet (still awaiting CBGV-advies)"
+resp="$(flcurl -X POST "$fl_base/query/tasks" -H 'Content-Type: application/json' -d "$query")"
+early="$(printf '%s' "$resp" | task_for_reg "$reg_idf")"
+[ -z "$early" ] || { echo "FAIL — foreign registration reached Beoordelen ($early) before CBGV-advies" >&2; exit 1; }
+
+echo ">> completing the CBGV-advies task"
+flcurl -X POST "$fl_base/runtime/tasks/$cbgv_task" -H 'Content-Type: application/json' -d '{"action":"complete"}' >/dev/null
+
+echo ">> asserting it now advances to Beoordelen"
+onward=""
+for _ in $(seq 1 15); do
+  resp="$(flcurl -X POST "$fl_base/query/tasks" -H 'Content-Type: application/json' -d "$query" 2>/dev/null || true)"
+  [ -n "$(printf '%s' "$resp" | task_for_reg "$reg_idf")" ] && { onward=1; break; }
+  sleep 2
+done
+[ -n "$onward" ] || { echo "FAIL — foreign registration did not reach Beoordelen after CBGV-advies" >&2; exit 1; }
+echo "OK — foreign diploma routed through CBGV-advies, then on to Beoordelen (DMN + gateway)"
+
+# ── S-14: escalation. A third registration parks at Beoordelen. We fire its 14-day boundary timer
+# early via Flowable's management API (the timer job is moved to executable and run), which routes a
+# parallel token to the BeoordelingEscaleren external task. The domain's escalation worker acquires
+# it and reassigns the still-open Beoordelen task from the behandelaar group to teamlead (ADR-0015). ─
+echo ">> submitting a third registration to escalate"
+loc3="$(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 "$loc3" ] || { echo "FAIL — third POST /registrations returned no Location" >&2; exit 1; }
+reg_id3="${loc3##*/}"
+echo ">> third registration $reg_id3"
+
+# Extracts "<taskId> <processInstanceId>" for a registration from a task-query response on stdin.
+task_and_pid_for_reg() { REG_ID="$1" python3 -c "import os,sys,json
+try:
+    d=json.load(sys.stdin)
+except Exception:
+    d={}
+rid=os.environ['REG_ID']
+t=next((t for t in (d.get('data') or [])
+    if any(v.get('name')=='registrationId' and v.get('value')==rid for v in (t.get('variables') or []))), None)
+print(f\"{t['id']} {t['processInstanceId']}\" if t else '')"; }
+
+# The candidate groups on a task (space-separated, sorted) from a runtime identitylinks response.
+candidate_groups() { python3 -c "import sys,json
+try:
+    links=json.load(sys.stdin)
+except Exception:
+    links=[]
+print(' '.join(sorted(l.get('group') or '' for l in links if l.get('type')=='candidate' and l.get('group'))))"; }
+
+# The first job id in a management jobs/timer-jobs response on stdin.
+first_job_id() { python3 -c "import sys,json
+try:
+    d=json.load(sys.stdin)
+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
+  resp="$(flcurl -X POST "$fl_base/query/tasks" -H 'Content-Type: application/json' -d "$query" 2>/dev/null || true)"
+  read -r task_id3 pid3 <<<"$(printf '%s' "$resp" | task_and_pid_for_reg "$reg_id3")"
+  [ -n "$task_id3" ] && break
+  sleep 2
+done
+[ -n "$task_id3" ] || { echo "FAIL — no Beoordelen task appeared for registration $reg_id3" >&2; docker logs "$dom" 2>&1 | tail -15 >&2; exit 1; }
+echo ">> Beoordelen task $task_id3 (instance $pid3) is waiting for the behandelaar"
+
+echo ">> asserting the task starts out claimable by the behandelaar group"
+before="$(flcurl "$fl_base/runtime/tasks/$task_id3/identitylinks" | candidate_groups)"
+[ "$before" = "behandelaar" ] || { echo "FAIL — expected candidate group 'behandelaar', got '$before'" >&2; exit 1; }
+
+echo ">> firing the 14-day boundary timer early via the management API"
+timer_id="$(flcurl "$fl_base/management/timer-jobs?processInstanceId=$pid3" | first_job_id)"
+[ -n "$timer_id" ] || { echo "FAIL — no timer job found for instance $pid3" >&2; exit 1; }
+# Move the timer job to an executable async job. Flowable's async executor (running in flowable-rest)
+# then picks it up and fires the non-interrupting boundary event. It may run the job before we can
+# look, so executing it explicitly is a best-effort nudge — tolerate the job already being gone.
+flcurl -X POST "$fl_base/management/timer-jobs/$timer_id" -H 'Content-Type: application/json' -d '{"action":"move"}' >/dev/null
+async_id="$(flcurl "$fl_base/management/jobs?processInstanceId=$pid3" 2>/dev/null | first_job_id || true)"
+if [ -n "$async_id" ]; then
+  flcurl -X POST "$fl_base/management/jobs/$async_id" -H 'Content-Type: application/json' -d '{"action":"execute"}' >/dev/null 2>&1 || true
+fi
+echo ">> timer fired; the BeoordelingEscaleren token is parked for the domain worker"
+
+echo ">> polling until the escalation worker reassigns the beoordeling to the teamlead"
+escalated=""
+for _ in $(seq 1 30); do
+  groups="$(flcurl "$fl_base/runtime/tasks/$task_id3/identitylinks" 2>/dev/null | candidate_groups || true)"
+  [ "$groups" = "teamlead" ] && { escalated=1; break; }
+  sleep 2
+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: 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 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"
 exit 0

infra/seed-config.sh

@@ -35,12 +35,21 @@ populate() {  # volume  source(file or dir/.)
 
 [ "$#" -gt 0 ] || { echo "usage: seed-config.sh <oz|nrc|kc|fl> ..." >&2; exit 2; }
 
+# The registratie process (BPMN) and its diploma-eligibility DMN are deployed as SEPARATE Flowable
+# deployments — the process engine and the DMN engine each own theirs (S-13, ADR-0016). flowable-rest
+# does not cascade a .dmn bundled in a process .bar into the DMN engine, so we seed both raw files and
+# let flowable-init deploy each via its own REST app. We stage them in a temp dir and copy its contents.
+stage_flowable_workflows() {
+  local dir="$1"
+  cp "$here/../workflows/registratie.bpmn" "$here/../workflows/diploma-eligibility.dmn" "$dir/"
+}
+
 for key in "$@"; do
   case "$key" in
     oz) populate rr-oz-config "$here/openzaak/setup_configuration/." ;;
     nrc) populate rr-nrc-config "$here/opennotificaties/setup_configuration/." ;;
     kc) populate rr-kc-realms "$here/keycloak/realms/." ;;
-    fl) populate rr-fl-bpmn  "$here/../workflows/registratie.bpmn" ;;
+    fl) d="$(mktemp -d)"; stage_flowable_workflows "$d"; populate rr-fl-bpmn "$d/." ;;
     *)  echo "unknown seed key: $key" >&2; exit 2 ;;
   esac
 done

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

@@ -35,6 +35,14 @@ 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;
@@ -192,6 +200,78 @@ export class BffApiV1Service {
     );
   }
 
+ postSelfServiceRegistrationsIdWithdraw<TData = void>(id: string, options?: HttpClientBodyOptions): Observable<TData>;
+ postSelfServiceRegistrationsIdWithdraw<TData = void>(id: string, options?: HttpClientEventOptions): Observable<HttpEvent<TData>>;
+ postSelfServiceRegistrationsIdWithdraw<TData = void>(id: string, options?: HttpClientResponseOptions): Observable<AngularHttpResponse<TData>>;
+  postSelfServiceRegistrationsIdWithdraw<TData = void>(
+    id: string, options?: HttpClientObserveOptions): Observable<TData | HttpEvent<TData> | AngularHttpResponse<TData>> {
+    if (options?.observe === 'events') {
+      return this.http.post<TData>(
+      `/self-service/registrations/${id}/withdraw`,
+      undefined,{
+        ...(options as Omit<NonNullable<typeof options>, 'observe'>),
+        observe: 'events',
+      }
+    );
+    }
+
+    if (options?.observe === 'response') {
+      return this.http.post<TData>(
+      `/self-service/registrations/${id}/withdraw`,
+      undefined,{
+        ...(options as Omit<NonNullable<typeof options>, 'observe'>),
+        observe: 'response',
+      }
+    );
+    }
+
+    return this.http.post<TData>(
+      `/self-service/registrations/${id}/withdraw`,
+      undefined,{
+        ...(options as Omit<NonNullable<typeof options>, 'observe'>),
+        observe: 'body',
+      }
+    );
+  }
+
+ 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

@@ -40,6 +40,15 @@ 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);
@@ -48,4 +57,6 @@ public sealed record SetStatusRequest(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,4 +7,8 @@ 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

@@ -37,4 +37,33 @@ 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

@@ -0,0 +1,17 @@
+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

@@ -16,4 +16,11 @@ public interface IZaakGateway
     /// <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

@@ -80,6 +80,39 @@ 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)
@@ -96,6 +129,26 @@ 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)
@@ -182,4 +235,26 @@ public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) :
 
     private sealed record ResultaattypeDto(
         [property: JsonPropertyName("url")] string Url);
+
+    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,6 +77,18 @@ 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)
     {

services/acl/Acl.IntegrationTests/OpenZaakGatewayIntegrationTests.cs

@@ -74,4 +74,58 @@ public sealed class OpenZaakGatewayIntegrationTests(OpenZaakFixture stack)
         var eindstatustype = await stack.FindEindstatustypeAsync(zaaktype!);
         Assert.Equal(eindstatustype.ToString(), status.GetProperty("statustype").GetString());
     }
+
+    [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

@@ -30,6 +30,15 @@ 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()
@@ -38,6 +47,7 @@ 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
@@ -55,6 +65,7 @@ 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)));
 
@@ -81,6 +92,7 @@ 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)));
 
@@ -114,6 +126,41 @@ public class AclServiceTests
         Assert.Null(gateway.Approved);
     }
 
+    [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

@@ -432,4 +432,114 @@ 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

@@ -22,6 +22,17 @@ public interface IDomainClient
 {
     Task<SubmitAccepted> SubmitRegistrationAsync(string bsn, CancellationToken ct = default);
 
+    /// <summary>Withdraw the caller's own registration ("trek aanvraag in"). Owner-scoped by
+    /// <paramref name="bsn"/>. Returns <c>false</c> when the domain reports the registration is
+    /// 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);
 
@@ -47,6 +58,30 @@ public sealed class DomainClient(HttpClient http) : IDomainClient
         return new SubmitAccepted(dto.RegistrationId, dto.Status);
     }
 
+    public async Task<bool> WithdrawRegistrationAsync(string registrationId, string bsn, CancellationToken ct = default)
+    {
+        using var response = await http.PostAsJsonAsync(
+            $"registrations/{registrationId}/withdraw", new { bsn }, 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<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

@@ -86,6 +86,46 @@ app.MapPost("/self-service/registrations", async (ClaimsPrincipal user, IDomainC
     .Produces(StatusCodes.Status400BadRequest)
     .Produces(StatusCodes.Status401Unauthorized);
 
+// Self-service withdrawal (S-11): the signed-in zorgprofessional withdraws their own registration.
+// The bsn comes from the DigiD token and is forwarded to the domain, which owner-scopes the action;
+// a registration that is unknown or not the caller's comes back 404 (ownership is not revealed).
+app.MapPost("/self-service/registrations/{id}/withdraw", async (string id, ClaimsPrincipal user, IDomainClient domain, CancellationToken ct) =>
+{
+    var bsn = user.FindFirstValue("bsn");
+    if (string.IsNullOrWhiteSpace(bsn))
+        return Results.BadRequest("The token carries no bsn claim.");
+
+    var withdrawn = await domain.WithdrawRegistrationAsync(id, bsn, ct);
+    return withdrawn ? Results.NoContent() : Results.NotFound();
+})
+    .RequireAuthorization()
+    .Produces(StatusCodes.Status204NoContent)
+    .Produces(StatusCodes.Status400BadRequest)
+    .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) =>
 {
@@ -125,6 +165,10 @@ 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

@@ -82,6 +82,30 @@ internal sealed class FakeDomainClient : IDomainClient
         return Task.FromResult(Result);
     }
 
+    public (string RegistrationId, string Bsn)? Withdrawn { get; private set; }
+
+    /// <summary>Whether the fake domain reports the withdrawal as done (true → 204) or not-found/not-owned
+    /// (false → 404). Tests set this to exercise the relay.</summary>
+    public bool WithdrawSucceeds { get; set; } = true;
+
+    public Task<bool> WithdrawRegistrationAsync(string registrationId, string bsn, CancellationToken ct = default)
+    {
+        Withdrawn = (registrationId, bsn);
+        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

@@ -71,5 +71,102 @@ public class SelfServiceEndpointTests
         Assert.Equal("reg-123", body!.RegistrationId);
     }
 
+    private static HttpRequestMessage Withdraw(string? bearer, string id = "reg-123")
+    {
+        var request = new HttpRequestMessage(HttpMethod.Post, $"/self-service/registrations/{id}/withdraw");
+        if (bearer is not null)
+            request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", bearer);
+        return request;
+    }
+
+    [Fact]
+    public async Task Rejects_a_withdrawal_without_a_token()
+    {
+        using var factory = new BffFactory();
+
+        var response = await factory.CreateClient().SendAsync(Withdraw(bearer: null));
+
+        Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
+        Assert.Null(factory.Domain.Withdrawn);
+    }
+
+    [Fact]
+    public async Task Withdraws_the_callers_registration_forwarding_the_id_and_bsn()
+    {
+        using var factory = new BffFactory();
+
+        var response = await factory.CreateClient().SendAsync(Withdraw(TestTokens.Valid("123456782"), "reg-9"));
+
+        Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
+        Assert.Equal(("reg-9", "123456782"), factory.Domain.Withdrawn);
+    }
+
+    [Fact]
+    public async Task Relays_not_found_when_the_registration_is_unknown_or_not_the_callers()
+    {
+        using var factory = new BffFactory();
+        factory.Domain.WithdrawSucceeds = false;
+
+        var response = await factory.CreateClient().SendAsync(Withdraw(TestTokens.Valid("123456782")));
+
+        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

@@ -30,6 +30,78 @@
         }
       }
     },
+    "/self-service/registrations/{id}/withdraw": {
+      "post": {
+        "tags": [
+          "Bff.Api"
+        ],
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "No Content"
+          },
+          "400": {
+            "description": "Bad Request"
+          },
+          "401": {
+            "description": "Unauthorized"
+          },
+          "404": {
+            "description": "Not Found"
+          }
+        }
+      }
+    },
+    "/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": [
@@ -166,6 +238,29 @@
           }
         }
       },
+      "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

@@ -21,17 +21,30 @@ builder.Services.AddHttpClient<FlowableWorkflowClient>();
 builder.Services.AddTransient<IWorkflowClient>(sp => sp.GetRequiredService<FlowableWorkflowClient>());
 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();
 
@@ -42,7 +55,12 @@ app.MapGet("/health", () => "Healthy");
 // a location to read the registration's progress (ADR-0009, eventual consistency).
 app.MapPost("/registrations", async (SubmitRegistrationRequest body, SubmitRegistration submit, CancellationToken ct) =>
 {
-    var id = await submit.HandleAsync(new SubmitRegistrationCommand(body.Bsn), ct);
+    // Diploma origin defaults to domestic; a foreign (eIDAS) submission passes "Buitenlands" so the
+    // workflow's DMN routes it through CBGV-advies (S-13). An unknown value is a bad request.
+    if (!Enum.TryParse<DiplomaOrigin>(body.DiplomaOrigin, ignoreCase: true, out var origin) && body.DiplomaOrigin is not null)
+        return Results.BadRequest(new { error = $"Unknown diplomaOrigin '{body.DiplomaOrigin}'. Expected 'Binnenlands' or 'Buitenlands'." });
+
+    var id = await submit.HandleAsync(new SubmitRegistrationCommand(body.Bsn, origin), ct);
     return Results.Accepted($"/registrations/{id}", new RegistrationResponse(id.ToString(), RegistrationStatus.Ingediend.ToString(), null));
 });
 
@@ -74,6 +92,48 @@ app.MapPost("/registrations/{id}/decide", async (string id, DecideRequest body,
     return Results.NoContent();
 });
 
+// Withdraw a registration (S-11): the zorgprofessional pulls their own still-open submission back,
+// advancing it to INGETROKKEN and cancelling its workflow. Owner-scoped by the caller's bsn (the BFF
+// forwards it from the DigiD token, S-11c); a registration that is unknown or not the caller's is
+// 404 (indistinguishable, so ownership isn't leaked). Idempotent.
+app.MapPost("/registrations/{id}/withdraw", async (string id, WithdrawRequest body, WithdrawRegistration withdraw, 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 withdraw a registration." });
+
+    var outcome = await withdraw.HandleAsync(new WithdrawRegistrationCommand(new RegistrationId(guid), body.Bsn), ct);
+    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).
@@ -95,10 +155,14 @@ app.MapGet("/registrations/{id}", async (string id, IRegistrationStore store, Ca
 
 await app.RunAsync();
 
-public sealed record SubmitRegistrationRequest(string Bsn);
+public sealed record SubmitRegistrationRequest(string Bsn, string? DiplomaOrigin = null);
 
 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

@@ -0,0 +1,37 @@
+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)
+{
+    /// <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;
+
+        registration.Expire();
+        await store.SaveAsync(registration, ct);
+    }
+}

services/domain/Big.Application/Ports.cs

@@ -11,10 +11,28 @@ public interface IWorkflowClient
 {
     /// <summary>
     /// Start one <c>registratie</c> process instance for the given registration, carrying the
-    /// registration id so the <c>OpenZaakAanmaken</c> external task can be correlated back to its
-    /// aggregate. Returns the process instance id.
+    /// registration id (so the <c>OpenZaakAanmaken</c> external task can be correlated back to its
+    /// aggregate) and the diploma origin (so the workflow's DMN can route foreign diplomas through
+    /// CBGV-advies, S-13). Returns the process instance id.
     /// </summary>
-    Task<string> StartRegistrationProcessAsync(RegistrationId registrationId, CancellationToken ct = default);
+    Task<string> StartRegistrationProcessAsync(
+        RegistrationId registrationId, DiplomaOrigin diplomaOrigin, CancellationToken ct = default);
+
+    /// <summary>
+    /// Cancel a running <c>registratie</c> process on withdrawal (S-11): correlate the
+    /// <c>RegistratieIngetrokken</c> message to the instance, tripping the interrupting message event
+    /// that ends it (ADR-0014). Best-effort — if the instance is not waiting on that message (already
+    /// 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>
@@ -34,6 +52,13 @@ 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>
@@ -78,3 +103,18 @@ public interface IRegistrationStore
 /// it) and the registration id it carries as a process variable.
 /// </summary>
 public sealed record OpenZaakJob(string JobId, RegistrationId RegistrationId);
+
+/// <summary>
+/// An acquired <c>BeoordelingEscaleren</c> escalation job (S-14): the Flowable job id and the process
+/// instance whose still-open <c>Beoordelen</c> task must be reassigned from behandelaar to teamlead
+/// 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

@@ -0,0 +1,54 @@
+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.Application/SubmitRegistration.cs

@@ -2,8 +2,10 @@ using Big.Domain;
 
 namespace Big.Application;
 
-/// <summary>A zorgprofessional's request to register, in domain language. No ZGW concepts.</summary>
-public sealed record SubmitRegistrationCommand(string Bsn);
+/// <summary>A zorgprofessional's request to register, in domain language. No ZGW concepts. The
+/// diploma origin defaults to domestic (the DigiD path); a foreign (eIDAS) submission sets it to
+/// <see cref="DiplomaOrigin.Buitenlands"/> so the workflow's DMN routes it through CBGV-advies (S-13).</summary>
+public sealed record SubmitRegistrationCommand(string Bsn, DiplomaOrigin DiplomaOrigin = DiplomaOrigin.Binnenlands);
 
 /// <summary>
 /// The submit use case: create the <see cref="Registration"/> aggregate (INGEDIEND), persist it,
@@ -18,13 +20,14 @@ public sealed class SubmitRegistration(IRegistrationStore store, IWorkflowClient
     {
         ArgumentNullException.ThrowIfNull(command);
 
-        var registration = Registration.Submit(command.Bsn);
+        var registration = Registration.Submit(command.Bsn, command.DiplomaOrigin);
 
         // Persist before starting the process so the worker can correlate the OpenZaakAanmaken
         // job back to an aggregate that already exists (ADR-0009).
         await store.SaveAsync(registration, ct);
 
-        var processInstanceId = await workflow.StartRegistrationProcessAsync(registration.Id, ct);
+        var processInstanceId = await workflow.StartRegistrationProcessAsync(
+            registration.Id, registration.DiplomaOrigin, ct);
         registration.RecordProcessStarted(processInstanceId);
         await store.SaveAsync(registration, ct);
 

services/domain/Big.Application/Werkbak.cs

@@ -1,3 +1,5 @@
+using Big.Domain;
+
 namespace Big.Application;
 
 /// <summary>One row of the behandelaar's werkbak: a registration awaiting beoordeling, with the
@@ -8,7 +10,8 @@ public sealed record WerkbakItem(string RegistrationId, string Bsn, string Statu
 /// The werkbak query (S-12c): the registrations awaiting a behandelaar's beoordeling. It reads the
 /// open <c>Beoordelen</c> tasks from the workflow engine (§8.2, via <see cref="IUserTaskClient"/>) —
 /// the authoritative set of work items — and enriches each with its aggregate (bsn + status). A task
-/// whose registration the domain doesn't know is skipped rather than invented.
+/// whose registration the domain doesn't know, or whose registration is no longer open for beoordeling
+/// (e.g. withdrawn — S-11 — while its task lingers until the workflow cancels it), is skipped.
 /// </summary>
 public sealed class Werkbak(IUserTaskClient tasks, IRegistrationStore store)
 {
@@ -20,7 +23,7 @@ public sealed class Werkbak(IUserTaskClient tasks, IRegistrationStore store)
         foreach (var task in open)
         {
             var registration = await store.GetAsync(task.RegistrationId, ct);
-            if (registration is null)
+            if (registration is null || !IsOpenForBeoordeling(registration.Status))
                 continue;
 
             items.Add(new WerkbakItem(
@@ -29,4 +32,9 @@ public sealed class Werkbak(IUserTaskClient tasks, IRegistrationStore store)
 
         return items;
     }
+
+    // Only registrations still open for a decision belong in the werkbak; a terminal one (decided or
+    // withdrawn — S-11) whose Beoordelen task has not yet been cleared must not surface to a behandelaar.
+    private static bool IsOpenForBeoordeling(RegistrationStatus status)
+        => status is RegistrationStatus.Ingediend or RegistrationStatus.InBehandeling;
 }

services/domain/Big.Application/WithdrawRegistration.cs

@@ -0,0 +1,55 @@
+using Big.Domain;
+
+namespace Big.Application;
+
+/// <summary>A zorgprofessional's request to withdraw their own registration ("trek aanvraag in").
+/// <paramref name="Bsn"/> is the authenticated caller (from the DigiD token, forwarded by the BFF):
+/// only the registration's own bsn may withdraw it.</summary>
+public sealed record WithdrawRegistrationCommand(RegistrationId RegistrationId, string Bsn);
+
+/// <summary>The outcome of a withdrawal request.</summary>
+public enum WithdrawOutcome
+{
+    /// <summary>The registration is now (or already was) INGETROKKEN.</summary>
+    Withdrawn,
+
+    /// <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 withdrawal use case (S-11): a zorgprofessional pulls a still-open registration back. It
+/// advances the aggregate to INGETROKKEN, persists it, then cancels the running registratie process
+/// by correlating the withdrawal message to its instance (ADR-0014), so the case leaves the
+/// behandelaar's werkbak. Idempotent — a repeated or redelivered withdrawal of an already-withdrawn
+/// registration is a no-op (not persisted or cancelled again). Cancelling is best-effort: if the
+/// registration never started a process the withdrawal still stands (the process cancel is skipped),
+/// mirroring how <see cref="BeoordeelRegistratie"/> completes its task best-effort.
+/// </summary>
+public sealed class WithdrawRegistration(IRegistrationStore store, IWorkflowClient workflow)
+{
+    public async Task<WithdrawOutcome> HandleAsync(WithdrawRegistrationCommand 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 WithdrawOutcome.NotFound;
+
+        // A repeated withdrawal is a no-op: don't persist or cancel the already-withdrawn one again.
+        if (registration.Status == RegistrationStatus.Ingetrokken)
+            return WithdrawOutcome.Withdrawn;
+
+        registration.Withdraw();
+        await store.SaveAsync(registration, ct);
+
+        // Cancel the running process (if one was started) so its Beoordelen task leaves the werkbak.
+        if (registration.ProcessInstanceId is not null)
+            await workflow.WithdrawProcessAsync(registration.ProcessInstanceId, ct);
+
+        return WithdrawOutcome.Withdrawn;
+    }
+}

services/domain/Big.Domain/DiplomaOrigin.cs

@@ -0,0 +1,17 @@
+namespace Big.Domain;
+
+/// <summary>
+/// Where a zorgprofessional's diploma was issued. It is the input to the diploma-eligibility decision
+/// (S-13): a <see cref="Buitenlands"/> (foreign) diploma routes the registratie through an extra
+/// CBGV-advies assessment step, a <see cref="Binnenlands"/> (domestic) one goes straight to beoordeling.
+/// The decision itself lives in the workflow's DMN, not here (ADR-0016); the domain only carries the
+/// origin and hands it to the process as a start variable.
+/// </summary>
+public enum DiplomaOrigin
+{
+    /// <summary>A Dutch (domestic) diploma. Default for a registration submitted via DigiD.</summary>
+    Binnenlands,
+
+    /// <summary>A foreign diploma (e.g. an eIDAS submission). Triggers the CBGV-advies step.</summary>
+    Buitenlands,
+}

services/domain/Big.Domain/Registration.cs

@@ -7,10 +7,11 @@ namespace Big.Domain;
 /// </summary>
 public sealed class Registration
 {
-    private Registration(RegistrationId id, string bsn)
+    private Registration(RegistrationId id, string bsn, DiplomaOrigin diplomaOrigin)
     {
         Id = id;
         Bsn = bsn;
+        DiplomaOrigin = diplomaOrigin;
         Status = RegistrationStatus.Ingediend;
     }
 
@@ -20,6 +21,10 @@ public sealed class Registration
     /// as the domain payload; the domain never constructs ZGW concepts from it (§8.1).</summary>
     public string Bsn { get; }
 
+    /// <summary>Where the diploma was issued. Rides along to the process as a start variable and
+    /// drives the diploma-eligibility DMN's foreign→CBGV-advies routing (S-13, ADR-0016).</summary>
+    public DiplomaOrigin DiplomaOrigin { get; }
+
     public RegistrationStatus Status { get; private set; }
 
     /// <summary>The Flowable process instance driving this registration, once started.</summary>
@@ -28,11 +33,13 @@ public sealed class Registration
     /// <summary>The zaak the ACL opened for this registration, once the external task has run.</summary>
     public Uri? ZaakUrl { get; private set; }
 
-    /// <summary>Submit a new registration. It begins in <see cref="RegistrationStatus.Ingediend"/>.</summary>
-    public static Registration Submit(string bsn)
+    /// <summary>Submit a new registration. It begins in <see cref="RegistrationStatus.Ingediend"/>.
+    /// The diploma origin defaults to <see cref="DiplomaOrigin.Binnenlands"/> — the common DigiD path;
+    /// a foreign (eIDAS) submission passes <see cref="DiplomaOrigin.Buitenlands"/>.</summary>
+    public static Registration Submit(string bsn, DiplomaOrigin diplomaOrigin = DiplomaOrigin.Binnenlands)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(bsn);
-        return new Registration(RegistrationId.New(), bsn);
+        return new Registration(RegistrationId.New(), bsn, diplomaOrigin);
     }
 
     /// <summary>Record that the registratie workflow process has been started for this registration.</summary>
@@ -111,7 +118,39 @@ public sealed class Registration
         Status = RegistrationStatus.Afgewezen;
     }
 
-    // A decision is only valid while the registration is still open (INGEDIEND or IN_BEHANDELING).
+    /// <summary>
+    /// Withdraw the registration — the zorgprofessional pulls their own submission back (S-11). Allowed
+    /// while it is still open (INGEDIEND or IN_BEHANDELING) and needs no zaak; a registration that has
+    /// already been decided (INGESCHREVEN/AFGEWEZEN) can no longer be withdrawn. Re-withdrawing one
+    /// already <see cref="RegistrationStatus.Ingetrokken"/> is a no-op.
+    /// </summary>
+    public void Withdraw()
+    {
+        if (Status == RegistrationStatus.Ingetrokken)
+            return;
+
+        RequireOpenForDecision(nameof(Withdraw));
+        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).
     private void RequireOpenForDecision(string decision)
     {
         if (Status is not (RegistrationStatus.Ingediend or RegistrationStatus.InBehandeling))

services/domain/Big.Domain/RegistrationStatus.cs

@@ -3,7 +3,8 @@ namespace Big.Domain;
 /// <summary>The lifecycle states a <see cref="Registration"/> moves through. Submission starts in
 /// <see cref="Ingediend"/>; a behandelaar takes it <see cref="InBehandeling"/> and decides it into one
 /// of the terminal states <see cref="Ingeschreven"/> (approved) or <see cref="Afgewezen"/> (rejected).
-/// Withdrawal and herregistratie states arrive in their own slices (S-11+).</summary>
+/// A zorgprofessional can withdraw a still-open registration into <see cref="Ingetrokken"/> (S-11).
+/// The herregistratie state arrives in its own slice.</summary>
 public enum RegistrationStatus
 {
     /// <summary>Submitted by the zorgprofessional; the registratie process has been started.</summary>
@@ -17,4 +18,11 @@ public enum RegistrationStatus
 
     /// <summary>Rejected by the behandelaar. Terminal.</summary>
     Afgewezen,
+
+    /// <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,6 +31,23 @@ public sealed class AclHttpClient(HttpClient http, AclOptions options) : IAclCli
         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);
@@ -38,4 +55,13 @@ 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 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/BeoordelingEscalatieProcessor.cs

@@ -0,0 +1,37 @@
+using Microsoft.Extensions.Logging;
+
+namespace Big.Infrastructure;
+
+/// <summary>
+/// One poll tick of the beoordeling-escalation worker (S-14, ADR-0015): acquire the parked
+/// <c>BeoordelingEscaleren</c> jobs — the tokens the 14-day boundary timer on <c>Beoordelen</c> spawns
+/// — reassign each instance's still-open <c>Beoordelen</c> task to the teamlead, and complete the job.
+/// 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→reassign→complete logic is unit-testable without a running host.
+/// </summary>
+public sealed class BeoordelingEscalatieProcessor(
+    IBeoordelingEscalatieClient client,
+    ILogger<BeoordelingEscalatieProcessor> logger)
+{
+    /// <summary>Acquire and process up to <paramref name="maxJobs"/> escalations. Returns the number acquired.</summary>
+    public async Task<int> PumpOnceAsync(int maxJobs, CancellationToken ct = default)
+    {
+        var jobs = await client.AcquireBeoordelingEscalatieJobsAsync(maxJobs, ct);
+
+        foreach (var job in jobs)
+        {
+            try
+            {
+                await client.ReassignBeoordelingToTeamleadAsync(job.ProcessInstanceId, ct);
+                await client.CompleteBeoordelingEscalatieJobAsync(job.JobId, ct);
+            }
+            catch (Exception ex)
+            {
+                // Leave the job un-completed: its lock expires and Flowable redelivers it (§8.6).
+                logger.LogError(ex, "BeoordelingEscaleren job {JobId} failed; leaving it for redelivery.", job.JobId);
+            }
+        }
+
+        return jobs.Count;
+    }
+}

services/domain/Big.Infrastructure/BeoordelingEscalatiePump.cs

@@ -0,0 +1,49 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace Big.Infrastructure;
+
+/// <summary>
+/// The hosted polling loop of the beoordeling-escalation worker (S-14, ADR-0015): on an interval it
+/// resolves a scoped <see cref="BeoordelingEscalatieProcessor"/> and asks it to drain the parked
+/// <c>BeoordelingEscaleren</c> jobs. A deliberately thin shell — all acquire/reassign/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="OpenZaakJobPump"/>.
+/// </summary>
+public sealed class BeoordelingEscalatiePump(
+    IServiceScopeFactory scopeFactory,
+    FlowableOptions options,
+    ILogger<BeoordelingEscalatiePump> logger) : BackgroundService
+{
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            try
+            {
+                using var scope = scopeFactory.CreateScope();
+                var processor = scope.ServiceProvider.GetRequiredService<BeoordelingEscalatieProcessor>();
+                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, "BeoordelingEscaleren job poll failed; retrying after the poll interval.");
+            }
+
+            try
+            {
+                await Task.Delay(options.PollInterval, stoppingToken);
+            }
+            catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
+            {
+                break;
+            }
+        }
+    }
+}

services/domain/Big.Infrastructure/FlowableWorkflowClient.cs

@@ -15,20 +15,31 @@ 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
+    : IWorkflowClient, IExternalWorkerClient, IUserTaskClient, IBeoordelingEscalatieClient, IRegistratieVerlopenClient
 {
     private const string Topic = "OpenZaakAanmaken";
+    private const string EscalatieTopic = "BeoordelingEscaleren";
+    private const string VerlopenTopic = "RegistratieVerlopen";
     private const string ProcessDefinitionKey = "registratie";
     private const string BeoordelenTaskKey = "Beoordelen";
+    private const string WachtOpDocumentenTaskKey = "WachtOpDocumenten";
+    private const string BehandelaarGroup = "behandelaar";
+    private const string TeamleadGroup = "teamlead";
     private const string RegistrationIdVariable = "registrationId";
+    private const string DiplomaOriginVariable = "diplomaOrigin";
     private const string ZaakUrlVariable = "zaakUrl";
     private const string BesluitVariable = "besluit";
+    private const string IngetrokkenMessage = "RegistratieIngetrokken";
 
-    public async Task<string> StartRegistrationProcessAsync(RegistrationId registrationId, CancellationToken ct = default)
+    public async Task<string> StartRegistrationProcessAsync(
+        RegistrationId registrationId, DiplomaOrigin diplomaOrigin, CancellationToken ct = default)
     {
         var request = new StartProcessRequest(
             ProcessDefinitionKey,
-            [new Variable(RegistrationIdVariable, "string", registrationId.ToString())]);
+            [
+                new Variable(RegistrationIdVariable, "string", registrationId.ToString()),
+                new Variable(DiplomaOriginVariable, "string", diplomaOrigin.ToString()),
+            ]);
 
         var created = await PostAsync<StartProcessRequest, ProcessInstance>(
             "service/runtime/process-instances", request, ct)
@@ -85,6 +96,120 @@ public sealed class FlowableWorkflowClient(HttpClient http, FlowableOptions opti
         response.EnsureSuccessStatusCode();
     }
 
+    public async Task WithdrawProcessAsync(string processInstanceId, CancellationToken ct = default)
+    {
+        // Correlate the withdrawal message to the instance: find the execution subscribed to it (the
+        // interrupting message event's own execution — NOT the user task's), then deliver
+        // messageEventReceived to that execution so the process ends (ADR-0014). If nothing is
+        // subscribed (the process is not parked at Beoordelen) this is a best-effort no-op.
+        var subscribed = await GetAsync<ExecutionQueryResult>(
+            $"service/runtime/executions?messageEventSubscriptionName={IngetrokkenMessage}&processInstanceId={processInstanceId}",
+            ct);
+
+        var execution = subscribed?.Data?.FirstOrDefault();
+        if (execution is null)
+            return;
+
+        var request = new MessageEventRequest("messageEventReceived", IngetrokkenMessage);
+        using var response = await SendAsync(
+            $"service/runtime/executions/{execution.Id}", request, ct, HttpMethod.Put);
+        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);
+
+        var jobs = await PostAsync<AcquireJobsRequest, List<AcquiredEscalatieJob>>(
+            "external-job-api/acquire/jobs", request, ct) ?? [];
+
+        return [.. jobs.Select(job => new EscalatieJob(job.Id, job.ProcessInstanceId))];
+    }
+
+    public async Task ReassignBeoordelingToTeamleadAsync(string processInstanceId, CancellationToken ct = default)
+    {
+        // The escalation token runs in parallel to the still-open Beoordelen task (non-interrupting
+        // boundary timer); find that task in this instance so we can move it to the teamlead. If the
+        // behandelaar completed it just before the timer fired there is nothing to reassign — a
+        // best-effort no-op (the timer/completion race, cf. §8.6).
+        var query = new TaskByInstanceQueryRequest(processInstanceId, BeoordelenTaskKey);
+        var page = await PostAsync<TaskByInstanceQueryRequest, TaskQueryResult>(
+            "service/query/tasks", query, ct);
+
+        var task = page?.Data?.FirstOrDefault();
+        if (task is null)
+            return;
+
+        // Add teamlead, then drop behandelaar: the task now belongs to the teamlead group.
+        using (var added = await SendAsync(
+            $"service/runtime/tasks/{task.Id}/identitylinks",
+            new IdentityLinkRequest(TeamleadGroup, "candidate"), ct))
+            added.EnsureSuccessStatusCode();
+
+        await DeleteAsync(
+            $"service/runtime/tasks/{task.Id}/identitylinks/groups/{BehandelaarGroup}/candidate", ct);
+    }
+
+    public async Task CompleteBeoordelingEscalatieJobAsync(string jobId, CancellationToken ct = default)
+    {
+        using var response = await SendAsync(
+            $"external-job-api/acquire/jobs/{jobId}/complete", new CompleteJobRequest(options.WorkerId, []), ct);
+        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));
+        message.Headers.Authorization = new AuthenticationHeaderValue("Basic", BasicCredentials());
+        using var response = await http.SendAsync(message, ct);
+        response.EnsureSuccessStatusCode();
+        return await response.Content.ReadFromJsonAsync<TResponse>(ct);
+    }
+
+    private async Task DeleteAsync(string path, CancellationToken ct)
+    {
+        var message = new HttpRequestMessage(HttpMethod.Delete, new Uri(options.BaseUrl, path));
+        message.Headers.Authorization = new AuthenticationHeaderValue("Basic", BasicCredentials());
+        using var response = await http.SendAsync(message, ct);
+        response.EnsureSuccessStatusCode();
+    }
+
     private async Task<TResponse?> PostAsync<TRequest, TResponse>(string path, TRequest body, CancellationToken ct)
     {
         using var response = await SendAsync(path, body, ct);
@@ -92,9 +217,9 @@ public sealed class FlowableWorkflowClient(HttpClient http, FlowableOptions opti
         return await response.Content.ReadFromJsonAsync<TResponse>(ct);
     }
 
-    private Task<HttpResponseMessage> SendAsync<TRequest>(string path, TRequest body, CancellationToken ct)
+    private Task<HttpResponseMessage> SendAsync<TRequest>(string path, TRequest body, CancellationToken ct, HttpMethod? method = null)
     {
-        var message = new HttpRequestMessage(HttpMethod.Post, new Uri(options.BaseUrl, path))
+        var message = new HttpRequestMessage(method ?? HttpMethod.Post, new Uri(options.BaseUrl, path))
         {
             Content = JsonContent.Create(body),
         };
@@ -124,6 +249,14 @@ public sealed class FlowableWorkflowClient(HttpClient http, FlowableOptions opti
         [property: JsonPropertyName("taskDefinitionKey")] string TaskDefinitionKey,
         [property: JsonPropertyName("includeProcessVariables")] bool IncludeProcessVariables);
 
+    private sealed record TaskByInstanceQueryRequest(
+        [property: JsonPropertyName("processInstanceId")] string ProcessInstanceId,
+        [property: JsonPropertyName("taskDefinitionKey")] string TaskDefinitionKey);
+
+    private sealed record IdentityLinkRequest(
+        [property: JsonPropertyName("group")] string Group,
+        [property: JsonPropertyName("type")] string Type);
+
     private sealed record ClaimTaskRequest(
         [property: JsonPropertyName("action")] string Action,
         [property: JsonPropertyName("assignee")] string Assignee);
@@ -132,6 +265,10 @@ public sealed class FlowableWorkflowClient(HttpClient http, FlowableOptions opti
         [property: JsonPropertyName("action")] string Action,
         [property: JsonPropertyName("variables")] IReadOnlyList<Variable> Variables);
 
+    private sealed record MessageEventRequest(
+        [property: JsonPropertyName("action")] string Action,
+        [property: JsonPropertyName("messageName")] string MessageName);
+
     private sealed record TaskQueryResult(
         [property: JsonPropertyName("data")] IReadOnlyList<UserTaskDto>? Data);
 
@@ -154,6 +291,15 @@ public sealed class FlowableWorkflowClient(HttpClient http, FlowableOptions opti
 
     private sealed record ProcessInstance([property: JsonPropertyName("id")] string Id);
 
+    private sealed record ExecutionQueryResult(
+        [property: JsonPropertyName("data")] IReadOnlyList<ExecutionDto>? Data);
+
+    private sealed record ExecutionDto([property: JsonPropertyName("id")] string Id);
+
+    private sealed record AcquiredEscalatieJob(
+        [property: JsonPropertyName("id")] string Id,
+        [property: JsonPropertyName("processInstanceId")] string ProcessInstanceId);
+
     private sealed record AcquiredJob(
         [property: JsonPropertyName("id")] string Id,
         [property: JsonPropertyName("variables")] IReadOnlyList<Variable> Variables)

services/domain/Big.Infrastructure/IExternalWorkerClient.cs

@@ -16,3 +16,39 @@ public interface IExternalWorkerClient
     /// <summary>Complete an acquired job, passing the opened zaak URL back into the process.</summary>
     Task CompleteOpenZaakJobAsync(string jobId, Uri zaakUrl, CancellationToken ct = default);
 }
+
+/// <summary>
+/// The escalation side of the Workflow Client (S-14): the <c>BeoordelingEscaleren</c> external-worker
+/// jobs parked by the 14-day boundary timer on <c>Beoordelen</c>, and the reassignment they drive.
+/// Kept separate from <see cref="IExternalWorkerClient"/> (interface segregation) so the OpenZaak
+/// worker never sees escalation. Implemented by <see cref="FlowableWorkflowClient"/> — the only code
+/// that talks to Flowable (§8.2, ADR-0015).
+/// </summary>
+public interface IBeoordelingEscalatieClient
+{
+    /// <summary>Acquire and lock up to <paramref name="maxJobs"/> <c>BeoordelingEscaleren</c> jobs.</summary>
+    Task<IReadOnlyList<EscalatieJob>> AcquireBeoordelingEscalatieJobsAsync(int maxJobs, CancellationToken ct = default);
+
+    /// <summary>Reassign the still-open <c>Beoordelen</c> task in the given process instance from the
+    /// behandelaar group to teamlead. Best-effort no-op if the task is no longer open.</summary>
+    Task ReassignBeoordelingToTeamleadAsync(string processInstanceId, CancellationToken ct = default);
+
+    /// <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

@@ -0,0 +1,41 @@
+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

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

services/domain/Big.Tests/BeoordelingEscalatieProcessorTests.cs

@@ -0,0 +1,82 @@
+using Big.Application;
+using Big.Infrastructure;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace Big.Tests;
+
+// S-14 (#15): the escalation drain loop. Mirrors OpenZaakJobProcessor — acquire the parked
+// BeoordelingEscaleren jobs, reassign each instance's Beoordelen task to teamlead, then complete the
+// job. A job whose reassignment fails is logged and left un-completed for Flowable to redeliver (§8.6).
+public class BeoordelingEscalatieProcessorTests
+{
+    /// <summary>A fake escalation client: scripts the jobs to acquire, records reassignments and
+    /// completions, and can be told to throw on reassigning a given instance.</summary>
+    private sealed class FakeEscalatieClient(params EscalatieJob[] jobs) : IBeoordelingEscalatieClient
+    {
+        public int AcquireCount { get; private set; }
+        public List<string> Reassigned { get; } = [];
+        public List<string> Completed { get; } = [];
+        public string? ThrowOnInstance { get; set; }
+
+        public Task<IReadOnlyList<EscalatieJob>> AcquireBeoordelingEscalatieJobsAsync(int maxJobs, CancellationToken ct = default)
+        {
+            AcquireCount++;
+            return Task.FromResult<IReadOnlyList<EscalatieJob>>(jobs.Take(maxJobs).ToList());
+        }
+
+        public Task ReassignBeoordelingToTeamleadAsync(string processInstanceId, CancellationToken ct = default)
+        {
+            if (processInstanceId == ThrowOnInstance)
+                throw new InvalidOperationException("reassign failed");
+            Reassigned.Add(processInstanceId);
+            return Task.CompletedTask;
+        }
+
+        public Task CompleteBeoordelingEscalatieJobAsync(string jobId, CancellationToken ct = default)
+        {
+            Completed.Add(jobId);
+            return Task.CompletedTask;
+        }
+    }
+
+    [Fact]
+    public async Task Acquires_an_escalation_reassigns_to_teamlead_and_completes_the_job()
+    {
+        var client = new FakeEscalatieClient(new EscalatieJob("job-9", "pi-1"));
+
+        var acquired = await new BeoordelingEscalatieProcessor(
+            client, NullLogger<BeoordelingEscalatieProcessor>.Instance).PumpOnceAsync(5);
+
+        Assert.Equal(1, acquired);
+        Assert.Equal("pi-1", Assert.Single(client.Reassigned));
+        Assert.Equal("job-9", Assert.Single(client.Completed));
+    }
+
+    [Fact]
+    public async Task A_failing_reassign_is_left_uncompleted_for_flowable_to_redeliver()
+    {
+        var client = new FakeEscalatieClient(new EscalatieJob("job-9", "pi-1")) { ThrowOnInstance = "pi-1" };
+        var logger = new CapturingLogger<BeoordelingEscalatieProcessor>();
+
+        var acquired = await new BeoordelingEscalatieProcessor(client, 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_escalations()
+    {
+        var client = new FakeEscalatieClient();
+
+        var acquired = await new BeoordelingEscalatieProcessor(
+            client, NullLogger<BeoordelingEscalatieProcessor>.Instance).PumpOnceAsync(5);
+
+        Assert.Equal(0, acquired);
+        Assert.Equal(1, client.AcquireCount);
+        Assert.Empty(client.Completed);
+    }
+}

services/domain/Big.Tests/ExpireRegistrationWorkerTests.cs

@@ -0,0 +1,84 @@
+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";
+
+    private static Registration Submitted(string processInstanceId = "proc-1")
+    {
+        var registration = Registration.Submit(Bsn);
+        registration.RecordProcessStarted(processInstanceId);
+        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).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 An_already_verlopen_registration_is_not_persisted_again()
+    {
+        // A redelivered job (§8.6) finds the aggregate already VERLOPEN: a no-op, not saved again.
+        var store = new FakeRegistrationStore();
+        var registration = Submitted();
+        registration.Expire();
+        store.Seed(registration);
+
+        await new ExpireRegistrationWorker(store).HandleAsync(
+            new RegistratieVerlopenJob("job-7", registration.Id));
+
+        Assert.Equal(0, store.SaveCount);
+        Assert.Equal(RegistrationStatus.Verlopen, (await store.GetAsync(registration.Id))!.Status);
+    }
+
+    [Fact]
+    public async Task An_already_resolved_registration_is_left_alone_and_the_job_completes()
+    {
+        // 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.
+        var store = new FakeRegistrationStore();
+        var registration = Submitted();
+        registration.Withdraw();
+        store.Seed(registration);
+
+        await new ExpireRegistrationWorker(store).HandleAsync(
+            new RegistratieVerlopenJob("job-7", registration.Id));
+
+        Assert.Equal(0, store.SaveCount);
+        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).HandleAsync(
+                new RegistratieVerlopenJob("job-7", RegistrationId.New())));
+    }
+
+    [Fact]
+    public async Task Rejects_a_null_job()
+        => await Assert.ThrowsAsync<ArgumentNullException>(() =>
+            new ExpireRegistrationWorker(new FakeRegistrationStore()).HandleAsync(null!));
+}

services/domain/Big.Tests/Fakes.cs

@@ -32,13 +32,30 @@ internal sealed class FakeWorkflowClient(string processInstanceId = "proc-1", Ac
     : 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, CancellationToken ct = default)
+    public Task<string> StartRegistrationProcessAsync(
+        RegistrationId registrationId, DiplomaOrigin diplomaOrigin, CancellationToken ct = default)
     {
         onStart?.Invoke(registrationId);
         StartedFor = registrationId;
+        StartedWithOrigin = diplomaOrigin;
         return Task.FromResult(processInstanceId);
     }
+
+    public Task WithdrawProcessAsync(string processInstanceId, CancellationToken ct = default)
+    {
+        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
@@ -93,4 +110,13 @@ 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);
+    }
 }

services/domain/Big.Tests/FlowableWorkflowClientTests.cs

@@ -24,7 +24,7 @@ public class FlowableWorkflowClientTests
         var client = Client(capture.Responds(HttpStatusCode.Created, """{"id":"pi-1"}"""));
         var rid = RegistrationId.New();
 
-        var pid = await client.StartRegistrationProcessAsync(rid);
+        var pid = await client.StartRegistrationProcessAsync(rid, DiplomaOrigin.Binnenlands);
 
         Assert.Equal("pi-1", pid);
         Assert.Equal(HttpMethod.Post, capture.Seen!.Method);
@@ -38,6 +38,22 @@ public class FlowableWorkflowClientTests
         Assert.Contains($"\"value\":\"{rid}\"", capture.Body);
     }
 
+    [Theory]
+    [InlineData(DiplomaOrigin.Binnenlands, "Binnenlands")]
+    [InlineData(DiplomaOrigin.Buitenlands, "Buitenlands")]
+    public async Task Start_posts_the_diploma_origin_as_a_process_variable(DiplomaOrigin origin, string expected)
+    {
+        // The diploma origin rides along as a start variable so the workflow's DMN can route foreign
+        // diplomas through CBGV-advies (S-13, ADR-0016).
+        var capture = new RequestCapture();
+        var client = Client(capture.Responds(HttpStatusCode.Created, """{"id":"pi-1"}"""));
+
+        await client.StartRegistrationProcessAsync(RegistrationId.New(), origin);
+
+        Assert.Contains("\"name\":\"diplomaOrigin\"", capture.Body);
+        Assert.Contains($"\"value\":\"{expected}\"", capture.Body);
+    }
+
     [Fact]
     public async Task Start_uses_the_configured_worker_credentials_and_defaults()
     {
@@ -125,7 +141,7 @@ public class FlowableWorkflowClientTests
         var client = Client(capture.Responds(HttpStatusCode.InternalServerError));
 
         await Assert.ThrowsAsync<HttpRequestException>(
-            () => client.StartRegistrationProcessAsync(RegistrationId.New()));
+            () => client.StartRegistrationProcessAsync(RegistrationId.New(), DiplomaOrigin.Binnenlands));
     }
 
     [Fact]
@@ -135,7 +151,7 @@ public class FlowableWorkflowClientTests
         var client = Client(capture.Responds(HttpStatusCode.Created, "null"));
 
         var ex = await Assert.ThrowsAsync<InvalidOperationException>(
-            () => client.StartRegistrationProcessAsync(RegistrationId.New()));
+            () => client.StartRegistrationProcessAsync(RegistrationId.New(), DiplomaOrigin.Binnenlands));
         Assert.Contains("empty process-instance", ex.Message);
     }
 
@@ -242,6 +258,61 @@ public class FlowableWorkflowClientTests
         Assert.Contains($"\"value\":\"{expected}\"", capture.Body);
     }
 
+    [Fact]
+    public async Task Withdraw_process_correlates_the_message_to_the_subscribed_execution()
+    {
+        HttpRequestMessage? getReq = null;
+        HttpRequestMessage? putReq = null;
+        string? putBody = null;
+        var client = Client(new StubHandler(async req =>
+        {
+            if (req.Method == HttpMethod.Get)
+            {
+                getReq = req;
+                return new HttpResponseMessage(HttpStatusCode.OK)
+                {
+                    Content = new StringContent("""{"data":[{"id":"exec-9"}]}""", Encoding.UTF8, "application/json"),
+                };
+            }
+            putReq = req;
+            putBody = await req.Content!.ReadAsStringAsync();
+            return new HttpResponseMessage(HttpStatusCode.OK);
+        }));
+
+        await client.WithdrawProcessAsync("pi-1");
+
+        // 1. Find the execution subscribed to the withdrawal message for this instance.
+        Assert.Equal(HttpMethod.Get, getReq!.Method);
+        Assert.Contains("service/runtime/executions", getReq.RequestUri!.ToString());
+        Assert.Contains("messageEventSubscriptionName=RegistratieIngetrokken", getReq.RequestUri!.Query);
+        Assert.Contains("processInstanceId=pi-1", getReq.RequestUri!.Query);
+        // 2. Deliver messageEventReceived to that execution (PUT), tripping the interrupting event.
+        Assert.Equal(HttpMethod.Put, putReq!.Method);
+        Assert.Equal("http://flowable/flowable-rest/service/runtime/executions/exec-9",
+            putReq.RequestUri!.ToString());
+        Assert.Contains("\"action\":\"messageEventReceived\"", putBody);
+        Assert.Contains("\"messageName\":\"RegistratieIngetrokken\"", putBody);
+    }
+
+    [Fact]
+    public async Task Withdraw_process_is_a_no_op_when_no_execution_is_subscribed()
+    {
+        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":[]}""", Encoding.UTF8, "application/json"),
+            });
+        }));
+
+        await client.WithdrawProcessAsync("pi-1");
+
+        // No subscribed execution → no message delivered (best-effort), no throw.
+        Assert.DoesNotContain(HttpMethod.Put, methods);
+    }
+
     [Fact]
     public async Task Complete_beoordeling_throws_when_flowable_rejects_the_request()
     {
@@ -251,4 +322,210 @@ public class FlowableWorkflowClientTests
         await Assert.ThrowsAsync<HttpRequestException>(
             () => client.CompleteBeoordelingAsync("task-1", BeoordelingsBesluit.Goedkeuren));
     }
+
+    // ── S-14 (#15): 14-day beoordeling escalation → reassign to teamlead (ADR-0015) ───────────────
+    // The BPMN parks a parallel escalation token on a non-interrupting P14D boundary timer, surfaced as
+    // an external-worker job on the BeoordelingEscaleren topic. The worker reassigns the still-open
+    // Beoordelen task from the behandelaar group to teamlead, then completes the escalation job.
+
+    [Fact]
+    public async Task Acquire_escalation_jobs_posts_the_escalation_topic_and_parses_the_process_instance()
+    {
+        var capture = new RequestCapture();
+        var client = Client(capture.Responds(HttpStatusCode.OK,
+            """[{"id":"job-9","processInstanceId":"pi-1"}]"""));
+
+        var jobs = await client.AcquireBeoordelingEscalatieJobsAsync(3);
+
+        var job = Assert.Single(jobs);
+        Assert.Equal("job-9", job.JobId);
+        Assert.Equal("pi-1", job.ProcessInstanceId);
+        Assert.Equal("http://flowable/flowable-rest/external-job-api/acquire/jobs",
+            capture.Seen!.RequestUri!.ToString());
+        Assert.Contains("\"topic\":\"BeoordelingEscaleren\"", capture.Body);
+        Assert.Contains("\"numberOfTasks\":3", capture.Body);
+        Assert.Contains("\"workerId\":\"worker-x\"", capture.Body);
+    }
+
+    [Theory]
+    [InlineData("[]")]
+    [InlineData("null")]
+    public async Task Acquire_escalation_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.AcquireBeoordelingEscalatieJobsAsync(1));
+        Assert.NotNull(capture.Seen);
+    }
+
+    [Fact]
+    public async Task Reassign_moves_the_open_beoordelen_task_from_behandelaar_to_teamlead()
+    {
+        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()));
+            // The task query returns the still-open Beoordelen task parked in this instance.
+            return req.RequestUri!.AbsoluteUri.EndsWith("service/query/tasks")
+                ? new HttpResponseMessage(HttpStatusCode.OK)
+                {
+                    Content = new StringContent("""{"data":[{"id":"task-7"}],"total":1}""",
+                        Encoding.UTF8, "application/json"),
+                }
+                : new HttpResponseMessage(HttpStatusCode.OK);
+        }));
+
+        await client.ReassignBeoordelingToTeamleadAsync("pi-1");
+
+        // 1. Find the still-open Beoordelen 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\":\"Beoordelen\"", query.Body);
+        // 2. Add teamlead as a candidate group on that task.
+        var add = requests.Single(r => r.Method == HttpMethod.Post
+            && r.Url.EndsWith("service/runtime/tasks/task-7/identitylinks"));
+        Assert.Contains("\"group\":\"teamlead\"", add.Body);
+        Assert.Contains("\"type\":\"candidate\"", add.Body);
+        // 3. Remove behandelaar as a candidate group — the task now belongs to teamlead.
+        Assert.Contains(requests, r => r.Method == HttpMethod.Delete
+            && r.Url.EndsWith("service/runtime/tasks/task-7/identitylinks/groups/behandelaar/candidate"));
+    }
+
+    [Fact]
+    public async Task Reassign_is_a_no_op_when_the_beoordelen_task_is_no_longer_open()
+    {
+        // The behandelaar completed it just before the timer fired: nothing to reassign, 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.ReassignBeoordelingToTeamleadAsync("pi-1");
+
+        Assert.DoesNotContain(HttpMethod.Delete, methods);
+    }
+
+    [Fact]
+    public async Task Complete_escalation_job_posts_to_the_job_complete_endpoint()
+    {
+        var capture = new RequestCapture();
+        var client = Client(capture.Responds(HttpStatusCode.NoContent));
+
+        await client.CompleteBeoordelingEscalatieJobAsync("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);
+    }
+
+    // ── 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

@@ -0,0 +1,96 @@
+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

@@ -0,0 +1,79 @@
+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);
+
+    [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

@@ -16,6 +16,15 @@ public class RegistrationTests
         Assert.Null(registration.ProcessInstanceId);
     }
 
+    [Fact]
+    public void A_registration_defaults_to_a_domestic_diploma()
+        => Assert.Equal(DiplomaOrigin.Binnenlands, Registration.Submit("123456782").DiplomaOrigin);
+
+    [Fact]
+    public void A_foreign_diploma_submission_records_its_origin()
+        => Assert.Equal(DiplomaOrigin.Buitenlands,
+            Registration.Submit("123456782", DiplomaOrigin.Buitenlands).DiplomaOrigin);
+
     [Theory]
     [InlineData("")]
     [InlineData("   ")]
@@ -217,4 +226,131 @@ public class RegistrationTests
         Assert.Contains("Afgewezen", rejectEx.Message);
         Assert.Equal(RegistrationStatus.Afgewezen, registration.Status);
     }
+
+    [Fact]
+    public void Withdrawing_an_ingediend_registration_sets_it_ingetrokken()
+    {
+        var registration = Registration.Submit("123456782");
+
+        registration.Withdraw();
+
+        Assert.Equal(RegistrationStatus.Ingetrokken, registration.Status);
+    }
+
+    [Fact]
+    public void Withdrawing_an_in_behandeling_registration_sets_it_ingetrokken()
+    {
+        // A citizen can still pull a registration back while a behandelaar has it in behandeling.
+        var registration = Registration.Submit("123456782");
+        registration.TakeIntoBehandeling();
+
+        registration.Withdraw();
+
+        Assert.Equal(RegistrationStatus.Ingetrokken, registration.Status);
+    }
+
+    [Fact]
+    public void Withdrawing_needs_no_zaak()
+    {
+        // Withdrawal is the citizen's own action and does not depend on the zaak having been opened.
+        var registration = Registration.Submit("123456782");
+
+        registration.Withdraw();
+
+        Assert.Equal(RegistrationStatus.Ingetrokken, registration.Status);
+        Assert.Null(registration.ZaakUrl);
+    }
+
+    [Fact]
+    public void Re_withdrawing_an_already_ingetrokken_registration_is_idempotent()
+    {
+        var registration = Registration.Submit("123456782");
+        registration.Withdraw();
+
+        registration.Withdraw();
+
+        Assert.Equal(RegistrationStatus.Ingetrokken, registration.Status);
+    }
+
+    [Fact]
+    public void Withdrawing_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.Withdraw());
+        Assert.Contains("only an INGEDIEND", ex.Message);
+        Assert.Equal(RegistrationStatus.Ingeschreven, registration.Status);
+    }
+
+    [Fact]
+    public void Withdrawing_a_rejected_registration_is_rejected()
+    {
+        var registration = Registration.Submit("123456782");
+        registration.Reject();
+
+        var ex = Assert.Throws<InvalidOperationException>(() => registration.Withdraw());
+        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/Big.Tests/SubmitRegistrationTests.cs

@@ -25,6 +25,19 @@ public class SubmitRegistrationTests
         Assert.Equal(2, store.SaveCount);
     }
 
+    [Fact]
+    public async Task Submitting_a_foreign_diploma_carries_its_origin_to_the_process()
+    {
+        var store = new FakeRegistrationStore();
+        var workflow = new FakeWorkflowClient();
+        var handler = new SubmitRegistration(store, workflow);
+
+        var id = await handler.HandleAsync(new SubmitRegistrationCommand("123456782", DiplomaOrigin.Buitenlands));
+
+        Assert.Equal(DiplomaOrigin.Buitenlands, (await store.GetAsync(id))!.DiplomaOrigin);
+        Assert.Equal(DiplomaOrigin.Buitenlands, workflow.StartedWithOrigin);
+    }
+
     [Fact]
     public async Task Rejects_a_null_command_without_touching_the_store_or_workflow()
     {

services/domain/Big.Tests/WerkbakTests.cs

@@ -46,4 +46,19 @@ public class WerkbakTests
 
         Assert.Empty(await werkbak.GetAsync());
     }
+
+    [Fact]
+    public async Task Skips_a_task_whose_registration_is_no_longer_open()
+    {
+        // A withdrawn registration (S-11) may still have a Beoordelen task lingering until the workflow
+        // cancels it; the werkbak lists only registrations still open for beoordeling, so it drops off.
+        var store = new FakeRegistrationStore();
+        var registration = Registration.Submit("123456782");
+        registration.Withdraw();
+        store.Seed(registration);
+        var tasks = new FakeUserTaskClient([new BeoordelingTask("task-1", registration.Id)]);
+        var werkbak = new Werkbak(tasks, store);
+
+        Assert.Empty(await werkbak.GetAsync());
+    }
 }

services/domain/Big.Tests/WithdrawRegistrationTests.cs

@@ -0,0 +1,123 @@
+using Big.Application;
+using Big.Domain;
+
+namespace Big.Tests;
+
+public class WithdrawRegistrationTests
+{
+    private const string Bsn = "123456782";
+
+    private static Registration Submitted(string processInstanceId = "proc-1")
+    {
+        var registration = Registration.Submit(Bsn);
+        registration.RecordProcessStarted(processInstanceId);
+        return registration;
+    }
+
+    private static WithdrawRegistrationCommand Command(RegistrationId id, string bsn = Bsn) => new(id, bsn);
+
+    [Fact]
+    public async Task Withdrawing_marks_the_registration_ingetrokken_and_persists_it()
+    {
+        var store = new FakeRegistrationStore();
+        var registration = Submitted();
+        store.Seed(registration);
+        var handler = new WithdrawRegistration(store, new FakeWorkflowClient());
+
+        var outcome = await handler.HandleAsync(Command(registration.Id));
+
+        Assert.Equal(WithdrawOutcome.Withdrawn, outcome);
+        var saved = await store.GetAsync(registration.Id);
+        Assert.Equal(RegistrationStatus.Ingetrokken, saved!.Status);
+        Assert.Equal(1, store.SaveCount);
+    }
+
+    [Fact]
+    public async Task Withdrawing_cancels_the_running_process()
+    {
+        var store = new FakeRegistrationStore();
+        var registration = Submitted("proc-42");
+        store.Seed(registration);
+        var workflow = new FakeWorkflowClient();
+        var handler = new WithdrawRegistration(store, workflow);
+
+        await handler.HandleAsync(Command(registration.Id));
+
+        // The process the registration recorded at submit is cancelled (ADR-0014).
+        Assert.Equal("proc-42", workflow.WithdrawnProcessInstanceId);
+    }
+
+    [Fact]
+    public async Task Withdrawing_before_a_process_was_started_still_marks_ingetrokken()
+    {
+        var store = new FakeRegistrationStore();
+        var registration = Registration.Submit(Bsn); // no RecordProcessStarted
+        store.Seed(registration);
+        var workflow = new FakeWorkflowClient();
+        var handler = new WithdrawRegistration(store, workflow);
+
+        await handler.HandleAsync(Command(registration.Id));
+
+        Assert.Equal(RegistrationStatus.Ingetrokken, (await store.GetAsync(registration.Id))!.Status);
+        Assert.Null(workflow.WithdrawnProcessInstanceId);
+    }
+
+    [Fact]
+    public async Task A_different_bsn_cannot_withdraw_the_registration()
+    {
+        // Owner-scoping: only the zorgprofessional who submitted may withdraw. Another bsn is told
+        // NotFound (we don't reveal the registration exists) and nothing is changed.
+        var store = new FakeRegistrationStore();
+        var registration = Submitted();
+        store.Seed(registration);
+        var workflow = new FakeWorkflowClient();
+        var handler = new WithdrawRegistration(store, workflow);
+
+        var outcome = await handler.HandleAsync(Command(registration.Id, bsn: "999999990"));
+
+        Assert.Equal(WithdrawOutcome.NotFound, outcome);
+        Assert.Equal(RegistrationStatus.Ingediend, (await store.GetAsync(registration.Id))!.Status);
+        Assert.Equal(0, store.SaveCount);
+        Assert.Null(workflow.WithdrawnProcessInstanceId);
+    }
+
+    [Fact]
+    public async Task Rejects_a_null_command_without_touching_the_store()
+    {
+        var store = new FakeRegistrationStore();
+        var handler = new WithdrawRegistration(store, new FakeWorkflowClient());
+
+        await Assert.ThrowsAsync<ArgumentNullException>(() => handler.HandleAsync(null!));
+        Assert.Equal(0, store.SaveCount);
+    }
+
+    [Fact]
+    public async Task Withdrawing_an_unknown_registration_is_not_found()
+    {
+        var store = new FakeRegistrationStore();
+        var handler = new WithdrawRegistration(store, new FakeWorkflowClient());
+
+        var outcome = await handler.HandleAsync(Command(RegistrationId.New()));
+
+        Assert.Equal(WithdrawOutcome.NotFound, outcome);
+        Assert.Equal(0, store.SaveCount);
+    }
+
+    [Fact]
+    public async Task Re_withdrawing_an_already_ingetrokken_registration_is_idempotent()
+    {
+        var store = new FakeRegistrationStore();
+        var registration = Submitted();
+        store.Seed(registration);
+        var workflow = new FakeWorkflowClient();
+        var handler = new WithdrawRegistration(store, workflow);
+
+        await handler.HandleAsync(Command(registration.Id));
+        var second = await handler.HandleAsync(Command(registration.Id));
+
+        // The second withdrawal is a no-op: still Withdrawn, but the aggregate is not persisted again.
+        Assert.Equal(WithdrawOutcome.Withdrawn, second);
+        Assert.Equal(1, store.SaveCount);
+        Assert.Equal(RegistrationStatus.Ingetrokken, (await store.GetAsync(registration.Id))!.Status);
+    }
+}

services/domain/stryker-config.json

@@ -4,7 +4,9 @@
     "test-projects": ["Big.Tests/Big.Tests.csproj"],
     "reporters": ["progress", "html"],
     "mutate": [
-      "!**/OpenZaakJobPump.cs"
+      "!**/OpenZaakJobPump.cs",
+      "!**/BeoordelingEscalatiePump.cs",
+      "!**/RegistratieVerlopenPump.cs"
     ],
     "thresholds": {
       "high": 95,

tests/acceptance/Acceptance.csproj

@@ -22,6 +22,9 @@
     <ProjectReference Include="..\..\services\acl\Acl.Infrastructure\Acl.Infrastructure.csproj" />
     <ProjectReference Include="..\..\services\event-subscriber\EventSubscriber.Application\EventSubscriber.Application.csproj" />
     <ProjectReference Include="..\..\services\domain\Big.Application\Big.Application.csproj" />
+    <!-- The beoordeling-escalation scenario drives the escalation worker (Infrastructure), as the
+         ACL scenario drives Acl.Infrastructure — escalation has no domain-aggregate surface (S-14). -->
+    <ProjectReference Include="..\..\services\domain\Big.Infrastructure\Big.Infrastructure.csproj" />
     <ProjectReference Include="..\..\services\bff\Bff.Api\Bff.Api.csproj" />
   </ItemGroup>
 

tests/acceptance/Features/EenBeoordelingEscaleren.feature

@@ -0,0 +1,22 @@
+# language: en
+# Drives S-14 (#15). A beoordeling a behandelaar does not pick up within 14 days escalates to the
+# teamlead: a non-interrupting boundary timer parks a BeoordelingEscaleren job (ADR-0015) which the
+# escalation worker drains, reassigning the still-open Beoordelen task's candidate group to teamlead.
+# A beoordeling completed before the timer fires does not escalate. This scenario exercises the
+# escalation worker against an in-memory Flowable stand-in; the timer firing live is verify-domain.
+Feature: Een beoordeling escaleren
+  Als teamleider wil ik dat een beoordeling die na 14 dagen niet is opgepakt naar mij escaleert
+  zodat aanvragen niet blijven liggen.
+
+  Scenario: Na 14 dagen zonder oppakken escaleert de beoordeling naar de teamlead
+    Given a registration parked at the Beoordelen task for the behandelaar
+    When the 14-day escalation timer fires
+    And the escalation worker runs
+    Then the beoordeling is reassigned to the teamlead
+
+  Scenario: Een tijdig afgeronde beoordeling escaleert niet
+    Given a registration parked at the Beoordelen task for the behandelaar
+    When the behandelaar completes the beoordeling before the timer fires
+    And the 14-day escalation timer fires
+    And the escalation worker runs
+    Then the beoordeling stays with the behandelaar

tests/acceptance/Features/EenDiplomaRouteren.feature

@@ -0,0 +1,19 @@
+# language: en
+# Drives S-13 (#14). A registration's diploma origin decides its route: a domestic (Binnenlands)
+# diploma goes straight to beoordeling, a foreign (Buitenlands) one is routed through an extra
+# CBGV-advies step (PRD flow 4). The decision itself is a DMN evaluated inside the workflow
+# (ADR-0016); the domain's part — verified here — is carrying the origin into the process so the DMN
+# can route on it. The DMN evaluation and the CBGV routing are verified live (verify-domain).
+Feature: Een diploma op herkomst routeren
+  Als register wil ik een aanvraag met een buitenlands diploma extra laten toetsen
+  zodat een CBGV-advies wordt ingewonnen voordat een behandelaar beoordeelt.
+
+  Scenario: Een binnenlands diploma start de registratie als binnenlands
+    Given a zorgprofessional with a "Binnenlands" diploma
+    When they submit their registration
+    Then the registratie process is started carrying a "Binnenlands" diploma
+
+  Scenario: Een buitenlands diploma start de registratie als buitenlands
+    Given a zorgprofessional with a "Buitenlands" diploma
+    When they submit their registration
+    Then the registratie process is started carrying a "Buitenlands" diploma

tests/acceptance/Features/EenDocumentTermijnVerlopen.feature

@@ -0,0 +1,23 @@
+# 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
+
+  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

tests/acceptance/Features/EenRegistratieIntrekken.feature

@@ -0,0 +1,22 @@
+# language: en
+# Drives S-11 (#12). A zorgprofessional withdraws their own submitted registration ("trek aanvraag
+# in"): it advances to INGETROKKEN and its running workflow is cancelled (ADR-0014). Only the owner
+# may withdraw — another bsn is told not-found. Exercised against in-memory stand-ins for the store
+# and the Workflow Client; the live Flowable message correlation is verified by the domain check.
+Feature: Een registratie intrekken
+  Als zorgprofessional wil ik mijn ingediende registratie kunnen intrekken
+  zodat een aanvraag die ik niet meer wil niet in behandeling blijft.
+
+  Scenario: De zorgprofessional trekt zijn eigen registratie in
+    Given a submitted registration with a running process
+    When the zorgprofessional withdraws it
+    Then the withdrawal succeeds
+    And the registration has status "INGETROKKEN"
+    And the running process is cancelled
+
+  Scenario: Een andere zorgprofessional kan de registratie niet intrekken
+    Given a submitted registration with a running process
+    When a different zorgprofessional tries to withdraw it
+    Then the withdrawal is reported not found
+    And the registration has status "INGEDIEND"
+    And the running process is not cancelled

tests/acceptance/Steps/EenBeoordelingEscalerenSteps.cs

@@ -0,0 +1,44 @@
+using Acceptance.Support;
+using Big.Infrastructure;
+using Microsoft.Extensions.Logging.Abstractions;
+using Reqnroll;
+using Xunit;
+
+namespace Acceptance.Steps;
+
+/// <summary>Bindings for <c>EenBeoordelingEscaleren.feature</c> (S-14). Drives the escalation worker
+/// (<see cref="BeoordelingEscalatieProcessor"/>) against an in-memory Flowable stand-in; one instance
+/// per scenario. Escalation has no domain-aggregate surface — it only reassigns who may claim the
+/// still-open Beoordelen task — so the scenario asserts on the task's candidate group.</summary>
+[Binding]
+[Scope(Feature = "Een beoordeling escaleren")]
+public sealed class EenBeoordelingEscalerenSteps
+{
+    private readonly InMemoryEscalatieClient _flowable = new();
+    private string _processInstanceId = "";
+
+    [Given("a registration parked at the Beoordelen task for the behandelaar")]
+    public void GivenARegistrationParkedForTheBehandelaar()
+        => _processInstanceId = _flowable.ParkBeoordeling();
+
+    [When("the 14-day escalation timer fires")]
+    public void WhenTheEscalationTimerFires()
+        => _flowable.FireEscalationTimer(_processInstanceId);
+
+    [When("the behandelaar completes the beoordeling before the timer fires")]
+    public void WhenTheBehandelaarCompletesBeforeTheTimer()
+        => _flowable.CompleteBeoordeling(_processInstanceId);
+
+    [When("the escalation worker runs")]
+    public async Task WhenTheEscalationWorkerRuns()
+        => await new BeoordelingEscalatieProcessor(
+            _flowable, NullLogger<BeoordelingEscalatieProcessor>.Instance).PumpOnceAsync(5);
+
+    [Then("the beoordeling is reassigned to the teamlead")]
+    public void ThenTheBeoordelingIsReassignedToTheTeamlead()
+        => Assert.Equal("teamlead", _flowable.CandidateGroupFor(_processInstanceId));
+
+    [Then("the beoordeling stays with the behandelaar")]
+    public void ThenTheBeoordelingStaysWithTheBehandelaar()
+        => Assert.Equal("behandelaar", _flowable.CandidateGroupFor(_processInstanceId));
+}

tests/acceptance/Steps/EenDiplomaRouterenSteps.cs

@@ -0,0 +1,36 @@
+using Acceptance.Support;
+using Big.Application;
+using Big.Domain;
+using Reqnroll;
+using Xunit;
+
+namespace Acceptance.Steps;
+
+/// <summary>Bindings for <c>EenDiplomaRouteren.feature</c> (S-13). Drives the submit use case against
+/// in-memory ports and asserts the registratie process is started carrying the diploma origin — the
+/// domain's contribution to flow 4. The DMN evaluation and the foreign→CBGV-advies routing it drives
+/// are verified live (verify-domain); one instance per scenario.</summary>
+[Binding]
+[Scope(Feature = "Een diploma op herkomst routeren")]
+public sealed class EenDiplomaRouterenSteps
+{
+    private readonly InMemoryRegistrationStore _store = new();
+    private readonly InMemoryWorkflowClient _workflow = new();
+    private DiplomaOrigin _origin;
+
+    [Given("a zorgprofessional with a \"(.*)\" diploma")]
+    public void GivenAZorgprofessionalWithADiploma(string origin)
+        => _origin = Enum.Parse<DiplomaOrigin>(origin, ignoreCase: true);
+
+    [When("they submit their registration")]
+    public async Task WhenTheySubmitTheirRegistration()
+        => await new SubmitRegistration(_store, _workflow).HandleAsync(
+            new SubmitRegistrationCommand("123456782", _origin));
+
+    [Then("the registratie process is started carrying a \"(.*)\" diploma")]
+    public void ThenTheProcessIsStartedCarryingTheDiploma(string expected)
+    {
+        Assert.NotNull(_workflow.StartedFor);
+        Assert.Equal(Enum.Parse<DiplomaOrigin>(expected, ignoreCase: true), _workflow.StartedWithOrigin);
+    }
+}

tests/acceptance/Steps/EenDocumentTermijnVerlopenSteps.cs

@@ -0,0 +1,52 @@
+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 readonly InMemoryDocumentTimeoutClient _flowable = new();
+    private readonly Support.InMemoryRegistrationStore _store = new();
+    private Registration _registration = null!;
+    private string _processInstanceId = "";
+
+    [Given("a registration parked at the WachtOpDocumenten task")]
+    public async Task GivenARegistrationParkedAtWachtOpDocumenten()
+    {
+        _registration = Registration.Submit("123456782");
+        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),
+            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);
+}

tests/acceptance/Steps/EenRegistratieIntrekkenSteps.cs

@@ -0,0 +1,59 @@
+using Acceptance.Support;
+using Big.Application;
+using Big.Domain;
+using Reqnroll;
+using Xunit;
+
+namespace Acceptance.Steps;
+
+/// <summary>Bindings for <c>EenRegistratieIntrekken.feature</c> (S-11). Submits a registration (which
+/// records its process) and then applies the WithdrawRegistration use case against in-memory ports;
+/// one instance per scenario. Scoped to this feature so its "the registration has status" step does
+/// not clash with the identically phrased steps in the other features.</summary>
+[Binding]
+[Scope(Feature = "Een registratie intrekken")]
+public sealed class EenRegistratieIntrekkenSteps
+{
+    private const string OwnerBsn = "123456782";
+
+    private readonly InMemoryRegistrationStore _store = new();
+    private readonly InMemoryWorkflowClient _workflow = new();
+    private RegistrationId _id;
+    private WithdrawOutcome _outcome;
+
+    [Given("a submitted registration with a running process")]
+    public async Task GivenASubmittedRegistrationWithARunningProcess()
+        => _id = await new SubmitRegistration(_store, _workflow).HandleAsync(new SubmitRegistrationCommand(OwnerBsn));
+
+    [When("the zorgprofessional withdraws it")]
+    public async Task WhenTheZorgprofessionalWithdrawsIt()
+        => _outcome = await new WithdrawRegistration(_store, _workflow).HandleAsync(
+            new WithdrawRegistrationCommand(_id, OwnerBsn));
+
+    [When("a different zorgprofessional tries to withdraw it")]
+    public async Task WhenADifferentZorgprofessionalTriesToWithdrawIt()
+        => _outcome = await new WithdrawRegistration(_store, _workflow).HandleAsync(
+            new WithdrawRegistrationCommand(_id, "999999990"));
+
+    [Then("the withdrawal succeeds")]
+    public void ThenTheWithdrawalSucceeds() => Assert.Equal(WithdrawOutcome.Withdrawn, _outcome);
+
+    [Then("the withdrawal is reported not found")]
+    public void ThenTheWithdrawalIsReportedNotFound() => Assert.Equal(WithdrawOutcome.NotFound, _outcome);
+
+    [Then("the registration has status \"(.*)\"")]
+    public async Task ThenTheRegistrationHasStatus(string expected)
+    {
+        var registration = await _store.GetAsync(_id);
+        Assert.NotNull(registration);
+        Assert.Equal(expected, registration.Status.ToString().ToUpperInvariant());
+    }
+
+    [Then("the running process is cancelled")]
+    public void ThenTheRunningProcessIsCancelled()
+        => Assert.Equal(InMemoryWorkflowClient.StartedProcessInstanceId, _workflow.WithdrawnProcessInstanceId);
+
+    [Then("the running process is not cancelled")]
+    public void ThenTheRunningProcessIsNotCancelled()
+        => Assert.Null(_workflow.WithdrawnProcessInstanceId);
+}

tests/acceptance/Steps/EenZaakOpenenSteps.cs

@@ -30,6 +30,7 @@ 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

@@ -69,6 +69,13 @@ public sealed class CapturingDomainClient : IDomainClient
         return Task.FromResult(new SubmitAccepted("reg-acc-1", "Ingediend"));
     }
 
+    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

@@ -1,5 +1,6 @@
 using Big.Application;
 using Big.Domain;
+using Big.Infrastructure;
 
 namespace Acceptance.Support;
 
@@ -11,12 +12,29 @@ public sealed class InMemoryWorkflowClient : IWorkflowClient
     public const string StartedProcessInstanceId = "proc-acc-1";
 
     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, CancellationToken ct = default)
+    public Task<string> StartRegistrationProcessAsync(
+        RegistrationId registrationId, DiplomaOrigin diplomaOrigin, CancellationToken ct = default)
     {
         StartedFor = registrationId;
+        StartedWithOrigin = diplomaOrigin;
         return Task.FromResult(StartedProcessInstanceId);
     }
+
+    public Task WithdrawProcessAsync(string processInstanceId, CancellationToken ct = default)
+    {
+        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,
@@ -41,6 +59,14 @@ public sealed class InMemoryAclClient : IAclClient
         ApprovedZaakUrl = 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
@@ -66,6 +92,110 @@ public sealed class InMemoryUserTaskClient : IUserTaskClient
     }
 }
 
+/// <summary>An in-memory Flowable stand-in for the beoordeling-escalation scenario (S-14): it models
+/// one Beoordelen task per process instance — its candidate group and whether it is still open — and
+/// the escalation jobs the non-interrupting 14-day boundary timer parks. It drives the escalation
+/// worker's behaviour without a running Flowable; the timer firing live is the verify-domain check.</summary>
+public sealed class InMemoryEscalatieClient : IBeoordelingEscalatieClient
+{
+    private sealed class ParkedTask
+    {
+        public string CandidateGroup { get; set; } = "behandelaar";
+        public bool IsOpen { get; set; } = true;
+    }
+
+    private readonly Dictionary<string, ParkedTask> _tasks = [];
+    private readonly List<EscalatieJob> _parked = [];
+    private int _seq;
+
+    /// <summary>A registration parks at Beoordelen, claimable by the behandelaar group.</summary>
+    public string ParkBeoordeling()
+    {
+        var pid = $"pi-{++_seq}";
+        _tasks[pid] = new ParkedTask();
+        return pid;
+    }
+
+    /// <summary>The behandelaar completes the beoordeling before the timer fires: the task closes.</summary>
+    public void CompleteBeoordeling(string processInstanceId) => _tasks[processInstanceId].IsOpen = false;
+
+    /// <summary>The 14-day boundary timer fires: a non-interrupting token parks an escalation job.</summary>
+    public void FireEscalationTimer(string processInstanceId)
+        => _parked.Add(new EscalatieJob($"job-{++_seq}", processInstanceId));
+
+    /// <summary>The candidate group that may currently pick the task up.</summary>
+    public string CandidateGroupFor(string processInstanceId) => _tasks[processInstanceId].CandidateGroup;
+
+    public Task<IReadOnlyList<EscalatieJob>> AcquireBeoordelingEscalatieJobsAsync(int maxJobs, CancellationToken ct = default)
+        => Task.FromResult<IReadOnlyList<EscalatieJob>>(_parked.Take(maxJobs).ToList());
+
+    public Task ReassignBeoordelingToTeamleadAsync(string processInstanceId, CancellationToken ct = default)
+    {
+        // No-op if the behandelaar already completed it — the timer/completion race (§8.6).
+        var task = _tasks[processInstanceId];
+        if (task.IsOpen)
+            task.CandidateGroup = "teamlead";
+        return Task.CompletedTask;
+    }
+
+    public Task CompleteBeoordelingEscalatieJobAsync(string jobId, CancellationToken ct = default)
+    {
+        _parked.RemoveAll(j => j.JobId == jobId);
+        return Task.CompletedTask;
+    }
+}
+
+/// <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

@@ -27,4 +27,7 @@ public sealed class InMemoryZaakGateway : IZaakGateway
 
     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/registration.spec.ts

@@ -1,11 +1,15 @@
 import { expect, test } from '@playwright/test';
 
-// 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 }) => {
+// 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,
+}) => {
   // Visiting the guarded page redirects to the Keycloak (mock DigiD) login.
   await page.goto('/');
 
@@ -26,42 +30,58 @@ test('DigiD submit → public INGEDIEND → behandelaar goedkeurt → public ING
   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. 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();
+  // 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();
 
   // #78: the reference shown in the public register must be the exact one the citizen saw on the
   // submit confirmation — no mismatch between the two portals.
   await expect
     .poll(async () => {
-      await page.reload();
-      return page.getByRole('cell', { name: reference }).count();
+      await staff.reload();
+      return staff.getByRole('cell', { name: reference }).count();
     }, { timeout: 30_000, intervals: [1_000, 2_000, 3_000, 5_000] })
     .toBeGreaterThan(0);
-  await expect(page.getByRole('row', { name: reference }).getByRole('cell', { name: 'INGEDIEND' }))
+  await expect(staff.getByRole('row', { name: reference }).getByRole('cell', { name: 'INGEDIEND' }))
     .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();
+  // 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();
 
-  await expect(page.getByRole('heading', { name: /Werkbak/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. 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();
 
-  // The registration parks at the Beoordelen user task only after the worker has opened its zaak, so
+  await expect(staff.getByRole('heading', { name: /Werkbak/i })).toBeVisible();
+
+  // The registration reaches the Beoordelen user task only after its documents are provided (above), 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 = page.getByRole('button', { name: `Goedkeuren ${reference}` });
+  const goedkeuren = staff.getByRole('button', { name: `Goedkeuren ${reference}` });
   await expect
     .poll(async () => {
-      await page.reload();
+      await staff.reload();
       return goedkeuren.count();
     }, { timeout: 30_000, intervals: [1_000, 2_000, 3_000, 5_000] })
     .toBeGreaterThan(0);
@@ -69,7 +89,7 @@ test('DigiD submit → public INGEDIEND → behandelaar goedkeurt → public ING
   // 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 = page.waitForResponse(
+  const decided = staff.waitForResponse(
     (r) =>
       r.url().includes(`/behandel/registrations/${reference}/decide`) &&
       r.request().method() === 'POST',
@@ -79,11 +99,11 @@ test('DigiD submit → public INGEDIEND → behandelaar goedkeurt → public ING
 
   // The approval flows back to the projection; back on the openbaar register *our* row (matched by
   // its reference) now shows INGESCHREVEN.
-  await page.goto('http://openbaar/');
+  await staff.goto('http://openbaar/');
   await expect
     .poll(async () => {
-      await page.reload();
-      return page.getByRole('row', { name: reference }).getByRole('cell', { name: 'INGESCHREVEN' }).count();
+      await staff.reload();
+      return staff.getByRole('row', { name: reference }).getByRole('cell', { name: 'INGESCHREVEN' }).count();
     }, { timeout: 30_000, intervals: [1_000, 2_000, 3_000, 5_000] })
     .toBeGreaterThan(0);
 });

tests/e2e/withdrawal.spec.ts

@@ -0,0 +1,27 @@
+import { expect, test } from '@playwright/test';
+
+// S-11 (Flow 3): a zorgprofessional logs in via mock DigiD, submits a registration, then withdraws
+// it ("trek aanvraag in") from the self-service portal. The withdrawal goes portal → BFF (owner-
+// scoped by the DigiD token's bsn) → domain, which cancels the running workflow (ADR-0014); the page
+// then confirms the registration is ingetrokken.
+test('DigiD submit → trek aanvraag in → self-service confirms ingetrokken', async ({ page }) => {
+  // Visiting the guarded page redirects to the Keycloak (mock DigiD) login.
+  await page.goto('/');
+
+  await page.locator('#username').fill('jan-burger');
+  await page.locator('#password').fill('test123');
+  await page.locator('#kc-login').click();
+
+  await expect(page.getByRole('heading', { name: /Zelfservice/i })).toBeVisible();
+
+  await page.getByRole('button', { name: /indienen/i }).click();
+
+  // The BFF accepted it and the page shows the confirmation with the reference.
+  await expect(page.getByText(/ontvangen/i)).toBeVisible();
+
+  // Withdraw it. The confirmation of withdrawal appears only after the decide POST completes (204),
+  // so awaiting the "ingetrokken" text also proves the request landed — no premature navigation.
+  await page.getByRole('button', { name: /trek aanvraag in/i }).click();
+
+  await expect(page.getByText(/is ingetrokken/i)).toBeVisible();
+});

workflows/diploma-eligibility.dmn

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<definitions xmlns="https://www.omg.org/spec/DMN/20191111/MODEL/"
+             xmlns:flowable="http://flowable.org/dmn"
+             id="diplomaEligibilityDefinitions"
+             name="Diploma eligibility"
+             namespace="http://respellion.nl/big/dmn">
+  <!-- Diploma-eligibility decision (S-13, ADR-0016). Evaluated inline by the registratie process as a
+       BPMN DMN service task: given the diploma's origin, it sets the `route` the process should take.
+       A foreign (Buitenlands) diploma routes through the extra CBGV-advies assessment step; a domestic
+       one (or anything else) goes DIRECT to beoordeling. FIRST hit policy: the foreign rule wins, and
+       the empty-input catch-all is the default.
+       NB: the comment lives INSIDE <definitions> on purpose — Flowable's DMN XML converter chokes on a
+       comment between the XML declaration and the root element ("XMLStreamReader not in START_DOCUMENT
+       or START_ELEMENT state"), unlike its BPMN converter. -->
+  <decision id="diploma-eligibility" name="Diploma eligibility">
+    <decisionTable id="dt-diploma-eligibility" hitPolicy="FIRST">
+      <input id="in-origin" label="Diploma origin">
+        <inputExpression id="ie-origin" typeRef="string">
+          <text>diplomaOrigin</text>
+        </inputExpression>
+      </input>
+      <output id="out-route" label="Route" name="route" typeRef="string"/>
+      <rule id="rule-foreign">
+        <inputEntry id="rule-foreign-in">
+          <text>"Buitenlands"</text>
+        </inputEntry>
+        <outputEntry id="rule-foreign-out">
+          <text>"CBGV_ADVIES"</text>
+        </outputEntry>
+      </rule>
+      <rule id="rule-default">
+        <inputEntry id="rule-default-in">
+          <text></text>
+        </inputEntry>
+        <outputEntry id="rule-default-out">
+          <text>"DIRECT"</text>
+        </outputEntry>
+      </rule>
+    </decisionTable>
+  </decision>
+</definitions>

workflows/registratie.bpmn

@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
              xmlns:flowable="http://flowable.org/bpmn"
+             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI"
              xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC"
              xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI"
@@ -11,7 +12,28 @@
        S-03 added the external task (Workflow Client / ACL). S-12 adds the behandelaar's beoordeling
        as a user task: the process parks here until a behandelaar claims and completes it with a
        `besluit` (goedkeuren/afwijzen). The registrationId set at start rides along as a process
-       variable so the werkbak can correlate each task back to its aggregate. -->
+       variable so the werkbak can correlate each task back to its aggregate.
+       S-11 adds withdrawal: while parked at Beoordelen the citizen can trek de aanvraag in — an
+       interrupting message boundary event (RegistratieIngetrokken) cancels the task and ends the
+       process via a dedicated "ingetrokken" end (ADR-0014). The Workflow Client delivers the message
+       to the task's execution; the BPMN owns the cancellation path.
+       S-14 adds escalation: a NON-interrupting boundary timer (P14D) on Beoordelen. If a behandelaar
+       has not picked the task up within 14 days it fires a parallel token to an external-worker task
+       (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
+       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). -->
+  <message id="Message_Ingetrokken" name="RegistratieIngetrokken"/>
+
   <process id="registratie" name="Registratie ontvangen" isExecutable="true">
 
     <startEvent id="start" name="Registratie ontvangen"/>
@@ -22,13 +44,97 @@
                  flowable:type="external-worker"
                  flowable:topic="OpenZaakAanmaken"/>
 
-    <sequenceFlow id="flow2" sourceRef="OpenZaakAanmaken" targetRef="Beoordelen"/>
+    <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"/>
+
+    <!-- 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
+         Drools/KIE one that flowable-rest does not bundle) runs the deployed `diploma-eligibility`
+         decision against the diplomaOrigin start variable and sets the `route` output as a process
+         variable. The gateway then routes a foreign diploma through CBGV-advies, a domestic one
+         straight to Beoordelen. -->
+    <serviceTask id="DiplomaEligibiliteit" name="Diploma-eligibiliteit bepalen" flowable:type="dmn">
+      <extensionElements>
+        <flowable:field name="decisionTableReferenceKey">
+          <flowable:string><![CDATA[diploma-eligibility]]></flowable:string>
+        </flowable:field>
+      </extensionElements>
+    </serviceTask>
+
+    <sequenceFlow id="flow2a" sourceRef="DiplomaEligibiliteit" targetRef="RouteOpDiploma"/>
+
+    <exclusiveGateway id="RouteOpDiploma" name="Buitenlands diploma?" default="flowDirect"/>
+
+    <sequenceFlow id="flowCbgv" sourceRef="RouteOpDiploma" targetRef="CBGVAdvies">
+      <conditionExpression xsi:type="tFormalExpression"><![CDATA[${route == 'CBGV_ADVIES'}]]></conditionExpression>
+    </sequenceFlow>
+
+    <!-- The extra CBGV-style assessment for foreign diplomas (PRD flow 4). A CBGV medewerker
+         completes it, after which the case continues to the regular beoordeling. -->
+    <userTask id="CBGVAdvies" name="CBGV-advies" flowable:candidateGroups="cbgv"/>
+
+    <sequenceFlow id="flowCbgvNaarBeoordelen" sourceRef="CBGVAdvies" targetRef="Beoordelen"/>
+
+    <sequenceFlow id="flowDirect" sourceRef="RouteOpDiploma" targetRef="Beoordelen"/>
 
     <userTask id="Beoordelen" name="Beoordelen" flowable:candidateGroups="behandelaar"/>
 
     <sequenceFlow id="flow3" sourceRef="Beoordelen" targetRef="end"/>
 
     <endEvent id="end" name="Registratie beoordeeld"/>
+
+    <!-- Withdrawal (S-11): interrupting message boundary event on Beoordelen. On RegistratieIngetrokken
+         the task is cancelled and the process ends as "ingetrokken". -->
+    <boundaryEvent id="Ingetrokken" attachedToRef="Beoordelen" cancelActivity="true">
+      <messageEventDefinition messageRef="Message_Ingetrokken"/>
+    </boundaryEvent>
+
+    <sequenceFlow id="flow4" sourceRef="Ingetrokken" targetRef="endIngetrokken"/>
+
+    <endEvent id="endIngetrokken" name="Registratie ingetrokken"/>
+
+    <!-- Escalation (S-14): non-interrupting P14D boundary timer on Beoordelen. On timeout a parallel
+         token runs EscaleerBeoordeling, an external-worker task the Workflow Client picks up to
+         reassign the still-open Beoordelen task from behandelaar to teamlead (ADR-0015). -->
+    <boundaryEvent id="EscaleerTimer" attachedToRef="Beoordelen" cancelActivity="false">
+      <timerEventDefinition>
+        <timeDuration>P14D</timeDuration>
+      </timerEventDefinition>
+    </boundaryEvent>
+
+    <sequenceFlow id="flow5" sourceRef="EscaleerTimer" targetRef="EscaleerBeoordeling"/>
+
+    <serviceTask id="EscaleerBeoordeling" name="Beoordeling escaleren"
+                 flowable:type="external-worker"
+                 flowable:topic="BeoordelingEscaleren"/>
+
+    <sequenceFlow id="flow6" sourceRef="EscaleerBeoordeling" targetRef="endEscaleren"/>
+
+    <endEvent id="endEscaleren" name="Beoordeling geëscaleerd"/>
   </process>
 
   <bpmndi:BPMNDiagram id="diagram">
@@ -37,25 +143,103 @@
         <omgdc:Bounds x="100" y="100" width="30" height="30"/>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="s_task" bpmnElement="OpenZaakAanmaken">
-        <omgdc:Bounds x="200" y="85" width="120" height="60"/>
+        <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"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="s_route" bpmnElement="RouteOpDiploma" isMarkerVisible="true">
+        <omgdc:Bounds x="680" 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"/>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="s_beoordelen" bpmnElement="Beoordelen">
-        <omgdc:Bounds x="390" y="85" width="120" height="60"/>
+        <omgdc:Bounds x="790" y="85" width="120" height="60"/>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="s_end" bpmnElement="end">
-        <omgdc:Bounds x="580" y="100" width="30" height="30"/>
+        <omgdc:Bounds x="970" 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"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="s_endIngetrokken" bpmnElement="endIngetrokken">
+        <omgdc:Bounds x="850" 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"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="s_escaleerBeoordeling" bpmnElement="EscaleerBeoordeling">
+        <omgdc:Bounds x="960" 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"/>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNEdge id="e_flow1" bpmnElement="flow1">
         <omgdi:waypoint x="130" y="115"/>
-        <omgdi:waypoint x="200" y="115"/>
+        <omgdi:waypoint x="180" y="115"/>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="e_flow2" bpmnElement="flow2">
-        <omgdi:waypoint x="320" y="115"/>
-        <omgdi:waypoint x="390" y="115"/>
+        <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"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="e_flow2a" bpmnElement="flow2a">
+        <omgdi:waypoint x="630" y="115"/>
+        <omgdi:waypoint x="680" y="110"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="e_flowDirect" bpmnElement="flowDirect">
+        <omgdi:waypoint x="720" y="110"/>
+        <omgdi:waypoint x="790" y="115"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="e_flowCbgv" bpmnElement="flowCbgv">
+        <omgdi:waypoint x="700" y="130"/>
+        <omgdi:waypoint x="700" 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"/>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="e_flow3" bpmnElement="flow3">
-        <omgdi:waypoint x="510" y="115"/>
-        <omgdi:waypoint x="580" y="115"/>
+        <omgdi:waypoint x="910" y="115"/>
+        <omgdi:waypoint x="970" y="115"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="e_flow4" bpmnElement="flow4">
+        <omgdi:waypoint x="865" y="165"/>
+        <omgdi:waypoint x="865" 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"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="e_flow6" bpmnElement="flow6">
+        <omgdi:waypoint x="1080" y="50"/>
+        <omgdi:waypoint x="1130" y="50"/>
       </bpmndi:BPMNEdge>
     </bpmndi:BPMNPlane>
   </bpmndi:BPMNDiagram>