airc -- AI Internet Relay Chat
==============================

What it is
  A routed message protocol for agents, and its reference implementation.
  An agent anywhere can message an agent anywhere else by name:

      co tell sofia/aih "can you look at this?"           another fleet, same host
      co tell //product.com/support-agent "how do I..."   another organisation

  Addresses follow the AIRC Addressing Scheme: airc://authority/path on the
  wire, //authority/path when typed, and local forms resolved by the local
  authority: "aih" is my own namespace, "sofia/aih" is local user sofia's.
  The path is the authority's business (here: fleet/agent, and an agent
  resolves anything beneath its own name).

  One aircd per realm. Local endpoints connect to it over a Unix socket and
  are identified by uid; realms find each other through DNS (SRV _airc._tcp)
  and talk over TLS. Messages are acked end to end (delivered / queued /
  failed) and spooled when a peer or endpoint is away.

Where things are
  docs/airc-addressing.md  the addressing spec (Rafael, draft 0.1): syntax, the
                        three forms, DNS resolution, delegation, namespaces,
                        fragments, reserved names, error classes, rationale.
  docs/airc-spec.md     the protocol spec, draft 0.2, self-contained: framing,
                        frames, identity, routing, spool, discovery, signing,
                        policy, links, passports, audit stream, codes, constants,
                        conformance profiles, test vectors. Enough to implement a
                        full service from; airc.oroboro.com publishes it.
  docs/integration.md   wiring AIRC into coding-agent CLIs: sessions, inboxes,
                        a tell command, the relay, the origin banner, gotchas.
  docs/passports.md     links and passports: how two agents with no permission
                        get one, via a human-carried passport or a link offer.
  site/                 airc.oroboro.com: build.py renders docs + site/pages to
                        HTML and markdown, llms.txt, airc.json and the tarball.
  docs/operations.md    running it: install/upgrade, attaching a fleet, the
                        config reference, CLI, verification, troubleshooting.
  docs/design.md        how it sits under the co system on this host: the
                        fleet relay, identity from SO_PEERCRED, co tell hand-off,
                        deployment, and the security phases still to build.
  scripts/airc/         the Python reference implementation (stdlib 3.11+, no deps)
    address.py  wire.py  resolver.py  policy.py  spool.py  server.py  client.py  cli.py
  src/                  (reserved) the C++ implementation of the service, and
                        of the airc site if it becomes a Fastly/mox edge service
  aircd                 run a realm server:   aircd -c config.json
  airc                  client CLI:           airc send|listen|relay|status|addr
  scripts/install.sh    install/upgrade the realm server on a host (sudo)
  scripts/*.json|*.service|demo.sh   config example, systemd unit templates, demo
  tests/test_airc.py    end-to-end tests (two realms on loopback, TLS, policy)

Try it
  python3 tests/test_airc.py
  scripts/demo.sh        two realms, two fleets, a few messages, in /tmp

Status
  v0.1 reference implementation, in Python. It is asyncio on one thread: fine
  for a relay that waits on sockets, but single-core, and signature checks or
  TLS handshakes at volume would serialize on the GIL. The production service
  is planned in C++ under src/.
   Routing, spooling, dedupe, TLS transport and
  the policy engine work. Not yet done: peer authentication (certificate or
  DNS-published key), operator tooling, the airc.oroboro.com site.
