test: authored fixtures, parametrized parity tests, hypothesis properties

Four authored fixtures in tests/fixtures/:
- manifest_minimal.json     — single READ tool
- manifest_basic.json       — six tools across the taxonomy with postures
- manifest_full.json        — all 6 effects, all 4 postures, metadata
- decisions_basic.json      — six expected (call, decision) pairs

Parametrized tests confirm every fixture loads and round-trips JSON
byte-stably (parse → dump → parse → dump → equal). Decision parity test
walks each case in decisions_basic.json against manifest_basic.json and
asserts effects + most_restrictive match.

Hypothesis property tests at 1,000 examples each cover:
- determinism: classify(call, manifest) yields the same Decision every call
- dominance: most_restrictive is in the effects tuple
- manifest fidelity: Decision.effects == ToolDefinition.effects
- byte-stable rationale
- round-trip stability: classify(call, M) == classify(call, parse(M.dump()))
- argument independence: arguments don't influence Phase 2 classification

mypy override added for tests.* to disable disallow_untyped_decorators —
hypothesis's @given/@settings don't satisfy strict-decorator typing.
Runtime modules stay strict. 99 tests passing, 100% coverage on every
runtime module.

Author: claude

pyproject.toml

@@ -132,6 +132,13 @@ pretty = true
 module = ["typer.*"]
 ignore_missing_imports = false
 
+# Hypothesis's @given / @settings decorators don't propagate types in a way
+# mypy --strict accepts as "typed" — disabling disallow_untyped_decorators
+# only inside the test suite keeps strict typing on the runtime modules.
+[[tool.mypy.overrides]]
+module = ["tests.*"]
+disallow_untyped_decorators = false
+
 [tool.pytest.ini_options]
 minversion = "8.0"
 addopts = [

tests/fixtures/decisions_basic.json

@@ -0,0 +1,59 @@
+{
+  "manifest": "manifest_basic.json",
+  "cases": [
+    {
+      "name": "read-only file read",
+      "tool": "read_file",
+      "expected": {
+        "tool": "read_file",
+        "effects": ["read"],
+        "most_restrictive": "read"
+      }
+    },
+    {
+      "name": "scoped write",
+      "tool": "write_file",
+      "expected": {
+        "tool": "write_file",
+        "effects": ["write"],
+        "most_restrictive": "write"
+      }
+    },
+    {
+      "name": "network read collapses to network",
+      "tool": "fetch_url",
+      "expected": {
+        "tool": "fetch_url",
+        "effects": ["network", "read"],
+        "most_restrictive": "network"
+      }
+    },
+    {
+      "name": "subprocess execute",
+      "tool": "shell_run",
+      "expected": {
+        "tool": "shell_run",
+        "effects": ["execute"],
+        "most_restrictive": "execute"
+      }
+    },
+    {
+      "name": "fork-and-detach spawn",
+      "tool": "shell_daemon",
+      "expected": {
+        "tool": "shell_daemon",
+        "effects": ["spawn"],
+        "most_restrictive": "spawn"
+      }
+    },
+    {
+      "name": "destructive dominates network",
+      "tool": "git_force_push",
+      "expected": {
+        "tool": "git_force_push",
+        "effects": ["destructive", "network"],
+        "most_restrictive": "destructive"
+      }
+    }
+  ]
+}

tests/fixtures/manifest_basic.json

@@ -0,0 +1,52 @@
+{
+  "tools": {
+    "read_file": {
+      "name": "read_file",
+      "description": "Read a file from disk.",
+      "effects": ["read"],
+      "permitted_postures": null,
+      "require_confirmation": false,
+      "metadata": {}
+    },
+    "write_file": {
+      "name": "write_file",
+      "description": "Write content to a file.",
+      "effects": ["write"],
+      "permitted_postures": null,
+      "require_confirmation": false,
+      "metadata": {}
+    },
+    "fetch_url": {
+      "name": "fetch_url",
+      "description": "Fetch a URL.",
+      "effects": ["network", "read"],
+      "permitted_postures": null,
+      "require_confirmation": false,
+      "metadata": {}
+    },
+    "shell_run": {
+      "name": "shell_run",
+      "description": "Run a shell command and wait for completion.",
+      "effects": ["execute"],
+      "permitted_postures": ["interactive", "autonomous"],
+      "require_confirmation": false,
+      "metadata": {}
+    },
+    "shell_daemon": {
+      "name": "shell_daemon",
+      "description": "Spawn a long-running daemon process.",
+      "effects": ["spawn"],
+      "permitted_postures": ["interactive"],
+      "require_confirmation": true,
+      "metadata": {}
+    },
+    "git_force_push": {
+      "name": "git_force_push",
+      "description": "Force push, irreversible if remote was rewritten.",
+      "effects": ["destructive", "network"],
+      "permitted_postures": ["interactive"],
+      "require_confirmation": true,
+      "metadata": {}
+    }
+  }
+}

tests/fixtures/manifest_full.json

@@ -0,0 +1,29 @@
+{
+  "tools": {
+    "all_classes": {
+      "name": "all_classes",
+      "description": "Synthetic tool exercising every effect class and posture.",
+      "effects": [
+        "destructive",
+        "spawn",
+        "execute",
+        "network",
+        "write",
+        "read"
+      ],
+      "permitted_postures": [
+        "interactive",
+        "autonomous",
+        "dry_run",
+        "locked"
+      ],
+      "require_confirmation": true,
+      "metadata": {
+        "category": "synthetic",
+        "tags": ["coverage", "reference"],
+        "owner": "spine-lite",
+        "audit_priority": "high"
+      }
+    }
+  }
+}

tests/fixtures/manifest_minimal.json

@@ -0,0 +1,8 @@
+{
+  "tools": {
+    "read_file": {
+      "name": "read_file",
+      "effects": ["read"]
+    }
+  }
+}

tests/unit/test_classifier.py

@@ -1,13 +1,24 @@
-"""Tests for the classifier (basic / unit).
+"""Tests for the classifier.
 
-Property-based tests with hypothesis live in commit 5 alongside the
-authored fixtures. This file covers the core behaviour and the error
-paths.
+Three layers:
+
+1. Unit tests covering happy paths, error paths, frozen dataclass
+   immutability, and the public-API surface.
+2. Parametrized parity tests against the authored fixtures in
+   ``tests/fixtures/``: round-trip JSON byte-stability per manifest,
+   and case-by-case decision parity for ``manifest_basic.json``.
+3. Hypothesis property tests for determinism, dominance, and round-trip
+   stability — 1,000 examples each.
 """
 
 from __future__ import annotations
 
+import json
+from pathlib import Path
+
 import pytest
+from hypothesis import HealthCheck, given, settings
+from hypothesis import strategies as st
 
 from spine_lite import (
     Decision,
@@ -18,6 +29,15 @@
     ToolCall,
     ToolDefinition,
     classify,
+    parse_manifest,
+)
+
+FIXTURES_DIR = Path(__file__).parent.parent / "fixtures"
+
+_HYPOTHESIS_THOROUGH = settings(
+    max_examples=1000,
+    deadline=None,
+    suppress_health_check=[HealthCheck.too_slow],
 )
 
 
@@ -178,3 +198,179 @@ def test_decision_classify_toolcall_in_public_api() -> None:
 
     for name in ("Decision", "ToolCall", "classify"):
         assert name in spine_lite.__all__
+
+
+# ---------- parity tests against authored fixtures ----------
+
+
+_MANIFEST_FIXTURES = (
+    "manifest_minimal.json",
+    "manifest_basic.json",
+    "manifest_full.json",
+)
+
+
+@pytest.mark.parametrize("fixture", _MANIFEST_FIXTURES)
+def test_manifest_fixture_loads_cleanly(fixture: str) -> None:
+    raw = (FIXTURES_DIR / fixture).read_text()
+    manifest = parse_manifest(raw)
+    assert isinstance(manifest, Manifest)
+
+
+@pytest.mark.parametrize("fixture", _MANIFEST_FIXTURES)
+def test_manifest_fixture_round_trip_byte_stable(fixture: str) -> None:
+    """parse → dump → parse → dump produces identical bytes the second time."""
+    raw = (FIXTURES_DIR / fixture).read_text()
+    parsed = parse_manifest(raw)
+    dumped_once = parsed.model_dump_json()
+    re_parsed = parse_manifest(dumped_once)
+    dumped_twice = re_parsed.model_dump_json()
+    assert dumped_once == dumped_twice
+    assert parsed == re_parsed
+
+
+def _load_decision_cases() -> list[dict[str, object]]:
+    payload = json.loads((FIXTURES_DIR / "decisions_basic.json").read_text())
+    cases: list[dict[str, object]] = payload["cases"]
+    return cases
+
+
+@pytest.fixture(scope="module")
+def basic_manifest() -> Manifest:
+    return parse_manifest((FIXTURES_DIR / "manifest_basic.json").read_text())
+
+
+@pytest.mark.parametrize(
+    "case",
+    _load_decision_cases(),
+    ids=lambda c: str(c["name"]),
+)
+def test_decision_parity_against_fixture(
+    case: dict[str, object],
+    basic_manifest: Manifest,
+) -> None:
+    expected = case["expected"]
+    assert isinstance(expected, dict)
+
+    decision = classify(ToolCall(tool=str(case["tool"])), basic_manifest)
+
+    assert decision.tool == expected["tool"]
+    expected_effects = tuple(Effect(e) for e in expected["effects"])
+    assert decision.effects == expected_effects
+    assert decision.most_restrictive == Effect(str(expected["most_restrictive"]))
+
+
+# ---------- hypothesis property tests ----------
+
+
+_NAME_STRATEGY = st.text(
+    alphabet=st.characters(min_codepoint=ord("a"), max_codepoint=ord("z")),
+    min_size=1,
+    max_size=15,
+)
+
+_EFFECTS_STRATEGY = st.lists(
+    st.sampled_from(list(Effect)),
+    min_size=1,
+    max_size=6,
+).map(tuple)
+
+_POSTURES_STRATEGY = st.one_of(
+    st.none(),
+    st.lists(
+        st.sampled_from(list(Posture)),
+        min_size=1,
+        max_size=4,
+    ).map(tuple),
+)
+
+
+@st.composite
+def _tool_definition_strategy(draw: st.DrawFn, name: str) -> ToolDefinition:
+    return ToolDefinition(
+        name=name,
+        description=draw(st.one_of(st.none(), st.text(max_size=30))),
+        effects=draw(_EFFECTS_STRATEGY),
+        permitted_postures=draw(_POSTURES_STRATEGY),
+        require_confirmation=draw(st.booleans()),
+    )
+
+
+@st.composite
+def _manifest_strategy(draw: st.DrawFn) -> Manifest:
+    names = draw(st.lists(_NAME_STRATEGY, min_size=1, max_size=5, unique=True))
+    tools = {name: draw(_tool_definition_strategy(name=name)) for name in names}
+    return Manifest(tools=tools)
+
+
+@_HYPOTHESIS_THOROUGH
+@given(manifest=_manifest_strategy())
+def test_classify_is_deterministic_property(manifest: Manifest) -> None:
+    """classify(call, manifest) returns the same Decision on every call."""
+    for tool_name in manifest.tools:
+        call = ToolCall(tool=tool_name)
+        first = classify(call, manifest)
+        second = classify(call, manifest)
+        assert first == second
+
+
+@_HYPOTHESIS_THOROUGH
+@given(manifest=_manifest_strategy())
+def test_classify_dominant_is_in_effects_property(manifest: Manifest) -> None:
+    """The Decision's most_restrictive is always a member of its effects."""
+    for tool_name in manifest.tools:
+        decision = classify(ToolCall(tool=tool_name), manifest)
+        assert decision.most_restrictive in decision.effects
+
+
+@_HYPOTHESIS_THOROUGH
+@given(manifest=_manifest_strategy())
+def test_classify_effects_match_manifest_definition(manifest: Manifest) -> None:
+    """The Decision's effects are exactly the manifest's declared effects."""
+    for tool_name, definition in manifest.tools.items():
+        decision = classify(ToolCall(tool=tool_name), manifest)
+        assert decision.effects == definition.effects
+
+
+@_HYPOTHESIS_THOROUGH
+@given(manifest=_manifest_strategy())
+def test_classify_rationale_is_byte_stable_property(manifest: Manifest) -> None:
+    """Identical inputs produce byte-identical rationale strings."""
+    for tool_name in manifest.tools:
+        call = ToolCall(tool=tool_name)
+        a = classify(call, manifest).rationale
+        b = classify(call, manifest).rationale
+        assert a == b
+
+
+@_HYPOTHESIS_THOROUGH
+@given(manifest=_manifest_strategy())
+def test_classify_stable_across_manifest_round_trip(manifest: Manifest) -> None:
+    """Manifest → JSON → Manifest produces identical decisions for every tool."""
+    re_parsed = parse_manifest(manifest.model_dump_json())
+    for tool_name in manifest.tools:
+        call = ToolCall(tool=tool_name)
+        original = classify(call, manifest)
+        replayed = classify(call, re_parsed)
+        assert original == replayed
+
+
+@_HYPOTHESIS_THOROUGH
+@given(
+    manifest=_manifest_strategy(),
+    arg_payload=st.dictionaries(
+        st.text(min_size=1, max_size=10),
+        st.text(max_size=20),
+        max_size=5,
+    ),
+)
+def test_classify_ignores_arguments_property(
+    manifest: Manifest,
+    arg_payload: dict[str, str],
+) -> None:
+    """Phase 2: arguments are stored on ToolCall but don't influence classification."""
+    for tool_name in manifest.tools:
+        no_args = classify(ToolCall(tool=tool_name), manifest)
+        with_args = classify(ToolCall(tool=tool_name, arguments=arg_payload), manifest)
+        assert no_args.effects == with_args.effects
+        assert no_args.most_restrictive == with_args.most_restrictive