Capture checking in Scala 3 enables lightweight and practical effect and resource checking by recording capabilities in types. However, the system offers no way to reason about kinds of capabilities. This limitation makes it impossible to express natural constraints such as “retaining only the control-flow capabilities of this closure” or “excluding all thread-local capabilities from this argument.” Both constraints prevent the Scala 3 standard library from being fully capture-checked. For instance, the Try construct re-throws caught exceptions, so it captures only the control-flow capabilities of its body, and Future cannot capture thread-local resources.

We introduce capability classifiers: a tree-structured, user-extensible system for tagging capabilities by semantic role. Classifiers are organized in an open hierarchy, and projections filter kinds of capabilities based on classifiers, supporting both inclusion (c.only[C]) and exclusion (c.except[C]). The tree structure enables decidable disjointness reasoning: classifiers on separate branches are guaranteed to be disjoint regardless of unknown extensions elsewhere in the hierarchy. We formalize classifiers as an extension of System Capless, a foundational calculus for capture checking, introducing a classifier kind algebra based on intersection, union, and subtraction of classifier subtrees. We extend the operational semantics to model exception interception and establish type safety via a big-step proof. Classifiers are implemented in the Scala 3 capture checker, and we demonstrate their use on standard library types and real-world effect exclusion patterns.