feat: Posture state machine enum

Closed StrEnum with four members pinned by docs/concepts/posture-and-hooks.md:
INTERACTIVE / AUTONOMOUS / DRY_RUN / LOCKED. Added to spine_lite.__all__
under the Phase 2 sub-option (a) decision recorded in RECEIPTS.md.

Phase 3 will add the transition functions; the enum is what the manifest
schema validates against in commit 3.

Author: claude

docs/reference/api.md

@@ -40,16 +40,21 @@ from spine_lite import (
         - PostureError
         - HookError
 
+## Posture
+
+::: spine_lite.posture
+    options:
+      members:
+        - Posture
+
 ## Phase 2 / Phase 3 modules
 
-Stub modules with phase-pinning docstrings. The reference will expand as the implementations land.
+Stubs and partials with phase-pinning docstrings. The reference expands as implementations land.
 
 ::: spine_lite.manifest
 
 ::: spine_lite.classifier
 
-::: spine_lite.posture
-
 ::: spine_lite.receipt
 
 ::: spine_lite.hook

src/spine_lite/__init__.py

@@ -1,7 +1,7 @@
 """spine-lite: deterministic policy and effects runtime for LLM tool calls.
 
-Phase 1 surface. Subsequent phases extend ``__all__`` as the classifier,
-posture machine, and hook ship. See ``CLAUDE.md`` and ``docs/architecture.md``.
+Phase 2 surface. Subsequent phases extend ``__all__`` as the classifier and
+hook ship. See ``CLAUDE.md`` and ``docs/explanation/architecture.md``.
 """
 
 from __future__ import annotations
@@ -16,6 +16,7 @@
     PostureError,
     SpineLiteError,
 )
+from spine_lite.posture import Posture
 
 __version__ = "0.1.0a0"
 
@@ -25,6 +26,7 @@
     "Effect",
     "HookError",
     "ManifestError",
+    "Posture",
     "PostureError",
     "SpineLiteError",
     "__version__",

src/spine_lite/posture.py

@@ -1,10 +1,31 @@
-"""Posture state machine (Phase 3).
+"""Posture state machine.
 
-A pure transition function over a closed ``Posture`` enum. No hidden state.
-Every transition is a value-in-value-out function. See
-``docs/architecture.md`` for the state diagram.
+Phase 2 ships the closed :class:`Posture` enum used by manifest validation.
+Phase 3 will add the transition functions (pure value-in-value-out).
 
 Pure module: deterministic, no I/O.
 """
 
 from __future__ import annotations
+
+from enum import StrEnum
+
+
+class Posture(StrEnum):
+    """Operational posture of the runtime.
+
+    Drives how the runtime treats ambiguous calls. Closed enum: extending
+    requires a project-level decision. The members and their string values
+    are pinned by ``docs/concepts/posture-and-hooks.md``.
+
+    Members:
+        INTERACTIVE: Operator at the keyboard; ambiguous calls escalate.
+        AUTONOMOUS: No operator in the loop; ambiguous calls fail closed.
+        DRY_RUN: Classification only; non-``READ`` effects don't fire.
+        LOCKED: Refuse everything except explicit allow-listed read-only calls.
+    """
+
+    INTERACTIVE = "interactive"
+    AUTONOMOUS = "autonomous"
+    DRY_RUN = "dry_run"
+    LOCKED = "locked"

tests/unit/test_posture.py

@@ -0,0 +1,56 @@
+"""Tests for the closed Posture enum."""
+
+from __future__ import annotations
+
+import pytest
+
+from spine_lite.posture import Posture
+
+
+def test_posture_has_exactly_four_members() -> None:
+    assert len(Posture) == 4
+
+
+def test_posture_member_names() -> None:
+    assert {p.name for p in Posture} == {
+        "INTERACTIVE",
+        "AUTONOMOUS",
+        "DRY_RUN",
+        "LOCKED",
+    }
+
+
+@pytest.mark.parametrize(
+    ("member", "value"),
+    [
+        (Posture.INTERACTIVE, "interactive"),
+        (Posture.AUTONOMOUS, "autonomous"),
+        (Posture.DRY_RUN, "dry_run"),
+        (Posture.LOCKED, "locked"),
+    ],
+)
+def test_posture_string_values_are_pinned(member: Posture, value: str) -> None:
+    assert member.value == value
+    assert member == value
+
+
+def test_posture_is_str_subclass() -> None:
+    assert isinstance(Posture.INTERACTIVE, str)
+    assert str(Posture.AUTONOMOUS) == "autonomous"
+
+
+def test_posture_unknown_value_raises() -> None:
+    with pytest.raises(ValueError, match="not a valid Posture"):
+        Posture("escalated")
+
+
+def test_posture_round_trip_through_value() -> None:
+    for member in Posture:
+        assert Posture(member.value) is member
+
+
+def test_posture_is_in_public_api() -> None:
+    import spine_lite
+
+    assert "Posture" in spine_lite.__all__
+    assert spine_lite.Posture is Posture