feat: Definitional Era — named predicates (define) (v31)

[rmichaelthomas]

Summary

Implements the Definitional Era (Liminate Checkpoint v31): named, reusable domain predicates via a new define declaration. define <name>: <condition> registers a predicate; is <name> / is not <name> applies it anywhere the condition grammar accepts a leaf (where/keep/filter/require/require each/forbid/permit/expect/choose if/when/unless).

Phases completed

1. Vocabulary — define added to DECLARATIONS. Public count 60 → 61.
2. AST nodes — DefineNode, PredicateApplicationNode in parser.py.
3. Parsing + threading — predicate_names/preds threaded through the entire condition-parsing chain and every condition-bearing verb, exactly parallel to composition_names/comp. define dispatches from the DECLARATION branch in _parse_one_operation_inner (not the about-only first-line path).
4. Collision resolution + field elision — is <name> resolves to a predicate only when <name> is a live predicate name; otherwise falls through to legacy string equality (non-breaking for every existing program, where the predicate set is always empty). Quoted values always force literal equality. define <name>: is above 100 elides to an implicit each, reusing the require-each clause mechanism.
5. Interpreter — _exec_define stores the body AST (type "predicate"); _eval_condition resolves the subject and re-evaluates the body fresh on every application (never cached — redefinitions of referenced values stay live); predicate composition falls out of the existing recursion. _walk_dependencies also tracks a predicate application's subject so when handlers re-fire correctly.
6. Analyzer / renderer / run.py / build.py — structural-only validation of define bodies (fields are unknown until application time); existence checks for predicate application; canonical rendering + round-trip; Session.predicate_names() threaded into run_line/run_when_block.

Files created/modified

• Created: tests/test_define.py (33 tests)
• Modified: src/liminate/vocabulary.py, parser.py, interpreter.py, analyzer.py, renderer.py, run.py, build.py
• Modified (pre-existing count-assertion fixes): tests/test_vocabulary.py, test_about.py, test_because.py, test_inherited.py, test_within_operator.py

Invariants satisfied (§9)

1. predicate_names/preds is threaded explicitly everywhere composition_names/comp already threads — no module global, no mutable default.
2. Public vocabulary count is 61; raw len(ALL_RESERVED) is 62 (includes the uncounted combine tombstone). All count assertions use len(ALL_RESERVED) - len(TOMBSTONES).
3. Predicate storage type is "predicate" consistently across _exec_define, Session.predicate_names(), and _eval_condition/analyzer checks.
4. define is a normal program statement (never first-line-intercepted); about keeps its existing first-line-only path.
5. Quoting preserves literal equality — the predicate check only ever fires on TokenType.UNKNOWN, never QUOTED_STRING.
6. listener.py needs no changes — predicate evaluation routes through the same _eval_condition it already calls into.

Undefined-predicate validation & redefinition-warning path (required disclosure)

• Undefined-predicate reference → analyzer. The analyzer already has full visibility into every predicate defined earlier in the program via the symbol table (identical to how _check_composition_call_shape already validates composition calls), so _check_predicate_application does a symtab existence/type check and raises a clear _SemanticError if the name isn't a registered predicate. This mirrors existing precedent exactly rather than deferring to a runtime-only check.
• Redefinition warning → interpreter (_exec_define), not the analyzer. The analyzer's _check dispatch functions only ever raise or pass silently — there's no channel for a non-blocking informational signal. _exec_op functions already return list[str] output lines for exactly this purpose (the same channel permit uses to emit without halting), so _exec_define emits "Predicate '<name>' is being redefined — the earlier definition will be replaced." there instead of inventing a new ResultStatus.

Bonus fixes found during implementation

Adding define as a second DECLARATION-category token exposed a latent bug in both run.py and build.py: their first-line dispatch checked only token.type is TokenType.DECLARATION, which now also matches define. Since define is not first-line-only, any define statement anywhere in a program was being routed into parse_about (which returns None for non-about input), crashing with AttributeError: 'NoneType' object has no attribute 'topic'. Both checks are narrowed to token.value == "about" specifically; build.py additionally gained its own predicate_names tracking (_collect_predicate_names) mirroring its existing _collect_composition_names, so liminate build validates define-using programs the same way liminate run executes them.

Test count

• Before: 1615 passing on main.
• After: 1648 passing (33 new in tests/test_define.py), zero regressions.

Test plan

• python3 -m pytest -q → 1648 passed
• Public vocabulary count smoke check → 61
• End-to-end define + keep/count smoke program
• Parse smoke check via parse(..., predicate_names=...)
• Round-trip check (predicate condition; define + because)
• liminate build validation path exercised with a define-using program

Stops at merge — no PyPI publish, repo creation, or deploy performed. Ready for review.

🤖 Generated with Claude Code