feat(odoo-spo): selection_value (wishlist P3)

Adds a fifth enrichment pass to spo_enrich.py: `fields.Selection`
declarations with a statically-resolvable list of 2-tuples emit one
`(odoo:<model>.<field>, selection_value, "<key>")` triple per enum key.

# Shape

`_extract_selection_values(call)` pulls the first element of each 2-tuple
from the Selection list — positional arg 0 OR `selection=` kwarg —
preserving source order, de-duplicating (first occurrence wins).

Skipped (values not statically knowable):
  - `selection='_compute_states'` (compute-method ref, a str)
  - `selection=STATE_CONSTANT` (bare Name)
  - `related=...` / any non-list/tuple selection arg
  - individual entries that aren't 2-tuples

Truth `(0.95, 0.90)` — read straight from the field decorator,
authoritative. Scoped to corpus-declared ObjectTypes (the additive
boundary, same as P1); Selection fields bind to the same `model_names`
as relational fields (`_name`, else `_inherit[0]`, per #525's decision).

# Consumer use

Lets odoo-rs lower a Selection field to
`DEFINE FIELD state … ASSERT $value IN ['draft','posted','cancel']`
— the UPSTREAM_WISHLIST P3 ask. The five-pass enrichment is now:
P1 (target/inverse_name) + P0 (deep reads_field) + P1b (inherits_from)
+ P2 (validation_kind) + P3 (selection_value).

# Corpus regen pending

The shipped corpus does not yet carry selection_value triples —
regenerating requires running the script against a live Odoo source
tree (`/home/user/odoo/addons`), not present on this host. The Rust
loader's predicate-histogram match arm gained `selection_value` so a
future regenerated corpus drops into the harness without code changes.
`parses_all_triples` count assertion stays at 24 579; re-locks the
moment a session with the source re-runs enrichment.

# Files

  spo_enrich.py:
    +`_extract_selection_values` helper, +`SELECTION_VALUE_TRUTH`,
    +`selections` param threaded through `_scan_file` / `build_all_facts`
    / `enrich`, +Selection branch in the field loop, +P3 emission loop,
    +CLI status field.
  test_spo_enrich.py:
    +12 tests (6 extraction edge cases + 3 scan-binding + 3 emission).
  odoo_ontology.rs:
    +doc table row, +histogram match arm for `selection_value`.
  EPIPHANIES.md: prepended E-ODOO-SPO-SELECTION-VALUE.

# Tests

  python3 -m unittest tests.test_spo_enrich : 53/53 OK (was 41)
  cargo test -p lance-graph --lib odoo_ontology : 13/13 OK

Author: claude

.claude/board/EPIPHANIES.md

@@ -1,3 +1,11 @@
+## 2026-06-18 — E-ODOO-SPO-SELECTION-VALUE — spo_enrich gains selection_value (wishlist P3); corpus regen pending Odoo source
+
+**Status:** FINDING for the code + tests; CONJECTURE for the wire effect on the shipped corpus (regenerates when a session has `/home/user/odoo/addons`). `spo_enrich.py` adds a fifth enrichment pass via the same single AST walk: `fields.Selection([('draft','Draft'), …])` declarations emit one `(odoo:<model>.<field>, selection_value, "<key>")` triple per statically-resolvable enum key. 12 new tests (6 extraction + 3 scan-binding + 3 emission); total suite 41→53 green. Rust loader histogram arm gained `selection_value`.
+
+**Shape.** `_extract_selection_values` pulls the first element of each 2-tuple from the Selection list (positional arg 0 OR `selection=` kwarg), preserving source order, de-duplicating. Dynamic selections — `selection='_compute_x'` (str method-ref), a bare Name constant, `related=` — are skipped (values not statically knowable). Truth `(0.95, 0.90)` — read straight from the decorator, authoritative. Scoped to corpus-declared ObjectTypes (the additive boundary); Selection fields bind to the same `model_names` as relational fields (`_name`, else `_inherit[0]`, per #525).
+
+**Consumer use.** Lets odoo-rs lower a Selection field to `DEFINE FIELD state … ASSERT $value IN ['draft','posted','cancel']` — the wishlist P3 ask. Once a session with the Odoo source re-runs `python -m odoo_blueprint_extractor.spo_enrich`, the triples land and the predicate-histogram count can be locked. Remaining wishlist item after this: `virtually_overrides` (genuine ClassView MRO design, not a single-predicate emission).
+
 ## 2026-06-18 — E-WITNESS-ARC-TWO-OBJECTS-1 — "witness arc" names TWO different objects; do NOT unify them under a `WitnessArcEvaluator` trait
 
 **Status:** FINDING (5+3 council, unanimous: convergence-architect DROP, iron-rule-savant REJECT-trait, dto-soa-savant FITS-COLUMN-as-free-fn, dilution-collapse-sentinel KEEP-SEPARATE, truth-architect PROVEN-math, brutally-honest-tester Option-B-LAND, baton-handoff-auditor CATCH-CRITICAL, integration-lead DEFER). B2 resolved as documentation, not code.

crates/lance-graph/src/graph/spo/odoo_ontology.rs

@@ -26,6 +26,7 @@
 //! | `inverse_name`       | `odoo:<fam>.<rel>`   | `"<inverse>"`        | One2many/inverse (declared) |
 //! | `inherits_from`      | `odoo:<family>`      | `odoo:<base_family>` | `_inherit`/`_inherits` base (declared) |
 //! | `validation_kind`    | `odoo:<fam>.<fn>`    | `"<kind>"`           | `@api.constrains` body pattern (inferred) |
+//! | `selection_value`    | `odoo:<fam>.<field>` | `"<value_key>"`      | `fields.Selection` enum key (declared) |
 //!
 //! ## FK-target + deep-read enrichment (`spo_enrich`)
 //!
@@ -183,6 +184,7 @@ mod tests {
                     "inverse_name" => "inverse_name",
                     "inherits_from" => "inherits_from",
                     "validation_kind" => "validation_kind",
+                    "selection_value" => "selection_value",
                     _ => "other",
                 })
                 .or_default() += 1;

tools/odoo-blueprint-extractor/odoo_blueprint_extractor/spo_enrich.py

@@ -1,5 +1,6 @@
 """SPO corpus enrichment — FK target/inverse_name (P1) + deep reads_field (P0)
-+ inherits_from (P1b, ruff#19) + validation_kind (P2, ruff#21).
++ inherits_from (P1b, ruff#19) + validation_kind (P2, ruff#21)
++ selection_value (P3).
 
 Stdlib-only Python 3. Reads the Odoo ORM source (the same addons tree the
 ORM extractor parses) to build a relation-target map, then enriches an
@@ -60,6 +61,22 @@
     extension classes bind to `_inherit[0]` (mirrors `_scan_file`'s field
     binding decision per #525 codex review).
 
+  * **P3 — `selection_value`** (UPSTREAM_WISHLIST P3): for every
+    `fields.Selection([('draft','Draft'), ('posted','Posted'), …])`
+    declaration with a *statically resolvable* list of 2-tuples, emit one
+    triple per value KEY (the first tuple element), keyed by the field IRI::
+
+        (odoo:account_move.state, selection_value, "draft")
+        (odoo:account_move.state, selection_value, "posted")
+        (odoo:account_move.state, selection_value, "cancel")
+
+    Enables the consumer to lower a Selection field to
+    `DEFINE FIELD state … ASSERT $value IN ['draft','posted','cancel']`.
+    Dynamic selections (`selection='_compute_states'`, a bare Name constant,
+    or `related=`) are skipped — their values aren't statically knowable.
+    Source order is preserved. Selection fields bind to the same
+    `model_names` as relational fields (`_name`, else `_inherit[0]`).
+
     This is *in addition* to the existing shallow relation read
     `(_compute_amount, reads_field, odoo:account_move.line_ids)`. The deep
     read makes the cross-model recompute-ordering edge visible to
@@ -110,12 +127,49 @@
 # validation_kind is an AST-pattern classification of a method body
 # (heuristic, not authoritative).
 VALIDATION_KIND_TRUTH = (0.85, 0.75)
+# selection_value is a statically-resolved enum key from a Selection
+# declaration (authoritative — read straight from the field decorator).
+SELECTION_VALUE_TRUTH = (0.95, 0.90)
 
 # Recognised `validation_kind` strings (matches ruff#21's Rails set where
 # semantics overlap; Odoo-specific patterns like `lookup` extend it).
 _VALIDATION_KINDS = ("presence", "uniqueness", "range", "format", "lookup")
 
 
+def _extract_selection_values(call: ast.Call) -> List[str]:
+    """Pull the value KEYS from a `fields.Selection([('k','Label'), …])`
+    declaration. The selection list is the first positional arg OR the
+    `selection=` kwarg; each entry is a 2-tuple whose first element is the
+    stored key.
+
+    Returns the keys in source order, de-duplicated (first occurrence wins).
+    Returns `[]` for dynamic selections — a bare Name (constant reference),
+    a string (compute-method name), `related=`, or any entry whose first
+    element isn't a string constant. Those values aren't statically known.
+    """
+    sel: Optional[ast.expr] = None
+    for kw in call.keywords:
+        if kw.arg == "selection":
+            sel = kw.value
+            break
+    if sel is None and call.args:
+        sel = call.args[0]
+    if not isinstance(sel, (ast.List, ast.Tuple)):
+        # `selection='_compute_x'` (str), a Name constant, or related= → skip.
+        return []
+
+    out: List[str] = []
+    seen: Set[str] = set()
+    for elt in sel.elts:
+        if not isinstance(elt, (ast.Tuple, ast.List)) or len(elt.elts) < 1:
+            continue
+        key = _const_str(elt.elts[0])
+        if key is not None and key not in seen:
+            seen.add(key)
+            out.append(key)
+    return out
+
+
 def _is_uniqueness_call(node: ast.expr) -> bool:
     """True iff `node` is a `<recordset>.search_count(...)` call — the LHS
     of the canonical Odoo uniqueness pattern. Used to suppress `range` for
@@ -222,6 +276,7 @@ def _scan_file(
     relmap: Dict[Tuple[str, str], Tuple[str, Optional[str]]],
     inherits: Optional[Dict[str, Set[str]]] = None,
     constrains: Optional[Dict[Tuple[str, str], Set[str]]] = None,
+    selections: Optional[Dict[Tuple[str, str], List[str]]] = None,
 ) -> None:
     """Parse one .py file; record every relational field on every named model.
     Optionally also record `inherits_from` edges and `@api.constrains`
@@ -262,6 +317,7 @@ def _scan_file(
         inherits_models: List[str] = []  # _inherits dict keys (delegation)
         local_fields: Dict[str, Tuple[str, Optional[str]]] = {}
         local_constrains: List[Tuple[str, ast.FunctionDef]] = []
+        local_selections: Dict[str, List[str]] = {}
 
         for stmt in node.body:
             # Method definitions — gather @api.constrains methods for P2.
@@ -311,6 +367,12 @@ def _scan_file(
             ):
                 continue
             field_type = stmt.value.func.attr
+            # Selection field — extract statically-known value keys (P3).
+            if field_type == "Selection" and selections is not None:
+                vals = _extract_selection_values(stmt.value)
+                if vals:
+                    local_selections[target_name] = vals
+                continue
             if field_type not in RELATIONAL_KINDS:
                 continue
 
@@ -359,6 +421,11 @@ def _scan_file(
                 # Last write wins across _inherit reopenings of the same model;
                 # comodel for a given (model, field) is stable in practice.
                 relmap[(mu, field_name)] = (comodel, inverse)
+            if selections is not None:
+                for field_name, vals in local_selections.items():
+                    # Last write wins (a later reopening that redeclares the
+                    # Selection with a fuller value list supersedes).
+                    selections[(mu, field_name)] = vals
 
         # ── P1b: inherits_from edges ─────────────────────────────────────
         # Only when the class declares a NEW model (_name is set). An
@@ -393,21 +460,24 @@ def build_all_facts(
     Dict[Tuple[str, str], Tuple[str, Optional[str]]],
     Dict[str, Set[str]],
     Dict[Tuple[str, str], Set[str]],
+    Dict[Tuple[str, str], List[str]],
 ]:
-    """Single-pass scan that populates (relmap, inherits, constrains).
+    """Single-pass scan that populates (relmap, inherits, constrains, selections).
 
     Returns:
         relmap     — (model_us, field) → (comodel_dotted, inverse_or_None)
         inherits   — model_us → set(base_us)  from `_inherit` + `_inherits`
         constrains — (model_us, method) → set(kind) from `@api.constrains`
+        selections — (model_us, field) → [value_key, …] from `fields.Selection`
     """
     relmap: Dict[Tuple[str, str], Tuple[str, Optional[str]]] = {}
     inherits: Dict[str, Set[str]] = {}
     constrains: Dict[Tuple[str, str], Set[str]] = {}
+    selections: Dict[Tuple[str, str], List[str]] = {}
     pattern = os.path.join(addons_root, "**", "*.py")
     for path in glob.iglob(pattern, recursive=True):
-        _scan_file(path, relmap, inherits, constrains)
-    return relmap, inherits, constrains
+        _scan_file(path, relmap, inherits, constrains, selections)
+    return relmap, inherits, constrains, selections
 
 
 def build_relation_map(addons_root: str) -> Dict[Tuple[str, str], Tuple[str, Optional[str]]]:
@@ -468,6 +538,7 @@ def enrich(
     relmap: Dict[Tuple[str, str], Tuple[str, Optional[str]]],
     inherits: Optional[Dict[str, Set[str]]] = None,
     constrains: Optional[Dict[Tuple[str, str], Set[str]]] = None,
+    selections: Optional[Dict[Tuple[str, str], List[str]]] = None,
 ) -> Tuple[List[str], dict]:
     """Compute the additive enrichment lines + a stats dict.
 
@@ -544,6 +615,8 @@ def enrich(
         "inherits_skip_unknown_base": 0,
         "validation_kind": 0,
         "validation_skip_unknown_method": 0,
+        "selection_value": 0,
+        "selection_skip_unknown_model": 0,
     }
 
     # ── P1: target / inverse_name ─────────────────────────────────────────
@@ -661,19 +734,40 @@ def enrich(
                 existing_spo.add(spo)
                 stats["validation_kind"] += 1
 
+    # ── P3: selection_value ───────────────────────────────────────────────
+    # One triple per statically-known enum key on a Selection field. Scoped to
+    # corpus-declared ObjectTypes (the additive boundary): never invent a
+    # selection on an unknown model. Value order preserved (source order).
+    if selections:
+        for (model_us, field_name), vals in sorted(selections.items()):
+            if model_us not in object_type_models:
+                stats["selection_skip_unknown_model"] += 1
+                continue
+            field_iri = f"odoo:{model_us}.{field_name}"
+            for val in vals:
+                spo = (field_iri, "selection_value", val)
+                if spo in existing_spo:
+                    continue
+                new_lines.append(
+                    triple_line(field_iri, "selection_value", val, *SELECTION_VALUE_TRUTH)
+                )
+                existing_spo.add(spo)
+                stats["selection_value"] += 1
+
     new_lines.sort()
     return new_lines, stats
 
 
 def run(corpus_path: str, addons_root: str, out_path: str) -> dict:
     """Enrich `corpus_path` using `addons_root`, write to `out_path`. Returns stats."""
     triples = load_corpus(corpus_path)
-    relmap, inherits, constrains = build_all_facts(addons_root)
-    new_lines, stats = enrich(triples, relmap, inherits, constrains)
+    relmap, inherits, constrains, selections = build_all_facts(addons_root)
+    new_lines, stats = enrich(triples, relmap, inherits, constrains, selections)
     stats["corpus_triples_in"] = len(triples)
     stats["relmap_entries"] = len(relmap)
     stats["inherits_entries"] = sum(len(v) for v in inherits.values())
     stats["constrains_entries"] = sum(len(v) for v in constrains.values())
+    stats["selections_entries"] = sum(len(v) for v in selections.values())
     stats["new_triples"] = len(new_lines)
 
     # Preserve the original corpus lines verbatim, then append the sorted new
@@ -733,6 +827,7 @@ def main(argv: Optional[List[str]] = None) -> None:
         f"self_loop={stats['deep_skip_self_loop']}) "
         f"inherits_from={stats['inherits_from']} "
         f"validation_kind={stats['validation_kind']} "
+        f"selection_value={stats['selection_value']} "
         f"out={stats['corpus_triples_out']}",
         file=sys.stderr,
     )

tools/odoo-blueprint-extractor/tests/test_spo_enrich.py

@@ -593,5 +593,137 @@ def test_name_plus_inherit_binds_to_name_only(self):
         self.assertEqual(c, {("account_move", "_check_subject"): {"presence"}})
 
 
+# ---------------------------------------------------------------------------
+# PR #529 — selection_value (P3)
+# ---------------------------------------------------------------------------
+
+
+def _scan_sel(src):
+    """Run `_scan_file` over a synthetic module; return the selections dict."""
+    from odoo_blueprint_extractor.spo_enrich import _scan_file
+    relmap, inherits, constrains, selections = {}, {}, {}, {}
+    with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False) as f:
+        f.write(src)
+        path = f.name
+    try:
+        _scan_file(path, relmap, inherits, constrains, selections)
+    finally:
+        os.unlink(path)
+    return selections
+
+
+def _classify_sel(src):
+    """Classify a single synthetic `fields.Selection(...)` call."""
+    import ast as _ast
+    from odoo_blueprint_extractor.spo_enrich import _extract_selection_values
+    tree = _ast.parse(src)
+    call = next(n for n in _ast.walk(tree) if isinstance(n, _ast.Call))
+    return _extract_selection_values(call)
+
+
+class TestSelectionExtraction(unittest.TestCase):
+    def test_list_of_tuples_positional(self):
+        vals = _classify_sel(
+            "fields.Selection([('draft','Draft'),('posted','Posted'),('cancel','Cancel')])"
+        )
+        self.assertEqual(vals, ["draft", "posted", "cancel"])
+
+    def test_selection_kwarg(self):
+        vals = _classify_sel(
+            "fields.Selection(selection=[('a','A'),('b','B')], string='X')"
+        )
+        self.assertEqual(vals, ["a", "b"])
+
+    def test_dynamic_method_name_skipped(self):
+        # selection='_compute_states' is a compute method ref → no static values.
+        vals = _classify_sel("fields.Selection(selection='_compute_states')")
+        self.assertEqual(vals, [])
+
+    def test_bare_name_constant_skipped(self):
+        # selection=SOME_CONSTANT — not statically resolvable from this AST.
+        vals = _classify_sel("fields.Selection(STATE_VALUES)")
+        self.assertEqual(vals, [])
+
+    def test_dedup_preserves_first_order(self):
+        vals = _classify_sel(
+            "fields.Selection([('a','A'),('b','B'),('a','A2')])"
+        )
+        self.assertEqual(vals, ["a", "b"])
+
+    def test_non_tuple_entries_skipped(self):
+        # A malformed entry (not a 2-tuple) is skipped, others survive.
+        vals = _classify_sel("fields.Selection([('a','A'), 'bogus', ('b','B')])")
+        self.assertEqual(vals, ["a", "b"])
+
+
+class TestSelectionScan(unittest.TestCase):
+    """`_scan_file` binds Selection values to model_names (per #525 rule)."""
+
+    def test_selection_bound_to_name_model(self):
+        sel = _scan_sel(
+            "class M:\n"
+            "    _name = 'account.move'\n"
+            "    state = fields.Selection([('draft','Draft'),('posted','Posted')])\n"
+        )
+        self.assertEqual(sel, {("account_move", "state"): ["draft", "posted"]})
+
+    def test_selection_on_inherit_only_binds_to_inherit_zero(self):
+        sel = _scan_sel(
+            "class Ext:\n"
+            "    _inherit = ['account.move', 'mail.thread']\n"
+            "    kind = fields.Selection([('x','X'),('y','Y')])\n"
+        )
+        self.assertEqual(sel, {("account_move", "kind"): ["x", "y"]})
+
+    def test_dynamic_selection_field_records_nothing(self):
+        sel = _scan_sel(
+            "class M:\n"
+            "    _name = 'account.move'\n"
+            "    s = fields.Selection(selection='_compute_s')\n"
+        )
+        self.assertEqual(sel, {})
+
+
+class TestP3SelectionValueEmission(unittest.TestCase):
+    def _triples(self, field_iri="odoo:account_move.state"):
+        return [
+            t("odoo:account_move", "rdf:type", "ogit:ObjectType"),
+        ]
+
+    def test_emits_one_triple_per_value(self):
+        lines, stats = enrich(
+            self._triples(),
+            RELMAP,
+            selections={("account_move", "state"): ["draft", "posted", "cancel"]},
+        )
+        self.assertEqual(stats["selection_value"], 3)
+        joined = "\n".join(lines)
+        for v in ("draft", "posted", "cancel"):
+            self.assertIn(
+                f'{{"s":"odoo:account_move.state","p":"selection_value","o":"{v}"',
+                joined,
+            )
+
+    def test_skip_unknown_model(self):
+        triples = [t("odoo:account_move", "rdf:type", "ogit:ObjectType")]
+        lines, stats = enrich(
+            triples, RELMAP, selections={("mystery_model", "s"): ["a"]}
+        )
+        self.assertEqual(stats["selection_value"], 0)
+        self.assertEqual(stats["selection_skip_unknown_model"], 1)
+        self.assertEqual(lines, [])
+
+    def test_dedup_against_existing(self):
+        triples = [
+            t("odoo:account_move", "rdf:type", "ogit:ObjectType"),
+            t("odoo:account_move.state", "selection_value", "draft"),
+        ]
+        _, stats = enrich(
+            triples, RELMAP, selections={("account_move", "state"): ["draft", "posted"]}
+        )
+        # 'draft' already present → only 'posted' is new.
+        self.assertEqual(stats["selection_value"], 1)
+
+
 if __name__ == "__main__":
     unittest.main(verbosity=2)