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:

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.

import arcaeon_all
arcaeon_all.versions()
# {'arcaeon-all': '0.2.1', 'arcaeon-ledger': '0.7.1',
#  'arcaeon-continuity': '0.2.1', 'arcaeon-audit': '0.1.5', ...}
# (whatever is actually installed; 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:

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