jep-authority-runtime 0.1.1__tar.gz

jep_authority_runtime-0.1.1/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: jep-authority-runtime
+Version: 0.1.1
+Summary: Reference runtime for JEP-compatible authority scope semantics.
+Author: JEP Authority Runtime contributors
+License: MIT
+Keywords: jep,authority,delegation,attenuation,replay
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# jep-authority-runtime
+
+Reference runtime for JEP authority scope, delegation boundaries, attenuation, revocation, and replay verification.
+
+This project is intentionally **not** real IAM and does not replace OAuth, X.509, DID, or any production authorization protocol. It is a small JEP-compatible reference runtime for making delegation semantics replayable and verifiable.
+
+## AuthorityScope
+
+`AuthorityScope` models the authority passed along a delegation chain:
+
+- `actor`: principal that issued the scope.
+- `subject`: principal receiving the scope.
+- `allowed_actions`: actions the subject may perform.
+- `denied_actions`: actions explicitly forbidden and inherited by descendants.
+- `resource_scope`: resource prefix the scope applies to (`*` means every resource).
+- `expires_at`: optional UTC expiration timestamp.
+- `parent_scope`: optional parent scope id for delegated or attenuated authority.
+- `attenuation_rules`: reference metadata describing how authority was narrowed.
+
+The runtime also stores `scope_id` and `revoked_at` so archives can refer to scopes deterministically and model revocation.
+
+## DelegationRuntime
+
+`DelegationRuntime` provides:
+
+- `create_scope()` for root authority grants.
+- `delegate_scope()` for child scopes that must be narrower than their parent.
+- `attenuate_scope()` as a convenience wrapper for narrower delegation.
+- `revoke_scope()` to invalidate a scope and its descendants for later checks.
+- `verify_scope()` to check action, resource, expiration, revocation, and chain validity.
+- `verify_delegation_path()` to check parent continuity and attenuation constraints.
+
+A child scope is valid only when it does not add actions, omit inherited denials, widen resources, outlive its parent, or rely on a missing/revoked/expired parent.
+
+## Replay archive format
+
+Archives are JSON Lines (`archive.jsonl`). Each line is an event with an `event` field:
+
+```json
+{"event":"create_scope","scope_id":"human-search","actor":"human:alice","subject":"agent:searcher","allowed_actions":["search"],"denied_actions":["payment"],"resource_scope":"web/search","expires_at":"2030-01-01T00:00:00Z"}
+{"event":"delegate_scope","scope_id":"agent-news","parent_scope":"human-search","actor":"agent:searcher","subject":"agent:sub-searcher","allowed_actions":["search"],"resource_scope":"web/search/news"}
+{"event":"action","scope_id":"agent-news","action":"search","resource":"web/search/news/politics","at":"2028-01-01T00:00:00Z"}
+{"event":"revoke_scope","scope_id":"human-search","revoked_at":"2028-06-01T00:00:00Z"}
+```
+
+Replay checks whether propagation or actions are invalid because authority is exceeded, a scope is expired, a scope or ancestor is revoked, a child exceeds the parent scope, or the delegation chain is broken.
+
+## CLI
+
+Install in editable mode:
+
+```sh
+python -m pip install -e .
+```
+
+Replay an archive:
+
+```sh
+jep-authority replay examples/archive.jsonl
+```
+
+Verify an archive and emit JSON:
+
+```sh
+jep-authority verify examples/archive.jsonl --json
+```
+
+Both commands exit with status `0` when the report has no violations and `1` when violations are found.
+
+## Example scenario
+
+`examples/archive.jsonl` demonstrates:
+
+1. A human delegates limited `search` permission to an agent.
+2. The agent delegates narrower `web/search/news` permission to a sub-agent.
+3. The sub-agent performs an allowed search.
+4. The sub-agent attempts a forbidden `payment` action.
+5. Revocation of the parent invalidates a later delegated action.

jep_authority_runtime-0.1.1/README.md

@@ -0,0 +1,78 @@
+# jep-authority-runtime
+
+Reference runtime for JEP authority scope, delegation boundaries, attenuation, revocation, and replay verification.
+
+This project is intentionally **not** real IAM and does not replace OAuth, X.509, DID, or any production authorization protocol. It is a small JEP-compatible reference runtime for making delegation semantics replayable and verifiable.
+
+## AuthorityScope
+
+`AuthorityScope` models the authority passed along a delegation chain:
+
+- `actor`: principal that issued the scope.
+- `subject`: principal receiving the scope.
+- `allowed_actions`: actions the subject may perform.
+- `denied_actions`: actions explicitly forbidden and inherited by descendants.
+- `resource_scope`: resource prefix the scope applies to (`*` means every resource).
+- `expires_at`: optional UTC expiration timestamp.
+- `parent_scope`: optional parent scope id for delegated or attenuated authority.
+- `attenuation_rules`: reference metadata describing how authority was narrowed.
+
+The runtime also stores `scope_id` and `revoked_at` so archives can refer to scopes deterministically and model revocation.
+
+## DelegationRuntime
+
+`DelegationRuntime` provides:
+
+- `create_scope()` for root authority grants.
+- `delegate_scope()` for child scopes that must be narrower than their parent.
+- `attenuate_scope()` as a convenience wrapper for narrower delegation.
+- `revoke_scope()` to invalidate a scope and its descendants for later checks.
+- `verify_scope()` to check action, resource, expiration, revocation, and chain validity.
+- `verify_delegation_path()` to check parent continuity and attenuation constraints.
+
+A child scope is valid only when it does not add actions, omit inherited denials, widen resources, outlive its parent, or rely on a missing/revoked/expired parent.
+
+## Replay archive format
+
+Archives are JSON Lines (`archive.jsonl`). Each line is an event with an `event` field:
+
+```json
+{"event":"create_scope","scope_id":"human-search","actor":"human:alice","subject":"agent:searcher","allowed_actions":["search"],"denied_actions":["payment"],"resource_scope":"web/search","expires_at":"2030-01-01T00:00:00Z"}
+{"event":"delegate_scope","scope_id":"agent-news","parent_scope":"human-search","actor":"agent:searcher","subject":"agent:sub-searcher","allowed_actions":["search"],"resource_scope":"web/search/news"}
+{"event":"action","scope_id":"agent-news","action":"search","resource":"web/search/news/politics","at":"2028-01-01T00:00:00Z"}
+{"event":"revoke_scope","scope_id":"human-search","revoked_at":"2028-06-01T00:00:00Z"}
+```
+
+Replay checks whether propagation or actions are invalid because authority is exceeded, a scope is expired, a scope or ancestor is revoked, a child exceeds the parent scope, or the delegation chain is broken.
+
+## CLI
+
+Install in editable mode:
+
+```sh
+python -m pip install -e .
+```
+
+Replay an archive:
+
+```sh
+jep-authority replay examples/archive.jsonl
+```
+
+Verify an archive and emit JSON:
+
+```sh
+jep-authority verify examples/archive.jsonl --json
+```
+
+Both commands exit with status `0` when the report has no violations and `1` when violations are found.
+
+## Example scenario
+
+`examples/archive.jsonl` demonstrates:
+
+1. A human delegates limited `search` permission to an agent.
+2. The agent delegates narrower `web/search/news` permission to a sub-agent.
+3. The sub-agent performs an allowed search.
+4. The sub-agent attempts a forbidden `payment` action.
+5. Revocation of the parent invalidates a later delegated action.

jep_authority_runtime-0.1.1/jep_authority/__init__.py

@@ -0,0 +1,19 @@
+"""JEP-compatible authority semantics reference runtime."""
+
+from .runtime import (
+    AuthorityScope,
+    DelegationRuntime,
+    ReplayEvent,
+    ReplayReport,
+    ReplayViolation,
+    replay_archive,
+)
+
+__all__ = [
+    "AuthorityScope",
+    "DelegationRuntime",
+    "ReplayEvent",
+    "ReplayReport",
+    "ReplayViolation",
+    "replay_archive",
+]

jep_authority_runtime-0.1.1/jep_authority/cli.py

@@ -0,0 +1,43 @@
+"""Command-line interface for the JEP authority reference runtime."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from .runtime import replay_archive
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="jep-authority",
+        description="Replay and verify JEP-compatible authority semantics archives.",
+    )
+    subcommands = parser.add_subparsers(dest="command", required=True)
+    for command in ("replay", "verify"):
+        subparser = subcommands.add_parser(command, help=f"{command} archive.jsonl")
+        subparser.add_argument("archive", help="Path to a JSON Lines authority archive")
+        subparser.add_argument(
+            "--json",
+            action="store_true",
+            help="Emit a machine-readable JSON report",
+        )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    report = replay_archive(args.archive, verify_only=args.command == "verify")
+    if args.json:
+        print(json.dumps(report.to_dict(), indent=2, sort_keys=True))
+    else:
+        status = "ok" if report.ok else "violations"
+        print(f"{args.command}: {status} ({report.events} events)")
+        for violation in report.violations:
+            print(f"line {violation.line}: {violation.event}: {violation.reason}")
+    return 0 if report.ok else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

jep_authority_runtime-0.1.1/jep_authority/runtime.py

@@ -0,0 +1,420 @@
+"""Reference authority semantics for JEP delegation archives.
+
+This module intentionally does not implement real IAM and does not replace
+OAuth, X.509, DID, or any production identity/security protocol.  It provides a
+small deterministic runtime for checking JEP-compatible authority propagation:
+allowed/denied actions, resource attenuation, expiration, revocation, and
+parent-chain continuity.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+import json
+import re
+from pathlib import Path
+from typing import Any, Iterable, Mapping
+from uuid import uuid4
+
+ISO_FORMAT = "%Y-%m-%dT%H:%M:%SZ"
+
+
+class AuthorityError(ValueError):
+    """Raised when an authority operation violates scope semantics."""
+
+
+def _utc_now() -> datetime:
+    return datetime.now(timezone.utc).replace(microsecond=0)
+
+
+def parse_time(value: str | datetime | None) -> datetime | None:
+    """Parse UTC-ish timestamps accepted by archive events."""
+    if value is None or isinstance(value, datetime):
+        return value
+    normalized = value.strip()
+    if normalized.endswith("Z"):
+        normalized = normalized[:-1] + "+00:00"
+    parsed = datetime.fromisoformat(normalized)
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=timezone.utc)
+    return parsed.astimezone(timezone.utc).replace(microsecond=0)
+
+
+def format_time(value: datetime | None) -> str | None:
+    """Format timestamps as stable UTC strings."""
+    if value is None:
+        return None
+    return value.astimezone(timezone.utc).strftime(ISO_FORMAT)
+
+
+def _as_set(values: Iterable[str] | None) -> set[str]:
+    return set(values or [])
+
+
+def _resource_within(child: str, parent: str) -> bool:
+    """Return whether child resource scope is equal to or narrower than parent.
+
+    The reference runtime uses simple prefix resource semantics.  The wildcard
+    "*" grants every resource; otherwise a child resource is in scope when it is
+    equal to the parent resource or is a slash-delimited descendant of it.
+    """
+    if any(not isinstance(value, str) or not value or "\\" in value or any(part in {".", ".."} for part in value.split("/")) or re.search(r"%(?:2e|2f|5c|25)", value, re.I) for value in (child, parent)):
+        return False
+    if parent == "*":
+        return True
+    if child == parent:
+        return True
+    normalized_parent = parent.rstrip("/") + "/"
+    return child.startswith(normalized_parent)
+
+
+@dataclass(slots=True)
+class AuthorityScope:
+    """Delegable authority scope used by the reference runtime."""
+
+    actor: str
+    subject: str
+    allowed_actions: set[str] = field(default_factory=set)
+    denied_actions: set[str] = field(default_factory=set)
+    resource_scope: str = "*"
+    expires_at: datetime | None = None
+    parent_scope: str | None = None
+    attenuation_rules: dict[str, Any] = field(default_factory=dict)
+    scope_id: str = field(default_factory=lambda: f"scope-{uuid4().hex}")
+    revoked_at: datetime | None = None
+
+    def __post_init__(self) -> None:
+        self.allowed_actions = _as_set(self.allowed_actions)
+        self.denied_actions = _as_set(self.denied_actions)
+        self.expires_at = parse_time(self.expires_at)
+        self.revoked_at = parse_time(self.revoked_at)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "scope_id": self.scope_id,
+            "actor": self.actor,
+            "subject": self.subject,
+            "allowed_actions": sorted(self.allowed_actions),
+            "denied_actions": sorted(self.denied_actions),
+            "resource_scope": self.resource_scope,
+            "expires_at": format_time(self.expires_at),
+            "parent_scope": self.parent_scope,
+            "attenuation_rules": self.attenuation_rules,
+            "revoked_at": format_time(self.revoked_at),
+        }
+
+    @classmethod
+    def from_dict(cls, payload: Mapping[str, Any]) -> "AuthorityScope":
+        return cls(
+            scope_id=str(payload.get("scope_id") or f"scope-{uuid4().hex}"),
+            actor=str(payload["actor"]),
+            subject=str(payload["subject"]),
+            allowed_actions=set(payload.get("allowed_actions") or []),
+            denied_actions=set(payload.get("denied_actions") or []),
+            resource_scope=str(payload.get("resource_scope") or "*"),
+            expires_at=parse_time(payload.get("expires_at")),
+            parent_scope=payload.get("parent_scope"),
+            attenuation_rules=dict(payload.get("attenuation_rules") or {}),
+            revoked_at=parse_time(payload.get("revoked_at")),
+        )
+
+    def permits(self, action: str, resource: str, at: datetime | None = None) -> tuple[bool, str]:
+        checked_at = at or _utc_now()
+        if self.revoked_at is not None and checked_at >= self.revoked_at:
+            return False, "scope revoked"
+        if self.expires_at is not None and checked_at >= self.expires_at:
+            return False, "scope expired"
+        if action in self.denied_actions:
+            return False, "action denied"
+        if action not in self.allowed_actions:
+            return False, "action not allowed"
+        if not _resource_within(resource, self.resource_scope):
+            return False, "resource out of scope"
+        return True, "ok"
+
+
+@dataclass(slots=True)
+class VerificationResult:
+    ok: bool
+    reason: str = "ok"
+
+
+class DelegationRuntime:
+    """In-memory authority runtime for scopes, attenuation, and revocation."""
+
+    def __init__(self) -> None:
+        self.scopes: dict[str, AuthorityScope] = {}
+
+    def create_scope(
+        self,
+        *,
+        actor: str,
+        subject: str,
+        allowed_actions: Iterable[str],
+        denied_actions: Iterable[str] | None = None,
+        resource_scope: str = "*",
+        expires_at: str | datetime | None = None,
+        attenuation_rules: Mapping[str, Any] | None = None,
+        scope_id: str | None = None,
+    ) -> AuthorityScope:
+        scope = AuthorityScope(
+            scope_id=scope_id or f"scope-{uuid4().hex}",
+            actor=actor,
+            subject=subject,
+            allowed_actions=set(allowed_actions),
+            denied_actions=set(denied_actions or []),
+            resource_scope=resource_scope,
+            expires_at=parse_time(expires_at),
+            parent_scope=None,
+            attenuation_rules=dict(attenuation_rules or {}),
+        )
+        if scope.scope_id in self.scopes:
+            raise AuthorityError("scope_id already exists")
+        self.scopes[scope.scope_id] = scope
+        return scope
+
+    def delegate_scope(
+        self,
+        *,
+        parent_scope: str,
+        actor: str,
+        subject: str,
+        allowed_actions: Iterable[str] | None = None,
+        denied_actions: Iterable[str] | None = None,
+        resource_scope: str | None = None,
+        expires_at: str | datetime | None = None,
+        attenuation_rules: Mapping[str, Any] | None = None,
+        scope_id: str | None = None,
+        at: str | datetime | None = None,
+    ) -> AuthorityScope:
+        parent = self._require_scope(parent_scope)
+        allowed = set(allowed_actions) if allowed_actions is not None else set(parent.allowed_actions)
+        denied = parent.denied_actions | set(denied_actions or [])
+        child_resource = resource_scope or parent.resource_scope
+        child_expires = parse_time(expires_at) or parent.expires_at
+        child = AuthorityScope(
+            scope_id=scope_id or f"scope-{uuid4().hex}",
+            actor=actor,
+            subject=subject,
+            allowed_actions=allowed,
+            denied_actions=denied,
+            resource_scope=child_resource,
+            expires_at=child_expires,
+            parent_scope=parent.scope_id,
+            attenuation_rules={**parent.attenuation_rules, **dict(attenuation_rules or {})},
+        )
+        result = self.verify_delegation_path(child, at=at)
+        if not result.ok:
+            raise AuthorityError(result.reason)
+        if child.scope_id in self.scopes:
+            raise AuthorityError("scope_id already exists")
+        self.scopes[child.scope_id] = child
+        return child
+
+    def attenuate_scope(self, scope_id: str, **updates: Any) -> AuthorityScope:
+        existing = self._require_scope(scope_id)
+        return self.delegate_scope(
+            parent_scope=scope_id,
+            actor=updates.get("actor", existing.subject),
+            subject=updates["subject"],
+            allowed_actions=updates.get("allowed_actions", existing.allowed_actions),
+            denied_actions=updates.get("denied_actions", set()),
+            resource_scope=updates.get("resource_scope", existing.resource_scope),
+            expires_at=updates.get("expires_at", existing.expires_at),
+            attenuation_rules=updates.get("attenuation_rules", {}),
+            scope_id=updates.get("scope_id"),
+        )
+
+    def revoke_scope(self, scope_id: str, revoked_at: str | datetime | None = None) -> AuthorityScope:
+        scope = self._require_scope(scope_id)
+        revoked = parse_time(revoked_at) or _utc_now()
+        scope.revoked_at = min(scope.revoked_at, revoked) if scope.revoked_at else revoked
+        return scope
+
+    def verify_scope(
+        self,
+        scope_id: str,
+        *,
+        action: str,
+        resource: str,
+        at: str | datetime | None = None,
+    ) -> VerificationResult:
+        scope = self._require_scope(scope_id)
+        ok, reason = scope.permits(action, resource, parse_time(at))
+        if not ok:
+            return VerificationResult(False, reason)
+        path = self.verify_delegation_path(scope, at=parse_time(at))
+        if not path.ok:
+            return path
+        return VerificationResult(True)
+
+    def verify_delegation_path(
+        self,
+        scope_or_id: AuthorityScope | str,
+        *,
+        at: str | datetime | None = None,
+    ) -> VerificationResult:
+        scope = self._require_scope(scope_or_id) if isinstance(scope_or_id, str) else scope_or_id
+        checked_at = parse_time(at) or _utc_now()
+        if scope.revoked_at is not None and checked_at >= scope.revoked_at:
+            return VerificationResult(False, "scope revoked")
+        if scope.expires_at is not None and checked_at >= scope.expires_at:
+            return VerificationResult(False, "scope expired")
+        seen: set[str] = set()
+        child = scope
+        while child.parent_scope is not None:
+            if child.scope_id in seen:
+                return VerificationResult(False, "delegation chain cycle")
+            seen.add(child.scope_id)
+            parent = self.scopes.get(child.parent_scope)
+            if parent is None:
+                return VerificationResult(False, "delegation chain broken")
+            if child.actor != parent.subject:
+                return VerificationResult(False, "delegating actor is not parent subject")
+            if parent.revoked_at is not None and checked_at >= parent.revoked_at:
+                return VerificationResult(False, "parent scope revoked")
+            if parent.expires_at is not None and checked_at >= parent.expires_at:
+                return VerificationResult(False, "parent scope expired")
+            if not child.allowed_actions <= parent.allowed_actions:
+                return VerificationResult(False, "child allows actions outside parent scope")
+            if not parent.denied_actions <= child.denied_actions:
+                return VerificationResult(False, "child omits parent denied actions")
+            if child.allowed_actions & parent.denied_actions:
+                return VerificationResult(False, "child allows parent-denied action")
+            if not _resource_within(child.resource_scope, parent.resource_scope):
+                return VerificationResult(False, "child resource outside parent scope")
+            if parent.expires_at is not None and (child.expires_at is None or child.expires_at > parent.expires_at):
+                return VerificationResult(False, "child expires after parent")
+            child = parent
+        return VerificationResult(True)
+
+    def _require_scope(self, scope_id: str) -> AuthorityScope:
+        try:
+            return self.scopes[scope_id]
+        except KeyError as exc:
+            raise AuthorityError(f"unknown scope: {scope_id}") from exc
+
+
+@dataclass(slots=True)
+class ReplayEvent:
+    line: int
+    event: str
+    payload: dict[str, Any]
+
+
+@dataclass(slots=True)
+class ReplayViolation:
+    line: int
+    event: str
+    reason: str
+    payload: dict[str, Any]
+
+
+@dataclass(slots=True)
+class ReplayReport:
+    ok: bool
+    events: int
+    violations: list[ReplayViolation]
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "ok": self.ok,
+            "events": self.events,
+            "violations": [
+                {
+                    "line": violation.line,
+                    "event": violation.event,
+                    "reason": violation.reason,
+                    "payload": violation.payload,
+                }
+                for violation in self.violations
+            ],
+        }
+
+
+def load_archive(path: str | Path) -> list[ReplayEvent]:
+    events: list[ReplayEvent] = []
+    with Path(path).open("r", encoding="utf-8") as handle:
+        for line_number, raw in enumerate(handle, 1):
+            stripped = raw.strip()
+            if not stripped:
+                continue
+            payload = json.loads(stripped)
+            event = str(payload.get("event") or payload.get("type") or "")
+            events.append(ReplayEvent(line_number, event, payload))
+    return events
+
+
+def replay_archive(path: str | Path, *, verify_only: bool = False) -> ReplayReport:
+    """Replay an archive.jsonl and report authority propagation violations."""
+    runtime = DelegationRuntime()
+    violations: list[ReplayViolation] = []
+    events = load_archive(path)
+
+    for item in events:
+        try:
+            _apply_event(runtime, item, verify_only=verify_only)
+        except (AuthorityError, KeyError, TypeError, ValueError) as exc:
+            violations.append(ReplayViolation(item.line, item.event, str(exc), item.payload))
+
+    return ReplayReport(ok=not violations, events=len(events), violations=violations)
+
+
+def _apply_event(runtime: DelegationRuntime, item: ReplayEvent, *, verify_only: bool) -> None:
+    payload = item.payload
+    event = item.event
+    if event in {"delegate_scope", "attenuate_scope", "action", "verify_scope", "verify_delegation_path"} and not payload.get("at"):
+        raise AuthorityError("archive event requires recorded at timestamp")
+    if event == "revoke_scope" and not (payload.get("revoked_at") or payload.get("at")):
+        raise AuthorityError("archive revocation requires recorded timestamp")
+    if event == "create_scope":
+        runtime.create_scope(
+            scope_id=payload.get("scope_id"),
+            actor=payload["actor"],
+            subject=payload["subject"],
+            allowed_actions=payload.get("allowed_actions") or [],
+            denied_actions=payload.get("denied_actions") or [],
+            resource_scope=payload.get("resource_scope") or "*",
+            expires_at=payload.get("expires_at"),
+            attenuation_rules=payload.get("attenuation_rules") or {},
+        )
+        return
+    if event in {"delegate_scope", "attenuate_scope"}:
+        runtime.delegate_scope(
+            scope_id=payload.get("scope_id"),
+            at=payload["at"],
+            parent_scope=payload["parent_scope"],
+            actor=payload["actor"],
+            subject=payload["subject"],
+            allowed_actions=payload.get("allowed_actions"),
+            denied_actions=payload.get("denied_actions") or [],
+            resource_scope=payload.get("resource_scope"),
+            expires_at=payload.get("expires_at"),
+            attenuation_rules=payload.get("attenuation_rules") or {},
+        )
+        return
+    if event == "revoke_scope":
+        runtime.revoke_scope(payload["scope_id"], payload.get("revoked_at") or payload.get("at"))
+        return
+    if event in {"action", "verify_scope"}:
+        result = runtime.verify_scope(
+            payload["scope_id"],
+            action=payload["action"],
+            resource=payload["resource"],
+            at=payload.get("at"),
+        )
+        expected = payload.get("expect")
+        if expected in {"deny", "denied", False}:
+            if result.ok:
+                raise AuthorityError("expected denial but action was allowed")
+            return
+        if not result.ok:
+            raise AuthorityError(result.reason)
+        return
+    if event == "verify_delegation_path":
+        result = runtime.verify_delegation_path(payload["scope_id"], at=payload.get("at"))
+        if not result.ok:
+            raise AuthorityError(result.reason)
+        return
+    raise AuthorityError(f"unknown event: {event}")

jep_authority_runtime-0.1.1/jep_authority_runtime.egg-info/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: jep-authority-runtime
+Version: 0.1.1
+Summary: Reference runtime for JEP-compatible authority scope semantics.
+Author: JEP Authority Runtime contributors
+License: MIT
+Keywords: jep,authority,delegation,attenuation,replay
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# jep-authority-runtime
+
+Reference runtime for JEP authority scope, delegation boundaries, attenuation, revocation, and replay verification.
+
+This project is intentionally **not** real IAM and does not replace OAuth, X.509, DID, or any production authorization protocol. It is a small JEP-compatible reference runtime for making delegation semantics replayable and verifiable.
+
+## AuthorityScope
+
+`AuthorityScope` models the authority passed along a delegation chain:
+
+- `actor`: principal that issued the scope.
+- `subject`: principal receiving the scope.
+- `allowed_actions`: actions the subject may perform.
+- `denied_actions`: actions explicitly forbidden and inherited by descendants.
+- `resource_scope`: resource prefix the scope applies to (`*` means every resource).
+- `expires_at`: optional UTC expiration timestamp.
+- `parent_scope`: optional parent scope id for delegated or attenuated authority.
+- `attenuation_rules`: reference metadata describing how authority was narrowed.
+
+The runtime also stores `scope_id` and `revoked_at` so archives can refer to scopes deterministically and model revocation.
+
+## DelegationRuntime
+
+`DelegationRuntime` provides:
+
+- `create_scope()` for root authority grants.
+- `delegate_scope()` for child scopes that must be narrower than their parent.
+- `attenuate_scope()` as a convenience wrapper for narrower delegation.
+- `revoke_scope()` to invalidate a scope and its descendants for later checks.
+- `verify_scope()` to check action, resource, expiration, revocation, and chain validity.
+- `verify_delegation_path()` to check parent continuity and attenuation constraints.
+
+A child scope is valid only when it does not add actions, omit inherited denials, widen resources, outlive its parent, or rely on a missing/revoked/expired parent.
+
+## Replay archive format
+
+Archives are JSON Lines (`archive.jsonl`). Each line is an event with an `event` field:
+
+```json
+{"event":"create_scope","scope_id":"human-search","actor":"human:alice","subject":"agent:searcher","allowed_actions":["search"],"denied_actions":["payment"],"resource_scope":"web/search","expires_at":"2030-01-01T00:00:00Z"}
+{"event":"delegate_scope","scope_id":"agent-news","parent_scope":"human-search","actor":"agent:searcher","subject":"agent:sub-searcher","allowed_actions":["search"],"resource_scope":"web/search/news"}
+{"event":"action","scope_id":"agent-news","action":"search","resource":"web/search/news/politics","at":"2028-01-01T00:00:00Z"}
+{"event":"revoke_scope","scope_id":"human-search","revoked_at":"2028-06-01T00:00:00Z"}
+```
+
+Replay checks whether propagation or actions are invalid because authority is exceeded, a scope is expired, a scope or ancestor is revoked, a child exceeds the parent scope, or the delegation chain is broken.
+
+## CLI
+
+Install in editable mode:
+
+```sh
+python -m pip install -e .
+```
+
+Replay an archive:
+
+```sh
+jep-authority replay examples/archive.jsonl
+```
+
+Verify an archive and emit JSON:
+
+```sh
+jep-authority verify examples/archive.jsonl --json
+```
+
+Both commands exit with status `0` when the report has no violations and `1` when violations are found.
+
+## Example scenario
+
+`examples/archive.jsonl` demonstrates:
+
+1. A human delegates limited `search` permission to an agent.
+2. The agent delegates narrower `web/search/news` permission to a sub-agent.
+3. The sub-agent performs an allowed search.
+4. The sub-agent attempts a forbidden `payment` action.
+5. Revocation of the parent invalidates a later delegated action.

jep_authority_runtime-0.1.1/jep_authority_runtime.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+jep_authority/__init__.py
+jep_authority/cli.py
+jep_authority/runtime.py
+jep_authority_runtime.egg-info/PKG-INFO
+jep_authority_runtime.egg-info/SOURCES.txt
+jep_authority_runtime.egg-info/dependency_links.txt
+jep_authority_runtime.egg-info/entry_points.txt
+jep_authority_runtime.egg-info/top_level.txt
+tests/test_hardening.py
+tests/test_resource_bounds.py
+tests/test_runtime.py

jep_authority_runtime-0.1.1/jep_authority_runtime.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jep_authority_runtime-0.1.1/jep_authority_runtime.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jep-authority = jep_authority.cli:main

jep_authority_runtime-0.1.1/jep_authority_runtime.egg-info/top_level.txt

@@ -0,0 +1 @@
+jep_authority

jep_authority_runtime-0.1.1/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "jep-authority-runtime"
+version = "0.1.1"
+description = "Reference runtime for JEP-compatible authority scope semantics."
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [{name = "JEP Authority Runtime contributors"}]
+keywords = ["jep", "authority", "delegation", "attenuation", "replay"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+]
+
+[project.scripts]
+jep-authority = "jep_authority.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["jep_authority*"]

jep_authority_runtime-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

jep_authority_runtime-0.1.1/tests/test_hardening.py

@@ -0,0 +1,27 @@
+import json
+import pytest
+from jep_authority.runtime import AuthorityError, DelegationRuntime, replay_archive
+
+
+def test_actor_binding_and_scope_ids_cannot_be_replaced():
+    runtime = DelegationRuntime()
+    runtime.create_scope(scope_id="root", actor="owner", subject="worker", allowed_actions=["read"])
+    with pytest.raises(AuthorityError, match="parent subject"):
+        runtime.delegate_scope(parent_scope="root", actor="stranger", subject="child")
+    runtime.revoke_scope("root", "2020-01-01T00:00:00Z")
+    with pytest.raises(AuthorityError, match="already exists"):
+        runtime.create_scope(scope_id="root", actor="owner", subject="worker", allowed_actions=["read"])
+
+
+def test_historical_delegation_uses_recorded_time(tmp_path):
+    rows = [
+        {"event": "create_scope", "scope_id": "root", "actor": "owner", "subject": "worker", "allowed_actions": ["read"], "expires_at": "2021-01-01T00:00:00Z"},
+        {"event": "delegate_scope", "scope_id": "child", "parent_scope": "root", "actor": "worker", "subject": "child", "at": "2020-01-01T00:00:00Z"},
+        {"event": "action", "scope_id": "child", "action": "read", "resource": "file", "at": "2020-02-01T00:00:00Z"},
+    ]
+    path = tmp_path / "archive.jsonl"
+    path.write_text("\n".join(map(json.dumps, rows)))
+    assert replay_archive(path).ok
+    rows[-1]["expect"] = "deny"
+    path.write_text("\n".join(map(json.dumps, rows)))
+    assert not replay_archive(path, verify_only=True).ok

jep_authority_runtime-0.1.1/tests/test_resource_bounds.py

@@ -0,0 +1,15 @@
+from datetime import datetime, timezone
+from jep_authority.runtime import AuthorityScope
+
+
+def test_resources_do_not_escape_by_path_traversal():
+    scope = AuthorityScope(actor="a", subject="b", allowed_actions={"read"}, resource_scope="repo/private")
+    for resource in ["repo/private/../public", "repo/private/%2e%2e/public", "repo/private/..\\public", "repo/private2"]:
+        assert not scope.permits("read", resource)[0]
+    assert scope.permits("read", "repo/private/file")[0]
+
+
+def test_expiry_is_exclusive():
+    end = datetime(2026, 1, 1, tzinfo=timezone.utc)
+    scope = AuthorityScope(actor="a", subject="b", allowed_actions={"read"}, expires_at=end)
+    assert not scope.permits("read", "anything", end)[0]

jep_authority_runtime-0.1.1/tests/test_runtime.py

@@ -0,0 +1,92 @@
+from pathlib import Path
+import tempfile
+import unittest
+
+from jep_authority.runtime import AuthorityError, DelegationRuntime, replay_archive
+
+
+class AuthorityRuntimeTests(unittest.TestCase):
+    def test_delegation_and_verification(self):
+        runtime = DelegationRuntime()
+        parent = runtime.create_scope(
+            scope_id="human-search",
+            actor="human:alice",
+            subject="agent:searcher",
+            allowed_actions=["search"],
+            denied_actions=["payment"],
+            resource_scope="web/search",
+            expires_at="2030-01-01T00:00:00Z",
+        )
+        child = runtime.delegate_scope(
+            scope_id="agent-news",
+            parent_scope=parent.scope_id,
+            actor="agent:searcher",
+            subject="agent:sub-searcher",
+            allowed_actions=["search"],
+            resource_scope="web/search/news",
+            expires_at="2029-01-01T00:00:00Z",
+        )
+
+        self.assertTrue(
+            runtime.verify_scope(
+                child.scope_id,
+                action="search",
+                resource="web/search/news/politics",
+                at="2028-01-01T00:00:00Z",
+            ).ok
+        )
+        payment = runtime.verify_scope(
+            child.scope_id,
+            action="payment",
+            resource="payments/card",
+            at="2028-01-01T00:00:00Z",
+        )
+        self.assertFalse(payment.ok)
+        self.assertEqual(payment.reason, "action denied")
+
+    def test_delegate_cannot_exceed_parent_scope(self):
+        runtime = DelegationRuntime()
+        runtime.create_scope(
+            scope_id="parent",
+            actor="human:alice",
+            subject="agent:a",
+            allowed_actions=["search"],
+            resource_scope="web/search",
+        )
+        with self.assertRaisesRegex(AuthorityError, "outside parent"):
+            runtime.delegate_scope(
+                scope_id="child",
+                parent_scope="parent",
+                actor="agent:a",
+                subject="agent:b",
+                allowed_actions=["payment"],
+                resource_scope="web/search",
+            )
+
+    def test_replay_reports_revocation_violation(self):
+        archive = "\n".join(
+            [
+                '{"event":"create_scope","scope_id":"s1","actor":"human","subject":"agent","allowed_actions":["search"],"resource_scope":"web/search"}',
+                '{"event":"revoke_scope","scope_id":"s1","revoked_at":"2028-01-01T00:00:00Z"}',
+                '{"event":"action","scope_id":"s1","action":"search","resource":"web/search/news","at":"2028-01-02T00:00:00Z"}',
+            ]
+        )
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "archive.jsonl"
+            path.write_text(archive, encoding="utf-8")
+            report = replay_archive(path)
+        self.assertFalse(report.ok)
+        self.assertEqual(report.violations[0].reason, "scope revoked")
+
+    def test_replay_reports_broken_chain(self):
+        archive = '{"event":"delegate_scope","at":"2025-01-01T00:00:00Z","scope_id":"orphan","parent_scope":"missing","actor":"a","subject":"b","allowed_actions":["search"],"resource_scope":"web/search"}\n'
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "archive.jsonl"
+            path.write_text(archive, encoding="utf-8")
+            report = replay_archive(path)
+        self.assertFalse(report.ok)
+        self.assertIn("unknown scope", report.violations[0].reason)
+
+
+if __name__ == "__main__":
+    unittest.main()