Metadata-Version: 2.5
Name: arcaeon-all
Version: 0.2.2
Summary: Everything Arcaeon in one install — the composed trust stack for AI agents
Project-URL: Homepage, https://arcaeon.io
Author: Arcaeon
License: MIT
License-File: LICENSE
Keywords: agents,ai,audit,compaction,context,continuity,hash-chain,idempotency,mcp,metering,provenance,tamper-evident,trust-stack
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Topic :: Software Development :: Libraries
Requires-Python: >=3.9
Requires-Dist: arcaeon-adapter>=0.1.3
Requires-Dist: arcaeon-audit>=0.1.8
Requires-Dist: arcaeon-baseline>=0.1.9
Requires-Dist: arcaeon-compact>=0.1.5
Requires-Dist: arcaeon-continuity>=0.2.4
Requires-Dist: arcaeon-dedup>=0.1.5
Requires-Dist: arcaeon-distill>=0.1.7
Requires-Dist: arcaeon-ledger>=0.7.4
Requires-Dist: arcaeon-meter>=0.1.7
Requires-Dist: arcaeon-once>=0.2.3
Provides-Extra: dev
Requires-Dist: hypothesis; extra == 'dev'
Requires-Dist: pytest; extra == 'dev'
Description-Content-Type: text/markdown

# arcaeon-all

**Everything Arcaeon in one install — the composed trust stack for AI agents.**

```
pip install arcaeon-all
```

Ten packages, each independently useful, that were built to compose:

| package | what it proves |
|---|---|
| [`arcaeon-ledger`](https://pypi.org/project/arcaeon-ledger/) | Tamper-evident, hash-chained action log. The spine every other package chains onto. |
| [`arcaeon-continuity`](https://pypi.org/project/arcaeon-continuity/) | Carry an agent's load-bearing self across a reset; prove the next instance is a faithful continuation. |
| [`arcaeon-audit`](https://pypi.org/project/arcaeon-audit/) | Audit-ready logs — ISO 42001 / SOC 2 / EU AI Act evidence — on top of the ledger chain. |
| [`arcaeon-baseline`](https://pypi.org/project/arcaeon-baseline/) | Pre-registered probe sets for measuring what a substrate swap actually changed. |
| [`arcaeon-compact`](https://pypi.org/project/arcaeon-compact/) | Tamper-evident receipts for context compaction — prove what your summarizer dropped. |
| [`arcaeon-dedup`](https://pypi.org/project/arcaeon-dedup/) | Strip near-duplicate text from an agent's context before it costs tokens. Pure stdlib, no LLM, a true leaf — no dependency on the rest of the stack. |
| [`arcaeon-distill`](https://pypi.org/project/arcaeon-distill/) | Deterministic, cache-stable tool-output distiller; keeps a drop receipt for what got cut. |
| [`arcaeon-meter`](https://pypi.org/project/arcaeon-meter/) | Keyed metering for agent tools — API keys, monthly caps, SQLite counts, billing export. |
| [`arcaeon-once`](https://pypi.org/project/arcaeon-once/) | Executed-once receipts for non-idempotent side effects. Refuses silent double-fires, flags crash-window uncertainty honestly. |
| [`arcaeon-adapter`](https://pypi.org/project/arcaeon-adapter/) | MCP stdio proxy that logs the tool-call seam to the ledger without the agent's cooperation: the pen moves from self-report to the wire. |

`arcaeon-all` doesn't add code — it's a metadata package that pins a known-good
floor of all ten at once, so `pip install arcaeon-all` gets you the whole
stack instead of ten separate installs each pinned by hand.

```python
import arcaeon_all
arcaeon_all.versions()
# {'arcaeon-all': '0.2.2', 'arcaeon-ledger': '0.7.3',
#  'arcaeon-continuity': '0.2.3', 'arcaeon-audit': '0.1.8', ...}
# (whatever is actually installed, shown here at the 0.2.2 floors; a
#  missing component reads None)
```

`arcaeon_all` itself imports nothing heavy — `versions()` reads installed
package metadata, it doesn't import the component packages. Import each one
directly for its real API: `from arcaeon_ledger import Ledger`, `import
arcaeon_continuity as ac`, and so on.

## Why compose instead of just picking one

Every package here has its own test suite (most with a Hypothesis property
suite as well), run in isolation. Isolation is exactly the blind spot. The worst bug found in
this stack so far (2026-08-15/16, a false-tamper report) was invisible to
every single package's own tests — it only existed at the *seam*, where
`arcaeon-continuity` writes a probe file that `arcaeon-baseline`'s
`load_probes()` reads back. A JSONL writer using `ensure_ascii=False` didn't
escape a few Unicode line-boundary characters (U+0085, U+2028, U+2029); a
reader using `str.splitlines()` treats those characters as row breaks. A
value that legitimately contained one of them sealed cleanly and then failed
to parse on read — reported as tamper that never happened. Two packages,
individually correct, wrong together.

`arcaeon-all` exists because "does the stack still compose" is a different
question than "does each package still pass its own tests," and the second
one answers `yes` right up until the seam breaks. The walkthrough below is
the cross-package check this repo's dependency floors are held to: three
producer packages, one shared ledger file, one workflow. `test_composition.py`
in this repo executes that exact block, and skips (naming the package) rather
than passing when the installed components are below the pinned floors.

## The composition story

The full life of one agent session, threaded through every layer:

```python
import tempfile
from pathlib import Path

import arcaeon_continuity as ac
from arcaeon_ledger import Ledger
from arcaeon_once import guard, receipt as once_receipt

with tempfile.TemporaryDirectory() as td:
    ledger_path = Path(td) / "agent_life.jsonl"

    # --- Act 1: the agent declares its self at wake, chained. ---
    manifest = {
        "identity_anchors": ["I am the agent, continuity carried forward"],
        "open_commitments": ["ship the integration tests"],
        "canon_pointers": ["memory/CORE.md"],
        "live_threads": ["topic-428: protocol amendment 8"],
    }
    snap = ac.snapshot(manifest, label="wake", ledger_path=ledger_path)
    assert Ledger(ledger_path).verify().ok

    # --- Act 2: mid-session, some context gets compacted. The drop is
    #     honestly receipted through continuity's compact delegation,
    #     chained to the SAME ledger file. ---
    before = ["msg 1: hello", "msg 2: routine chatter", "msg 3: also routine"]
    after = ["msg 1: hello", "summary of routine chatter"]
    drop = ac.drop_receipt(before, after, ledger_path=ledger_path)
    assert drop.verify(before, after)["ok"]

    # --- Act 3: a scheduled once-guarded side effect ("send the morning
    #     receipt") runs exactly once, chained to the SAME ledger, with
    #     integrity checking on. ---
    with guard("morning_receipt:2026-08-16", ledger_path=ledger_path,
               verify_integrity=True) as g:
        g.done({"sent": True})
    assert once_receipt("morning_receipt:2026-08-16", ledger_path=ledger_path).ledger_ok

    # --- Act 4: the WHOLE shared ledger — snapshot row, compaction receipt,
    #     once.intent + once.executed rows — verifies as one unbroken chain.
    #     Three producers, one consumer (Ledger.verify), zero disagreement
    #     about what's real. ---
    vr = Ledger(ledger_path).verify()
    assert vr.ok and vr.rows == 4

    # --- Act 5: the next instance restates against the sealed baseline —
    #     also chained to the SAME ledger. ---
    restated = ac.restate(manifest)
    verdict = ac.verify_continuation(snap, restated=restated, ledger_path=ledger_path)
    assert verdict.faithful and verdict.comparison == "exact_match"

    final = Ledger(ledger_path).verify()
    assert final.ok and final.rows == 5
```

Five rows, three producer packages, one ledger, one `verify()` call at the
end that either agrees the whole story is intact or names the exact line
that isn't. That's the shape `arcaeon-all` is pinning: not ten unrelated
libraries, one composed trust stack that's been proven to hold together at
its seams, not just within each package's own walls.

## Installing individual pieces

Nothing here requires the whole stack. `arcaeon-dedup` is a true leaf — zero
`arcaeon-*` dependencies, pure stdlib. `arcaeon-meter` and `arcaeon-distill`
only take `arcaeon-ledger` as an *optional* extra (`pip install
arcaeon-meter[ledger]`) for callers who want chained audit rows; without it
they run standalone. Install `arcaeon-all` when you want the composed
stack; install a single package when you only need one primitive.

## License

MIT © 2026 Arcaeon
