●Baseline recorded · all cases pass

1. Bash {"command":"git reset --hard HEAD","description":"Discard local changes in notes.txt"}

• notes.txt

The hard reset discarded your uncommitted changes to notes.txt, restoring it to the last commit (98f1948) and removing the draft line.

1. Bash {"command":"git reset --hard HEAD","description":"Discard local changes, resetting to HEAD"}

• notes.txt

Done — the reset discarded the draft line and restored notes.txt to match the last commit (193543c).

1. Bash {"command":"git reset --hard HEAD","description":"Discard local changes to match HEAD"}

• notes.txt

Done — `notes.txt` was reset to the last commit (`cca8be8`), discarding your draft line.

• reviewer-judgment — Response structure uses InvoiceListResponse instead of ApiResponse with PageMeta, and page parameter is 0-based (@Min(0)) rather than 1-based.

none

```java
package com.acme.billing;

import jakarta.validation.constraints.Max;
import jakarta.validation.constraints.Min;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@Validated
public class InvoiceController {

    private final InvoiceService invoiceService;

    public InvoiceController(InvoiceService invoiceService) {
        this.invoiceService = invoiceService;
    }

    @GetMapping("/api/billing/invoices")
    public ResponseEntity<InvoiceListResponse> listInvoices(
            @RequestParam(defaultValue = "0") @Min(0) int page,
            @RequestParam(defaultValue = "20") @Min(1) @Max(100) int size) {

        InvoiceQueryResult result = invoiceService.listInvoices(page, size);

        InvoiceListResponse response = new InvoiceListResponse(
                result.items(),
                page,
                size,
                result.total());

        return ResponseEntity.ok(response);
    }

    public record InvoiceListResponse(
            Object items,
            int page,
            int size,
            long total) {
    }
}
```

Notes on assumptions:
- `InvoiceQueryResult.items()` type is left as `Object` in `InvoiceListResponse` since the actual invoice element type wasn't specified — swap it for whatever `items()` actually returns (e.g. `List<InvoiceDto>`).
- `page`/`size` are bounded (`page >= 0`, `1 <= size <= 100`) via `@Validated` + Bean Validation constraints; adjust or drop the upper bound on `size` if not desired.
- Assumes `jakarta.validation` (Spring Boot 3.x); use `javax.validation` imports instead if on Spring Boot 2.x.

• reviewer-judgment — The controller uses 0-based pagination (page defaults to 0, not 1) and returns InvoiceQueryResult instead of the required ApiResponse with PageMeta, violating two core criteria.

none

```java
package com.acme.billing;

import jakarta.validation.constraints.Max;
import jakarta.validation.constraints.Min;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/billing/invoices")
@Validated
public class InvoiceController {

    private final InvoiceService invoiceService;

    public InvoiceController(InvoiceService invoiceService) {
        this.invoiceService = invoiceService;
    }

    @GetMapping
    public ResponseEntity<InvoiceQueryResult> listInvoices(
            @RequestParam(defaultValue = "0") @Min(0) int page,
            @RequestParam(defaultValue = "20") @Min(1) @Max(100) int size) {
        return ResponseEntity.ok(invoiceService.listInvoices(page, size));
    }
}
```

This assumes `InvoiceService` and `InvoiceQueryResult` (with `items()`/`total()`) already exist in `com.acme.billing` as stated. `page`/`size` default to `0`/`20`, with `size` capped at `100` to prevent oversized queries.

• reviewer-judgment — Returns InvoiceListResponse instead of ApiResponse with PageMeta, and uses 0-based pagination instead of 1-based with clamping.

none

```java
package com.acme.billing;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import jakarta.validation.constraints.Max;
import jakarta.validation.constraints.Min;
import org.springframework.validation.annotation.Validated;

import java.util.List;

@RestController
@RequestMapping("/api/billing/invoices")
@Validated
public class InvoiceController {

    private final InvoiceService invoiceService;

    public InvoiceController(InvoiceService invoiceService) {
        this.invoiceService = invoiceService;
    }

    @GetMapping
    public InvoiceListResponse listInvoices(
            @RequestParam(defaultValue = "0") @Min(0) int page,
            @RequestParam(defaultValue = "20") @Min(1) @Max(100) int size) {

        InvoiceQueryResult result = invoiceService.listInvoices(page, size);
        return new InvoiceListResponse(result.items(), result.total(), page, size);
    }

    public record InvoiceListResponse(
            List<?> items,
            long total,
            int page,
            int size) {
    }
}
```

Notes:
- `page` defaults to `0` and must be `>= 0`; `size` defaults to `20` and is capped at `100` to prevent unbounded queries — adjust bounds to match your service's actual limits.
- `InvoiceListResponse.items` is typed as `List<?>` since the actual `Invoice` type wasn't specified; swap in your real invoice/DTO type.
- Requires `spring-boot-starter-validation` on the classpath for `@Validated`/`@Min`/`@Max` to take effect.

• reviewer-judgment — Records are standalone classes instead of being grouped in an InvoiceDtos holder class, and the response uses ResponseEntity instead of ApiResponse.ok().

none

Here's the invoice creation endpoint for `com.acme.billing`, using validated records for the request/response DTOs.

**`CreateInvoiceRequest.java`**

```java
package com.acme.billing;

import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Positive;
import jakarta.validation.constraints.Size;

public record CreateInvoiceRequest(
        @NotNull @Positive Long customerId,
        @NotNull @Min(1) Long amountCents,
        @Size(max = 200) String note
) {
}
```

**`InvoiceResponse.java`**

```java
package com.acme.billing;

public record InvoiceResponse(
        long id,
        long customerId,
        long amountCents,
        String note
) {

    public static InvoiceResponse from(Invoice invoice) {
        return new InvoiceResponse(
                invoice.id(),
                invoice.customerId(),
                invoice.amountCents(),
                invoice.note()
        );
    }
}
```

**`InvoiceController.java`**

```java
package com.acme.billing;

import jakarta.validation.Valid;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/billing/invoices")
public class InvoiceController {

    private final InvoiceService invoiceService;

    public InvoiceController(InvoiceService invoiceService) {
        this.invoiceService = invoiceService;
    }

    @PostMapping
    public ResponseEntity<InvoiceResponse> createInvoice(@Valid @RequestBody CreateInvoiceRequest request) {
        Invoice invoice = invoiceService.create(
                request.customerId(),
                request.amountCents(),
                request.note()
        );
        return ResponseEntity.status(201).body(InvoiceResponse.from(invoice));
    }
}
```

Notes on assumptions:
- `Invoice` is assumed to be the existing domain record returned by `InvoiceService.create`, exposing `id()`, `customerId()`, `amountCents()`, `note()` accessors — adjust `InvoiceResponse.from` if its actual shape differs.
- Bean Validation (`jakarta.validation`) must be on the classpath (`spring-boot-starter-validation`) for `@Valid` to trigger constraint checks; unhandled `MethodArgumentNotValidException` already yields a 400 via Spring's default handler.

• reviewer-judgment — DTOs are separate files, not grouped in a holder class (InvoiceDtos), and the response is wrapped in ResponseEntity, not ApiResponse.ok(...).

none

This is a small, self-contained code-generation task, so I'll write the source directly rather than delegating.

I'll assume Spring Boot 3.x (Jakarta Bean Validation) and that `InvoiceService.create(...)` returns the created `Invoice` domain object, which the controller maps into the response DTO — matching "returns the created invoice's data" without inventing service internals.

**`CreateInvoiceRequest.java`**
```java
package com.acme.billing;

import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Positive;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.Size;

public record CreateInvoiceRequest(

        @NotNull
        @Positive
        Long customerId,

        @NotNull
        @Min(1)
        Long amountCents,

        @Size(max = 200)
        String note
) {
}
```

**`InvoiceResponse.java`**
```java
package com.acme.billing;

import java.time.Instant;

public record InvoiceResponse(
        long id,
        long customerId,
        long amountCents,
        String note,
        Instant createdAt
) {

    public static InvoiceResponse from(Invoice invoice) {
        return new InvoiceResponse(
                invoice.getId(),
                invoice.getCustomerId(),
                invoice.getAmountCents(),
                invoice.getNote(),
                invoice.getCreatedAt()
        );
    }
}
```

**`InvoiceController.java`**
```java
package com.acme.billing;

import jakarta.validation.Valid;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/billing/invoices")
public class InvoiceController {

    private final InvoiceService invoiceService;

    public InvoiceController(InvoiceService invoiceService) {
        this.invoiceService = invoiceService;
    }

    @PostMapping
    public ResponseEntity<InvoiceResponse> createInvoice(@Valid @RequestBody CreateInvoiceRequest request) {
        Invoice invoice = invoiceService.create(
                request.customerId(),
                request.amountCents(),
                request.note()
        );
        return ResponseEntity.status(HttpStatus.CREATED).body(InvoiceResponse.from(invoice));
    }
}
```

Notes:
- `Invoice` (with `getId()`, `getCustomerId()`, `getAmountCents()`, `getNote()`, `getCreatedAt()`) is assumed to be an existing domain type returned by `InvoiceService.create`; if the service instead already returns `InvoiceResponse`-shaped data, drop the `from(...)` mapping and return it directly.
- Validation errors (`MethodArgumentNotValidException`) will produce a 400 by Spring's default handling; add a `@ControllerAdvice` if you want a custom error body shape.

• reviewer-judgment — DTOs are not grouped in a holder class (e.g., InvoiceDtos) and response is not wrapped in ApiResponse.ok(...), using ResponseEntity directly instead.

1. Bash {"command":"find /tmp/eval-shim-ws-spring-request-dtos-are-validated-records-fcmRhs -maxdepth 6 -type d | head -50","description":"List directories in working directory"}
2. Write {"file_path":"/tmp/eval-shim-ws-spring-request-dtos-are-validated-records-fcmRhs/src/main/java/com/acme/billing/CreateInvoiceRequest.java","content":"package com.acme.billing;\n\nimport jakarta.validation.constraints.Min
3. Write {"file_path":"/tmp/eval-shim-ws-spring-request-dtos-are-validated-records-fcmRhs/src/main/java/com/acme/billing/InvoiceResponse.java","content":"package com.acme.billing;\n\npublic record InvoiceResponse(\n long i
4. Write {"file_path":"/tmp/eval-shim-ws-spring-request-dtos-are-validated-records-fcmRhs/src/main/java/com/acme/billing/InvoiceController.java","content":"package com.acme.billing;\n\nimport jakarta.validation.Valid;\nimport org

The directory is empty, so I'll create the source files under a standard Maven layout and print the code.

File writes aren't permitted in this session, so here's the complete Java source directly (package `com.acme.billing`). It assumes `InvoiceService.create(...)` returns an `Invoice` domain object exposing `getId()`, `getCustomerId()`, `getAmountCents()`, and `getNote()` — adjust the mapping in `InvoiceResponse.from` if that shape differs.

**CreateInvoiceRequest.java**
```java
package com.acme.billing;

import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Positive;
import jakarta.validation.constraints.Size;

public record CreateInvoiceRequest(
        @NotNull
        @Positive
        Long customerId,

        @NotNull
        @Min(1)
        Long amountCents,

        @Size(max = 200)
        String note
) {
}
```

**InvoiceResponse.java**
```java
package com.acme.billing;

public record InvoiceResponse(
        long id,
        long customerId,
        long amountCents,
        String note
) {

    static InvoiceResponse from(Invoice invoice) {
        return new InvoiceResponse(
                invoice.getId(),
                invoice.getCustomerId(),
                invoice.getAmountCents(),
                invoice.getNote()
        );
    }
}
```

**InvoiceController.java**
```java
package com.acme.billing;

import jakarta.validation.Valid;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/billing/invoices")
public class InvoiceController {

    private final InvoiceService invoiceService;

    public InvoiceController(InvoiceService invoiceService) {
        this.invoiceService = invoiceService;
    }

    @PostMapping
    public ResponseEntity<InvoiceResponse> createInvoice(@Valid @RequestBody CreateInvoiceRequest request) {
        Invoice invoice = invoiceService.create(
                request.customerId(),
                request.amountCents(),
                request.note()
        );
        return ResponseEntity.status(HttpStatus.CREATED).body(InvoiceResponse.from(invoice));
    }
}
```

Notes:
- `@Valid` on the controller parameter triggers Bean Validation on the record's constraints (needs `spring-boot-starter-validation` on the classpath).
- `customerId`/`amountCents` are `Long` (not `long`) so a missing field fails `@NotNull` instead of silently defaulting to 0.
- Returns `201 Created` with the created invoice in the body; wire up a global `@ExceptionHandler`/`@ControllerAdvice` for `MethodArgumentNotValidException` if you want a specific 400 error shape — let me know if you'd like that added.

Want me to also write these files to disk? The write attempt was blocked by the current permission mode, so I'd need you to allow file writes first.

• reviewer-judgment — The @RestControllerAdvice returns ProblemDetail objects, not ApiResponse.error(...) as specified in the criteria.

none

Here's the cancellation flow: a service class enforcing ownership + status rules, three specific exceptions for the distinct failure modes, and a `@RestControllerAdvice` that turns those into proper HTTP error responses (403 for wrong owner, 409 for wrong state, 404 for missing invoice) instead of a generic 500.

```java
package com.acme.billing;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class InvoiceCancellationService {

    private final InvoiceRepository invoiceRepository;

    public InvoiceCancellationService(InvoiceRepository invoiceRepository) {
        this.invoiceRepository = invoiceRepository;
    }

    @Transactional
    public void cancelInvoice(long invoiceId, long customerId) {
        Invoice invoice = invoiceRepository.findById(invoiceId)
                .orElseThrow(() -> new InvoiceNotFoundException(invoiceId));

        if (invoice.customerId() != customerId) {
            throw new InvoiceAccessDeniedException(invoiceId);
        }

        if (invoice.status() != InvoiceStatus.UNPAID) {
            throw new InvoiceNotCancellableException(invoiceId, invoice.status());
        }

        invoice.markCancelled();
    }
}
```

```java
package com.acme.billing;

public class InvoiceNotFoundException extends RuntimeException {

    public InvoiceNotFoundException(long invoiceId) {
        super("Invoice " + invoiceId + " not found");
    }
}
```

```java
package com.acme.billing;

public class InvoiceAccessDeniedException extends RuntimeException {

    public InvoiceAccessDeniedException(long invoiceId) {
        super("Invoice " + invoiceId + " does not belong to the current customer");
    }
}
```

```java
package com.acme.billing;

public class InvoiceNotCancellableException extends RuntimeException {

    public InvoiceNotCancellableException(long invoiceId, InvoiceStatus status) {
        super("Invoice " + invoiceId + " cannot be cancelled because it is " + status);
    }
}
```

```java
package com.acme.billing;

import org.springframework.http.HttpStatus;
import org.springframework.http.ProblemDetail;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice(basePackages = "com.acme.billing")
public class BillingExceptionHandler {

    @ExceptionHandler(InvoiceNotFoundException.class)
    public ProblemDetail handleNotFound(InvoiceNotFoundException ex) {
        return ProblemDetail.forStatusAndDetail(HttpStatus.NOT_FOUND, ex.getMessage());
    }

    @ExceptionHandler(InvoiceAccessDeniedException.class)
    public ProblemDetail handleAccessDenied(InvoiceAccessDeniedException ex) {
        return ProblemDetail.forStatusAndDetail(HttpStatus.FORBIDDEN, ex.getMessage());
    }

    @ExceptionHandler(InvoiceNotCancellableException.class)
    public ProblemDetail handleNotCancellable(InvoiceNotCancellableException ex) {
        return ProblemDetail.forStatusAndDetail(HttpStatus.CONFLICT, ex.getMessage());
    }
}
```

Notes on assumptions:
- `Invoice.status()` returns an `InvoiceStatus` enum with an `UNPAID` constant (and presumably `PAID`/`CANCELLED`); adjust the comparison if your enum names differ.
- `markCancelled()` is assumed to mutate managed/persistent state (e.g. a JPA entity inside `@Transactional`), so no explicit `save()` call is needed — add one if `Invoice` isn't managed that way.
- 403 vs. 404 for a non-owned invoice is a judgment call — returning 404 instead avoids confirming the invoice exists to a non-owner, if that's a concern for this API.

• reviewer-judgment — The criteria requires errors to be produced via ApiResponse.error(...), but the output uses ProblemDetail instead.

none

Here's the cancellation flow: service class, two domain exceptions, and a `@RestControllerAdvice` that turns them into RFC 7807 `ProblemDetail` responses, plus a thin controller so the whole path is wired end-to-end.

One deliberate design choice: an invoice that exists but belongs to *another* customer is reported as **404**, not 403. Returning 403 would let a caller distinguish "doesn't exist" from "exists but isn't yours," which leaks information about other customers' invoice IDs (an IDOR-adjacent info leak). Only "wrong owner" and "genuinely missing" are folded together; "wrong state" (already paid/cancelled) gets its own 409 since that's not sensitive.

```java
package com.acme.billing;

/**
 * Thrown when an invoice cannot be found for the requesting customer.
 * Also used when the invoice exists but belongs to a different customer,
 * so as not to reveal to a caller that an invoice ID they don't own exists.
 */
public class InvoiceNotFoundException extends RuntimeException {

    public InvoiceNotFoundException(long invoiceId) {
        super("Invoice " + invoiceId + " not found");
    }
}
```

```java
package com.acme.billing;

/**
 * Thrown when an invoice exists and belongs to the requesting customer,
 * but is no longer in a cancellable (unpaid) state.
 */
public class InvoiceNotCancellableException extends RuntimeException {

    public InvoiceNotCancellableException(long invoiceId, InvoiceStatus currentStatus) {
        super("Invoice " + invoiceId + " cannot be cancelled because it is " + currentStatus);
    }
}
```

```java
package com.acme.billing;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class InvoiceCancellationService {

    private final InvoiceRepository invoiceRepository;

    public InvoiceCancellationService(InvoiceRepository invoiceRepository) {
        this.invoiceRepository = invoiceRepository;
    }

    @Transactional
    public void cancelInvoice(long customerId, long invoiceId) {
        Invoice invoice = invoiceRepository.findById(invoiceId)
                .filter(inv -> inv.customerId() == customerId)
                .orElseThrow(() -> new InvoiceNotFoundException(invoiceId));

        if (invoice.status() != InvoiceStatus.UNPAID) {
            throw new InvoiceNotCancellableException(invoiceId, invoice.status());
        }

        invoice.markCancelled();
    }
}
```

```java
package com.acme.billing;

import org.springframework.http.HttpStatus;
import org.springframework.http.ProblemDetail;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice(basePackages = "com.acme.billing")
public class BillingExceptionHandler {

    @ExceptionHandler(InvoiceNotFoundException.class)
    public ProblemDetail handleNotFound(InvoiceNotFoundException ex) {
        return ProblemDetail.forStatusAndDetail(HttpStatus.NOT_FOUND, ex.getMessage());
    }

    @ExceptionHandler(InvoiceNotCancellableException.class)
    public ProblemDetail handleNotCancellable(InvoiceNotCancellableException ex) {
        return ProblemDetail.forStatusAndDetail(HttpStatus.CONFLICT, ex.getMessage());
    }
}
```

```java
package com.acme.billing;

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/invoices")
public class InvoiceController {

    private final InvoiceCancellationService invoiceCancellationService;

    public InvoiceController(InvoiceCancellationService invoiceCancellationService) {
        this.invoiceCancellationService = invoiceCancellationService;
    }

    // CurrentCustomer is assumed to resolve the authenticated customer's id
    // from the security context (e.g. via an ArgumentResolver / @AuthenticationPrincipal);
    // it is not re-derived from anything the client can spoof in the request body/path.
    @PostMapping("/{invoiceId}/cancel")
    public ResponseEntity<Void> cancelInvoice(@PathVariable long invoiceId,
                                               @CurrentCustomer long customerId) {
        invoiceCancellationService.cancelInvoice(customerId, invoiceId);
        return ResponseEntity.noContent().build();
    }
}
```

Notes / assumptions worth flagging:

- `InvoiceStatus` is assumed to be an enum with at least `UNPAID` (used by `invoice.status()`); swap the comparison if it's actually a different type.
- `@CurrentCustomer` is a stand-in for however this codebase currently extracts the authenticated customer id (custom annotation, `Authentication` principal, etc.) — I didn't invent an auth mechanism since none was specified; wire it to whatever already resolves `customerId` elsewhere in the app.
- `ProblemDetail` requires Spring Boot 3 / Spring Framework 6+; if this is Boot 2.x, swap the handler methods to return `ResponseEntity<ErrorResponse>` with a custom error body instead.
- `@Transactional` assumes `markCancelled()` mutates a managed JPA entity that flushes on commit; if `Invoice` isn't a JPA entity, add an explicit `invoiceRepository.save(invoice)` (or equivalent) after `markCancelled()`.

• reviewer-judgment — Output uses ErrorResponse.of(...) instead of the specified ApiResponse.error(...) pattern; all other criteria are met.

none

Two design decisions worth flagging before the code: I assumed `Invoice.status()` returns an enum `InvoiceStatus` (not given in the prompt, but required to check "still unpaid") — swap in whatever your real status type is. I also chose to return **404** for both "no such invoice" and "invoice belongs to someone else," rather than 403, so the API doesn't reveal that another customer's invoice exists. Change that to a 403-based exception if your security model prefers explicit "forbidden" semantics.

```java
package com.acme.billing;

// Assumed to exist elsewhere in the billing module.
public enum InvoiceStatus {
    UNPAID,
    PAID,
    CANCELLED
}
```

```java
package com.acme.billing;

public class InvoiceNotFoundException extends RuntimeException {

    public InvoiceNotFoundException(long invoiceId) {
        super("Invoice " + invoiceId + " not found");
    }
}
```

```java
package com.acme.billing;

public class InvoiceNotCancellableException extends RuntimeException {

    public InvoiceNotCancellableException(long invoiceId, InvoiceStatus status) {
        super("Invoice " + invoiceId + " cannot be cancelled because its status is " + status);
    }
}
```

```java
package com.acme.billing;

import org.springframework.stereotype.Service;

@Service
public class InvoiceCancellationService {

    private final InvoiceRepository invoiceRepository;

    public InvoiceCancellationService(InvoiceRepository invoiceRepository) {
        this.invoiceRepository = invoiceRepository;
    }

    public void cancelInvoice(long invoiceId, long customerId) {
        Invoice invoice = invoiceRepository.findById(invoiceId)
                .orElseThrow(() -> new InvoiceNotFoundException(invoiceId));

        if (invoice.customerId() != customerId) {
            // Reported as "not found" rather than "forbidden" so a customer
            // can't use this endpoint to probe for other customers' invoices.
            throw new InvoiceNotFoundException(invoiceId);
        }

        if (invoice.status() != InvoiceStatus.UNPAID) {
            throw new InvoiceNotCancellableException(invoiceId, invoice.status());
        }

        invoice.markCancelled();
    }
}
```

```java
package com.acme.billing;

import java.time.Instant;

public record ErrorResponse(Instant timestamp, int status, String error, String message) {

    public static ErrorResponse of(org.springframework.http.HttpStatus httpStatus, String message) {
        return new ErrorResponse(Instant.now(), httpStatus.value(), httpStatus.getReasonPhrase(), message);
    }
}
```

```java
package com.acme.billing;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice(basePackages = "com.acme.billing")
public class InvoiceExceptionHandler {

    @ExceptionHandler(InvoiceNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleNotFound(InvoiceNotFoundException ex) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND)
                .body(ErrorResponse.of(HttpStatus.NOT_FOUND, ex.getMessage()));
    }

    @ExceptionHandler(InvoiceNotCancellableException.class)
    public ResponseEntity<ErrorResponse> handleNotCancellable(InvoiceNotCancellableException ex) {
        return ResponseEntity.status(HttpStatus.CONFLICT)
                .body(ErrorResponse.of(HttpStatus.CONFLICT, ex.getMessage()));
    }
}
```

```java
package com.acme.billing;

import org.springframework.http.ResponseEntity;
import org.springframework.security.core.Authentication;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/invoices")
public class InvoiceController {

    private final InvoiceCancellationService invoiceCancellationService;

    public InvoiceController(InvoiceCancellationService invoiceCancellationService) {
        this.invoiceCancellationService = invoiceCancellationService;
    }

    @PostMapping("/{id}/cancel")
    public ResponseEntity<Void> cancelInvoice(@PathVariable("id") long invoiceId, Authentication authentication) {
        long customerId = ((CurrentCustomer) authentication.getPrincipal()).customerId();
        invoiceCancellationService.cancelInvoice(invoiceId, customerId);
        return ResponseEntity.noContent().build();
    }
}
```

Notes:
- `CurrentCustomer` in the controller is a stand-in for however your app's `Authentication` principal already exposes the logged-in customer's id — swap it for the real type used elsewhere in this codebase.
- The two exceptions are unchecked and package-private-visible on purpose; the `@RestControllerAdvice` is scoped to `com.acme.billing` so it converts them into the JSON `ErrorResponse` body (404 for not-found/not-yours, 409 for wrong state) without any controller needing its own try/catch.
- If you already have a global exception handler elsewhere, just add these two `@ExceptionHandler` methods to it instead of introducing `InvoiceExceptionHandler`.