Cooren Signal Protocol (CSP)

A transport-agnostic, coordination-native communication protocol. CSP carries the semantics of the Cooren coordination loop at the wire level: who is participating, what they are signaling, under whose authority, and through what chain of custody — expressed in every frame, not bolted on by a separate application layer.

CSP is deaf by default. A connection confers no trust. Every frame must pass two gates — authentication and schema — before the loop advances state. Frames that fail either gate are silently dropped. The loop does not acknowledge unauthenticated or malformed input.

Released to the public by McLeod Interactive Group LLC under Apache-2.0. See PUBLIC_AND_PRIVATE.md for the precise line between what is public (all of this) and what MIG holds private.

Why CSP

• Coordination-native. The frame is the coordination layer: session.create → participant.invite → signal.submit → tally.get → decision.record → announcement.send.
• Deaf by default. Forged, malformed, or unauthorized frames get silence — no error, no state disclosure, nothing for a prober to work with.
• Chain of custody = audit log. Every frame carries its signed lineage back to a genesis root (K0). Auditing is walking that chain; a forged or broken link fails at exactly its position. No separate logging system.
• Transport-agnostic. The same CBOR frame runs over TCP, WebSocket, UART/serial, MQTT, or HTTP/2. Swap one adapter file; the protocol is untouched.
• Human-auditable on demand. Compact CBOR on the wire, deterministic JSON expansion for human eyes. Identical frames always expand identically.

Install

pip install cryptography cbor2

Clone the repository and run from its root. (A pyproject.toml for pip install . can be added; the CLI wrappers below work as-is.)

Quickstart

# 1. Genesis: the authority anchor mints K0 and issues identities.
#    (Reference mode — see the note on the intent aligner below.)
./csp-keyvault genesis engine alice bob

# 2. Start the appliance (deaf-by-default coordination engine).
./csp-engined --identity keys/engine.identity.json \
              --anchor keys/k0.anchor.json \
              --revoked keys/revoked.json \
              --keys-dir keys --port 7227

# 3. Run a coordination loop from a participant.
./csp-participant loop keys/alice.identity.json \
                  127.0.0.1 7227 2 '{"temp_c":21.4}'

# 4. Prove it's CSP on the wire (no key needed to identify a frame):
./csp-verify identify <cbor_hex>

# 5. Prove deaf-by-default against the live engine (silence = pass):
./csp-verify probe 127.0.0.1 7227

Verify the whole thing

python3 tests/acceptance.py

Twenty-one checks across genesis, the public/private intent seam, the full coordination loop, deaf-by-default silence (five hostile frame classes), revocation, chain-of-custody verification, peer convergence, and canonical audit expansion.

The intent aligner (how the private part plugs in)

CSP's authority anchor refuses a succession whose stated intent conflicts with the founding intent (Specification §5.5). The scoring of that alignment — and MIG's founding question set — is private. This repository ships only the interface and an honest reference stub:

from cooren_signal_protocol import intent
intent.set_aligner(my_aligner)   # implements intent.IntentAligner

Without a registered aligner, CSP runs on the stub and says so. The public protocol is fully runnable and testable by anyone; the guarded scorer never has to be disclosed to make CSP work. Details in PUBLIC_AND_PRIVATE.md.

Layout

cooren_signal_protocol/   the package
  protocol.py             frames, two gates, chain of custody, pulse
  engine.py               csp-engined: the deaf-by-default appliance
  participant.py          a client / endpoint
  keyvault.py             genesis + key derivation (reference)
  tcp_transport.py        one transport adapter (TCP)
  intent.py               alignment INTERFACE + reference stub
  verify.py               auditor + deaf-by-default prober
tests/acceptance.py       21-check suite
docs/                     conformance, key manifest, operations
csp-keyvault, csp-engined, csp-participant, csp-verify   CLI wrappers

Documentation

• docs/CONFORMANCE.md — mapping to CSP Spec v0.1.
• docs/KEY_MANIFEST.md — what the vault issues and where each artifact goes.
• docs/OPERATIONS.md — standing up the appliance and connecting participants.

License

Apache License 2.0 — see LICENSE and NOTICE. Copyright 2026 McLeod Interactive Group LLC.