Skip to content

rozmiarD/SCLite

BranchesTags

Repository files navigation

SCLite

CI: pytest Package: sclite-core Python: 3.11+ Contracts: JSON Schema License: MIT

Lightweight Security Contract Layer for auditable AI/security contract lifecycles.

SCLite's canonical lifecycle separates what an agent wants, what policy allows, what was approved, what was executed, and what can be proven. The published 0.5.1 line adds GovEngine integration-readiness fixtures and gates plus review bundles, lifecycle review records, trust/carrier references, scoped-ticket review, and receipt-bounded-evidence checks on top of that lifecycle.

Status

  • Version: 0.5.1
  • Status: published 0.5.x review-bundle line
  • Runtime execution: not included
  • Protocol/carrier adapters: not included
  • Integrity: canonical SHA-256 artifact descriptors + ordered hash-linked lifecycle manifest
  • Identity/PKI: not included in core

SCLite's core is a contract/review lifecycle, not an execution engine. Runtimes such as Ravenclaw can consume SCLite artifacts and enforce tickets, but executors, sandboxes, policy engines, raw evidence storage, agent loops, and carrier adapters stay outside this package.

Project sentence

SCLite separates what an agent wants, what policy allows, what was approved, what was executed, and what can be proven.

Version surface map

Surface Role Current status
v0.1 proof trace Legacy public-safe proof fixtures and validation receipts Supported for compatibility
v0.2 lifecycle Canonical intent → policy → contract → ticket → receipt → evidence chain Canonical lifecycle model
v0.3 scoped tickets Runtime-consumable ticket semantics and receipt-bounded evidence checks Available via validate-ticket, explain-ticket, verify-ticket-use
v0.4 references/review records Digest-bound trust/carrier references and lifecycle review records Available via profile validators and review-lifecycle
v0.5 review bundles Packaged lifecycle artifacts plus reviewer Markdown and verification receipt Current adoption/demo surface

What problem does SCLite solve?

AI-assisted security workflows often blur separate authority boundaries:

  1. a model proposes intent;
  2. policy/scope decides whether the request may proceed;
  3. code prepares a concrete execution shape;
  4. an auditor/reviewer approves or rejects that shape;
  5. a runtime executes or dry-runs under bounds;
  6. evidence is summarized for review.

SCLite turns those steps into small schema-backed JSON artifacts and verifies their integrity locally. A reviewer can check the public-safe bundle without running live targets or reading private logs.

The canonical lifecycle keeps each authority boundary visible:

flowchart LR
    A[intent_contract] --> B[policy_decision]
    B --> C[execution_contract]
    C --> D[execution_ticket]
    D --> E[execution_receipt]
    E --> F[evidence_contract]
    F --> G[artifact_chain_manifest]
Loading

v0.2 canonical lifecycle

intent_contract -> policy_decision -> execution_contract -> execution_ticket -> execution_receipt -> evidence_contract -> artifact_chain_manifest

Current v0.2 artifacts:

Artifact Purpose
IntentContract Captures what an agent/caller wants before authority exists.
PolicyDecision v0.2 Captures allow/deny/review policy outcome bound to intent.
ExecutionContract Captures the exact bounded execution shape prepared for review.
ExecutionTicket Captures approval for one exact execution contract under explicit bounds and validity.
ExecutionReceipt v0.2 Captures what an external runtime reports as executed or dry-run.
EvidenceContract Captures public-safe claims, non-claims, replay, verification, and evidence links.
ArtifactChainManifest Ordered tamper-evident hash chain over lifecycle artifacts.

Verify the lifecycle fixture:

sclite validate-chain sclite/examples/contract-lifecycle-v0.2/artifact_chain_manifest.json
sclite verify-lifecycle sclite/examples/contract-lifecycle-v0.2/artifact_chain_manifest.json

verify-lifecycle uses the same underlying verifier as validate-chain; the command name exists because it describes the v0.2 review action more clearly.

What the verifier checks

The v0.2 verifier checks more than raw hashes:

  • manifest paths cannot escape the artifact root;
  • artifact descriptors match canonical SHA-256 digests;
  • hash-chain links and root digest recompute correctly;
  • lifecycle artifacts appear in the canonical order;
  • policy binds the correct intent digest;
  • ticket binds the correct execution contract digest;
  • receipt binds the correct execution ticket and execution contract digests;
  • evidence contract binds the correct receipt and execution ticket digests.

JSON Schema validation modes

SCLite has two validation modes:

Mode Dependency Intended use Boundary
dependency-free subset validator none fast/offline local checks and minimal installs only supports the keyword subset SCLite implements directly
strict Draft 2020-12 validator optional jsonschema extra CI, release gates, and reviewer validation uses jsonschema.Draft202012Validator

The default CLI path preserves the zero-runtime-dependency package. Release and CI validation must also run strict mode through scripts/strict_schema_gate.sh. See SCLite Validation for the supported keyword table and strict-mode commands.

What SCLite is

SCLite core is limited to:

define / validate / hash / bind / redact / verify / review

The published 0.5.x review-bundle surface packages lifecycle artifacts, review records, and verification receipts for local public-safe review. The scoped-ticket surface still bounds what a runtime may consume, and verify-ticket-use checks that public-safe evidence stays inside the linked receipt. See ROADMAP.md.

It provides:

  • JSON schemas for lifecycle and compatibility artifacts;
  • deterministic artifact hashing helpers;
  • v0.2 lifecycle/chain verification;
  • scoped-ticket review helpers (validate-ticket, explain-ticket);
  • ticket-use / receipt-bounded-evidence checks (verify-ticket-use);
  • digest-bound trust/carrier profile reference checks (validate-trust-profile, validate-carrier-profile);
  • lifecycle review records and Scope Fidelity v0.2 checks (review-lifecycle);
  • canonical review-bundle validation and Markdown export (review, export-review-bundle);
  • redaction/public-snapshot helper artifacts;
  • a CLI for local validation and review fixtures;
  • legacy v0.1 compatibility fixtures and schemas.

The package stays centered on local validation, review, profile references, and integrity checks:

flowchart TB
    CLI[CLI] --> Validation[validation]
    CLI --> ReviewBundles[review bundles]
    CLI --> Profiles[profiles]
    Validation --> Schemas[schemas]
    Validation --> Artifacts[artifacts]
    Artifacts --> Integrity[integrity chain]
    Artifacts --> Tickets[tickets]
    ReviewBundles --> Integrity
    ReviewBundles --> ScopeFidelity[scope fidelity]
    ReviewBundles --> Profiles
    Profiles --> Integrity
Loading

What SCLite is not

SCLite is not:

  • a security scanner;
  • an executor;
  • a sandbox;
  • a full policy engine;
  • an approval authority by itself;
  • an agent loop;
  • a tool wrapper package for nmap, ffuf, etc.;
  • an MCP/OpenClaw/A2A protocol replacement;
  • a proof of legal authorization;
  • a proof of live vulnerability evidence;
  • a proof of signer identity or PKI trust;
  • a tamper-proof transparency log.

Execution, authorization, raw evidence storage, and trust decisions belong to the host runtime:

flowchart LR
    Runtime[GovEngine or Ravenclaw runtime] --> Artifacts[SCLite artifacts]
    Artifacts --> SCLite[SCLite validate hash bind review]
    SCLite --> Record[review record or receipt]
    Record --> Runtime

    Runtime --> Execute[execute tools]
    Runtime --> Authorize[decide authorization]
    Runtime --> Evidence[store raw evidence]
    Runtime --> Trust[verify PKI or signer trust]

    SCLite -. does not .-> Execute
    SCLite -. does not .-> Authorize
    SCLite -. does not .-> Evidence
    SCLite -. does not .-> Trust
Loading

Legacy v0.1 compatibility

The older public-safe v0.1 proof trace remains supported:

scope/input -> policy decision -> prepared execution spec -> approved execution spec -> dry-run execution receipt -> evidence summary

v0.1 compatibility artifacts remain available for existing integrations, including Ravenclaw public proof fixtures. New lifecycle work should use the v0.2 model.

See SPEC.md for the canonical model, artifact definitions, integrity chain, compatibility notes, and explicit security boundaries.

Project docs

Installation

Install from PyPI:

pip install sclite-core

Install directly from GitHub:

pip install git+https://github.com/rozmiarD/SCLite.git

From a local checkout:

python -m venv .venv
. .venv/bin/activate
python -m pip install -e '.[dev]'

Runtime dependencies are intentionally empty. The dev extra installs pytest for local tests.

CLI quickstart

Validate the v0.2 lifecycle chain:

sclite validate-chain sclite/examples/contract-lifecycle-v0.2/artifact_chain_manifest.json
sclite verify-lifecycle sclite/examples/contract-lifecycle-v0.2/artifact_chain_manifest.json

Validate and explain the v0.3 scoped-ticket fixture:

sclite validate-ticket \
  sclite/examples/scoped-ticket-v0.3/execution_ticket.json \
  --contract sclite/examples/scoped-ticket-v0.3/execution_contract.json
sclite explain-ticket sclite/examples/scoped-ticket-v0.3/execution_ticket.json
sclite verify-ticket-use \
  sclite/examples/scoped-ticket-v0.3/execution_ticket.json \
  --contract sclite/examples/scoped-ticket-v0.3/execution_contract.json \
  --receipt sclite/examples/scoped-ticket-v0.3/execution_receipt.json \
  --evidence-contract sclite/examples/scoped-ticket-v0.3/evidence_contract.json

Validate the legacy public-safe proof fixture:

sclite validate examples/security-contract-proof

Validate one artifact against a schema:

sclite validate-artifact \
  --schema prepared_execution_spec.v0.1 \
  examples/prepared-execution-spec/prepared_execution_spec.json

Use strict Draft 2020-12 validation with the optional jsonschema extra:

pip install 'sclite-core[jsonschema]'
sclite validate-artifact \
  --strict-jsonschema \
  --schema prepared_execution_spec.v0.1 \
  examples/prepared-execution-spec/prepared_execution_spec.json

Hash one artifact with deterministic SCLite canonical JSON + SHA-256:

sclite hash-artifact \
  --schema approved_execution_spec.v0.1 \
  examples/security-contract-proof/approved_execution_spec.json

Generate a Scope Fidelity report from the approved spec fixture:

sclite scope-fidelity \
  --approved-spec examples/security-contract-proof/approved_execution_spec.json \
  --fail-on review

Review and export the v0.5 review-bundle fixture:

sclite review examples/review-bundle --format json
sclite export-review-bundle examples/review-bundle --format markdown

Review bundles package the lifecycle chain into a reviewer-facing record and optional Markdown export:

flowchart LR
    Bundle[review bundle directory] --> Shape[validate shape]
    Shape --> Chain[verify chain]
    Chain --> Lifecycle[lifecycle review]
    Lifecycle --> Record[review_record]
    Record --> Markdown[markdown export]
Loading

Review the GovEngine integration-readiness fixture and enforce conservative CI thresholds:

sclite review examples/govengine-integration --format json --fail-on review
sclite validate-trust-profile examples/govengine-integration/trust_profile_ref.json --subject examples/govengine-integration/04_execution_ticket.json
sclite validate-carrier-profile examples/govengine-integration/carrier_profile_ref.json --subject examples/govengine-integration/04_execution_ticket.json

Emit a validation receipt for the proof fixture:

sclite validation-receipt examples/security-contract-proof

Run tests:

python -m pytest -q

Python usage

Verify a v0.2 lifecycle manifest:

from sclite.integrity import verify_artifact_chain_manifest

# Load artifact_chain_manifest.json as a dict and verify it against a local root.
result = verify_artifact_chain_manifest(manifest, root=fixture_dir)
assert result["status"] == "passed"

Review scoped-ticket / receipt-bounded-evidence fixtures:

from sclite.tickets import validate_ticket_semantics, verify_ticket_use

checks = validate_ticket_semantics(ticket, execution_contract)
assert "ticket_scope_matches_execution_contract" in checks

result = verify_ticket_use(ticket, execution_contract, execution_receipt, evidence_contract)
assert "evidence_claims_bounded_by_receipt" in result["checks"]

Review a canonical v0.5 bundle:

from sclite.bundles import review_bundle

record = review_bundle("examples/govengine-integration")
assert record["verdict"] == "pass"

Repository layout

sclite/                         Python package
sclite/schemas/                 Packaged schemas
sclite/examples/contract-lifecycle-v0.2/
sclite/examples/review-bundle/  Packaged v0.5 review-bundle fixture
sclite/examples/govengine-integration/ Packaged downstream integration fixture
examples/review-bundle/         Public v0.5 review-bundle fixture
examples/govengine-integration/ Public GovEngine integration-readiness fixture
examples/security-contract-proof/ Legacy v0.1 public-safe proof fixture
schemas/                        Source schema copies
SPEC.md                         Current public specification
CHANGELOG.md                    Release notes

License

MIT. See LICENSE.

About

Lightweight Security Contract Layer for auditable AI/security execution contracts.

Topics

python redaction security validation json-schema audit mit-license governance ai-safety evidence security-research dry-run security-contracts public-safe

Resources

Readme

License

MIT license

Contributing

Contributing

Security policy

Security policy
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

5 tags

Packages

 
 
 

Contributors

Languages