ogar-from-ruff: extend odoo kausal pin to Arm B (constrains) post ruff #49

The rebase onto main (which carries arms B+D via ruff #49 /
D-ATC2-KAUSAL-RUFF-GATED) surfaced that @api.constrains methods now get
KausalSpec::Constrains. Extend the W1 witness to pin all 3 constrains
methods verbatim (was: asserted kausal==None). Now 11/11 kausal (8 depends
+ 3 constrains); _check_lines moved from the plain-methods list to the
Constrains pin.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NSfzujtWL1BnHgnJGAhg9N

Author: claude

crates/ogar-from-ruff/tests/odoo_kausal_parity_probe.rs

@@ -22,10 +22,12 @@
 //!
 //! # Scope (named, not hidden)
 //!
-//! - Only Arm A (`compute=` + `@api.depends`) is pinned here. Arm B
-//!   (`@api.constrains` / `@api.onchange` -> a `KausalSpec` shape) and
-//!   `computed.stored` parity remain out of scope pending ruff #49 (no
-//!   `ActionDef`/`Class` slot exists yet for either).
+//! - Arm A (`compute=` + `@api.depends` -> `KausalSpec::Depends`) AND Arm B
+//!   (`@api.constrains` -> `KausalSpec::Constrains`) are both pinned here —
+//!   Arm B opened up once ruff #49 landed `Function::constrains` on main
+//!   (`D-ATC2-KAUSAL-RUFF-GATED`). The fixture has no `@api.onchange`, so the
+//!   Onchange arm is not exercised by this witness. `computed.stored` (Arm D)
+//!   is a `Class`-side field, out of scope for this DO-arm/kausal probe.
 //! - `account.payment.term` / `account.payment.term.line` are NOT in
 //!   `ogar_vocab::ports::ODOO_ALIASES`, so both mint the bootstrap facet
 //!   classid `0` (see `mint.rs`'s
@@ -34,8 +36,8 @@
 //!   bootstrap value is asserted as a fact, not treated as a defect.
 
 use ogar_from_ruff::mint::compile_graph_python;
-use ogar_vocab::ports::OdooPort;
 use ogar_vocab::KausalSpec;
+use ogar_vocab::ports::OdooPort;
 use ruff_python_spo::extract_from_source;
 
 /// Verbatim Odoo 19 source, `addons/account/models/account_payment_term.py`
@@ -108,14 +110,35 @@ const PAYMENT_TERM_LINE_DEPENDS: &[ExpectedDepends] = &[
     },
 ];
 
-/// Plain (non-compute) methods on `AccountPaymentTerm`, read off the same
-/// source, that must NOT carry a `kausal` fact — the facts-only guard
-/// (`D-ATC2-KAUSAL-AUTARK`: a method's own body `reads` never gets promoted
-/// into a reactive `KausalSpec::Depends` trigger).
+/// `AccountPaymentTerm` methods carrying `@api.constrains(...)` — the Arm-B
+/// witness that opened up once ruff #49 landed `Function::constrains` on main
+/// (`D-ATC2-KAUSAL-RUFF-GATED`). Each becomes
+/// `KausalSpec::Constrains { paths }` (validation trigger), Depends still
+/// wins when both are present (`kausal.is_none()` gate in `lift_actions`).
+const PAYMENT_TERM_CONSTRAINS: &[ExpectedDepends] = &[ExpectedDepends {
+    method: "_check_lines",
+    paths: &["line_ids", "early_discount"],
+}];
+
+/// `AccountPaymentTermLine` methods carrying `@api.constrains(...)`.
+const PAYMENT_TERM_LINE_CONSTRAINS: &[ExpectedDepends] = &[
+    ExpectedDepends {
+        method: "_check_valid_char_value",
+        paths: &["days_next_month"],
+    },
+    ExpectedDepends {
+        method: "_check_percent",
+        paths: &["value", "value_amount"],
+    },
+];
+
+/// Plain (non-compute, non-constrains) methods on `AccountPaymentTerm`, read
+/// off the same source, that must NOT carry a `kausal` fact — the facts-only
+/// guard (`D-ATC2-KAUSAL-AUTARK`: a method's own body `reads` never gets
+/// promoted into a reactive `KausalSpec` trigger).
 const PAYMENT_TERM_PLAIN_METHODS: &[&str] = &[
     "_get_amount_due_after_discount",
     "_get_amount_by_date",
-    "_check_lines",
     "_compute_terms", // named like a compute target but has no `compute=` field pointing at it
     "_unlink_except_referenced_terms",
     "_get_last_discount_date",
@@ -141,6 +164,24 @@ fn assert_kausal_depends(
     );
 }
 
+fn assert_kausal_constrains(
+    actions: &[ogar_vocab::ActionDef],
+    expected: &ExpectedDepends,
+    model: &str,
+) {
+    let action = actions
+        .iter()
+        .find(|a| a.predicate == expected.method)
+        .unwrap_or_else(|| panic!("{model}: no ActionDef for method {:?}", expected.method));
+    let expected_paths: Vec<String> = expected.paths.iter().map(|s| s.to_string()).collect();
+    assert_eq!(
+        action.kausal,
+        Some(KausalSpec::constrains(expected_paths)),
+        "{model}::{} kausal constrains-paths mismatch",
+        expected.method
+    );
+}
+
 #[test]
 fn odoo_kausal_parity_pin_account_payment_term() {
     let graph = extract_from_source(ACCOUNT_PAYMENT_TERM_PY);
@@ -179,17 +220,32 @@ fn odoo_kausal_parity_pin_account_payment_term() {
         );
     }
 
-    // Exactly one ActionDef per compute METHOD, not per field —
-    // _compute_example_preview emits two fields but appears once.
+    // ── Arm B pin: every @api.constrains method → KausalSpec::Constrains ──
+    // (opened up by ruff #49 / D-ATC2-KAUSAL-RUFF-GATED; Depends still wins
+    // when both are present, so these are the pure-constrains methods.)
+    for expected in PAYMENT_TERM_CONSTRAINS {
+        assert_kausal_constrains(&payment_term.actions, expected, "account_payment_term");
+    }
+    for expected in PAYMENT_TERM_LINE_CONSTRAINS {
+        assert_kausal_constrains(
+            &payment_term_line.actions,
+            expected,
+            "account_payment_term_line",
+        );
+    }
+
+    // Exactly one kausal-bearing ActionDef per @api.depends compute METHOD
+    // (not per field — _compute_example_preview emits two fields, appears once)
+    // PLUS one per @api.constrains method.
     let kausal_bearing = payment_term
         .actions
         .iter()
         .filter(|a| a.kausal.is_some())
         .count();
     assert_eq!(
         kausal_bearing,
-        PAYMENT_TERM_DEPENDS.len(),
-        "one kausal-bearing ActionDef per @api.depends compute method (account_payment_term)"
+        PAYMENT_TERM_DEPENDS.len() + PAYMENT_TERM_CONSTRAINS.len(),
+        "one kausal-bearing ActionDef per @api.depends + @api.constrains method (account_payment_term)"
     );
     let kausal_bearing_line = payment_term_line
         .actions
@@ -198,8 +254,8 @@ fn odoo_kausal_parity_pin_account_payment_term() {
         .count();
     assert_eq!(
         kausal_bearing_line,
-        PAYMENT_TERM_LINE_DEPENDS.len(),
-        "one kausal-bearing ActionDef per @api.depends compute method (account_payment_term_line)"
+        PAYMENT_TERM_LINE_DEPENDS.len() + PAYMENT_TERM_LINE_CONSTRAINS.len(),
+        "one kausal-bearing ActionDef per @api.depends + @api.constrains method (account_payment_term_line)"
     );
 
     // ── facts-only guard: plain methods carry no kausal fact ──
@@ -215,10 +271,16 @@ fn odoo_kausal_parity_pin_account_payment_term() {
         );
     }
 
+    let expected_kausal = PAYMENT_TERM_DEPENDS.len()
+        + PAYMENT_TERM_LINE_DEPENDS.len()
+        + PAYMENT_TERM_CONSTRAINS.len()
+        + PAYMENT_TERM_LINE_CONSTRAINS.len();
     println!(
-        "OK: account_payment_term(+line) kausal_actions={}/{} plain_checked={} total_actions={}/{}",
+        "OK: account_payment_term(+line) kausal_actions={}/{} (depends={} constrains={}) plain_checked={} total_actions={}/{}",
         kausal_bearing + kausal_bearing_line,
+        expected_kausal,
         PAYMENT_TERM_DEPENDS.len() + PAYMENT_TERM_LINE_DEPENDS.len(),
+        PAYMENT_TERM_CONSTRAINS.len() + PAYMENT_TERM_LINE_CONSTRAINS.len(),
         PAYMENT_TERM_PLAIN_METHODS.len(),
         payment_term.actions.len(),
         payment_term_line.actions.len(),