pollard-jev 0.1__py3-none-any.whl

pollard_jev/__init__.py

@@ -0,0 +1,3 @@
+"""Typed decisions with Pollard execution governance. Simulation only."""
+
+__version__ = "0.1"

pollard_jev/__main__.py

@@ -0,0 +1,3 @@
+from .demo import main
+
+main()

pollard_jev/contracts.py

@@ -0,0 +1,223 @@
+"""Versioned JSON contracts. Scores describe evidence, never physical success."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Annotated, Literal
+
+from pydantic import (
+    AwareDatetime, BaseModel, ConfigDict, Field, StrictBool, StrictInt,
+    StrictStr, field_validator, model_validator,
+)
+
+Name = Annotated[str, Field(min_length=1, max_length=200)]
+Number = Annotated[float, Field(strict=True, allow_inf_nan=False)]
+Score = Annotated[float, Field(strict=True, ge=0, le=1, allow_inf_nan=False)]
+
+
+class Contract(BaseModel):
+    model_config = ConfigDict(extra="forbid", frozen=True, allow_inf_nan=False)
+
+
+class Observation(Contract):
+    observation_id: Name
+    source: Name
+    feature: Name
+    value: Number | None
+    unit: Name
+    observed_at: AwareDatetime
+    valid_until: AwareDatetime
+    status: Literal["known", "unknown"] = "known"
+
+    @model_validator(mode="after")
+    def valid_observation(self):
+        if self.valid_until <= self.observed_at:
+            raise ValueError("valid_until must follow observed_at")
+        if (self.status == "known") != (self.value is not None):
+            raise ValueError("known observations require a value; unknown ones require None")
+        return self
+
+
+class ActionChoice(Contract):
+    name: Name
+    hypothesis: Annotated[str, Field(min_length=1, max_length=4000)]
+    parameters: dict[str, StrictInt] = Field(default_factory=dict)
+
+
+class DecisionRequest(Contract):
+    request_id: Name
+    question: Annotated[str, Field(min_length=1, max_length=8000)]
+    created_at: AwareDatetime
+    valid_until: AwareDatetime
+    observations: tuple[Observation, ...]
+    choices: Annotated[tuple[ActionChoice, ...], Field(min_length=1)]
+
+    @model_validator(mode="after")
+    def valid_request(self):
+        if self.valid_until <= self.created_at:
+            raise ValueError("request validity must be positive")
+        names = [choice.name for choice in self.choices]
+        ids = [obs.observation_id for obs in self.observations]
+        if len(names) != len(set(names)) or len(ids) != len(set(ids)):
+            raise ValueError("choice names and observation IDs must be unique")
+        return self
+
+
+class ProviderIdentity(Contract):
+    provider: Name
+    provider_version: Name
+    model: Name
+    model_version: Name
+    synthetic: StrictBool
+    settings: dict[str, Number | StrictStr | StrictBool] = Field(default_factory=dict)
+
+
+class NLIScores(Contract):
+    contradiction: Score
+    entailment: Score
+    neutral: Score
+
+    @model_validator(mode="after")
+    def distribution(self):
+        if abs(self.contradiction + self.entailment + self.neutral - 1) > 1e-5:
+            raise ValueError("NLI labels must form a distribution for each hypothesis")
+        return self
+
+
+class ProviderResult(Contract):
+    request_id: Name
+    identity: ProviderIdentity
+    semantics: Literal["synthetic_support", "independent_entailment", "categorical"]
+    scores: dict[str, Score]
+    proposed_action: Name | None
+    parameters: dict[str, StrictInt] = Field(default_factory=dict)
+    evidence: Literal["sufficient", "insufficient", "unknown", "conflicting"]
+    nli_scores: dict[str, NLIScores] = Field(default_factory=dict)
+
+    @model_validator(mode="after")
+    def valid_scores(self):
+        if self.semantics == "synthetic_support" and not self.identity.synthetic:
+            raise ValueError("synthetic support must have a synthetic provider identity")
+        if self.semantics == "categorical" and self.scores:
+            if abs(sum(self.scores.values()) - 1) > 1e-5:
+                raise ValueError("categorical scores must sum to one")
+        if self.nli_scores:
+            if self.semantics != "independent_entailment" or self.scores.keys() != self.nli_scores.keys():
+                raise ValueError("NLI detail must match independent entailment scores")
+            if any(abs(self.scores[k] - v.entailment) > 1e-6 for k, v in self.nli_scores.items()):
+                raise ValueError("entailment detail disagrees with score")
+        return self
+
+
+class PolicyConfig(Contract):
+    version: Name = "robot-demo-policy-v1"
+    allowlist: tuple[Name, ...] = ("continue", "inspect", "recover", "request_help")
+    acceptance_threshold: Score = 0.8
+    minimum_margin: Score = 0.15
+    required_units: dict[str, str] = Field(default_factory=lambda: {
+        "front_range_m": "m", "camera_clearance_m": "m", "battery_pct": "%", "stuck": "bool",
+    })
+    conflict_tolerance_m: Annotated[float, Field(ge=0, allow_inf_nan=False)] = 0.4
+    minimum_clearance_m: Annotated[float, Field(ge=0, allow_inf_nan=False)] = 0.5
+    minimum_battery_pct: Annotated[float, Field(ge=0, le=100, allow_inf_nan=False)] = 10.0
+
+    @field_validator("required_units")
+    @classmethod
+    def fixed_robot_units(cls, units):
+        required = {"front_range_m": "m", "camera_clearance_m": "m", "battery_pct": "%", "stuck": "bool"}
+        if any(units.get(feature) != unit for feature, unit in required.items()):
+            raise ValueError("robot features and their physical units cannot be removed or redefined")
+        if any(not key or not value for key, value in units.items()):
+            raise ValueError("feature and unit labels cannot be empty")
+        return units
+
+
+class PolicyOutcome(Contract):
+    request_id: Name
+    policy_version: Name
+    disposition: Literal["accept", "need_evidence", "defer"]
+    reason: Name
+    evaluated_at: AwareDatetime
+    action: Name | None = None
+    parameters: dict[str, StrictInt] = Field(default_factory=dict)
+
+    @model_validator(mode="after")
+    def accepted_action(self):
+        if (self.disposition == "accept") != (self.action is not None):
+            raise ValueError("only an accepted outcome specifies a dispatchable action")
+        if self.disposition != "accept" and self.parameters:
+            raise ValueError("a deferred outcome cannot specify action parameters")
+        return self
+
+
+class ActionOutcome(Contract):
+    request_id: Name
+    action: Name
+    action_version: Name = "sim-skill-v1"
+    status: Literal["completed", "refused", "failed"]
+    started_at: AwareDatetime
+    completed_at: AwareDatetime
+    simulated: Literal[True] = True
+    parameters: dict[str, StrictInt]
+    observed: dict[str, Number | StrictStr | StrictBool] = Field(default_factory=dict)
+
+    @model_validator(mode="after")
+    def valid_times(self):
+        if self.completed_at < self.started_at:
+            raise ValueError("completion precedes start")
+        return self
+
+
+class DecisionRecord(Contract):
+    schema_version: Literal["1"] = "1"
+    record_id: Name
+    batch_id: Name
+    recorded_at: AwareDatetime
+    request: DecisionRequest
+    provider_identity: ProviderIdentity
+    provider_result: ProviderResult | None
+    provider_status: Literal["ok", "failure", "malformed", "timeout", "cancelled", "budget_exhausted", "busy"]
+    policy_config: PolicyConfig
+    policy: PolicyOutcome
+    action: ActionOutcome | None
+    pollard_version: Name
+    pollard_root_id: Name
+    pollard_model_node_id: Name | None
+    pollard_action_node_id: Name | None
+    budget_limit_requests: Annotated[StrictInt, Field(ge=0)]
+    budget_spent_requests: Annotated[StrictInt, Field(ge=0)]
+    inference_elapsed_s: Annotated[float, Field(ge=0, allow_inf_nan=False)]
+    inference_timeout_s: Annotated[float, Field(gt=0, allow_inf_nan=False)]
+    mode: Literal["decision", "live_reevaluation"] = "decision"
+    reevaluates_record_id: Name | None = None
+
+    @model_validator(mode="after")
+    def linked_record(self):
+        if self.policy.request_id != self.request.request_id or self.policy.policy_version != self.policy_config.version:
+            raise ValueError("policy must match the recorded request and configuration")
+        if (self.provider_status == "ok") != (self.provider_result is not None):
+            raise ValueError("only successful inference has a validated provider result")
+        if self.provider_result is not None and (
+            self.provider_result.request_id != self.request.request_id or self.provider_result.identity != self.provider_identity
+        ):
+            raise ValueError("provider result must match the request and identity")
+        if self.action is not None:
+            if self.action.request_id != self.request.request_id:
+                raise ValueError("action must match the request")
+            if self.action.status == "completed" and (
+                self.policy.disposition != "accept" or self.action.action != self.policy.action
+                or self.action.parameters != self.policy.parameters
+            ):
+                raise ValueError("completed action must match its accepted policy")
+        if self.budget_spent_requests > self.budget_limit_requests:
+            raise ValueError("logical request budget cannot be exceeded")
+        if self.mode == "live_reevaluation" and (self.action is not None or self.reevaluates_record_id is None):
+            raise ValueError("live reevaluation must link a record and cannot dispatch")
+        return self
+
+
+def fresh(request: DecisionRequest, now: datetime) -> bool:
+    """All supplied evidence must be valid now; expiry is an exclusive bound."""
+    return request.created_at <= now < request.valid_until and all(
+        obs.observed_at <= now < obs.valid_until for obs in request.observations
+    )

pollard_jev/demo.py

@@ -0,0 +1,101 @@
+"""Credential-free offline scenarios and read-only record commands."""
+
+from __future__ import annotations
+
+import argparse
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from uuid import uuid4
+
+from .contracts import DecisionRequest, Observation
+from .loop import DecisionLoop
+from .providers.fixture import FixtureProvider
+from .records import inspect_history, simulate_policy
+from .simulator import baseline, default_choices
+
+
+def example_request(
+    now: datetime, *, request_id: str = "example", conflict: bool = False, missing: bool = False,
+) -> DecisionRequest:
+    values = {"front_range_m": (1.5, "m"), "camera_clearance_m": (0.2 if conflict else 1.4, "m"),
+              "battery_pct": (75.0, "%"), "stuck": (0.0, "bool")}
+    observations = tuple(Observation(
+        observation_id=f"{request_id}-{feature}", source="synthetic-sensors-v1", feature=feature,
+        value=value, unit=unit, observed_at=now, valid_until=now + timedelta(seconds=30),
+    ) for feature, (value, unit) in values.items() if not (missing and feature == "front_range_m"))
+    return DecisionRequest(
+        request_id=request_id, question="Which bounded supervisory skill should the mobile robot run next?",
+        created_at=now, valid_until=now + timedelta(seconds=30), observations=observations, choices=default_choices(),
+    )
+
+
+class ScenarioClock:
+    def __init__(self):
+        self.now = datetime.now(timezone.utc)
+
+    def __call__(self):
+        return self.now
+
+
+class ExpiringFixture(FixtureProvider):
+    def __init__(self, clock):
+        super().__init__()
+        self.clock = clock
+
+    def infer(self, requests):
+        results = super().infer(requests)
+        # Deterministic virtual passage of time during inference; no timing race.
+        self.clock.now += timedelta(seconds=31)
+        return results
+
+
+def run_demo(output: Path) -> tuple:
+    output.mkdir(parents=True, exist_ok=True)
+    run_id = uuid4().hex[:12]
+    records_path = output / f"decisions-{run_id}.jsonl"
+    pollard_path = output / f"pollard-{run_id}.db"
+    records = []
+    print("Offline mobile-robot supervisor | SYNTHETIC scores | SIMULATED actions")
+    print("Demonstration thresholds: support >= 0.80; top-score margin >= 0.15")
+    print("Budget unit: one logical provider batch attempt (not tokens or joules)")
+    print(f"{'scenario':<27} {'proposal':<14} {'policy':<15} {'baseline':<15} result")
+    for name in ("fresh_coherent", "conflicting_observations", "missing_evidence", "stale_during_inference", "exhausted_budget", "provider_failure"):
+        clock = ScenarioClock()
+        request = example_request(clock(), request_id=name, conflict=name == "conflicting_observations", missing=name == "missing_evidence")
+        provider = ExpiringFixture(clock) if name == "stale_during_inference" else FixtureProvider(failure=name == "provider_failure")
+        with DecisionLoop(
+            provider, max_requests=0 if name == "exhausted_budget" else 1, clock=clock,
+            records_path=records_path, pollard_path=pollard_path,
+        ) as loop:
+            record = loop.decide(request)
+        records.append(record)
+        proposal = record.provider_result.proposed_action if record.provider_result else "(none)"
+        baseline_action = baseline(request, record.policy.evaluated_at)
+        result = f"simulated {record.action.action}" if record.action and record.action.status == "completed" else record.policy.reason
+        print(f"{name:<27} {proposal:<14} {record.policy.disposition:<15} {baseline_action:<15} {result}")
+    print(f"Records: {records_path.resolve()}")
+    print(f"Pollard ledger: {pollard_path.resolve()}")
+    return tuple(records)
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__)
+    commands = parser.add_subparsers(dest="command", required=True)
+    demo = commands.add_parser("demo", help="run all six offline scenarios")
+    demo.add_argument("--output", type=Path, default=Path("artifacts"))
+    for name in ("history", "simulate-policy"):
+        command = commands.add_parser(name)
+        command.add_argument("records", type=Path)
+    args = parser.parse_args(argv)
+    if args.command == "demo":
+        run_demo(args.output)
+    elif args.command == "history":
+        for record in inspect_history(args.records):
+            print(record.model_dump_json())
+    else:
+        for record in inspect_history(args.records):
+            print(simulate_policy(record).model_dump_json())
+
+
+if __name__ == "__main__":
+    main()

pollard_jev/loop.py

@@ -0,0 +1,283 @@
+"""Pollard-backed supervisory loop; inference workers can only return data."""
+
+from __future__ import annotations
+
+import json
+import math
+import queue
+import threading
+import time
+from datetime import datetime, timezone
+from importlib.metadata import version
+from pathlib import Path
+from typing import Callable
+from uuid import uuid4
+
+from pollard import ActionSpec, Budget, Registry, Runtime
+from pollard.errors import BudgetExceeded, PolicyViolation
+
+from .contracts import ActionOutcome, DecisionRecord, DecisionRequest, PolicyConfig, ProviderIdentity, ProviderResult, fresh
+from .policy import DecisionPolicy
+from .providers.base import DecisionProvider
+from .records import RecordStore
+from .simulator import RobotSimulator, SKILL_PARAMETERS
+
+
+def utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def canonical_json(value) -> str:
+    # Pollard identities prohibit float JSON values. A canonical JSON *string*
+    # preserves numeric precision and full typed inputs without inventing an API.
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False)
+
+
+class RequestMeter:
+    """One logical provider batch attempt, including failure/timeout, costs one."""
+    name = "requests"
+
+    def precheck_estimate(self, node_kind, payload):
+        return int(node_kind == "model_call")
+
+    def charge(self, node_kind, payload, result, meta):
+        return int(node_kind == "model_call")
+
+
+class DecisionLoop:
+    def __init__(
+        self, provider: DecisionProvider, *, max_requests: int = 10,
+        timeout_s: float = 1.0, policy: PolicyConfig | None = None,
+        simulator: RobotSimulator | None = None, records_path: str | Path | None = None,
+        pollard_path: str | Path | None = None, clock: Callable[[], datetime] = utc_now,
+    ):
+        if type(max_requests) is not int or max_requests < 0:
+            raise ValueError("max_requests must be a nonnegative integer")
+        if isinstance(timeout_s, bool) or not math.isfinite(timeout_s) or timeout_s <= 0:
+            raise ValueError("timeout_s must be positive and finite")
+        self.provider = provider
+        self.identity = ProviderIdentity.model_validate(provider.identity.model_dump())
+        self.policy = DecisionPolicy(policy)
+        self.simulator = simulator or RobotSimulator()
+        self.max_requests, self.timeout_s, self.clock = max_requests, timeout_s, clock
+        self.records = RecordStore(records_path) if records_path is not None else None
+        self._lock = threading.Lock()
+        self._worker: threading.Thread | None = None
+        self._dispatch_context = None
+        self._closed = False
+        self._registry = Registry([
+            ActionSpec(
+                name, "sim-skill-v1", "Bounded simulated robot skill",
+                {"type": "object", "properties": {
+                    key: {"type": "integer", "minimum": lo, "maximum": hi}
+                    for key, (lo, hi) in bounds.items()
+                }, "required": list(bounds), "additionalProperties": False},
+                True, handler=self._handler(name),
+            ) for name, bounds in SKILL_PARAMETERS.items() if name in self.policy.config.allowlist
+        ])
+        if pollard_path is not None:
+            Path(pollard_path).parent.mkdir(parents=True, exist_ok=True)
+        self.runtime = Runtime(pollard_path, meters=[RequestMeter()], registry=self._registry,
+                               refuse_duplicate_recordings=True)
+        self.run = self.runtime.run("pollard-jev-" + uuid4().hex, budget=Budget(extra={"requests": max_requests}))
+        self.run.note({"configuration_json": canonical_json({
+            "policy": self.policy.config.model_dump(mode="json"),
+            "provider": self.identity.model_dump(mode="json"),
+            "max_requests": max_requests, "timeout_s": timeout_s,
+            "budget_unit": "logical_provider_batch_attempts", "simulator": "sim-skill-v1",
+        })})
+
+    @property
+    def spent_requests(self) -> int:
+        return int(self.run.report()["spent"].get("requests", 0))
+
+    def _handler(self, action):
+        def handle(parameters):
+            # This guard is inside the registered callable, after Pollard's own
+            # schema/budget gate, immediately before the simulator is invoked.
+            context = self._dispatch_context
+            if context is None:
+                return {"status": "refused", "reason": "no_dispatch_context"}
+            request, result, cancel, deadline = context
+            now = self.clock()
+            if cancel.is_set():
+                return {"status": "refused", "reason": "cancelled"}
+            if time.monotonic() >= deadline:
+                return {"status": "refused", "reason": "timeout"}
+            check = self.policy.evaluate(request, result, now)
+            if check.disposition != "accept" or check.action != action or check.parameters != parameters:
+                return {"status": "refused", "reason": check.reason}
+            # Validation itself can consume time. Check the cheap mutable gates
+            # again at the actual dispatch boundary, including wall-clock expiry.
+            now = self.clock()
+            if cancel.is_set():
+                return {"status": "refused", "reason": "cancelled"}
+            if time.monotonic() >= deadline:
+                return {"status": "refused", "reason": "timeout"}
+            if not fresh(request, now):
+                return {"status": "refused", "reason": "stale_or_future_evidence"}
+            try:
+                outcome = self.simulator.execute(request.request_id, action, parameters, now)
+                return {"status": "completed", "outcome": outcome.model_dump(mode="json")}
+            except Exception:
+                # Never persist exception strings, which can contain credentials.
+                return {"status": "failed", "reason": "simulator_failure"}
+        return handle
+
+    def _infer(self, requests, cancel, deadline):
+        replies = queue.Queue(maxsize=1)
+        provider = self.provider
+        # Pass a detached validated copy so a provider cannot mutate policy inputs.
+        inputs = tuple(DecisionRequest.model_validate(r.model_dump()) for r in requests)
+
+        def work():
+            try:
+                output = provider.infer(inputs)
+            except Exception:
+                replies.put(("failure", None))
+                return
+            try:
+                if not isinstance(output, (tuple, list)) or len(output) != len(requests):
+                    raise ValueError("wrong batch shape")
+                results = tuple(ProviderResult.model_validate(
+                    item.model_dump() if isinstance(item, ProviderResult) else item
+                ) for item in output)
+                if [r.request_id for r in results] != [r.request_id for r in requests]:
+                    raise ValueError("wrong request IDs/order")
+                if any(r.identity != self.identity for r in results):
+                    raise ValueError("wrong provider identity")
+                replies.put(("ok", [r.model_dump(mode="json") for r in results]))
+            except Exception:
+                # Malformed raw output is deliberately not stored.
+                replies.put(("malformed", None))
+
+        self._worker = threading.Thread(target=work, daemon=True, name="pollard-jev-inference")
+        self._worker.start()
+        while True:
+            if cancel.is_set():
+                return {"status": "cancelled", "results": None}
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                return {"status": "timeout", "results": None}
+            try:
+                status, result = replies.get(timeout=min(remaining, 0.01))
+            except queue.Empty:
+                continue
+            # A queued reply may itself have arrived too late.
+            if cancel.is_set():
+                return {"status": "cancelled", "results": None}
+            if time.monotonic() >= deadline:
+                return {"status": "timeout", "results": None}
+            return {"status": status, "results": result}
+
+    def decide(self, request: DecisionRequest, *, cancel: threading.Event | None = None) -> DecisionRecord:
+        return self.decide_batch((request,), cancel=cancel)[0]
+
+    def decide_batch(
+        self, requests: tuple[DecisionRequest, ...], *, cancel: threading.Event | None = None,
+        dispatch: bool = True, mode: str = "decision", reevaluates_record_id: str | None = None,
+    ) -> tuple[DecisionRecord, ...]:
+        if mode not in ("decision", "live_reevaluation"):
+            raise ValueError("invalid record mode")
+        if mode == "live_reevaluation" and dispatch:
+            raise ValueError("live reevaluation must disable dispatch")
+        if mode == "live_reevaluation" and not reevaluates_record_id:
+            raise ValueError("live reevaluation must reference a historical record")
+        requests = tuple(DecisionRequest.model_validate(r.model_dump()) for r in requests)
+        if not requests or len({r.request_id for r in requests}) != len(requests):
+            raise ValueError("a batch requires distinct request IDs")
+        cancel = cancel if cancel is not None else threading.Event()
+        with self._lock:
+            if self._closed:
+                raise RuntimeError("decision loop is closed")
+            batch_id = uuid4().hex
+            started = time.monotonic()
+            deadline = started + self.timeout_s
+            node_id = None
+            if cancel.is_set():
+                envelope = {"status": "cancelled", "results": None}
+            elif self._worker is not None and self._worker.is_alive():
+                # A timed-out native call may still be working. Bound this loop
+                # to one worker rather than accumulating abandoned inference.
+                envelope = {"status": "busy", "results": None}
+            else:
+                try:
+                    node = self.run.model_call(
+                        {"batch_id": batch_id, "requests_json": canonical_json([r.model_dump(mode="json") for r in requests]),
+                         "provider_json": canonical_json(self.identity.model_dump(mode="json"))},
+                        fn=lambda _: self._infer(requests, cancel, deadline),
+                    )
+                    node_id, envelope = node.id, node.result
+                except BudgetExceeded as exc:
+                    node_id = exc.refusal_id
+                    envelope = {"status": "budget_exhausted", "results": None}
+            elapsed = time.monotonic() - started
+            status = envelope["status"]
+            results = envelope["results"] or [None] * len(requests)
+            records = []
+            did_dispatch = False
+            for request, raw in zip(requests, results, strict=True):
+                result = ProviderResult.model_validate(raw) if raw is not None else None
+                now = self.clock()
+                outcome = self.policy.evaluate(request, result, now) if status == "ok" else self.policy.outcome(request, now, "defer", status)
+                if cancel.is_set():
+                    outcome = self.policy.outcome(request, now, "defer", "cancelled")
+                elif status == "ok" and time.monotonic() >= deadline:
+                    outcome = self.policy.outcome(request, now, "defer", "timeout")
+                action = None
+                action_node_id = None
+                if outcome.disposition == "accept" and dispatch:
+                    if did_dispatch:
+                        outcome = self.policy.outcome(request, now, "defer", "batch_requires_new_observation")
+                    else:
+                        self.run.note({"dispatch_intent_json": outcome.model_dump_json()})
+                        self._dispatch_context = (request, result, cancel, deadline)
+                        # A failed response cannot prove that the first action
+                        # had no effect. Permit at most one attempt per batch.
+                        did_dispatch = True
+                        try:
+                            action_node = self.run.tool_call(outcome.action, outcome.parameters, version="sim-skill-v1")
+                            action_node_id = action_node.id
+                            if action_node.result["status"] == "completed":
+                                action = ActionOutcome.model_validate(action_node.result["outcome"])
+                            else:
+                                outcome = self.policy.outcome(request, self.clock(), "defer", action_node.result["reason"])
+                                action = ActionOutcome(
+                                    request_id=request.request_id, action=result.proposed_action,
+                                    status=action_node.result["status"], started_at=now, completed_at=self.clock(),
+                                    parameters=result.parameters,
+                                )
+                        except (PolicyViolation, BudgetExceeded) as exc:
+                            action_node_id = exc.refusal_id
+                            outcome = self.policy.outcome(request, self.clock(), "defer", "pollard_refusal")
+                        finally:
+                            self._dispatch_context = None
+                record = DecisionRecord(
+                    record_id=uuid4().hex, batch_id=batch_id, recorded_at=self.clock(), request=request,
+                    provider_identity=self.identity, provider_result=result, provider_status=status,
+                    policy_config=self.policy.config, policy=outcome, action=action,
+                    pollard_version=version("pollard"), pollard_root_id=self.run.root_id,
+                    pollard_model_node_id=node_id, pollard_action_node_id=action_node_id,
+                    budget_limit_requests=self.max_requests, budget_spent_requests=self.spent_requests,
+                    inference_elapsed_s=elapsed, inference_timeout_s=self.timeout_s,
+                    mode=mode, reevaluates_record_id=reevaluates_record_id,
+                )
+                self.run.note({"decision_record_json": record.model_dump_json()})
+                if self.records is not None:
+                    self.records.append(record)
+                records.append(record)
+            return tuple(records)
+
+    def close(self):
+        with self._lock:
+            if not self._closed:
+                close = getattr(self.runtime.store, "close", None)
+                if close is not None:
+                    close()
+                self._closed = True
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self.close()