behavior-contracts 0.1.3__tar.gz → 0.2.0__tar.gz

{behavior_contracts-0.1.3 → behavior_contracts-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: behavior-contracts
-Version: 0.1.3
+Version: 0.2.0
 Summary: Multi-language IR-Runtime common core (Python port). The COMMON 'thin core' primitives from dsl-contracts runtime-boundary.md — validate_envelope / evaluate_expression / render_template / run_plan / canonical_value / canonical_json / py_float_repr / assert_portable — with zero backend (DynamoDB/graphddb) dependencies.
 Author: foo-log
 License: MIT
@@ -60,12 +60,12 @@ string matching the conformance protocol's failure-code set.
 
 ## Conformance
 
-Runs the 4 shared suites (105 vectors) from `../conformance/vectors/*.json`
+Runs the 7 shared suites (147 vectors) from `../conformance/vectors/*.json`
 through this package per [`../conformance/PROTOCOL.md`](../conformance/PROTOCOL.md),
 including the pre-flight version fail-closed sweep.
 
 ```bash
-python -m behavior_contracts.conformance      # → "105 passed, 0 failed / 105 vectors across 4 suites"
+python -m behavior_contracts.conformance      # → "147 passed, 0 failed / 147 vectors across 7 suites"
 # or the console script:
 behavior-contracts-conformance
 ```

{behavior_contracts-0.1.3 → behavior_contracts-0.2.0}/README.md

@@ -48,12 +48,12 @@ string matching the conformance protocol's failure-code set.
 
 ## Conformance
 
-Runs the 4 shared suites (105 vectors) from `../conformance/vectors/*.json`
+Runs the 7 shared suites (147 vectors) from `../conformance/vectors/*.json`
 through this package per [`../conformance/PROTOCOL.md`](../conformance/PROTOCOL.md),
 including the pre-flight version fail-closed sweep.
 
 ```bash
-python -m behavior_contracts.conformance      # → "105 passed, 0 failed / 105 vectors across 4 suites"
+python -m behavior_contracts.conformance      # → "147 passed, 0 failed / 147 vectors across 7 suites"
 # or the console script:
 behavior-contracts-conformance
 ```

{behavior_contracts-0.1.3 → behavior_contracts-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "behavior-contracts"
-version = "0.1.3"
+version = "0.2.0"
 description = "Multi-language IR-Runtime common core (Python port). The COMMON 'thin core' primitives from dsl-contracts runtime-boundary.md — validate_envelope / evaluate_expression / render_template / run_plan / canonical_value / canonical_json / py_float_repr / assert_portable — with zero backend (DynamoDB/graphddb) dependencies."
 readme = "README.md"
 requires-python = ">=3.9"

{behavior_contracts-0.1.3 → behavior_contracts-0.2.0}/src/behavior_contracts/__init__.py

@@ -22,6 +22,9 @@ SPEC_VERSIONS = {
     "template": 1,
     "plan": 1,
     "canonical": 2,  # v2: obj 値の __proto__ own key を FORBIDDEN_KEY に（fail-closed）
+    "behavior": 2,  # v2: map.when / map.into / map.batched / handler ctx（bc#22。v1 IR の意味論は不変）
+    "guard": 1,  # 初版（bc#25: assert_portable_component_graph の accept/reject を vector-pin）
+    "c2": 1,  # 初版（bc#28: c2-catalog-swap — catalog-swap 実行 + IR 構造一致の 5 言語 pin）
 }
 
 # validate_envelope に渡す graphddb 形式の既定 supported 版（``"<major>.<minor>"``）。
@@ -66,8 +69,16 @@ from .envelope import (  # noqa: E402
 
 # ── guard（Portability Guard） ────────────────────────────────────────────────
 from .guard import (  # noqa: E402
+    PORTABLE_EXPR_OPERATORS,
     PortabilityError,
     assert_portable,
+    assert_portable_component_graph,
+)
+
+# ── behavior（component-graph IR + run_behavior） ──────────────────────────────
+from .behavior import (  # noqa: E402
+    BehaviorFailure,
+    run_behavior,
 )
 
 # ── conformance runner adapter 共通部 ─────────────────────────────────────────
@@ -76,6 +87,12 @@ from .codec import (  # noqa: E402
     deep_equals,
 )
 
+# ── generator 支援（共通 Generator の生成モジュールが使う fingerprint, bc#13）──
+from .fingerprint import (  # noqa: E402
+    FingerprintFailure,
+    fingerprint_component_graph,
+)
+
 __all__ = [
     "SPEC_VERSIONS",
     "ENVELOPE_SPEC_VERSION",
@@ -103,8 +120,16 @@ __all__ = [
     "EnvelopeFailure",
     # guard
     "assert_portable",
+    "assert_portable_component_graph",
+    "PORTABLE_EXPR_OPERATORS",
     "PortabilityError",
+    # behavior
+    "run_behavior",
+    "BehaviorFailure",
     # codec
     "decode_value",
     "deep_equals",
+    # generator 支援（fingerprint）
+    "fingerprint_component_graph",
+    "FingerprintFailure",
 ]

behavior_contracts-0.2.0/src/behavior_contracts/behavior.py

@@ -0,0 +1,260 @@
+"""behavior.py — component-graph IR + run_behavior 統合実行 IF（Python port）。
+
+TS 参照実装 ``ts/src/behavior.ts`` の意味論を完全一致で移植（scp-ir-architecture.md §5–§7）。
+
+component-graph IR（``components[]{name, inputPorts, body[], output, plan}``）を、既存 COMMON の
+``run_plan``（stage 実行・Skip 伝播・Policy Kind）+ ``evaluate``（Expression IR）の上に実行する。
+専用コンポーネントの実装は handler registry（catalog名 → 実装。境界注入）で名前解決して委譲する。
+
+body ノード種:
+  - componentRef: ``{id, component, ports, parent?, bindField?, relationKind?, policy?}``
+  - map:          ``{id, map:{over, as, component, ports, when?, into?, batched?, parent?,
+                   relationKind?, policy?}}``（when/into/batched は behaviorVersion 2）
+  - cond:         ``{id, cond:{if, then, else, parent?}}``（純 Expression、handler を呼ばない）
+
+behaviorVersion 2（bc#22）:
+  - ``map.when``   — per-element guard。``{cond:[when,true,false]}`` へ lower して評価
+    （strict-bool・非 bool は TYPE_MISMATCH で fail-closed）。false の要素は skip。
+  - ``map.into``   — zip-attach。結果は「over の各 guard 通過要素へ into キーで handler 結果を
+    書き戻した augment 済みリスト」（over と同じ長さ・順序。skip 要素は無変更で pass through）。
+  - ``map.batched``— guard 通過全要素の ports を先に評価し handler を 1 回だけ
+    ``handler({"items": [...]}, ctx)`` で呼ぶ。結果は items と同じ長さ・順序のリスト契約
+    （違反は MAP_BATCH_RESULT_MISMATCH）。通過 0 件なら handler は呼ばれず空リスト。
+  - handler ctx    — 全 handler 呼び出しに ``{"nodeId", "component"}``（map 非 batched は
+    さらに ``"bound"``）を渡す。追加のみ・既存 handler 互換。
+"""
+
+from __future__ import annotations
+
+import threading
+from typing import Any, Callable, Dict, List, Mapping, Optional
+
+from .expr_eval import evaluate as evaluate_expression
+from .plan import run_plan
+
+Value = Any
+
+# handler(ports: dict, ctx: dict) -> ExecOutcome（{"ok": Value} | {"error": str}）
+Handler = Callable[[Dict[str, Value], Dict[str, Any]], Mapping[str, Any]]
+Handlers = Mapping[str, Handler]
+
+
+class BehaviorFailure(Exception):
+    """run_behavior の Failure（UNKNOWN_COMPONENT / MAP_OVER_NOT_ARRAY / ...）。"""
+
+    def __init__(self, code: str, message: str) -> None:
+        super().__init__(message)
+        self.code = code
+
+
+def _bfail(code: str, message: str) -> "None":
+    raise BehaviorFailure(code, message)
+
+
+def _node_kind(n: Mapping[str, Any]) -> str:
+    if "map" in n:
+        return "map"
+    if "cond" in n:
+        return "cond"
+    if "component" in n:
+        return "componentRef"
+    _bfail("UNKNOWN_NODE_KIND", f"body node '{n.get('id', '?')}' is not componentRef/map/cond")
+
+
+def _node_parent(n: Mapping[str, Any]) -> Optional[str]:
+    if "map" in n:
+        return n["map"].get("parent")
+    if "cond" in n:
+        return n["cond"].get("parent")
+    return n.get("parent")
+
+
+def _node_bind_field(n: Mapping[str, Any]) -> Optional[str]:
+    if "map" in n or "cond" in n:
+        return None
+    return n.get("bindField")
+
+
+def _node_policy(n: Mapping[str, Any]) -> Optional[str]:
+    if "map" in n:
+        return n["map"].get("policy")
+    if "cond" in n:
+        return None
+    return n.get("policy")
+
+
+def _node_relation_kind(n: Mapping[str, Any]) -> Optional[str]:
+    if "map" in n:
+        return n["map"].get("relationKind")
+    if "cond" in n:
+        return None
+    return n.get("relationKind")
+
+
+def _eval_ports(ports: Mapping[str, Any], scope: Dict[str, Value]) -> Dict[str, Value]:
+    # key はソートせず宣言順のまま。FORBIDDEN_KEY 等は evaluate が投げる（fail-closed）。
+    return {k: evaluate_expression(v, scope) for k, v in ports.items()}
+
+
+def run_behavior(
+    ir: Mapping[str, Any],
+    handlers: Handlers,
+    input: Optional[Mapping[str, Value]] = None,
+    entry: Optional[str] = None,
+) -> Value:
+    """component-graph IR の統合実行 IF（scp-ir-architecture.md §7）。
+
+    :param ir:       component-graph 可搬 IR（``{components:[...]}``）。
+    :param handlers: 専用コンポーネント handler registry（catalog名 → 実装。境界注入）。
+    :param input:    エントリ component の inputPorts 束縛（param 値）。
+    :param entry:    実行する component 名（省略時は先頭 component）。
+    :returns:        ``output`` を評価した最終 Value（Φ 合流）。
+    """
+    input = dict(input or {})
+    components = list(ir.get("components", []))
+    comp = None
+    if entry is not None:
+        comp = next((c for c in components if c.get("name") == entry), None)
+    elif components:
+        comp = components[0]
+    if comp is None:
+        _bfail("UNKNOWN_ENTRY", f"component '{entry if entry is not None else '<first>'}' not found in IR")
+
+    body: List[Mapping[str, Any]] = list(comp["body"])
+    id_to_index = {n["id"]: i for i, n in enumerate(body)}
+
+    ops: List[Dict[str, Any]] = []
+    for n in body:
+        pid = _node_parent(n)
+        parent = id_to_index.get(pid) if pid is not None else None
+        op: Dict[str, Any] = {"id": n["id"], "parent": parent}
+        bf = _node_bind_field(n)
+        if bf is not None:
+            op["bindField"] = bf
+        rk = _node_relation_kind(n)
+        if rk is not None:
+            op["relationKind"] = rk
+        pol = _node_policy(n)
+        if pol is not None:
+            op["policy"] = pol
+        ops.append(op)
+
+    # run_plan は concurrency > 1 の stage で exec を worker thread から並行に呼ぶ（bc#23）。
+    # results への書き込みは disjoint スロット（自ノード id）だが、base_scope の dict 展開
+    # （iteration）と挿入が並行すると RuntimeError になり得るため lock で直列化する。
+    # 兄弟は互いのスロットを読まない（§1: stage 内は相互独立）ので結果は決定的。
+    results: Dict[str, Value] = {}
+    results_lock = threading.Lock()
+
+    def base_scope() -> Dict[str, Value]:
+        with results_lock:
+            return {**input, **results}
+
+    def exec_node(op: Mapping[str, Any], _bound: Optional[Value]) -> Mapping[str, Any]:
+        idx = id_to_index[op["id"]]
+        node = body[idx]
+        kind = _node_kind(node)
+
+        if kind == "cond":
+            c = node["cond"]
+            value = evaluate_expression({"cond": [c["if"], c["then"], c["else"]]}, base_scope())
+            return {"ok": value}
+
+        if kind == "map":
+            m = node["map"]
+            over = evaluate_expression(m["over"], base_scope())
+            if not isinstance(over, list):
+                _bfail("MAP_OVER_NOT_ARRAY", f"map '{op['id']}': 'over' did not evaluate to an array")
+            handler = handlers.get(m["component"])
+            if handler is None:
+                _bfail("UNKNOWN_COMPONENT", f"component '{m['component']}' has no handler (fail-closed)")
+            ctx = {"nodeId": op["id"], "component": m["component"]}
+            when = m.get("when")
+
+            def keep(scope: Dict[str, Value]) -> bool:
+                # per-element guard（v2）: `{cond:[when,true,false]}` へ lower（strict-bool）。
+                if when is None and "when" not in m:
+                    return True
+                return evaluate_expression({"cond": [when, True, False]}, scope) is True
+
+            kept_idx: List[int] = []  # guard を通過した over 内 index（into の整列用）
+
+            if m.get("batched") is True:
+                # batched（v2）: guard 通過全要素の ports を先に評価し、handler を 1 回だけ呼ぶ。
+                items: List[Value] = []
+                for i, el in enumerate(over):
+                    scope = {**base_scope(), m["as"]: el}
+                    if not keep(scope):
+                        continue
+                    items.append(_eval_ports(m["ports"], scope))
+                    kept_idx.append(i)
+                if not items:
+                    collected: List[Value] = []  # guard 全落ち: handler は呼ばれない
+                else:
+                    outcome = handler({"items": items}, ctx)
+                    if "error" in outcome:
+                        return outcome
+                    r = outcome["ok"]
+                    if not isinstance(r, list) or len(r) != len(items):
+                        _bfail(
+                            "MAP_BATCH_RESULT_MISMATCH",
+                            f"map '{op['id']}': batched handler must return a list aligned to items "
+                            f"(want {len(items)}, got {len(r) if isinstance(r, list) else type(r).__name__})",
+                        )
+                    collected = r
+            else:
+                collected = []
+                for i, el in enumerate(over):
+                    scope = {**base_scope(), m["as"]: el}
+                    if not keep(scope):
+                        continue
+                    ports = _eval_ports(m["ports"], scope)
+                    outcome = handler(ports, {**ctx, "bound": el})
+                    if "error" in outcome:
+                        return outcome
+                    collected.append(outcome["ok"])
+                    kept_idx.append(i)
+
+            into = m.get("into")
+            if into is None and "into" not in m:
+                return {"ok": collected}
+
+            # into（v2）: over と同じ長さ・順序の augment 済みリスト（skip 要素は無変更）。
+            augmented: List[Value] = []
+            k = 0
+            for i, el in enumerate(over):
+                if k < len(kept_idx) and kept_idx[k] == i:
+                    if not isinstance(el, dict):
+                        _bfail(
+                            "MAP_INTO_ELEMENT_NOT_OBJECT",
+                            f"map '{op['id']}': 'into' requires object elements (element {i} is not an object)",
+                        )
+                    augmented.append({**el, into: collected[k]})
+                    k += 1
+                else:
+                    augmented.append(el)
+            return {"ok": augmented}
+
+        # componentRef
+        handler = handlers.get(node["component"])
+        if handler is None:
+            _bfail("UNKNOWN_COMPONENT", f"component '{node['component']}' has no handler (fail-closed)")
+        ports = _eval_ports(node.get("ports", {}), base_scope())
+        return handler(ports, {"nodeId": op["id"], "component": node["component"]})
+
+    def wrapped_exec(op: Mapping[str, Any], bound: Optional[Value]) -> Mapping[str, Any]:
+        outcome = exec_node(op, bound)
+        if "ok" in outcome:
+            with results_lock:
+                results[op["id"]] = outcome["ok"]
+        return outcome
+
+    plan = comp.get("plan")
+    run = run_plan(plan, ops, wrapped_exec)
+
+    for i, s in enumerate(run["states"]):
+        if s is not None and s.get("status") == "skipped":
+            rk = _node_relation_kind(body[i])
+            results[ops[i]["id"]] = {"items": [], "cursor": None} if rk == "connection" else None
+
+    return evaluate_expression(comp["output"], base_scope())

{behavior_contracts-0.1.3 → behavior_contracts-0.2.0}/src/behavior_contracts/conformance.py

@@ -19,15 +19,19 @@ from __future__ import annotations
 import json
 import os
 import sys
+import threading
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from . import (
     SPEC_VERSIONS,
+    BehaviorFailure,
     CanonicalFailure,
     ExprFailure,
     PlanFailure,
+    PortabilityError,
     TemplateFailure,
+    assert_portable_component_graph,
     canonical_json,
     canonical_value,
     decode_value,
@@ -37,6 +41,7 @@ from . import (
     final_tree,
     py_float_repr,
     render_template,
+    run_behavior,
     run_plan,
 )
 
@@ -85,6 +90,9 @@ def _preflight(vectors_dir: Path) -> Dict[str, Any]:
         ("template.json", "template", "templateVersion", SPEC_VERSIONS["template"]),
         ("plan.json", "plan", "planVersion", SPEC_VERSIONS["plan"]),
         ("canonical.json", "canonical", "canonicalVersion", SPEC_VERSIONS["canonical"]),
+        ("behavior.json", "behavior", "behaviorVersion", SPEC_VERSIONS["behavior"]),
+        ("guard.json", "guard", "guardVersion", SPEC_VERSIONS["guard"]),
+        ("c2-catalog-swap.json", "c2", "c2Version", SPEC_VERSIONS["c2"]),
     ]
     loaded = [(f, suite, vk, want, _load_json(vectors_dir, f)) for (f, suite, vk, want) in specs]
     mismatches = [(suite, doc.get(vk), want) for (_, suite, vk, want, doc) in loaded if doc.get(vk) != want]
@@ -247,6 +255,177 @@ def _run_plan(t: _Tally, doc: Any) -> None:
         _bump(t, ok)
 
 
+# ── behavior suite ────────────────────────────────────────────────────────────
+def _build_handlers(spec: Dict[str, Any]):
+    """handlers[name] = FIFO の scripted outcome 列（配列でなければ「毎回同じ 1 要素」の短縮形）。
+
+    v2 の観測用 outcome（PROTOCOL.md §3.5）:
+      ``{"echo":"ctx"}``   → ``{ok: {nodeId, component}}``（handler ctx の中身を返す）
+      ``{"echo":"items"}`` → ``{ok: ports["items"]}``（batched handler が受け取った items）
+    """
+    handlers = {}
+    for name, raw in spec.items():
+        queue = list(raw) if isinstance(raw, list) else None
+        single = None if isinstance(raw, list) else raw
+
+        def make(queue=queue, single=single):
+            # run_behavior は concurrency > 1 の stage を ThreadPoolExecutor で並列 dispatch
+            # し得るため、FIFO pop（check-then-act）は per-queue lock で原子化する
+            # （PROTOCOL.md §3.5「runner の FIFO pop は並行呼び出しに対して原子的」）。
+            lock = threading.Lock()
+
+            def handler(ports, ctx):
+                if single is not None:
+                    o = single
+                else:
+                    with lock:
+                        o = queue.pop(0) if len(queue) > 1 else queue[0]
+                if o.get("echo") == "ctx":
+                    return {"ok": {"nodeId": ctx["nodeId"], "component": ctx["component"]}}
+                if o.get("echo") == "items":
+                    return {"ok": ports.get("items")}
+                if "ok" in o:
+                    return {"ok": decode_value(o["ok"])}
+                return {"error": o["error"]}
+
+            return handler
+
+        handlers[name] = make()
+    return handlers
+
+
+def _run_behavior(t: _Tally, doc: Any) -> None:
+    print(f"\nbehavior.json (v{doc['behaviorVersion']}) — {len(doc['vectors'])} vectors")
+    for v in doc["vectors"]:
+        ok = False
+        detail = ""
+        ir = v["ir"]
+        input_scope = {k: decode_value(val) for k, val in (v.get("input") or {}).items()}
+        handlers = _build_handlers(v.get("handlers") or {})
+        try:
+            result = run_behavior(ir, handlers, input_scope, v.get("entry"))
+            if "value" in v["expect"]:
+                ok = deep_equals(result, decode_value(v["expect"]["value"]))
+                if not ok:
+                    detail = (
+                        f"expected value {json.dumps(v['expect']['value'])}, "
+                        f"got {json.dumps(encode_value(result))}"
+                    )
+            else:
+                detail = f"expected Failure({v['expect']['failure']}), got a value"
+        except (BehaviorFailure, PlanFailure, ExprFailure) as e:
+            if "failure" in v["expect"]:
+                ok = e.code == v["expect"]["failure"]
+                if not ok:
+                    detail = f"expected Failure({v['expect']['failure']}), got Failure({e.code})"
+            else:
+                detail = f"expected a value, got Failure({e.code})"
+        _line(ok, v["name"], detail)
+        _bump(t, ok)
+
+
+# ── guard suite（assert_portable_component_graph, bc#25）────────────────────────
+def _run_guard(t: _Tally, doc: Any) -> None:
+    """`ir` は RAW JSON のまま guard へ渡す（§2 の型付き decode 不適用 — 静的構造検査）。
+
+    reject は PortabilityError を固定コード PORTABILITY に map し、`expect.path` を
+    文字列完全一致で照合する（メッセージ本文は判定対象外。PROTOCOL.md §3.6）。
+    関数残存 reject は JSON vector に載らないため unit test（test_public_api.py）で pin。
+    """
+    print(f"\nguard.json (v{doc['guardVersion']}) — {len(doc['vectors'])} vectors")
+    for v in doc["vectors"]:
+        ok = False
+        detail = ""
+        try:
+            assert_portable_component_graph(v["ir"])
+            if "ok" in v["expect"]:
+                ok = True
+            else:
+                detail = (
+                    f"expected Failure({v['expect']['failure']} at {v['expect']['path']}), "
+                    f"guard passed"
+                )
+        except PortabilityError as e:
+            if "failure" in v["expect"]:
+                ok = v["expect"]["failure"] == "PORTABILITY" and e.path == v["expect"]["path"]
+                if not ok:
+                    detail = f"expected reject path {v['expect']['path']}, got {e.path}"
+            else:
+                detail = f"expected guard to pass, got PORTABILITY at {e.path}"
+        _line(ok, v["name"], detail)
+        _bump(t, ok)
+
+
+# ── c2 suite（c2-catalog-swap: catalog-swap 実行 + IR 構造一致, bc#28）──────────
+def _c2_normalize(decoded_ir: Any, role_by_name: Dict[str, str]) -> Any:
+    """component leaf 名を role に置換（構造は不変）。unmapped は ValueError。"""
+    for c in decoded_ir["components"]:
+        for n in c["body"]:
+            ref = n.get("map", n)
+            if "component" in ref:
+                name = ref["component"]
+                if name not in role_by_name:
+                    raise ValueError(f"unmapped component '{name}'")
+                ref["component"] = role_by_name[name]
+    return decoded_ir
+
+
+def _run_c2(t: _Tally, doc: Any) -> None:
+    """各 consumer の vector を behavior-suite 形式で実行し、構造検査
+    （正規化後 deep-equal / 正規化前は不一致 = catalog が唯一の差分）を行う。
+    PROTOCOL.md §3.7。
+    """
+    consumer_names = sorted(doc["consumers"].keys())
+    n_vec = sum(len(doc["consumers"][c]["vectors"]) for c in consumer_names)
+    print(f"\nc2-catalog-swap.json (v{doc['c2Version']}) — {n_vec} vectors + structural")
+
+    # 1) execution: 同一 runBehavior + consumer 固有 handlers → consumer 固有の期待出力。
+    for cname in consumer_names:
+        for v in doc["consumers"][cname]["vectors"]:
+            ok = False
+            detail = ""
+            try:
+                assert_portable_component_graph(v["ir"])  # 共有 guard が全 consumer IR を accept
+                input_scope = {k: decode_value(val) for k, val in (v.get("input") or {}).items()}
+                handlers = _build_handlers(v.get("handlers") or {})
+                result = run_behavior(v["ir"], handlers, input_scope, v.get("entry"))
+                ok = deep_equals(result, decode_value(v["expect"]["value"]))
+                if not ok:
+                    detail = (
+                        f"expected value {json.dumps(v['expect']['value'])}, "
+                        f"got {json.dumps(encode_value(result))}"
+                    )
+            except (BehaviorFailure, PlanFailure, ExprFailure, PortabilityError) as e:
+                detail = f"expected a value, got {type(e).__name__}({e})"
+            _line(ok, f"{cname}: {v['name']}", detail)
+            _bump(t, ok)
+
+    # 2) structural: 正規化（component 名 → role）後の IR が consumer 間で deep-equal、
+    #    正規化前は不一致であること。
+    a, b = consumer_names
+    role_of = lambda c: {name: role for role, name in doc["consumers"][c]["catalog"].items()}  # noqa: E731
+    va = doc["consumers"][a]["vectors"]
+    vb = doc["consumers"][b]["vectors"]
+    for i in range(min(len(va), len(vb))):
+        ok = False
+        detail = ""
+        try:
+            da = decode_value(va[i]["ir"])
+            db = decode_value(vb[i]["ir"])
+            if deep_equals(da, db):
+                detail = "raw IRs must differ before normalization"
+            else:
+                na = _c2_normalize(da, role_of(a))
+                nb = _c2_normalize(db, role_of(b))
+                ok = deep_equals(na, nb)
+                if not ok:
+                    detail = "IRs must be deep-equal modulo catalog names"
+        except ValueError as e:
+            detail = str(e)
+        _line(ok, f"structural[{i}]: IR equal modulo catalog ({va[i]['name']})", detail)
+        _bump(t, ok)
+
+
 def _same_set(a: List[str], b: List[str]) -> bool:
     return sorted(a) == sorted(b)
 
@@ -271,9 +450,12 @@ def run(vectors_dir: Optional[Path] = None) -> int:
     _run_template(t, docs["template"])
     _run_plan(t, docs["plan"])
     _run_canonical(t, docs["canonical"])
+    _run_behavior(t, docs["behavior"])
+    _run_guard(t, docs["guard"])
+    _run_c2(t, docs["c2"])
 
     total = t.passed + t.failed
-    print(f"\n{t.passed} passed, {t.failed} failed / {total} vectors across 4 suites")
+    print(f"\n{t.passed} passed, {t.failed} failed / {total} vectors across 7 suites")
     return t.failed