topkit 0.2.0a3__tar.gz → 0.2.0a4__tar.gz

{topkit-0.2.0a3/topkit.egg-info → topkit-0.2.0a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topkit
-Version: 0.2.0a3
+Version: 0.2.0a4
 Summary: TopKit: the Python reference implementation of Tag-Oriented Programming.
 Author: Julio Toboso
 License-Expression: Apache-2.0
@@ -11,12 +11,10 @@ Keywords: tag-oriented-programming,top,topkit,tags
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Python: >=3.10
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: license-file
@@ -76,38 +74,52 @@ assert ari.Attack() == "Ari casts Magic Missile while holding a shield"
 assert ari.Wizard.Attack() == "Ari casts Magic Missile"   # the view after Wizard
 ```
 
-Read [`TopKit/GUIDE.md`](TopKit/GUIDE.md) for the patterns, and run
+Read [`TopKit/GUIDE.md`](https://github.com/JulTob/Tag_Oriented_Programming/blob/main/TopKit/GUIDE.md) for the patterns, and run
 `examples/dnd_character.py` and `examples/biome.py` for the long form;
 `examples/fleet_patching.py` and `examples/crew_access.py` for the design
 patterns Pins and published members give you.
 
+## Installing
+
+```
+pip install topkit
+```
+
+TopKit is in alpha. While no final release exists, a plain
+`pip install topkit` installs the newest alpha. Once a final release is
+out, it installs that, and `pip install --pre topkit` asks for the newest
+alpha.
+
 ## This repository
 
 | Path | What | License |
 | --- | --- | --- |
-| [`spec/SPECIFICATION.md`](spec/SPECIFICATION.md) | **The Specification**, written in rings from the kernel outward. The source of truth. | CC-BY-4.0 |
-| [`TopKit/GUIDE.md`](TopKit/GUIDE.md) | **The Guide**: TOP for people, pattern by pattern. Start here. | Apache-2.0 |
-| [`TopKit/`](TopKit/) | **TopKit**, the Python reference implementation (the T is the Tag in T.O.P.). | Apache-2.0 |
-| [`TopKit/CONTRACTS.md`](TopKit/CONTRACTS.md) | **The Contracts Guide**: gates, promises, membership and error control, aboard a starship. | Apache-2.0 |
-| [`tests/`](tests/) | The conformance suite, organized by ring. | Apache-2.0 |
-| [`examples/`](examples/) | A D&D character sheet, a mix-and-match biome, a drone fleet patched through Pins, a starship crew under published members. Each is a set of design patterns. | Apache-2.0 |
-| [`benchmarks/`](benchmarks/) | The runtime budget: reads, calls, tagging, memory. | Apache-2.0 |
-| [`steps/`](steps/) | **STEP**s, Standard TOP Enhancement Proposals. | CC-BY-4.0 |
-| [`RELEASING.md`](RELEASING.md) | How TopKit reaches PyPI, and what to check first. | Apache-2.0 |
+| [`spec/SPECIFICATION.md`](https://github.com/JulTob/Tag_Oriented_Programming/blob/main/spec/SPECIFICATION.md) | **The Specification**, written in rings from the kernel outward. The source of truth. | CC-BY-4.0 |
+| [`TopKit/GUIDE.md`](https://github.com/JulTob/Tag_Oriented_Programming/blob/main/TopKit/GUIDE.md) | **The Guide**: TOP for people, pattern by pattern. Start here. | Apache-2.0 |
+| [`TopKit/`](https://github.com/JulTob/Tag_Oriented_Programming/tree/main/TopKit) | **TopKit**, the Python reference implementation (the T is the Tag in T.O.P.). | Apache-2.0 |
+| [`TopKit/CONTRACTS.md`](https://github.com/JulTob/Tag_Oriented_Programming/blob/main/TopKit/CONTRACTS.md) | **The Contracts Guide**: gates, promises, membership and error control, aboard a starship. | Apache-2.0 |
+| [`TopKit/FIELDS.md`](https://github.com/JulTob/Tag_Oriented_Programming/blob/main/TopKit/FIELDS.md) | **The Fields Guide**: populations, partitions and the algebra between them. | Apache-2.0 |
+| [`tests/`](https://github.com/JulTob/Tag_Oriented_Programming/tree/main/tests) | The conformance suite, the examples and every document block, the oracle (an independent model of the paradigm checked against the kit on a random walk), and the differential fuzzer (the same random programs on two versions of the kit, transcripts compared). | Apache-2.0 |
+| [`examples/`](https://github.com/JulTob/Tag_Oriented_Programming/tree/main/examples) | A D&D character sheet, a mix-and-match biome, a drone fleet patched through Pins, a starship crew under published members. Each is a set of design patterns. | Apache-2.0 |
+| [`benchmarks/`](https://github.com/JulTob/Tag_Oriented_Programming/tree/main/benchmarks) | The runtime budget: reads, calls, tagging, memory. | Apache-2.0 |
+| [`steps/`](https://github.com/JulTob/Tag_Oriented_Programming/tree/main/steps) | **STEP**s, Standard TOP Enhancement Proposals. | CC-BY-4.0 |
+| [`RELEASING.md`](https://github.com/JulTob/Tag_Oriented_Programming/blob/main/RELEASING.md) | How TopKit reaches PyPI, and what to check first. | Apache-2.0 |
 
 The **Specification is the source of truth.** TopKit demonstrates it and
 must perform as the Specification describes; any gap in TopKit is TopKit's
 to fix, not a change to TOP.
 
-## Using TopKit
+## Using TopKit from a checkout
+
+From a checkout of this repository:
 
 ```
 pip install .                         # or: PYTHONPATH=. python3 ...
-PYTHONPATH=. python3 -m unittest tests.test_topkit tests.test_examples
+PYTHONPATH=. python3 -m unittest discover -s tests -t .
 PYTHONPATH=. python3 benchmarks/bench.py
 ```
 
-Python 3.10 or later, no dependencies. TopKit is built so that an Agent's
+Python 3.12 or later, no dependencies. TopKit is built so that an Agent's
 attribute reads and Action calls cost what they cost on a plain object;
 tagging is the slower, rarer act.
 
@@ -115,22 +127,22 @@ tagging is the slower, rarer act.
 
 An implementation in any language is welcome. "TOP-conformant" means it
 preserves the observable semantics in the Specification, ring by ring, and
-passes the conformance suite. See [`CONFORMANCE.md`](CONFORMANCE.md). The
+passes the conformance suite. See [`CONFORMANCE.md`](https://github.com/JulTob/Tag_Oriented_Programming/blob/main/CONFORMANCE.md). The
 **TOP Verified** mark is granted by the steward, so the standard stays
 meaningful.
 
 ## Governance & contributing
 
 TOP is led by a **Director**, with a path to shared governance; see
-[`GOVERNANCE.md`](GOVERNANCE.md). Propose changes through the **STEP**
-process ([`CONTRIBUTING.md`](CONTRIBUTING.md)); every decision is recorded,
+[`GOVERNANCE.md`](https://github.com/JulTob/Tag_Oriented_Programming/blob/main/GOVERNANCE.md). Propose changes through the **STEP**
+process ([`CONTRIBUTING.md`](https://github.com/JulTob/Tag_Oriented_Programming/blob/main/CONTRIBUTING.md)); every decision is recorded,
 in the open, with its reason.
 
 ## License & trademark
 
 Code is **Apache-2.0**; the Specification and STEPs are **CC-BY-4.0**.
 "Tag-Oriented Programming", "TOP", and "TopKit" are trademarks; see
-[`TRADEMARK.md`](TRADEMARK.md). You may implement the paradigm freely; the
+[`TRADEMARK.md`](https://github.com/JulTob/Tag_Oriented_Programming/blob/main/TRADEMARK.md). You may implement the paradigm freely; the
 marks identify the official spec and conformant implementations.
 
 © 2026 Julio Toboso.

topkit-0.2.0a4/README.md

@@ -0,0 +1,127 @@
+# Tag-Oriented Programming (TOP)™
+
+> Compose semantic layers on one stable object identity.
+
+**TOP** is a programming paradigm: a Target keeps its identity while Tags
+add meaning, species, roles, backgrounds, capabilities, that cut across
+ordinary class hierarchies. Where traditional code asks *"what is this
+object?"*, TOP asks *"what is this object for, here?"*, and lets the answer
+grow. The inspiration is tabletop character creation: species, class,
+background and feats are independent choices, and the character sheet is
+what they compose.
+
+```python
+from TopKit import Tag, Record, Action, Underlay, Pre
+
+class Character:
+    def __init__(self, name, level):
+        self.name, self.level = name, level
+
+class Elf(Tag):
+    @Record
+    def spells(agent, stored):                 # piles up with other Tags
+        return (stored or []) + ["Light"]
+
+class Wizard(Tag):
+    @Pre
+    def Can_Study(agent):
+        return agent.level >= 1
+
+    @Record
+    def spells(agent, stored):
+        return (stored or []) + ["Magic Missile"]
+
+    def Attack(agent):
+        return f"{agent.name} casts {agent.spells[-1]}"
+
+class War_Caster(Tag):
+    @Pre
+    def Is_A_Caster(agent):                    # synergy: needs Wizard
+        return agent in Wizard
+
+    @Action
+    @Underlay
+    def Attack(agent, underlay):
+        return underlay() + " while holding a shield"
+
+ari = Character("Ari", level=3)
+Elf(ari); Wizard(ari); War_Caster(ari)
+
+assert ari in Wizard                           # active membership
+assert ari.spells == ["Light", "Magic Missile"]
+assert ari.Attack() == "Ari casts Magic Missile while holding a shield"
+assert ari.Wizard.Attack() == "Ari casts Magic Missile"   # the view after Wizard
+```
+
+Read [`TopKit/GUIDE.md`](https://github.com/JulTob/Tag_Oriented_Programming/blob/main/TopKit/GUIDE.md) for the patterns, and run
+`examples/dnd_character.py` and `examples/biome.py` for the long form;
+`examples/fleet_patching.py` and `examples/crew_access.py` for the design
+patterns Pins and published members give you.
+
+## Installing
+
+```
+pip install topkit
+```
+
+TopKit is in alpha. While no final release exists, a plain
+`pip install topkit` installs the newest alpha. Once a final release is
+out, it installs that, and `pip install --pre topkit` asks for the newest
+alpha.
+
+## This repository
+
+| Path | What | License |
+| --- | --- | --- |
+| [`spec/SPECIFICATION.md`](https://github.com/JulTob/Tag_Oriented_Programming/blob/main/spec/SPECIFICATION.md) | **The Specification**, written in rings from the kernel outward. The source of truth. | CC-BY-4.0 |
+| [`TopKit/GUIDE.md`](https://github.com/JulTob/Tag_Oriented_Programming/blob/main/TopKit/GUIDE.md) | **The Guide**: TOP for people, pattern by pattern. Start here. | Apache-2.0 |
+| [`TopKit/`](https://github.com/JulTob/Tag_Oriented_Programming/tree/main/TopKit) | **TopKit**, the Python reference implementation (the T is the Tag in T.O.P.). | Apache-2.0 |
+| [`TopKit/CONTRACTS.md`](https://github.com/JulTob/Tag_Oriented_Programming/blob/main/TopKit/CONTRACTS.md) | **The Contracts Guide**: gates, promises, membership and error control, aboard a starship. | Apache-2.0 |
+| [`TopKit/FIELDS.md`](https://github.com/JulTob/Tag_Oriented_Programming/blob/main/TopKit/FIELDS.md) | **The Fields Guide**: populations, partitions and the algebra between them. | Apache-2.0 |
+| [`tests/`](https://github.com/JulTob/Tag_Oriented_Programming/tree/main/tests) | The conformance suite, the examples and every document block, the oracle (an independent model of the paradigm checked against the kit on a random walk), and the differential fuzzer (the same random programs on two versions of the kit, transcripts compared). | Apache-2.0 |
+| [`examples/`](https://github.com/JulTob/Tag_Oriented_Programming/tree/main/examples) | A D&D character sheet, a mix-and-match biome, a drone fleet patched through Pins, a starship crew under published members. Each is a set of design patterns. | Apache-2.0 |
+| [`benchmarks/`](https://github.com/JulTob/Tag_Oriented_Programming/tree/main/benchmarks) | The runtime budget: reads, calls, tagging, memory. | Apache-2.0 |
+| [`steps/`](https://github.com/JulTob/Tag_Oriented_Programming/tree/main/steps) | **STEP**s, Standard TOP Enhancement Proposals. | CC-BY-4.0 |
+| [`RELEASING.md`](https://github.com/JulTob/Tag_Oriented_Programming/blob/main/RELEASING.md) | How TopKit reaches PyPI, and what to check first. | Apache-2.0 |
+
+The **Specification is the source of truth.** TopKit demonstrates it and
+must perform as the Specification describes; any gap in TopKit is TopKit's
+to fix, not a change to TOP.
+
+## Using TopKit from a checkout
+
+From a checkout of this repository:
+
+```
+pip install .                         # or: PYTHONPATH=. python3 ...
+PYTHONPATH=. python3 -m unittest discover -s tests -t .
+PYTHONPATH=. python3 benchmarks/bench.py
+```
+
+Python 3.12 or later, no dependencies. TopKit is built so that an Agent's
+attribute reads and Action calls cost what they cost on a plain object;
+tagging is the slower, rarer act.
+
+## Conformance
+
+An implementation in any language is welcome. "TOP-conformant" means it
+preserves the observable semantics in the Specification, ring by ring, and
+passes the conformance suite. See [`CONFORMANCE.md`](https://github.com/JulTob/Tag_Oriented_Programming/blob/main/CONFORMANCE.md). The
+**TOP Verified** mark is granted by the steward, so the standard stays
+meaningful.
+
+## Governance & contributing
+
+TOP is led by a **Director**, with a path to shared governance; see
+[`GOVERNANCE.md`](https://github.com/JulTob/Tag_Oriented_Programming/blob/main/GOVERNANCE.md). Propose changes through the **STEP**
+process ([`CONTRIBUTING.md`](https://github.com/JulTob/Tag_Oriented_Programming/blob/main/CONTRIBUTING.md)); every decision is recorded,
+in the open, with its reason.
+
+## License & trademark
+
+Code is **Apache-2.0**; the Specification and STEPs are **CC-BY-4.0**.
+"Tag-Oriented Programming", "TOP", and "TopKit" are trademarks; see
+[`TRADEMARK.md`](https://github.com/JulTob/Tag_Oriented_Programming/blob/main/TRADEMARK.md). You may implement the paradigm freely; the
+marks identify the official spec and conformant implementations.
+
+© 2026 Julio Toboso.

{topkit-0.2.0a3 → topkit-0.2.0a4}/TopKit/access.py

@@ -11,10 +11,19 @@ from __future__ import annotations
 
 from functools import partial
 from typing import Any
+from typing import Callable
+import sys
 
+from . import declarations
+from .contracts import _condition_member
+from .contracts import _holds
 from .errors import TagCompositionError
 from .errors import TagResolutionError
+from .declarations import STATE
 from .declarations import _MISSING
+from .declarations import _is_flag
+from .declarations import _words_of
+from .lifecycle import _teardown_all
 from .state import _Bound
 from .state import _Pinned_Operation
 from .state import _Snapshot
@@ -46,6 +55,43 @@ def _host_member(
     return None
 
 
+IN_SEAT = (
+        "__contains__",
+        "__iter__",
+        )
+
+
+def _host_in_seat(
+        host_type: type,
+        ) -> tuple[str, type] | None:
+    """How the host answers `in`: the special method and the class that
+    defines it, or None when the seat is free (STEP-SPEC-7).
+
+    Resolved as Python resolves `in`: ``__contains__``, then ``__iter__``.
+    For each, the first class in the MRO that defines the name decides. A
+    method owns the seat; the value None says `in` is unavailable, Python
+    tries nothing further, and the seat is free. ``__getitem__`` alone is
+    not a seat a Flag respects: on a keyed host its `in` fails or never
+    ends; on an index-style host it worked, and stops meaning membership
+    once a Flag lands (the Director's call, STEP-SPEC-7)."""
+
+    for name in IN_SEAT:
+        for klass in host_type.__mro__:
+            if klass is object:
+                break
+
+            if name in klass.__dict__:
+                if klass.__dict__[name] is None:
+                    return None
+
+                return (
+                        name,
+                        klass,
+                        )
+
+    return None
+
+
 def _hooks_for(
         host_type: type,
         has_posts: bool,
@@ -56,7 +102,6 @@ def _hooks_for(
             "__del__": _agent_del,
             "_TOPKIT_HOST_TYPE": host_type,
             "_TOPKIT_HOST_GETATTR": _host_member(host_type, "__getattr__"),
-            "_TOPKIT_HOST_DEL": _host_member(host_type, "__del__"),
             }
 
     if has_posts and _host_member(host_type, "__bool__") is None:
@@ -65,7 +110,7 @@ def _hooks_for(
     if _host_member(host_type, "__format__") is None:
         hooks["__format__"] = _agent_format
 
-    if has_flags and _host_member(host_type, "__contains__") is None:
+    if has_flags and _host_in_seat(host_type) is None:
         hooks["__contains__"] = _agent_contains
 
     if _host_member(host_type, "__copy__") is None:
@@ -81,7 +126,8 @@ def _agent_getattr(
         agent: object,
         name: str,
         ) -> Any:
-    """Miss path only: Tag views by name, then the host's own __getattr__."""
+    """Miss path only: Tag views by name, then a condition by name as a
+    plain bool (STEP-SPEC-14), then the host's own __getattr__."""
 
     state = _state_of(agent)
 
@@ -101,6 +147,16 @@ def _agent_getattr(
                         state,
                         )
 
+        if state.postconditions or state.preconditions:
+            verdict = _condition_member(
+                    agent,
+                    state,
+                    name,
+                    )
+
+            if verdict is not None:
+                return verdict
+
     host_getattr = type(agent).__dict__.get("_TOPKIT_HOST_GETATTR")
 
     if host_getattr is not None:
@@ -185,7 +241,7 @@ def _agent_contains(
         probe: object,
         ) -> bool:
     """``"Undead" in ghoul`` and ``Undead in ghoul``: an active Flag, by
-    name or by class."""
+    name, alias or class."""
 
     return _keyword(
             agent,
@@ -197,18 +253,33 @@ def _keyword(
         agent: object,
         probe: object,
         ) -> bool:
-    from .declarations import _is_flag
-
     state = _state_of(agent)
 
     if state is None:
         return False
 
     if isinstance(probe, str):
-        return any(
-                _is_flag(tag) and tag.__name__ == probe
-                for tag in state.active
-                )
+        if type(probe) is not str:
+            probe = str.__str__(probe)   # its text: exact, and hashable
+
+        words = state.words
+
+        if words is None or words.flags_declared != declarations._flags_declared:
+            # Read the count before gathering: a @Flag declared meanwhile then
+            # marks these words stale, instead of letting them pass for new.
+            words = state.words = _words_of(
+                    state.active,
+                    declarations._flags_declared,
+                    )
+
+        if probe in words.aliases:
+            return True
+
+        for tag in words.flags:
+            if tag.__name__ == probe:
+                return True
+
+        return False
 
     return (
             probe in state.active
@@ -219,28 +290,100 @@ def _keyword(
 def _agent_bool(
         agent: object,
         ) -> bool:
-    from .contracts import _holds
-
     return _holds(agent)
 
 
-def _agent_del(
+def _host_finalizer(
         agent: object,
+        kind: type = type,
+        missing: type = AttributeError,
         ) -> None:
-    # Best effort: run remaining teardowns, then the host's finalizer.
-    # Python does not promise finalizers at shutdown or inside cycles;
-    # Scope() is the guaranteed path.
+    """The host's own ``__del__``, found as Python finds it: through the
+    object's type, past the kit's runtime types, the first class that
+    defines one decides, ``None`` there means there is none, and a
+    descriptor is bound first.
+
+    It also runs late in interpreter exit, when this module's globals and
+    even the builtins may be gone, so it needs neither: ``kind`` and
+    ``missing`` are bound here."""
+
+    for klass in kind(agent).__mro__:
+        if "_TOPKIT_HOST_TYPE" in klass.__dict__:
+            continue   # a runtime type: its __del__ is the kit's finalizer
+
+        if "__del__" in klass.__dict__:
+            finalizer = klass.__dict__["__del__"]
+            break
+    else:
+        return
+
+    if finalizer is None:
+        return
+
     try:
-        from .lifecycle import _teardown_all
+        bind = kind(finalizer).__get__
+    except missing:
+        finalizer()   # not a descriptor: Python calls it as it is
+        return
 
-        _teardown_all(agent)
+    bind(
+            finalizer,
+            agent,
+            kind(agent),
+            )()
 
-        host_del = type(agent).__dict__.get("_TOPKIT_HOST_DEL")
 
-        if host_del is not None:
-            host_del(agent)
-    except Exception:
-        pass
+def _agent_del(
+        agent: object,
+        finalizing: Callable[[], bool] = sys.is_finalizing,
+        state_key: str = STATE,
+        host_finalizer: Callable[[object], None] = _host_finalizer,
+        read: Callable[[object, str], Any] = object.__getattribute__,
+        ) -> None:
+    """Deletion (§3.2, STEP-SPEC-18). The teardowns still due run, best
+    effort; then the Agent's ``__del__`` runs as its Overlay shows it: the
+    top Layer, which reaches the host's own through ``@Underlay``, or the
+    host's own when no Tag declares one. At interpreter exit only the
+    ``__del__`` Layers run: teardowns there are At_Exit's, and opt-in. A
+    ``__del__`` Layer's own error is reported as Python reports any
+    finalizer's.
+
+    At exit this module's globals, and even the builtins, may already be
+    gone. So the exit path uses neither: what it needs is bound here as a
+    default, or found on the Agent. The Agent is read as Python reads it,
+    never through the host's own ``__getattribute__``."""
+
+    state = read(agent, "__dict__").get(state_key)
+
+    if state is None:
+        host_finalizer(agent)   # built from an Agent's runtime type, never tagged: a plain host
+        return
+
+    interrupted = None
+
+    if not finalizing():
+        try:
+            _teardown_all(agent)
+        except Exception:
+            pass   # best effort (§3.2)
+        except BaseException as error:
+            interrupted = error   # Ctrl-C in a teardown: the __del__ Layers still run
+
+    try:
+        layer = state.actions.get("__del__")
+
+        if layer is not None:
+            state.composing += 1   # a Tag's Layer runs inside the composition door (§1.5)
+
+            try:
+                layer(agent)
+            finally:
+                state.composing -= 1
+        elif "__del__" not in state.deleted:
+            host_finalizer(agent)
+    finally:
+        if interrupted is not None:
+            raise interrupted   # reported after the Layers, whatever they raised
 
 
 def _agent_copy(

{topkit-0.2.0a3 → topkit-0.2.0a4}/TopKit/contracts.py

@@ -70,6 +70,18 @@ def _bind_condition(
 
     skip = 2 if uses_underlay else 1
 
+    if not uses_underlay and not with_inputs:
+        def Plain_Check(
+                agent: object,
+                inputs: dict[str, Any],
+                ) -> Any:
+            return function(agent)   # holds no prior binding: re-applying cannot pile up
+
+        return Plain_Check
+
+    if not uses_underlay:
+        prior = None   # never called: do not keep the earlier binding alive
+
     def Check(
             agent: object,
             inputs: dict[str, Any],
@@ -182,13 +194,62 @@ def _holds(
         ) -> bool:
     """True exactly when every visible Postcondition holds."""
 
-    return _guarded(
-            agent,
-            "postconditions",
-            False,
-            TagPostconditionError,
-            "Postcondition",
-            )
+    state = _state_of(agent)
+
+    if state is None or state.checking or not state.postconditions:
+        return True   # nothing promised, or asked from inside a check
+
+    state.checking = True
+    state.composing += 1
+
+    try:
+        for name, check in state.postconditions.items():
+            try:
+                if not _verdict(check(agent, {}), name):
+                    return False
+            except Exception:
+                return False
+
+        return True
+    finally:
+        state.composing -= 1
+        state.checking = False
+
+
+def _condition_member(
+        agent: object,
+        state: _State,
+        name: str,
+        ) -> bool | None:
+    """The condition called ``name`` on the Agent, read as a plain bool
+    (STEP-SPEC-14): a Postcondition first, then a Precondition. None when
+    the Agent has no condition of that name."""
+
+    check = state.postconditions.get(name)
+
+    if check is None:
+        check = state.preconditions.get(name)
+
+    if check is None:
+        return None
+
+    reentrant = state.checking
+    state.checking = True
+    state.composing += 1
+
+    try:
+        try:
+            return _verdict(
+                    check(agent, {}),
+                    name,
+                    )
+        except TagContractError:
+            raise
+        except Exception:
+            return False
+    finally:
+        state.composing -= 1
+        state.checking = reentrant
 
 
 def _status_of(