sasana 1.0.0__tar.gz

sasana-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 sahiee-dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sasana-1.0.0/PKG-INFO

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: sasana
+Version: 1.0.0
+Summary: Tamper-evident cryptographic audit trail for OpenClaw and multi-agent AI sessions
+Author-email: Sahir Shaik Ahamed <sahir150305@gmail.com>
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cryptography>=41.0
+Provides-Extra: observer
+Requires-Dist: websockets>=12.0; extra == "observer"
+Requires-Dist: pyyaml>=6.0; extra == "observer"
+Provides-Extra: archeion
+Requires-Dist: fastapi>=0.110; extra == "archeion"
+Requires-Dist: uvicorn[standard]>=0.27; extra == "archeion"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Requires-Dist: httpx>=0.27; extra == "dev"
+Requires-Dist: fastapi>=0.110; extra == "dev"
+Dynamic: license-file
+
+# Sasana
+
+**Your AI agent logs are not evidence. Sasana makes them defensible.**
+
+Every major observability tool — LangSmith, Arize, Langfuse — stores logs in mutable,
+operator-controlled storage. An administrator with file-system or database access can
+modify or delete a record with no detectable trace. Those logs satisfy a reporting
+requirement. They do not prove what happened.
+
+Sasana records a SHA-256 hash-chained audit trail where any modification — to any byte,
+in any historical event — is detectable. Raw content never leaves your machine: only
+hashes are stored.
+
+```
+$ sasana verify session.jsonl --trust-key <archeion-pubkey>
+
+Sasana Verifier v1.0.0
+File     : session.jsonl
+Session  : 3f8a2c1d-…
+Events   : 7
+Evidence : AUTHORITATIVE_EVIDENCE
+
+[1/5] Structural validity  ... PASS
+[2/5] Sequence integrity   ... PASS
+[3/5] Hash chain integrity ... PASS
+[4/5] Session completeness ... PASS
+[5/5] Seal signature       ... PASS
+
+Result: INTACT ✅
+```
+
+---
+
+## Who this is for
+
+Teams deploying AI agents in regulated environments — fintech, healthtech, HR tech.
+Specifically:
+
+- Compliance engineers implementing **EU AI Act Article 12** (tamper-evident logging for
+  high-risk AI systems)
+- Security teams who need a cryptographically verifiable audit trail for incident response
+- DevSecOps engineers who need to prove a session log has not been touched since it ended
+
+If you are building an AI agent for a use case that falls under GDPR, SOC 2, HIPAA, or
+EU AI Act audit requirements, Sasana is the audit layer.
+
+---
+
+## What it produces
+
+A completed session produces a JSONL file. The verifier checks five properties and
+returns one of three results:
+
+| Result | Meaning |
+|---|---|
+| `INTACT` | All checks pass. The log has not been modified. |
+| `PARTIAL` | Hash chain intact but events were dropped during the session. |
+| `COMPROMISED` | Hash chain broken. Log has been modified after the fact. |
+
+Exit codes: `0` (INTACT), `1` (COMPROMISED), `2` (PARTIAL), `3` (ERROR) — suitable for
+CI pipeline integration.
+
+The evidence class tells you how strong the guarantee is:
+
+| Class | Meaning |
+|---|---|
+| `AUTHORITATIVE_EVIDENCE` | Independent sealing authority verified this log. The agent could not have forged this. |
+| `SIGNED_NON_AUTHORITATIVE` | Ed25519 signatures present. Requires private key to forge. |
+| `NON_AUTHORITATIVE_EVIDENCE` | Hash chain intact. Proves no post-hoc modification. |
+
+---
+
+## Install
+
+```bash
+pip install sasana
+```
+
+### Install via OpenClaw
+
+```bash
+# Via GitHub URL
+openclaw skill install https://github.com/sahiee-dev/Sasana
+
+# Via skills.sh shorthand (when listed in the registry)
+openclaw skill install sahiee-dev/Sasana/sasana
+```
+
+Every session automatically produces `~/.openclaw/sasana/<session_id>.jsonl`.
+No configuration required.
+
+---
+
+## Quick start
+
+```python
+from sasana.sqlite_ledger import SqliteLedger
+import hashlib
+
+def sha256(text: str) -> str:
+    return hashlib.sha256(text.encode()).hexdigest()
+
+ledger = SqliteLedger(db_path="session.db")
+ledger.connect()
+ledger.open_session(session_id="my-session", agent_id="my-agent")
+ledger.record("LLM_CALL",     {"prompt_hash":   sha256(prompt)})
+ledger.record("LLM_RESPONSE", {"response_hash": sha256(response)})
+ledger.close_session(status="success")
+ledger.export_jsonl("session.jsonl")
+ledger.close()
+```
+
+Verify:
+
+```bash
+sasana verify session.jsonl
+```
+
+Passive observer (zero code changes required):
+
+```bash
+pip install sasana[observer]
+sasana observe  # auto-detects OpenClaw WebSocket port
+```
+
+---
+
+## Authority sealing
+
+For regulatory submissions and legal proceedings, `NON_AUTHORITATIVE_EVIDENCE` means the
+operator is attesting their own logs. That is insufficient when the operator is a party
+to a dispute.
+
+[Archeion](archeion/) is a sealing server that runs inside your security perimeter,
+controlled by your security team — structurally separate from the agent process. The
+agent cannot forge a seal. The sealed log carries `AUTHORITATIVE_EVIDENCE`.
+
+```bash
+# Start Archeion (self-hosted, inside your perimeter)
+docker compose up -d
+
+# Seal a completed session
+sasana seal session.jsonl --server http://localhost:8747
+
+# Verify with key pinning
+sasana verify session.jsonl --trust-key <archeion-pubkey>
+```
+
+See [docs/DEPLOYMENT.md](docs/DEPLOYMENT.md) for the full deployment guide — key
+lifecycle, network isolation, and what to tell a security reviewer.
+
+---
+
+## How it works
+
+Each event is stored with:
+
+- **SHA-256 hash** over RFC 8785 canonical JSON — any mutation changes the hash
+- **`prev_hash`** — each event commits to all prior events, forming a chain
+- **Ed25519 signature** — optional per-session keypair; or Archeion's independent key
+
+Raw content is **never stored** — only hashes. You cannot reconstruct what the agent said
+from a Sasana log.
+
+A Rust binary (`sasana-rs/`) verifies sessions without a Python dependency — for forensic
+environments where Python is not present or trusted.
+
+---
+
+## Compliance mapping
+
+| Regulation | Requirement addressed |
+|---|---|
+| EU AI Act Article 12 | Tamper-evident automatic recording for high-risk AI systems |
+| SOC 2 CC7.2 | System monitoring with cryptographically verifiable audit trail |
+| HIPAA §164.312(b) | Audit control for healthcare AI; raw PHI never recorded |
+
+---
+
+## What Sasana does not do
+
+- **Does not record raw content.** Hashes only — you cannot reconstruct prompts or
+  responses.
+- **Does not prevent tampering.** Detects it. Detection and prevention are different.
+- **Does not replace LangSmith or Arize.** Those tools are for observability. Sasana is
+  for evidence production. They are complementary.
+- **Does not have a managed cloud offering.** Self-hosted only.
+
+---
+
+## License
+
+MIT

sasana-1.0.0/README.md

@@ -0,0 +1,193 @@
+# Sasana
+
+**Your AI agent logs are not evidence. Sasana makes them defensible.**
+
+Every major observability tool — LangSmith, Arize, Langfuse — stores logs in mutable,
+operator-controlled storage. An administrator with file-system or database access can
+modify or delete a record with no detectable trace. Those logs satisfy a reporting
+requirement. They do not prove what happened.
+
+Sasana records a SHA-256 hash-chained audit trail where any modification — to any byte,
+in any historical event — is detectable. Raw content never leaves your machine: only
+hashes are stored.
+
+```
+$ sasana verify session.jsonl --trust-key <archeion-pubkey>
+
+Sasana Verifier v1.0.0
+File     : session.jsonl
+Session  : 3f8a2c1d-…
+Events   : 7
+Evidence : AUTHORITATIVE_EVIDENCE
+
+[1/5] Structural validity  ... PASS
+[2/5] Sequence integrity   ... PASS
+[3/5] Hash chain integrity ... PASS
+[4/5] Session completeness ... PASS
+[5/5] Seal signature       ... PASS
+
+Result: INTACT ✅
+```
+
+---
+
+## Who this is for
+
+Teams deploying AI agents in regulated environments — fintech, healthtech, HR tech.
+Specifically:
+
+- Compliance engineers implementing **EU AI Act Article 12** (tamper-evident logging for
+  high-risk AI systems)
+- Security teams who need a cryptographically verifiable audit trail for incident response
+- DevSecOps engineers who need to prove a session log has not been touched since it ended
+
+If you are building an AI agent for a use case that falls under GDPR, SOC 2, HIPAA, or
+EU AI Act audit requirements, Sasana is the audit layer.
+
+---
+
+## What it produces
+
+A completed session produces a JSONL file. The verifier checks five properties and
+returns one of three results:
+
+| Result | Meaning |
+|---|---|
+| `INTACT` | All checks pass. The log has not been modified. |
+| `PARTIAL` | Hash chain intact but events were dropped during the session. |
+| `COMPROMISED` | Hash chain broken. Log has been modified after the fact. |
+
+Exit codes: `0` (INTACT), `1` (COMPROMISED), `2` (PARTIAL), `3` (ERROR) — suitable for
+CI pipeline integration.
+
+The evidence class tells you how strong the guarantee is:
+
+| Class | Meaning |
+|---|---|
+| `AUTHORITATIVE_EVIDENCE` | Independent sealing authority verified this log. The agent could not have forged this. |
+| `SIGNED_NON_AUTHORITATIVE` | Ed25519 signatures present. Requires private key to forge. |
+| `NON_AUTHORITATIVE_EVIDENCE` | Hash chain intact. Proves no post-hoc modification. |
+
+---
+
+## Install
+
+```bash
+pip install sasana
+```
+
+### Install via OpenClaw
+
+```bash
+# Via GitHub URL
+openclaw skill install https://github.com/sahiee-dev/Sasana
+
+# Via skills.sh shorthand (when listed in the registry)
+openclaw skill install sahiee-dev/Sasana/sasana
+```
+
+Every session automatically produces `~/.openclaw/sasana/<session_id>.jsonl`.
+No configuration required.
+
+---
+
+## Quick start
+
+```python
+from sasana.sqlite_ledger import SqliteLedger
+import hashlib
+
+def sha256(text: str) -> str:
+    return hashlib.sha256(text.encode()).hexdigest()
+
+ledger = SqliteLedger(db_path="session.db")
+ledger.connect()
+ledger.open_session(session_id="my-session", agent_id="my-agent")
+ledger.record("LLM_CALL",     {"prompt_hash":   sha256(prompt)})
+ledger.record("LLM_RESPONSE", {"response_hash": sha256(response)})
+ledger.close_session(status="success")
+ledger.export_jsonl("session.jsonl")
+ledger.close()
+```
+
+Verify:
+
+```bash
+sasana verify session.jsonl
+```
+
+Passive observer (zero code changes required):
+
+```bash
+pip install sasana[observer]
+sasana observe  # auto-detects OpenClaw WebSocket port
+```
+
+---
+
+## Authority sealing
+
+For regulatory submissions and legal proceedings, `NON_AUTHORITATIVE_EVIDENCE` means the
+operator is attesting their own logs. That is insufficient when the operator is a party
+to a dispute.
+
+[Archeion](archeion/) is a sealing server that runs inside your security perimeter,
+controlled by your security team — structurally separate from the agent process. The
+agent cannot forge a seal. The sealed log carries `AUTHORITATIVE_EVIDENCE`.
+
+```bash
+# Start Archeion (self-hosted, inside your perimeter)
+docker compose up -d
+
+# Seal a completed session
+sasana seal session.jsonl --server http://localhost:8747
+
+# Verify with key pinning
+sasana verify session.jsonl --trust-key <archeion-pubkey>
+```
+
+See [docs/DEPLOYMENT.md](docs/DEPLOYMENT.md) for the full deployment guide — key
+lifecycle, network isolation, and what to tell a security reviewer.
+
+---
+
+## How it works
+
+Each event is stored with:
+
+- **SHA-256 hash** over RFC 8785 canonical JSON — any mutation changes the hash
+- **`prev_hash`** — each event commits to all prior events, forming a chain
+- **Ed25519 signature** — optional per-session keypair; or Archeion's independent key
+
+Raw content is **never stored** — only hashes. You cannot reconstruct what the agent said
+from a Sasana log.
+
+A Rust binary (`sasana-rs/`) verifies sessions without a Python dependency — for forensic
+environments where Python is not present or trusted.
+
+---
+
+## Compliance mapping
+
+| Regulation | Requirement addressed |
+|---|---|
+| EU AI Act Article 12 | Tamper-evident automatic recording for high-risk AI systems |
+| SOC 2 CC7.2 | System monitoring with cryptographically verifiable audit trail |
+| HIPAA §164.312(b) | Audit control for healthcare AI; raw PHI never recorded |
+
+---
+
+## What Sasana does not do
+
+- **Does not record raw content.** Hashes only — you cannot reconstruct prompts or
+  responses.
+- **Does not prevent tampering.** Detects it. Detection and prevention are different.
+- **Does not replace LangSmith or Arize.** Those tools are for observability. Sasana is
+  for evidence production. They are complementary.
+- **Does not have a managed cloud offering.** Self-hosted only.
+
+---
+
+## License
+
+MIT

sasana-1.0.0/archeion/__init__.py

@@ -0,0 +1,12 @@
+# Archeion — Sasana authority sealing server.
+
+
+def run() -> None:
+    """Entry point for the `archeion` CLI command."""
+    try:
+        from archeion.server import run as _run
+    except ModuleNotFoundError as exc:
+        raise SystemExit(
+            f"archeion: missing dependency ({exc.name}). Install with: pip install sasana[archeion]"
+        ) from exc
+    _run()

sasana-1.0.0/archeion/keys.py

@@ -0,0 +1,46 @@
+"""
+archeion/keys.py — Persistent Ed25519 server keypair.
+
+Storage priority:
+  1. ARCHEION_PRIVATE_KEY env var (base64 raw bytes) — for containers / CI.
+  2. ARCHEION_KEY_FILE env var path.
+  3. ~/.archeion/server_key.b64 — default persistent location.
+
+A new keypair is generated and persisted when none of the above exist.
+"""
+
+from __future__ import annotations
+
+import base64
+import os
+from pathlib import Path
+
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+
+_DEFAULT_KEY_FILE = Path.home() / ".archeion" / "server_key.b64"
+
+
+def _key_path() -> Path:
+    return Path(os.environ.get("ARCHEION_KEY_FILE", str(_DEFAULT_KEY_FILE)))
+
+
+def load_or_generate() -> Ed25519PrivateKey:
+    """Return the server private key, generating and persisting one if absent."""
+    raw_b64 = os.environ.get("ARCHEION_PRIVATE_KEY")
+    if raw_b64:
+        return Ed25519PrivateKey.from_private_bytes(base64.b64decode(raw_b64))
+
+    key_path = _key_path()
+    if key_path.exists():
+        return Ed25519PrivateKey.from_private_bytes(base64.b64decode(key_path.read_text().strip()))
+
+    private_key = Ed25519PrivateKey.generate()
+    key_path.parent.mkdir(parents=True, exist_ok=True)
+    key_path.write_text(base64.b64encode(private_key.private_bytes_raw()).decode())
+    key_path.chmod(0o600)
+    return private_key
+
+
+def pubkey_b64(private_key: Ed25519PrivateKey) -> str:
+    """Return the base64-encoded raw public key bytes."""
+    return base64.b64encode(private_key.public_key().public_bytes_raw()).decode()

sasana-1.0.0/archeion/server.py

@@ -0,0 +1,154 @@
+"""
+archeion/server.py — Sasana authority sealing server.
+
+Endpoints:
+  POST /seal   — Verify a session JSONL, append a signed CHAIN_SEAL, return sealed JSONL.
+  GET  /pubkey — Return the server Ed25519 public key.
+
+Run:
+  uvicorn archeion.server:app --host 0.0.0.0 --port 8747
+
+The server key is loaded from ~/.archeion/server_key.b64 on startup (generated if absent).
+Override with ARCHEION_PRIVATE_KEY (base64) or ARCHEION_KEY_FILE env vars.
+"""
+
+from __future__ import annotations
+
+import datetime
+import json
+import logging
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import PlainTextResponse
+
+from archeion.keys import load_or_generate, pubkey_b64
+from sasana.signing import sign_event_hash
+from sasana.verifier import compute_event_hash, verify
+
+logger = logging.getLogger("archeion")
+
+app = FastAPI(
+    title="Archeion",
+    description="Sasana authority sealing server — upgrades sessions to AUTHORITATIVE_EVIDENCE.",
+    version="1.0.0",
+)
+
+# Keypair is loaded once at module import so TestClient and uvicorn share the same key.
+_private_key = load_or_generate()
+_pubkey = pubkey_b64(_private_key)
+
+
+@app.get("/health")
+async def health() -> dict:
+    """Liveness + readiness probe. Returns current server pubkey for key-change detection."""
+    return {"status": "ok", "version": app.version, "pubkey": _pubkey}
+
+
+@app.get("/pubkey")
+async def get_pubkey() -> dict:
+    """Return the server Ed25519 public key. Clients pin this to trust sealed sessions."""
+    return {"pubkey": _pubkey, "algorithm": "ed25519", "encoding": "base64"}
+
+
+@app.post("/seal", response_class=PlainTextResponse)
+async def seal(request: Request) -> str:
+    """
+    Accept a session JSONL body, verify its hash chain, append a signed CHAIN_SEAL event,
+    and return the sealed JSONL.
+
+    Errors:
+      400 — malformed or empty body.
+      409 — session already carries a CHAIN_SEAL.
+      422 — hash chain broken or session incomplete.
+    """
+    body = await request.body()
+    try:
+        events = [json.loads(ln) for ln in body.decode().splitlines() if ln.strip()]
+    except (json.JSONDecodeError, UnicodeDecodeError) as exc:
+        raise HTTPException(status_code=400, detail=f"Invalid JSONL: {exc}")
+
+    if not events:
+        raise HTTPException(status_code=400, detail="Empty session body")
+
+    if any(e.get("event_type") == "CHAIN_SEAL" for e in events):
+        raise HTTPException(status_code=409, detail="Session is already sealed")
+
+    result = verify(events)
+    if result.status == "PARTIAL":
+        raise HTTPException(
+            status_code=422,
+            detail=(
+                f"Cannot seal: session has {result.log_drop_count} LOG_DROP event(s). "
+                "Sealing a partial log would falsely imply a complete record."
+            ),
+        )
+    if result.status != "INTACT":
+        raise HTTPException(
+            status_code=422,
+            detail=f"Cannot seal: session is {result.status}. Errors: {result.errors[:5]}",
+        )
+    if not result.checks.get("completeness", {}).get("has_session_end"):
+        raise HTTPException(status_code=422, detail="Cannot seal: SESSION_END not present")
+
+    sorted_events = sorted(events, key=lambda e: e.get("seq", 0))
+    last = sorted_events[-1]
+
+    # Verify RFC 3161 timestamp token if SESSION_START carries one
+    _ts_verified = False
+    _ts_utc: str | None = None
+    session_start = next((e for e in sorted_events if e.get("event_type") == "SESSION_START"), None)
+    if session_start:
+        import base64 as _b64
+        import hashlib as _hl
+
+        from sasana.jcs import canonicalize as _jcs
+        from sasana.rfc3161 import verify_timestamp
+
+        token_b64 = session_start.get("payload", {}).get("rfc3161_token")
+        if token_b64:
+            try:
+                token_der = _b64.b64decode(token_b64)
+                payload_no_tok = {
+                    k: v
+                    for k, v in session_start.get("payload", {}).items()
+                    if k != "rfc3161_token"
+                }
+                ev_no_tok = {
+                    k: v for k, v in session_start.items() if k not in ("event_hash", "signature")
+                }
+                ev_no_tok["payload"] = payload_no_tok
+                pre_token_hash = _hl.sha256(_jcs(ev_no_tok)).digest()
+                _ts_verified, _ts_utc = verify_timestamp(token_der, pre_token_hash)
+            except Exception as exc:
+                logger.debug("Archeion: RFC 3161 verification skipped: %s", exc)
+
+    ts = datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f") + "Z"
+    seal_payload: dict = {
+        "session_hash": last["event_hash"],
+        "sealed_by": "archeion",
+        "server_pubkey": _pubkey,
+        "timestamp_verified": _ts_verified,
+    }
+    if _ts_utc is not None:
+        seal_payload["timestamp_utc"] = _ts_utc
+
+    seal_event: dict = {
+        "seq": last["seq"] + 1,
+        "event_type": "CHAIN_SEAL",
+        "session_id": last["session_id"],
+        "timestamp": ts,
+        "payload": seal_payload,
+        "prev_hash": last["event_hash"],
+    }
+    seal_event["event_hash"] = compute_event_hash(seal_event)
+    seal_event["signature"] = sign_event_hash(_private_key, seal_event["event_hash"])
+
+    logger.info("Sealed session=%s events=%d", last["session_id"], len(sorted_events) + 1)
+    return "\n".join(json.dumps(e) for e in sorted_events + [seal_event]) + "\n"
+
+
+def run() -> None:
+    """Entry point for `archeion` CLI command."""
+    import uvicorn
+
+    uvicorn.run("archeion.server:app", host="0.0.0.0", port=8747, reload=False)

sasana-1.0.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sasana"
+version = "1.0.0"
+description = "Tamper-evident cryptographic audit trail for OpenClaw and multi-agent AI sessions"
+authors = [{name = "Sahir Shaik Ahamed", email = "sahir150305@gmail.com"}]
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+dependencies = [
+    "cryptography>=41.0",
+]
+
+[project.optional-dependencies]
+observer = ["websockets>=12.0", "pyyaml>=6.0"]
+archeion = ["fastapi>=0.110", "uvicorn[standard]>=0.27"]
+dev      = ["pytest>=7.0", "ruff>=0.4", "httpx>=0.27", "fastapi>=0.110"]
+
+[project.scripts]
+sasana          = "sasana_cli:main"
+agentops-verify = "verify:main"
+archeion        = "archeion:run"
+
+[tool.setuptools.packages.find]
+include = ["sasana*", "archeion*"]
+
+[tool.setuptools]
+py-modules = ["verify", "sasana_cli"]
+
+[tool.ruff]
+line-length = 100
+
+[tool.ruff.lint]
+ignore = ["E501"]

sasana-1.0.0/sasana/__init__.py

@@ -0,0 +1,16 @@
+"""
+sasana — Tamper-evident cryptographic audit trail for OpenClaw sessions.
+
+Every session produces two artifacts:
+    ~/.openclaw/sasana/<session_id>.db     — SHA-256 hash-chained SQLite ledger
+    ~/.openclaw/sasana/<session_id>.jsonl  — JSONL export for offline verification
+
+Verify with:
+    sasana verify ~/.openclaw/sasana/<session_id>.jsonl
+"""
+
+from sasana.skill import SasanaSkill
+from sasana.observer import OpenClawObserver
+
+__version__ = "1.0.0"
+__all__ = ["SasanaSkill", "OpenClawObserver"]