GIT · C2
git-c2 · a canary control center

FORWARD OBSERVERS

A control center that lives on a git repo. HQ posts orders in one file, forward observers sweep public indexes for your planted canary tokens, findings append to a git ledger, and a page reads it back — a topographical map of where your markers surface online. The repo is the comms fabric, not the compute.

HQ
orders.json
canaries, observer assignments, cadence
→
field
observers sweep
poll public indexes for each canary
→
ledger
hits.jsonl
append-only, deduped, committed to git
→
readout
this page
reads the ledger back, plots the map
The chain of command

Three tiers, one repo

Everything is a plain file in the repo, so the whole system is auditable in a diff. Command flows down; findings flow up.

HQ · command

The order surface

orders.json names the canaries to track, assigns observers to sources, and sets cadence. .github/workflows/observer.yml is the cron Action: self-test → sweep → commit the ledger.

field · the trust boundary

Pure detection

fo_core.py is network-free: scan_text finds a canary only where it stands alone (case-sensitive, not inside a larger token), and record_hit appends to the ledger with SHA-256 dedupe. A hit here is ground truth.

observers · bases

The reporters

fo_github.py polls GitHub code search per canary and records hits; base_checkin.py writes a heartbeat so HQ can see fleet status. Everything upstream of fo_core is a lead, not proof.

Verify first

The trust boundary, live

Before trusting any hit, you verify the detector. This is fo_core.py’s logic ported faithfully to run in your browser — the same word-boundary rule, the same SHA-256 dedupe. Type into the field document; the detector reacts. Nothing leaves this page.

◎ FO-CORE · scan_text + record_hit, ported verbatim — the real detection, running client-side (no network)

the field document

self-test · three assertions, no network

the ledger · append-only, deduped

record a detected canary at a URL — a repeated (canary, url) is refused by fingerprint.
The word-boundary rule uses a regex lookbehind, exactly as fo_core.scan_text: (?<![A-Za-z0-9_-]) canary (?![A-Za-z0-9_-]). The fingerprint is the first 16 hex of sha256(canary + NUL + url), computed here with the browser’s WebCrypto — the same bytes as the Python.
The honest scope

Command vs. influence

What you command

Your bases and observers are yours — full command. They run your code, on your cadence, and write to your ledger. The repo is the shared, tamper-evident record of the whole fleet.

The ledger is append-only and deduped; the Action commits it back, so the history is the audit trail.

What is only influence

Public indexes are not yours. The ledger records where your canary surfaced in that outside territory — it grants no control over it.

And it sees only what a crawler already indexed: it maps published propagation, not a token swallowed into a training set and never re-emitted. Absence in the ledger is not absence in the world.

The colophon

What this catches — and what it does not

Sound

  • The detector is real and verifiable: fo_core.py --selftest proves detection + word-boundary + dedupe with no network. A ledger hit is ground truth.
  • The git-as-ledger pattern is a legit GitOps design: orders in one file, findings in an append-only ledger, a page reads it back — all auditable in a diff.
  • The code ships verbatim; the self-test above is that exact logic, running client-side.

Limits (and it says so)

  • Index lookup ≠ ground truth. GitHub code search is fuzzy; harden fo_github.py by fetching each candidate’s raw blob and re-running scan_text before recording (marked in-file).
  • Published-only. It maps a canary where a crawler indexed it — not tokens ingested into training and never re-emitted. Its inverse, surfacing, catches that other thing: a canary re-emitted from the weights.
  • Be a good neighbour. A fleet of pollers can resemble abuse traffic — stay in ToS and rate limits, respect robots.txt, keep commits sane.
  • Published safely: the Action’s hourly cron is commented out and the sweep is guarded, so this repo does not auto-poll — you activate it deliberately with a PAT.
SOURCE · the runnable kit — github.com/DavidWise01/forward-observers · fo_core.py (detector + ledger, self-testable) · fo_github.py · base_checkin.py · orders.json · .github/workflows/observer.yml. The canaries in the demo (stoch-6x6, STOICHEION-7Q9) are the kit’s own — ROOT0 markers for mapping where the STOICHEION corpus surfaces.
⧉ the code (GitHub) ▽ surfacing · the weights-side watcher ⊞ the membrane map · the family ⌗ the city · command center ⌂ ud0 · the atlas ↑ verify