●No drift

• reviewer-judgment — All criteria met: BillingDtos holder contains records for request/response, @Valid annotation on controller parameter, appropriate jakarta.validation constraints (@NotNull/@Positive/@Min/@Size) matching stated rules, and response wrapped in ApiResponse.ok(...).

1. Skill {"skill":"komo-stack:spring-boot-conventions"}

Two things I had to assume since they weren't given: the location/shape of the shared `ApiResponse<T>` wrapper (assumed `com.acme.common.ApiResponse`, per the "every response is wrapped" convention) and the shape of the object `InvoiceService.create(...)` returns (assumed an existing `Invoice` record with `id`, `customerId`, `amountCents`, `note`, `createdAt`).

```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;

import java.time.Instant;

public class BillingDtos {

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

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

```java
package com.acme.billing;

import com.acme.common.ApiResponse;
import jakarta.validation.Valid;
import org.springframework.http.HttpStatus;
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.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;

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

    private final InvoiceService invoiceService;

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

    @PostMapping("/invoices")
    @ResponseStatus(HttpStatus.CREATED)
    public ApiResponse<BillingDtos.InvoiceResponse> createInvoice(
            @Valid @RequestBody BillingDtos.CreateInvoiceRequest request) {
        Invoice invoice = invoiceService.create(
                request.customerId(), request.amountCents(), request.note());
        return ApiResponse.ok(toResponse(invoice));
    }

    private static BillingDtos.InvoiceResponse toResponse(Invoice invoice) {
        return new BillingDtos.InvoiceResponse(
                invoice.id(),
                invoice.customerId(),
                invoice.amountCents(),
                invoice.note(),
                invoice.createdAt());
    }
}
```

Applied conventions: request/response as `record`s grouped in a `BillingDtos` holder validated with `jakarta.validation`, and a thin controller using constructor injection that wraps the result in `ApiResponse.ok(...)` rather than returning the raw entity.

• reviewer-judgment — Output contains both BillingDtos records (CreateInvoiceRequest and InvoiceResponse) with correct jakarta.validation annotations (@Positive/@Min(1)/@Size(max=200)) and the controller properly uses @Valid on the parameter and wraps the response in ApiResponse.ok(...).

1. Skill {"skill":"komo-stack:spring-boot-conventions"}
2. Write {"file_path":"/tmp/eval-shim-ws-spring-request-dtos-are-validated-records-o8u1Ic/BillingDtos.java","content":"package com.acme.billing;\n\nimport jakarta.validation.constraints.Min;\nimport jakarta.validation.constraints

Since file writes aren't permitted here, I'll just print the source directly as requested.

```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 final class BillingDtos {

    private BillingDtos() {
    }

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

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

```java
package com.acme.billing;

import com.acme.common.web.ApiResponse;
import jakarta.validation.Valid;
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")
public class BillingController {

    private final InvoiceService invoiceService;

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

    @PostMapping("/invoices")
    public ApiResponse<BillingDtos.InvoiceResponse> createInvoice(
            @Valid @RequestBody BillingDtos.CreateInvoiceRequest request) {
        Invoice invoice = invoiceService.create(
                request.customerId(),
                request.amountCents(),
                request.note());

        BillingDtos.InvoiceResponse response = new BillingDtos.InvoiceResponse(
                invoice.id(),
                invoice.customerId(),
                invoice.amountCents(),
                invoice.note());

        return ApiResponse.ok(response);
    }
}
```

Notes:
- Followed house conventions: constructor injection (no Lombok/`@Autowired`), request/response as records in a `BillingDtos` holder, `jakarta.validation` annotations, thin controller wrapping the result in `ApiResponse.ok(...)`.
- Assumed `InvoiceService.create(...)` returns a domain `Invoice` type (with `id()`, `customerId()`, `amountCents()`, `note()` accessors) that the controller maps into `InvoiceResponse`; adjust the mapping if the real return type differs. Errors (e.g. unknown customer) are assumed to throw a domain exception handled by an existing `@RestControllerAdvice`, per convention — no try/catch added here.

• reviewer-judgment — All criteria satisfied: ownership and unpaid-status checks enforced in service with distinct exceptions (InvoiceAccessDeniedException, InvoiceNotCancellableException), @RestControllerAdvice handler converts all three exceptions to ApiResponse.error(...), no try/catch in controller, and service returns void.

1. Skill {"skill":"komo-stack:spring-boot-conventions"}
2. Bash {"command":"true","description":"no-op"}

Here's the full implementation — service, domain exceptions, the `@RestControllerAdvice` that turns them into `ApiResponse.error(...)`, and a thin controller wiring it up.

```java
package com.acme.billing;

public enum InvoiceStatus {
    UNPAID,
    PAID,
    CANCELLED
}
```

```java
package com.acme.billing;

public class InvoiceNotFoundException extends RuntimeException {

    public InvoiceNotFoundException(long invoiceId) {
        super("Invoice %d not found".formatted(invoiceId));
    }
}
```

```java
package com.acme.billing;

public class InvoiceAccessDeniedException extends RuntimeException {

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

```java
package com.acme.billing;

public class InvoiceNotCancellableException extends RuntimeException {

    public InvoiceNotCancellableException(long invoiceId, InvoiceStatus status) {
        super("Invoice %d cannot be cancelled because it is %s".formatted(invoiceId, status));
    }
}
```

```java
package com.acme.billing;

public record ApiResponse<T>(boolean success, T data, ApiError error) {

    public static <T> ApiResponse<T> ok(T data) {
        return new ApiResponse<>(true, data, null);
    }

    public static ApiResponse<Void> error(String code, String message) {
        return new ApiResponse<>(false, null, new ApiError(code, message));
    }

    public record ApiError(String code, String message) {}
}
```

```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 cancel(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;

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
public class InvoiceExceptionHandler {

    @ExceptionHandler(InvoiceNotFoundException.class)
    public ResponseEntity<ApiResponse<Void>> handleNotFound(InvoiceNotFoundException ex) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND)
                .body(ApiResponse.error("INVOICE_NOT_FOUND", ex.getMessage()));
    }

    @ExceptionHandler(InvoiceAccessDeniedException.class)
    public ResponseEntity<ApiResponse<Void>> handleAccessDenied(InvoiceAccessDeniedException ex) {
        return ResponseEntity.status(HttpStatus.FORBIDDEN)
                .body(ApiResponse.error("INVOICE_ACCESS_DENIED", ex.getMessage()));
    }

    @ExceptionHandler(InvoiceNotCancellableException.class)
    public ResponseEntity<ApiResponse<Void>> handleNotCancellable(InvoiceNotCancellableException ex) {
        return ResponseEntity.status(HttpStatus.CONFLICT)
                .body(ApiResponse.error("INVOICE_NOT_CANCELLABLE", 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;
    }

    @PostMapping("/{id}/cancel")
    public ResponseEntity<ApiResponse<Void>> cancel(@PathVariable("id") long invoiceId,
                                                      @CurrentCustomerId long customerId) {
        invoiceCancellationService.cancel(invoiceId, customerId);
        return ResponseEntity.ok(ApiResponse.ok(null));
    }
}
```

Convention decisions: constructor injection (no Lombok/field injection); ownership and unpaid-status checks live in the service as the "second lock" even though the route would already be authenticated, with three distinct domain exceptions (404/403/409) mapped by a single `@RestControllerAdvice` into `ApiResponse.error(...)` rather than any try/catch in the controller.

Two assumptions I had to make since they weren't given: `InvoiceStatus` is an enum with an `UNPAID` value (status()'s return type wasn't specified), and `@CurrentCustomerId` is a pre-existing argument-resolver annotation your app uses to pull the authenticated customer's id — swap it for however you actually get `customerId` today.

• reviewer-judgment — Service enforces both ownership and unpaid-status checks with distinct exceptions; errors flow through @RestControllerAdvice producing ApiResponse.error(...); controller has no try/catch; service returns void.

1. Skill {"skill":"komo-stack:spring-boot-conventions"}
2. Bash {"command":"true","description":"noop, proceeding directly to answer"}

Here's the full implementation. Since you only gave me `Invoice`/`InvoiceRepository` signatures, I've assumed `Invoice.status()` returns an `InvoiceStatus` enum with an `UNPAID` constant, and that `ApiResponse`/`ApiError` already exist in your codebase per house convention — I've included minimal versions of them so the code is self-contained; drop them if you already have equivalents.

```java
package com.acme.billing;

public enum InvoiceStatus {
    UNPAID,
    PAID,
    CANCELLED
}
```

```java
package com.acme.billing;

public class InvoiceNotFoundException extends RuntimeException {
    public InvoiceNotFoundException(long invoiceId) {
        super("Invoice %d not found".formatted(invoiceId));
    }
}
```

```java
package com.acme.billing;

public class InvoiceAccessDeniedException extends RuntimeException {
    public InvoiceAccessDeniedException(long invoiceId) {
        super("Invoice %d does not belong to the current customer".formatted(invoiceId));
    }
}
```

```java
package com.acme.billing;

public class InvoiceNotCancellableException extends RuntimeException {
    public InvoiceNotCancellableException(long invoiceId, InvoiceStatus status) {
        super("Invoice %d cannot be cancelled while in status %s".formatted(invoiceId, status));
    }
}
```

```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 record ApiError(String code, String message) {
}
```

```java
package com.acme.billing;

public record ApiResponse<T>(boolean success, T data, ApiError error) {

    public static <T> ApiResponse<T> ok(T data) {
        return new ApiResponse<>(true, data, null);
    }

    public static <T> ApiResponse<T> error(String code, String message) {
        return new ApiResponse<>(false, null, new ApiError(code, 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
public class BillingExceptionHandler {

    @ExceptionHandler(InvoiceNotFoundException.class)
    public ResponseEntity<ApiResponse<Void>> handleNotFound(InvoiceNotFoundException ex) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND)
                .body(ApiResponse.error("INVOICE_NOT_FOUND", ex.getMessage()));
    }

    @ExceptionHandler(InvoiceAccessDeniedException.class)
    public ResponseEntity<ApiResponse<Void>> handleAccessDenied(InvoiceAccessDeniedException ex) {
        return ResponseEntity.status(HttpStatus.FORBIDDEN)
                .body(ApiResponse.error("INVOICE_ACCESS_DENIED", ex.getMessage()));
    }

    @ExceptionHandler(InvoiceNotCancellableException.class)
    public ResponseEntity<ApiResponse<Void>> handleNotCancellable(InvoiceNotCancellableException ex) {
        return ResponseEntity.status(HttpStatus.CONFLICT)
                .body(ApiResponse.error("INVOICE_NOT_CANCELLABLE", 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;
    }

    @PostMapping("/{invoiceId}/cancel")
    public ResponseEntity<ApiResponse<Void>> cancelInvoice(
            @PathVariable long invoiceId,
            @AuthenticationPrincipal CurrentCustomer currentCustomer) {
        invoiceCancellationService.cancelInvoice(invoiceId, currentCustomer.customerId());
        return ResponseEntity.ok(ApiResponse.ok(null));
    }
}
```

Note: `CurrentCustomer`/`@AuthenticationPrincipal` in the controller is a placeholder for however you currently resolve `customerId` from the authenticated request — swap it for your actual mechanism.

Conventions applied: constructor injection (no Lombok/field injection), and authorization + state checks live in the service ("two locks on the door") even though the route may already be secured, with domain exceptions mapped to HTTP status via a single `@RestControllerAdvice` rather than try/catch in the controller.

• reviewer-judgment — All five criteria met: ownership and unpaid-status checks both enforced in the service as distinct exceptions (InvoiceAccessDeniedException and InvoiceNotCancellableException), errors routed through @RestControllerAdvice handler producing ApiResponse.error(...), no try/catch in controller, and service returns void.

1. Skill {"skill":"komo-stack:spring-boot-conventions"}
2. Write {"file_path":"/tmp/eval-shim-ws-spring-service-owns-rules-and-errors-REPZQ4/InvoiceService.java","content":"package com.acme.billing;\n\npublic class InvoiceService {\n\n private final InvoiceRepository invoiceReposit

Here's the implementation. Since the working directory isn't a repo with an existing `InvoiceStatus`/`ApiResponse`, I've assumed a standard `InvoiceStatus` enum (with `UNPAID`) already exists alongside `Invoice`, and included a minimal `ApiResponse` envelope — drop that file if your codebase already has one.

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

public class InvoiceService {

    private final InvoiceRepository invoiceRepository;

    public InvoiceService(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) {
            throw new InvoiceAccessDeniedException(invoiceId);
        }

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

        invoice.markCancelled();
    }
}
```

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

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

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

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

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

public class InvoiceNotCancellableException extends RuntimeException {
    public InvoiceNotCancellableException(long invoiceId) {
        super("Invoice " + invoiceId + " is no longer cancellable");
    }
}
```

**web/ApiResponse.java**
```java
package com.acme.billing.web;

public record ApiResponse<T>(boolean success, T data, ApiError error) {

    public static <T> ApiResponse<T> ok(T data) {
        return new ApiResponse<>(true, data, null);
    }

    public static <T> ApiResponse<T> error(String code, String message) {
        return new ApiResponse<>(false, null, new ApiError(code, message));
    }

    public record ApiError(String code, String message) {}
}
```

**web/BillingExceptionHandler.java**
```java
package com.acme.billing.web;

import com.acme.billing.InvoiceAccessDeniedException;
import com.acme.billing.InvoiceNotCancellableException;
import com.acme.billing.InvoiceNotFoundException;
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
public class BillingExceptionHandler {

    @ExceptionHandler(InvoiceNotFoundException.class)
    public ResponseEntity<ApiResponse<Void>> handleNotFound(InvoiceNotFoundException ex) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND)
                .body(ApiResponse.error("INVOICE_NOT_FOUND", ex.getMessage()));
    }

    @ExceptionHandler(InvoiceAccessDeniedException.class)
    public ResponseEntity<ApiResponse<Void>> handleAccessDenied(InvoiceAccessDeniedException ex) {
        return ResponseEntity.status(HttpStatus.FORBIDDEN)
                .body(ApiResponse.error("INVOICE_ACCESS_DENIED", ex.getMessage()));
    }

    @ExceptionHandler(InvoiceNotCancellableException.class)
    public ResponseEntity<ApiResponse<Void>> handleNotCancellable(InvoiceNotCancellableException ex) {
        return ResponseEntity.status(HttpStatus.CONFLICT)
                .body(ApiResponse.error("INVOICE_NOT_CANCELLABLE", ex.getMessage()));
    }
}
```

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

import com.acme.billing.InvoiceService;
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("/api/invoices")
public class InvoiceController {

    private final InvoiceService invoiceService;

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

    @PostMapping("/{id}/cancel")
    public ApiResponse<Void> cancel(@PathVariable("id") long id, Authentication authentication) {
        long customerId = Long.parseLong(authentication.getName());
        invoiceService.cancelInvoice(id, customerId);
        return ApiResponse.ok(null);
    }
}
```

Convention notes: authorization ("own invoice") and state check ("still unpaid") both live in `InvoiceService`, not the controller, per the "two locks on the door" rule; constructor injection only, no Lombok. The customer-id extraction from `Authentication.getName()` is a placeholder — swap it for however your security context actually exposes the numeric customer id.

1. Skill {"skill":"komo-stack:spring-boot-conventions"}

```java
package com.acme.billing;

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

import com.acme.common.ApiResponse;

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

    private final InvoiceService invoiceService;

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

    @GetMapping("/invoices/{id}")
    public ApiResponse<Invoice> getInvoice(@PathVariable long id) {
        Invoice invoice = invoiceService.getInvoice(id);
        return ApiResponse.ok(invoice);
    }
}
```

Notes:
- No try/catch here — if `id` doesn't resolve, `InvoiceService.getInvoice` is expected to throw a domain exception (e.g. `InvoiceNotFoundException`) that a `@RestControllerAdvice` translates into `ApiResponse.error(...)`.
- Single param, no pagination clamping needed since this returns one resource, not a list; response is still wrapped in `ApiResponse.ok(...)` per convention.

1. Skill {"skill":"komo-stack:spring-boot-conventions"}
2. Write {"file_path":"/tmp/eval-shim-ws-spring-work-triggers-skill-L38LfH/InvoiceController.java","content":"package com.acme.billing;\n\nimport com.acme.common.ApiResponse;\nimport org.springframework.web.bind.annotation.GetMap

No problem — I'll just print the source in my reply instead of writing files.

```java
package com.acme.billing;

import com.acme.common.ApiResponse;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

    private final InvoiceService invoiceService;

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

    @GetMapping("/invoices/{id}")
    public ApiResponse<InvoiceDtos.InvoiceView> getInvoice(@PathVariable long id) {
        Invoice invoice = invoiceService.getInvoice(id);
        return ApiResponse.ok(InvoiceDtos.InvoiceView.from(invoice));
    }
}
```

```java
package com.acme.billing;

import java.math.BigDecimal;
import java.time.Instant;

public final class InvoiceDtos {

    private InvoiceDtos() {}

    public record InvoiceView(
            long id,
            long customerId,
            BigDecimal amount,
            String status,
            Instant issuedAt) {

        public static InvoiceView from(Invoice invoice) {
            return new InvoiceView(
                    invoice.getId(),
                    invoice.getCustomerId(),
                    invoice.getAmount(),
                    invoice.getStatus(),
                    invoice.getIssuedAt());
        }
    }
}
```

Notes:
- Constructor injection (no Lombok/field injection), and the raw `Invoice` entity is mapped to an `InvoiceDtos.InvoiceView` record before returning, wrapped in `ApiResponse.ok(...)`, per house conventions — I guessed at `Invoice`'s fields (id/customerId/amount/status/issuedAt) since its actual shape wasn't given.
- Not-found handling is assumed to be a domain exception (e.g. `InvoiceNotFoundException`) thrown by `InvoiceService.getInvoice` and mapped by an existing `@RestControllerAdvice` — no try/catch added here; let me know if that exception/advice doesn't exist yet and I'll sketch it too.

1. Skill {"skill":"komo-stack:spring-boot-conventions"}

```java
package com.acme.billing;

import com.acme.common.web.ApiResponse;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

    private final InvoiceService invoiceService;

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

    @GetMapping("/invoices/{id}")
    public ApiResponse<Invoice> getInvoice(@PathVariable long id) {
        Invoice invoice = invoiceService.getInvoice(id);
        return ApiResponse.ok(invoice);
    }
}
```

Notes:
- Constructor injection with a hand-written constructor (no `@Autowired`, no Lombok); response wrapped in `ApiResponse.ok(...)` per house convention rather than returning the raw `Invoice`.
- Not-found handling is assumed to live in a domain exception (e.g. `InvoiceNotFoundException`) thrown from `InvoiceService` and mapped by an existing `@RestControllerAdvice` — no try/catch added here. `ApiResponse` is assumed to live in a shared package (`com.acme.common.web`); adjust the import if yours differs.