All Long Subsequences Are Dictionary Words

Given a lowercase string text and a finite lowercase dictionary, consider every subsequence of text whose length is at least 3. A subsequence keeps relative order and is identified by its resulting string; repeated ways to form the same string do not change the decision.
Return two booleans:
answer[0] is true exactly when every considered subsequence appears in the dictionary.
answer[1] is true exactly when, for every considered subsequence, at least one dictionary word is an anagram of it.
If text.length < 3, both statements are vacuously true. Duplicate dictionary entries have no effect.

Function
allSubsequencesAreWords(text: String, dictionary: String[]) → boolean[]

Examples
Example 1
text = "abc"
dictionary = ["abc","cab"]
return = [true,true]
The only qualifying subsequence is abc. It is present directly and also has dictionary anagrams.
Example 2
text = "abc"
dictionary = ["bca"]
return = [false,true]
The subsequence abc is not itself in the dictionary, but bca is an anagram of it.
Example 3
text = "abcd"
dictionary = ["abc","abd","acd","bcd","abcd"]
return = [true,true]
The four length-three subsequences and the full length-four subsequence all appear directly, so both conditions hold.

Constraints
0 <= text.length <= 18
0 <= dictionary.length <= 200000
text and every dictionary word contain only lowercase English letters.
Each dictionary word has length at most 18.
The total number of dictionary characters is at most 1000000.

Enumerate every bitmask of text, up to 262144 of them. Skip masks with fewer than 3 bits. Build the subsequence string, then dedupe with a set so repeated strings count once. Put all dictionary words in a hash set for part one. For part two, build a second hash set of sorted-letter keys (or 26-count signatures) from every dictionary word. Then for each unique subsequence, check membership in the word set and check its sorted key in the anagram set. Both answers are just AND across all subsequences. The common pitfall is looping over the dictionary per subsequence, which is far too slow. Another is forgetting the vacuous case when length is under 3, where you return [true,true]. Sorting 18 characters per subsequence is cheap enough. StealthCoder is the hedge if you freeze on the anagram key idea during the live OA.

The honest play: practice the pattern, and have StealthCoder ready for the one you didn't see coming.