sovereignty-protocol 0.1.0__tar.gz

sovereignty_protocol-0.1.0/LICENSE

@@ -0,0 +1,55 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work.
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on or derived from the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link or bind by name to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, provided that You meet the following conditions:
+
+(a) You must give any other recipients of the Work or Derivative Works a copy of this License; and
+
+(b) You must cause any modified files to carry prominent notices stating that You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions.
+
+6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+8. Limitation of Liability. In no event and under no legal theory shall any Contributor be liable to You for damages arising in any way out of the use of or inability to use the Work.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer support, warranty, indemnity, or other liability obligations and/or rights consistent with this License.
+
+END OF TERMS AND CONDITIONS
+
+Copyright 2026 Sovereignty contributors

sovereignty_protocol-0.1.0/PKG-INFO

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: sovereignty-protocol
+Version: 0.1.0
+Summary: Local-first agent delegation protocol and reference implementation
+Author: Sovereignty contributors
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/m0ntydad0n/sovereignty
+Project-URL: Repository, https://github.com/m0ntydad0n/sovereignty
+Project-URL: Issues, https://github.com/m0ntydad0n/sovereignty/issues
+Keywords: agents,local-first,llm,privacy,protocol,router
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Security
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: jsonschema>=4.0; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Dynamic: license-file
+
+# Sovereignty
+
+```text
+                         .-.
+                        /___\
+                       (|o o|)
+                    .--.\_-_/ .--.
+                   /  _  '-'  _  \
+                  /__/ |     | \__\
+                  |  | |     | |  |
+                  |__| |_____| |__|
+                       /  |  \
+                      /___|___\
+
+   ______                               _             __
+  / ___/ /___ _   _____  ________  (_)___ _____  / /___  __
+  \__ \/ __ \ | / / _ \/ ___/ _ \/ / __ `/ __ \/ __/ / / /
+ ___/ / /_/ / |/ /  __/ /  /  __/ / /_/ / / / / /_/ /_/ /
+/____/\____/|___/\___/_/   \___/_/\__, /_/ /_/\__/\__, /
+                                  /____/          /____/
+
+        local models do the prep. your agent keeps authority.
+```
+
+Sovereignty is an open-source protocol and reference implementation for local-first agent delegation. It defines how local model lanes can perform private prep work — classification, extraction, drafting, code triage, and sensitivity checks — while a main agent retains authority over final answers and side effects.
+
+Sovereignty is not an LLM gateway. It is a contract for local-prep / cloud-authority workflows; see `docs/protocol-not-gateway.md` for the design note on why this is a protocol, not a gateway:
+
+- local lanes produce structured review packets;
+- local lanes do not invoke side-effecting tools;
+- model and lane metadata is redacted before it leaves the local boundary;
+- cloud exposure claims are explicit about their trust model;
+- measured exposure reports can attach evidence without leaking raw prompts or endpoints;
+- proposed side effects use a strict review-only schema before any authority-bearing tool acts;
+- callers can validate packets and policies before a main agent acts.
+
+## Status
+
+v0.1.0 protocol release. The public surface is intentionally small and falsifiable: schema contracts, policy checks, metadata redaction, measured exposure reporting, side-effect review boundaries, a sober threat model, and Hermes adapter examples.
+
+Sovereignty is still not a router or gateway. The private router implementation can evolve independently; this repository publishes the boundary contract local-prep systems must satisfy before an authority-bearing agent acts.
+
+## Repository layout
+
+```text
+sovereignty/
+  SPEC.md                 # Local-prep / cloud-authority protocol
+  THREAT_MODEL.md         # Assumptions, non-goals, failure modes
+  docs/measured-exposure.md # Evidence-backed exposure report shape
+  docs/telemetry.md         # Metadata-only packet telemetry contract
+  docs/side-effect-review.md # Authority-side side-effect review records
+  docs/policy.md            # Policy-origin validation and exposure/side-effect gates
+  docs/operations.md        # Guardrail events and lane health records
+  docs/broker-decision.md   # Metadata-only execution broker decision packets
+  docs/protocol-not-gateway.md # Why this is a protocol, not a gateway
+  docs/public-private-boundary.md # What belongs in public vs private implementations
+  docs/current-router-compatibility.md # Current Hermes local-router adapter boundary
+  docs/release-checklist.md # v0.1.0 package/release checklist
+  schemas/                # Language-agnostic JSON Schema contracts
+  src/sovereignty/        # Reference Python implementation
+  examples/hermes/        # Hermes local-router adapter examples
+  tests/                  # Contract tests
+```
+
+## Design principles
+
+1. Local models can prepare. They do not decide.
+2. Side effects require main-agent or human authority.
+3. Exposure accounting must state whether it is measured or caller-attested.
+4. Review packets are structured, versioned, and validated.
+5. Privacy/security claims should be falsifiable, not vibes.
+
+## First public proof
+
+The v0.1 proof is intentionally narrow: a local lane reads raw diagnostic context, emits a compact `ReviewPacket`, attaches measured exposure evidence, and proposes a side effect that remains review-only until the authority-bearing agent acts.
+
+Run it from a checkout:
+
+```bash
+PYTHONPATH=src .venv/bin/python examples/hermes/local_router_review_packet.py
+```
+
+What to look for in the JSON output:
+
+- `review_packet.local_output` contains the compact local summary, not the raw incident text.
+- `review_packet.model_metadata` keeps sanitized `worker_profile`, `model_used`, and `lane_model_map` fields, without base URLs, host paths, or tokens.
+- `review_packet.exposure.trust_model` is `measured`, and the attached `measured_exposure_report` avoids raw request bodies.
+- `packet_telemetry.token_accounting` separates estimated local/input/output counts from exposed-to-cloud counts.
+- `current_router_compatibility.actual_avoided_cloud_tokens` is only claimed for the pre-cloud/local-ingress shape where `raw_context_seen_by_cloud=false`.
+- Side effects are proposals only; the local lane cannot create issues, send messages, publish, deploy, trade, pay, or order.
+
+That is the positioning wedge: LiteLLM, Portkey, and RouteLLM are useful gateway/routing layers; Sovereignty is the local-prep / cloud-authority contract around what local workers may prepare, what evidence crosses the boundary, and who is allowed to act.
+
+## Quick start
+
+```bash
+python3 -m venv .venv
+.venv/bin/python -m pip install --upgrade pip
+.venv/bin/python -m pip install -e '.[dev]'
+.venv/bin/python -m pytest tests -q
+```
+
+The PyPI distribution name is `sovereignty-protocol` because `sovereignty` is already taken on PyPI. The import package and CLI command remain `sovereignty`.
+
+Install from a local checkout:
+
+```bash
+python3 -m pip install -e .
+sovereignty --help
+```
+
+Create a basic review packet:
+
+```bash
+.venv/bin/python examples/basic_packet.py
+```
+
+Run the measured-exposure recording boundary example:
+
+```bash
+.venv/bin/python examples/recording_boundary.py
+```
+
+Run the Hermes local-router integration example:
+
+```bash
+PYTHONPATH=src .venv/bin/python examples/hermes/local_router_review_packet.py
+```
+
+The local-router integration demonstrates a local prep lane producing a review packet with measured exposure evidence, metadata-only packet telemetry, and a review-only side-effect proposal for the main Hermes agent.
+
+Validate a packet JSON file:
+
+```bash
+sovereignty validate packet.json
+```
+
+Redact model metadata:
+
+```bash
+sovereignty redact metadata.json
+```
+
+## CLI
+
+Sovereignty's first CLI commands are protocol utilities, not router commands:
+
+- `validate packet.json` validates a review packet and returns a JSON status object.
+- `redact metadata.json` removes secrets, host-local URLs, and private paths from model metadata.
+
+## JSON Schema contracts
+
+Language-agnostic schemas live in `schemas/`:
+
+- `schemas/review-packet.schema.json`
+- `schemas/exposure.schema.json`
+- `schemas/measured-exposure-report.schema.json`
+- `schemas/side-effect-proposal.schema.json`
+- `schemas/packet-telemetry.schema.json`
+- `schemas/side-effect-review-record.schema.json`
+- `schemas/policy.schema.json`
+- `schemas/guardrail-event.schema.json`
+- `schemas/lane-health.schema.json`
+- `schemas/exposure-budget.schema.json`
+- `schemas/broker-decision.schema.json`
+
+These schemas mirror the v0.1 protocol surface for non-Python validators and integrations. Packet telemetry is documented in `docs/telemetry.md` and is metadata-only by default. Side-effect review records are documented in `docs/side-effect-review.md` and remain separate from local-lane side-effect proposals. Policy-origin validation and exposure budgets are documented in `docs/policy.md`. Guardrail events and lane health are documented in `docs/operations.md`. Broker decisions are documented in `docs/broker-decision.md`; the public/private boundary is documented in `docs/public-private-boundary.md`.
+
+## Release path
+
+The v0.1.0 release checklist lives at `docs/release-checklist.md`. `python -m build` is part of CI, and the package is published under the distribution name `sovereignty-protocol` while preserving the `sovereignty` import package and CLI.
+
+## License
+
+Apache-2.0. Sovereignty is intended to remain open source.

sovereignty_protocol-0.1.0/README.md

@@ -0,0 +1,175 @@
+# Sovereignty
+
+```text
+                         .-.
+                        /___\
+                       (|o o|)
+                    .--.\_-_/ .--.
+                   /  _  '-'  _  \
+                  /__/ |     | \__\
+                  |  | |     | |  |
+                  |__| |_____| |__|
+                       /  |  \
+                      /___|___\
+
+   ______                               _             __
+  / ___/ /___ _   _____  ________  (_)___ _____  / /___  __
+  \__ \/ __ \ | / / _ \/ ___/ _ \/ / __ `/ __ \/ __/ / / /
+ ___/ / /_/ / |/ /  __/ /  /  __/ / /_/ / / / / /_/ /_/ /
+/____/\____/|___/\___/_/   \___/_/\__, /_/ /_/\__/\__, /
+                                  /____/          /____/
+
+        local models do the prep. your agent keeps authority.
+```
+
+Sovereignty is an open-source protocol and reference implementation for local-first agent delegation. It defines how local model lanes can perform private prep work — classification, extraction, drafting, code triage, and sensitivity checks — while a main agent retains authority over final answers and side effects.
+
+Sovereignty is not an LLM gateway. It is a contract for local-prep / cloud-authority workflows; see `docs/protocol-not-gateway.md` for the design note on why this is a protocol, not a gateway:
+
+- local lanes produce structured review packets;
+- local lanes do not invoke side-effecting tools;
+- model and lane metadata is redacted before it leaves the local boundary;
+- cloud exposure claims are explicit about their trust model;
+- measured exposure reports can attach evidence without leaking raw prompts or endpoints;
+- proposed side effects use a strict review-only schema before any authority-bearing tool acts;
+- callers can validate packets and policies before a main agent acts.
+
+## Status
+
+v0.1.0 protocol release. The public surface is intentionally small and falsifiable: schema contracts, policy checks, metadata redaction, measured exposure reporting, side-effect review boundaries, a sober threat model, and Hermes adapter examples.
+
+Sovereignty is still not a router or gateway. The private router implementation can evolve independently; this repository publishes the boundary contract local-prep systems must satisfy before an authority-bearing agent acts.
+
+## Repository layout
+
+```text
+sovereignty/
+  SPEC.md                 # Local-prep / cloud-authority protocol
+  THREAT_MODEL.md         # Assumptions, non-goals, failure modes
+  docs/measured-exposure.md # Evidence-backed exposure report shape
+  docs/telemetry.md         # Metadata-only packet telemetry contract
+  docs/side-effect-review.md # Authority-side side-effect review records
+  docs/policy.md            # Policy-origin validation and exposure/side-effect gates
+  docs/operations.md        # Guardrail events and lane health records
+  docs/broker-decision.md   # Metadata-only execution broker decision packets
+  docs/protocol-not-gateway.md # Why this is a protocol, not a gateway
+  docs/public-private-boundary.md # What belongs in public vs private implementations
+  docs/current-router-compatibility.md # Current Hermes local-router adapter boundary
+  docs/release-checklist.md # v0.1.0 package/release checklist
+  schemas/                # Language-agnostic JSON Schema contracts
+  src/sovereignty/        # Reference Python implementation
+  examples/hermes/        # Hermes local-router adapter examples
+  tests/                  # Contract tests
+```
+
+## Design principles
+
+1. Local models can prepare. They do not decide.
+2. Side effects require main-agent or human authority.
+3. Exposure accounting must state whether it is measured or caller-attested.
+4. Review packets are structured, versioned, and validated.
+5. Privacy/security claims should be falsifiable, not vibes.
+
+## First public proof
+
+The v0.1 proof is intentionally narrow: a local lane reads raw diagnostic context, emits a compact `ReviewPacket`, attaches measured exposure evidence, and proposes a side effect that remains review-only until the authority-bearing agent acts.
+
+Run it from a checkout:
+
+```bash
+PYTHONPATH=src .venv/bin/python examples/hermes/local_router_review_packet.py
+```
+
+What to look for in the JSON output:
+
+- `review_packet.local_output` contains the compact local summary, not the raw incident text.
+- `review_packet.model_metadata` keeps sanitized `worker_profile`, `model_used`, and `lane_model_map` fields, without base URLs, host paths, or tokens.
+- `review_packet.exposure.trust_model` is `measured`, and the attached `measured_exposure_report` avoids raw request bodies.
+- `packet_telemetry.token_accounting` separates estimated local/input/output counts from exposed-to-cloud counts.
+- `current_router_compatibility.actual_avoided_cloud_tokens` is only claimed for the pre-cloud/local-ingress shape where `raw_context_seen_by_cloud=false`.
+- Side effects are proposals only; the local lane cannot create issues, send messages, publish, deploy, trade, pay, or order.
+
+That is the positioning wedge: LiteLLM, Portkey, and RouteLLM are useful gateway/routing layers; Sovereignty is the local-prep / cloud-authority contract around what local workers may prepare, what evidence crosses the boundary, and who is allowed to act.
+
+## Quick start
+
+```bash
+python3 -m venv .venv
+.venv/bin/python -m pip install --upgrade pip
+.venv/bin/python -m pip install -e '.[dev]'
+.venv/bin/python -m pytest tests -q
+```
+
+The PyPI distribution name is `sovereignty-protocol` because `sovereignty` is already taken on PyPI. The import package and CLI command remain `sovereignty`.
+
+Install from a local checkout:
+
+```bash
+python3 -m pip install -e .
+sovereignty --help
+```
+
+Create a basic review packet:
+
+```bash
+.venv/bin/python examples/basic_packet.py
+```
+
+Run the measured-exposure recording boundary example:
+
+```bash
+.venv/bin/python examples/recording_boundary.py
+```
+
+Run the Hermes local-router integration example:
+
+```bash
+PYTHONPATH=src .venv/bin/python examples/hermes/local_router_review_packet.py
+```
+
+The local-router integration demonstrates a local prep lane producing a review packet with measured exposure evidence, metadata-only packet telemetry, and a review-only side-effect proposal for the main Hermes agent.
+
+Validate a packet JSON file:
+
+```bash
+sovereignty validate packet.json
+```
+
+Redact model metadata:
+
+```bash
+sovereignty redact metadata.json
+```
+
+## CLI
+
+Sovereignty's first CLI commands are protocol utilities, not router commands:
+
+- `validate packet.json` validates a review packet and returns a JSON status object.
+- `redact metadata.json` removes secrets, host-local URLs, and private paths from model metadata.
+
+## JSON Schema contracts
+
+Language-agnostic schemas live in `schemas/`:
+
+- `schemas/review-packet.schema.json`
+- `schemas/exposure.schema.json`
+- `schemas/measured-exposure-report.schema.json`
+- `schemas/side-effect-proposal.schema.json`
+- `schemas/packet-telemetry.schema.json`
+- `schemas/side-effect-review-record.schema.json`
+- `schemas/policy.schema.json`
+- `schemas/guardrail-event.schema.json`
+- `schemas/lane-health.schema.json`
+- `schemas/exposure-budget.schema.json`
+- `schemas/broker-decision.schema.json`
+
+These schemas mirror the v0.1 protocol surface for non-Python validators and integrations. Packet telemetry is documented in `docs/telemetry.md` and is metadata-only by default. Side-effect review records are documented in `docs/side-effect-review.md` and remain separate from local-lane side-effect proposals. Policy-origin validation and exposure budgets are documented in `docs/policy.md`. Guardrail events and lane health are documented in `docs/operations.md`. Broker decisions are documented in `docs/broker-decision.md`; the public/private boundary is documented in `docs/public-private-boundary.md`.
+
+## Release path
+
+The v0.1.0 release checklist lives at `docs/release-checklist.md`. `python -m build` is part of CI, and the package is published under the distribution name `sovereignty-protocol` while preserving the `sovereignty` import package and CLI.
+
+## License
+
+Apache-2.0. Sovereignty is intended to remain open source.

sovereignty_protocol-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sovereignty-protocol"
+version = "0.1.0"
+description = "Local-first agent delegation protocol and reference implementation"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "Apache-2.0"
+authors = [{name = "Sovereignty contributors"}]
+keywords = ["agents", "local-first", "llm", "privacy", "protocol", "router"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+  "Topic :: Security",
+  "Typing :: Typed",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "jsonschema>=4.0", "build>=1.0", "twine>=5.0"]
+
+[project.scripts]
+sovereignty = "sovereignty.__main__:main"
+
+[project.urls]
+Homepage = "https://github.com/m0ntydad0n/sovereignty"
+Repository = "https://github.com/m0ntydad0n/sovereignty"
+Issues = "https://github.com/m0ntydad0n/sovereignty/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+sovereignty = ["py.typed"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]

sovereignty_protocol-0.1.0/setup.cfg

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

sovereignty_protocol-0.1.0/src/sovereignty/__init__.py

@@ -0,0 +1,43 @@
+__version__ = "0.1.0"
+
+from .exposure import Exposure
+from .exposure_budget import ExposureBudget
+from .guardrails import GuardrailEvent, validate_guardrail_event
+from .lane_health import LaneHealth, validate_lane_health
+from .measured_exposure import (
+    RecordedRequest,
+    RecordingBoundary,
+    build_measured_exposure_report,
+)
+from .packet import ReviewPacket, validate_packet, validate_packet_dict
+from .policy import SovereigntyPolicy, SovereigntyPolicyError
+from .redaction import redact_model_metadata
+from .side_effect_review import SideEffectReviewRecord, validate_side_effect_review_record
+from .side_effects import SideEffectProposal, validate_side_effect_proposal
+from .telemetry import PacketTelemetry, build_error_digest, validate_packet_telemetry
+
+__all__ = [
+    "__version__",
+    "Exposure",
+    "ExposureBudget",
+    "GuardrailEvent",
+    "LaneHealth",
+    "RecordedRequest",
+    "RecordingBoundary",
+    "ReviewPacket",
+    "SideEffectProposal",
+    "SideEffectReviewRecord",
+    "PacketTelemetry",
+    "SovereigntyPolicyError",
+    "SovereigntyPolicy",
+    "build_error_digest",
+    "build_measured_exposure_report",
+    "redact_model_metadata",
+    "validate_guardrail_event",
+    "validate_lane_health",
+    "validate_packet",
+    "validate_packet_dict",
+    "validate_packet_telemetry",
+    "validate_side_effect_proposal",
+    "validate_side_effect_review_record",
+]

sovereignty_protocol-0.1.0/src/sovereignty/__main__.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+from .packet import validate_packet_dict
+from .policy import SovereigntyPolicyError
+from .redaction import redact_model_metadata
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="sovereignty")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    validate_parser = subparsers.add_parser("validate", help="Validate a review packet JSON file")
+    validate_parser.add_argument("path", help="Path to packet JSON")
+
+    redact_parser = subparsers.add_parser("redact", help="Redact model metadata JSON")
+    redact_parser.add_argument("path", help="Path to metadata JSON")
+
+    args = parser.parse_args(argv)
+
+    try:
+        data = _read_json(args.path)
+        if args.command == "validate":
+            packet = validate_packet_dict(data)
+            _print_json({"ok": True, "packet": packet.to_dict()})
+            return 0
+        if args.command == "redact":
+            _print_json(redact_model_metadata(data))
+            return 0
+    except (OSError, json.JSONDecodeError, SovereigntyPolicyError, TypeError) as exc:
+        _print_json({"ok": False, "error": str(exc)})
+        return 1
+
+    _print_json({"ok": False, "error": f"unsupported command: {args.command}"})
+    return 1
+
+
+def _read_json(path: str) -> Any:
+    return json.loads(Path(path).read_text())
+
+
+def _print_json(payload: Any) -> None:
+    print(json.dumps(payload, sort_keys=True))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

sovereignty_protocol-0.1.0/src/sovereignty/exposure.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .policy import SovereigntyPolicyError
+
+EXPOSURE_CLASSIFICATIONS = {"raw", "excerpt", "summary", "none", "unknown"}
+EXPOSURE_TRUST_MODELS = {"caller_attested", "measured", "not_applicable"}
+
+
+@dataclass(frozen=True)
+class Exposure:
+    classification: str
+    trust_model: str
+    evidence: str | None = None
+
+    def __post_init__(self) -> None:
+        if self.classification not in EXPOSURE_CLASSIFICATIONS:
+            raise SovereigntyPolicyError(
+                f"unsupported exposure classification: {self.classification}"
+            )
+        if self.trust_model not in EXPOSURE_TRUST_MODELS:
+            raise SovereigntyPolicyError(
+                f"unsupported exposure trust_model: {self.trust_model}"
+            )
+        if self.trust_model == "measured" and not self.evidence:
+            raise SovereigntyPolicyError("measured exposure requires evidence")