ruv.sgit.airUv + sgit

Ruflo's hive-mind (MIT, by rUv) · sgit vaults · the way this site's materials are now made

ruv.sgit

a Ruflo hive + sgit vaults + Agent Behaviour Policies

A Ruflo hive, a queen and workers running in parallel, whose memory and output is one ephemeral sgit vault per run: created when the work starts, a branch per worker, every delivery committed and merged, measured when the run closes, then deleted. What stays is the ledger: what each run made, how long each step took, what the server held (ciphertext only), and whether a fresh clone got back exactly what the workers delivered.

loading the ledger…

One run, six steps

  1. OpenThe queen spawns one worker per role and queues a task each; a new vault is created and the feedback that started the run is committed as its brief.
  2. Work in parallelEach worker builds its part at the same time, on its own branch.
  3. DeliverEach delivery is committed on the worker's branch, pushed, and merged into current; the hive gets a broadcast with its hash.
  4. Close and measureHistory, files, bytes; text fragments sampled from the delivered files (up to 40) are searched for in every byte the server stored; a fresh clone is compared file by file.
  5. DeleteEphemeral: the vault's objects leave the server, the key is destroyed, the working copy goes.
  6. LedgerThe run's numbers join data/vaults.json and its full record evidence/ruv-sgit/<run>.json.

The pattern is the one the newsroom wrote up in Agent workflows on ephemeral vaults: a vault as the shared file system and channel for agents working together, living only as long as the work.

Every run

Read from the ledger at load: each row is a vault that existed for one run.

loading…

See it

ruv.sgit in motion

A real run, animated from its ledger entry: the queen, the workers in parallel, branches, merges, the close, the delete.

The vault ledger

Every vault so far: lifecycles, commits, bytes, what the server held, clone checks, sgit operation timings.

One ephemeral vault

A case study, start to finish, with the numbers of one run, beside what the newsroom measured on append lanes.

The definition, animated (run r3-define)

The equation

A Ruflo hive + sgit vaults + Agent Behaviour Policies, each with one measured number, fused into ruv.sgit.

The layers

Hive, mandate and vault as three planes: POC1's decisions at the mandate, run r2-materials' deliveries in the vault, then the stack lays flat into the tagline.

One action's journey

Three of POC1's recorded decisions, act by act: a file write allowed, an email denied with its why, a deploy waiting for a named human.

Run it

npm ci && pip install sgit-ai==0.21.0 sgraph-ai-app-send "mcp<2"     # Ruflo 3.56.10 and a local SG/Send vault server
python3 poc/ruv-sgit/ruvsgit.py server-start                       # local server, disk storage in ~/.ruv-sgit, a token made there (mode 0600)
python3 poc/ruv-sgit/ruvsgit.py open    r3 poc/ruv-sgit/runs/r3.spec.json   # hive + vault + brief
python3 poc/ruv-sgit/ruvsgit.py deliver r3 <worker> <role> <folder>   # once per worker, as each finishes
python3 poc/ruv-sgit/ruvsgit.py close   r3 workers.json                # measure, ledger, evidence
python3 poc/ruv-sgit/ruvsgit.py delete  r3                             # ephemeral

The vault key and the server token never leave ~/.ruv-sgit; they are passed on stdin or in files, never printed. The workers here are Claude Code subagents of the session that runs the hive; Ruflo holds the queen, the roles, the tasks and the broadcasts. The local server is one process on the same machine: the numbers are local numbers.