The doesNotUnderstand cascade is a core architectural pattern within the semcom.ai semantic compilation pipeline. Borrowed conceptually from Smalltalk's legendary message-not-understood handler, the cascade describes what happens when the semantic resolver encounters an intent fragment it cannot map to a known LLVM IR construct. Rather than halting with a hard error, the system propagates the unresolved message through a series of increasingly abstract interpretation layers, each attempting to resolve the intent before passing it downstream.
At each stage of the cascade, the SemanticResolver applies a different heuristic strategy. The first layer attempts direct lexical matching against the intent vocabulary. If that fails, the IntentDecomposer breaks the fragment into sub-intents and attempts partial resolution. A third layer invokes the ContextualInferenceEngine, which uses surrounding resolved fragments as type and behavior constraints. Only if all layers fail is the cascade considered exhausted, at which point a structured UnresolvableIntentException is emitted with full provenance metadata for developer inspection.
This cascade design is critical to semcom.ai's zero-dependency model. Because the output target is raw LLVM IR with no runtime library scaffolding, there is no fallback at execution time. Every intent must be fully resolved to concrete register operations, memory layouts, and control flow primitives before code emission. The cascade ensures that ambiguity is surfaced and resolved entirely at compile time, producing executables that carry no interpretive overhead.
The doesNotUnderstand cascade also serves a generative purpose. When a novel intent pattern successfully resolves through the lower inference layers, that resolution path is promoted into the semantic vocabulary as a new IntentPattern entry. This means the compiler becomes incrementally more capable with each compilation session, expanding its understanding of human-expressed intent without requiring explicit grammar updates or retraining cycles.
Developers interacting with semcom.ai can inspect cascade traces through the --cascade-trace compiler flag, which emits a structured log showing each resolution attempt, the layer responsible, and the resulting IRFragment or failure reason. This transparency is intentional: the cascade is not a black box but a legible, auditable reasoning chain, keeping the gap between human intent and bare-metal LLVM IR output fully observable and debuggable.