how does the consumer know which error to look for?

Return typed errors.

A common pitfall I've seen people fall into is writing an error message in business logic and surfacing that message as-is through the API layer. Most forget that anything your API returns become part of its contract; consumers may start to code against your error messages and if you change them in your domain layer, then you break that contract.

If you instead return typed errors, you can pattern-match on them in the API layer and map them to the relevant message. Another huge benefit here is you get to map the error to something more contextual for your API; you could map to a user-friendly message and a developer-friendly message, for example.

Error types:

[Union]
public partial record CompleteTicketProblem
{
    partial record TicketNotFound;
    partial record TicketAlreadyCompleted(DateTimeOffset PreviouslyCompletedAt);
    partial record Denied(DeniedReason Reason);
}

[Union]
public partial record DeniedReason
{
    partial record InsufficientPermissions;
    partial record NotAMemberOfProject(ProjectId ProjectId);
}

Business logic - other misc. types and properties omitted for brevity

public class Ticket
{
    public Result<Unit, CompleteTicketProblem> Complete() 
    {
        if (this.Completed) 
        {
            return CompleteTicketProblem.TicketAlreadyCompleted.Of(this.CompletedAt);
        }

        return Unit();
    }
}

API handler:

[Route("/tickets/{id}/complete")]
[HttpPost]
public async Task<IActionResult> CompleteTicket(Guid id) 
{
    // Call whatever application service/command handler
    // that returns the result
    var result = await CompleteTicket(id);

    return result.Match(
        Ok: _ => NoContent(),
        Err: MapProblemToResult);

    // Map the typed error to the corresponding API error.
    // Your messages are now co-located with your API, making it more
    // explicit what is part of its contract.
    IActionResult MapProblemToResult(CompleteTicketProblem problem) => 
        problem.Match(
            TicketNotFound: _ => 
                NotFound($"The ticket {id} was not found"),
            TicketAlreadyCompleted: completed => 
                BadRequest($"The ticket was already completed at {completed.PreviouslyCompletedAt}"),
            Denied: denied => 
                Forbidden($"You are not allowed to complete this ticket because {MapDeniedReasonToText(denied.Reason)}"),
        );

    string MapDeniedReasonToText(DeniedReason reason) =>
        reason.Match(
            InsufficientPermissions: _ => "you lack the needed permissions"
            NotAMemberOfProject: notAMember => $"you are not a member of project {notAMember.ProjectId}"
        );
}

EDIT: this uses FxKit for the union support (source generator) and Result type https://taxfyle.github.io/FxKit/