Overengineering

Well, as you've mentioned in the comments, my solution is a bit of overengineering.

Class

I'd write a bianry_response class.

class binary_response
{
    static std::unordered_set<std::string> positives;
    static std::unordered_set<std::string> negatives; //define both and give some defaults
    std::optional<bool> answer;
    std::string answer_str;
public:
    //rule of zero

    friend std::istream& operator>>(std::istream& is, binary_response& response)
    {
        is >> answer_str;
        if (positives.count(answer_str) == 1)
            {answer = true;}
        else if (negatives.count(answer_str) == 1)
            {answer = false;}
        else
        {
            is.setstate(std::ios::failbit); //standard behavior
            answer_str.clear();
        } 

        return is;
    }

    bool valid() const
    {
        return answer.has_value();
    }

    operator bool() const
    {
        return answer.value();
    }

    const std::string& literal_answer() const
    {return answer_str;}

    //manipulators for positives and negatives
    static void positives() {return positives;}
    static void positives(std::unordered_set<std::string> new_positives)
    {
        positives = std::move(new_positives);
    }

    static void negatives() {return negatives;}
    static void negatives(std::unordered_set<std::string> new_negatives) 
    {
        negatives = std::move(new_negatives);
    }

    //maybe something that would return default ones
}

Example

The above code would enable us to write the following:

binary_response response;
while (!(is >> response))
{
    os << "Please enter one of the variants shown above\n";
    is.ignore(std::numeric_limits<std::streamsize>::max());
}

return response; //will convert to bool automatically

Do note that operator>> is callable only using ADL, as it is not defined outside. Usually it should work as is, but some people might get confused from not seeing it in their IDE.

After trying to parse darn CSV data files I discovered some of the awesome features of iostreams. It is unfortunate that very few people care about it. The above code would enable us to get multiple responses in a row using std::copy(), for example (not sure if it is a useful feature). Although we teach how to overload operator>> here, we don't really mention that one should set failbit if the extraction fails for whatever reason.

Design decisions

• Sets enforce uniqueness of valid responses in each category

  I don't think that having duplicates are bad, but enforcement comes almost for free, or even improves things. Though one can make a text that belongs to both, but I believe it is hard to do by accident.

• Shared pool of valid responses

  I wasn't sure if local pool of responses would be useful. It would create very big memory overhead for such a simple task, but since the class itself is overkill, it is quite arguable.

• Standard compliant streaming operator overload

  By far not all people know internals of iostream, but the idiomatic loop while (is >> variable) is quite widespread and well understood, so I thought that not having to learn something new is a good thing. Practically, the only thing they need to know is the name of the class. Everything else is intuitive (I'm sure IDE will help them out with that). This also provides fine grained control over the stream, and lets users to ignore/unget themselves.

• Can only be extracted from the stream

  This is one of the "easy to use correctly, hard to use incorrectly". Copying into a local string, then passing into a function doesn't seem correct to me. People can always make std::istringstream from a string.