# Warnings

Every answer carries `warnings`: known traps in this request, found by checks that cost nothing. The answer is returned either way; a warning says where it may be wrong.

| Code | When |
|---|---|
| `no_other_option` | a choice of 3 or more options has no `other` / `none` option, so a state that fits none must still pick one |
| `many_options` | more than 20 options read by the engine (`"method": "engine"`), answered in two rounds; a matched choice (the default above 20) has no such warning |
| `degree_words` | score levels written as "low", "medium", "high"; describe each level as a situation |
| `compound_noul` | a yes/no question asks two things at once |
| `criteria_conflict` | a noul's `true` and `false` descriptions are the same, or look swapped (`true` has a negation and `false` has none) |
| `negated_instructions` | a yes/no or choice question whose instructions contain a negation (not, never, no, without, avoid …); phrase it for yes |
| `state_cut` | the engine read only part of the state; for an array with memory or computed lines, how many of its oldest elements Jepela left out so that the lines were read; for a matched choice, how much the matching model read (at most 512 tokens: of a string or an object its start, of an array its newest elements); see State and Choice |
| `state_long` | the state fills most of the window |
| `memory_cut` | the engine read fewer memory lines than were sent (fired rules and recalled lines); each line's `read` says which. In an array this happens only when the lines and its newest element alone are longer than the engine reads. When every question was matched, the matching model read them: it reads at most 512 tokens, the lines first before a string or an object, and in an array as the engine does |
| `memory_full` | more fired rules and recalled lines than the engine's 64 context lines; computed facts come first, then rules, then recall, and `memory.lines_dropped` counts what was left out |
| `memory_number_rule` | a memory line compares numbers in words; use a rule with `when` |
| `memory_names_option_negatively` | a memory line names an option of this question after a negation (not, never, no, nor, without, avoid, words ending in n't) in the same clause, which pulls the engine toward it. An option is named by the words of its key in any order (`gold_coins` by "gold coins", `coin_corridor` by "the corridor with the gold coins") or by its description, as whole words or their plural (`potion` by "potions", `map` not by "roadmap"); a clause ends at . ; ! ? or "but", and at a comma before "instead" or "rather"; a catch-all option such as `other` is never counted. The message gives the whole `POST /v1/memory/rules` body (subject, the line as its text, `exclude`, `question`) of the exclusion rule that removes, in code, the option named first after the negation; when the line names more, add the others it forbids to `exclude` |
| `rule_skipped` | a rule of the subject was not checked because this request has no field its `when` reads (the rule is listed in `memory.rules_broken` with `missing`, the field). Normal for a rule meant for other requests; send the field when the rule should be checked. The message names the rule and the field |
| `rule_broken` | a rule of the subject was skipped because its `when` could not be evaluated although the fields it reads were there: a value it compares is text that is not one number (a date, `1 250`), values that cannot be compared, or a condition stored before Jepela refused such conditions. The message names the rule and why |
| `memory_presence_only` | with `placebo`, this question moved as much with neutral lines as with the memory |
| `unknown_field` | the request, its `memory` or a question (then with `question`) has a field Jepela does not read; the message names it and the closest field Jepela reads ("unknown field subjet; did you mean subject?"), and the answer was made without it (see the API reference). The memory routes and `POST /v1/golden` (then with `case`) give it too, for the fields of their bodies. A name that looks like a key or a token (over 40 characters, other characters than letters, digits and `_ . -`, or 16 letters and digits in a row with a digit among them) is not repeated |
| `language_not_served` | `jepela` routed the state to a checkpoint that is not served now (`GET /v1/models` shows it as not available), so another checkpoint answered: a state that does not read as English is then answered by the English checkpoint, which is much less accurate outside English and stays confident there; `engine.checkpoint` names the one that answered |

`remember` warns at write time too: `memory_number_rule` and `memory_negative_rule` (a line that says what to avoid; the message points to an exclusion rule).