The live repo should receive chosen code, not every heavy folder a customer or founder needs to inspect.
How does a fifty-gigabyte codebase become a command room instead of a repo burden?
A massive codebase does not need to live inside the active Git repo just so an operator can inspect it. Custody first, selection second, receipt always.
Reape0r13 Relay becomes useful when scanned code, selected imports, runtime package delivery, command queues, agent claims, completion receipts, and paid gating share one control story.
The proof has to speak in artifacts: digests, byte counts, vault paths, restore commands, package manifests, entitlement checks, and receipts that a future operator can read without guessing what happened.
- Pulse: source custody, restore posture, owner control.
- Proof: The package is not the full source, and that is the point. Customers get runtime capability and proof; owner source stays controlled.
- Boundary: The boundary is just as valuable as the artifact. Customer recovery, runtime packages, owner source custody, and private implementation source are not the same thing, and the public story gets stronger when it keeps those lanes separate.
The part that has to stay honest.
The boundary is just as valuable as the artifact. Customer recovery, runtime packages, owner source custody, and private implementation source are not the same thing, and the public story gets stronger when it keeps those lanes separate.
The useful move is to reduce the loss window, make restore evidence easier to read, and turn source safety into something a buyer can understand before the emergency hits.
The operator question I carry forward.
I want the reader to leave this piece with a sharper decision, not just a nicer impression. The question is not "does this sound impressive?" The question is whether the surface can help a real person act with more confidence after the click. That is where DevodeRator has to stay different from content noise.
The proof also has to survive a second read. A first read can be carried by energy, but a second read is where the claim either keeps its weight or starts to feel inflated. I care about that second read because a serious buyer, developer, or operator will come back to the page with sharper eyes after the first impression fades. The piece has to keep answering.
That means the public lane needs three things close together: the claim, the evidence shape, and the limit. The claim tells the reader what changed. The evidence shape tells them how the system knows. The limit tells them what is private, gated, unfinished, provider-bound, or waiting on a stronger receipt. When those three stay together, the public archive can be proud without getting sloppy.
I also want the reader to feel the operational consequence. If the lane is healthier, what becomes easier tomorrow? If the lane is weaker than it looked, what should be watched before money, trust, or reputation moves through it? That practical consequence keeps the writing tied to the business instead of floating above it.
For a founder, the useful question is what risk this lane reduces. For a developer, it is what architecture pressure the lane exposes. For a buyer, it is what proof can be followed without a private tour. For an operator, it is what next action becomes easier because the system exists. The article has to serve all four without pretending they are the same reader.
That is why I keep the proof and the boundary in the same room. Proof without boundary becomes hype. Boundary without proof becomes fear. The strong version says what happened, why it matters, where the public can inspect it, and where the private operating layer stays protected. That balance is the whole reason this archive can sell the 0S without turning the company inside out.
The next move is simple: keep making the lane more usable, keep the receipts close, keep the links loud enough to click, and keep the language alive enough that a serious reader remembers the point after the tab closes. That is the standard this archive has to carry now. ⚡
The command room sells control, not chaos.
The twin has a different job.
Reape0r protects and mirrors the working source lane. Reape0r13 Relay is the room between the working repo and the larger vault or drive codebase. It scans ignored external folders, records file manifests, imports selected files, and can hand those writes to the local Reape0r bridge when the operator wants the live workspace touched through the bridge lane.
That matters because the platform can keep a massive project outside Git while still making it searchable, retrievable, and useful. The operator does not have to pretend the entire external codebase belongs in the live repo. The operator can ask for the piece that matters, import it, and keep the proof trail attached.
- Runtime-only Reape0r13 Relay agent package with install, doctor, scan, import, bridge-import, command, receipt, and receipt-list commands.
- Relay13 command-room routes for queued commands, agent claims, completion receipts, and command proof.
- SkyePay Pro, Command, and Sovereign plans with no free trial and payment required before package download.
- 0S gated install and package delivery with settled paid session or owner/admin session required.
The package is not the full source.
The buyer archive is a runtime package, not the full development tree. The release manifest marks the artifact as buyer-runtime-package, with fullSourceIncluded:false, rawCliSourceIncluded:false, sourceMapIncluded:false, and resale or redistribution prohibited. The latest deterministic archive is Reape0r13 Relay v1.0.1, SHA-256 72d8f0f2dab40b2135971c3a633bc3cb19367712989a4f878747a0a552078c67.
The command room is live.
Relay13 production health now advertises reape0r13_relay_command_room, reape0r13_local_agent_receipts, /api/admin/reape0r13/commands, /api/v1/reape0r13/commands, /api/v1/reape0r13/proof, and migration 0008_reape0r13_relay_commands.sql.
The live command API proof seeded one queued command, used a temporary scoped r13_ agent key to list the queue, claimed the command, posted a completed receipt, verified the proof endpoint, and revoked the temporary key. The command id was r13cmd_afc01037-60b7-4f4d-afc0-0a078d98987b. The proof endpoints returned HTTP 200 for list, claim, receipt, and proof.
The receipt makes the room sellable.
The customer experience has to be more than a clever CLI. A serious buyer needs to see the command enter the room, see an installed agent claim it, and see the result come back with enough detail to trust the handoff. That is the difference between "the agent probably did something" and "the system has a recorded operating path." Reape0r13 Relay gives the command a visible life cycle: queued, claimed, completed, or failed.
That receipt chain also protects the product from bad sales language. I do not need to pretend the browser itself is running the customer's filesystem. I can say the Relay13 room is the command and visibility layer, while the installed runtime and local bridge are the execution lane. That makes the offer easier to defend because the boundary is explicit. The customer pays for a real command-room workflow, not a vague promise that some hidden automation might move code somewhere.
It also gives support a sane answer. When a buyer asks what happened, the room can point to the command state and the agent receipt instead of asking everyone to reconstruct the moment from memory.
Why I needed the room to exist.
I do not want source custody to become another place where the operator has to guess. A big codebase in a vault is useful only if I can ask what is inside it, decide what belongs in the working system, and leave a clean record of the movement. Otherwise the vault becomes a storage closet. It may hold the thing, but it does not help me operate the thing.
Reape0r13 Relay changes that pressure point. The folder can stay ignored. The vault and drive can keep custody. The live repo can stay small enough to reason about. The command room can show when a scan entered the queue, when the relay picked it up, what action completed, and what receipt came back. That is the product shape I needed because the danger is not only losing code. The danger is pulling the wrong code into the wrong place with no trail.
The 50GB problem is really a control problem.
A huge folder is not automatically bad. Huge folders are normal once a platform collects old repos, client builds, media-heavy prototypes, generated assets, and research branches. The bad part is pretending every huge folder should be Git-normal. Git can remain part of the workflow, but it should not be forced to carry every external codebase just because the operator needs to inspect it.
My standard here is simple: custody should be broad, import should be narrow. Reape0r and SkyeVault can prove that the wider source universe exists and can be recovered. Reape0r13 Relay can narrow that universe to the file or fragment that belongs in the current repo. Relay13 can keep the command visible. That stack gives me sovereignty without turning the live worktree into a junk drawer.
The boundary is part of the product.
This is not a cloud shell that silently runs arbitrary filesystem work from a chat window. The live Relay13 room queues and displays commands. The installed Reape0r13 Relay agent performs local scans and imports. The local Reape0r bridge performs controlled writes only when it is explicitly running. That boundary matters because a customer should not have to wonder whether a website chat box can suddenly mutate their codebase.
I want the room to be powerful, but I also want it to be legible. The proof says what happened. The bridge says where execution happened. The plan says what the customer paid for before package delivery. That is how the system avoids overclaiming. It does not promise that every unknown project can be understood perfectly on the first scan. It promises custody, selection, command visibility, and receipt-backed movement.
The sales lane is strict.
Reape0r13 Relay is not a free trial download. FS27 now exposes three live offers: Pro at $149, Command at $499, and Sovereign at $1,500. Each offer reports trial_days:0, zero_upfront_trial:false, and delivery.type:gated-agent-install. The 0S installer redirects anonymous traffic to the shared gate, while anonymous manifest and archive requests return HTTP 402 until a matching paid SkyePay session or owner/admin session exists.
That strictness is not hostility toward buyers. It is respect for the product. If a runtime agent can inspect vault code, bridge selected files, and create receipts against a live operator system, it cannot be treated like a disposable trial download. The public offer should be clear before checkout, the package should stay gated after checkout, and the archive should not hand over the full development source to someone who only bought runtime access.
Closeout facts
Local agent proof passed 8/8. Double Trouble repo proof passed 13/13. Double Trouble stress passed 31/31 with 0 failures. Live HTTP stress passed 100/100 with 0 failures. FS27 deployed as 0e1eecc1-9e5f-47e2-bd5e-2759aa562a72. 0S deployed as 0ae6e083-54be-4195-8d58-80752279ae4c. Relay13 production version for the command-room pass is 7736a565-425a-4fe2-aef1-2c04e841b84f.
The newer Double Trouble proof records the two-agent custody handoff: ignored source staged into drive custody, selected output landed in a non-ignored repo section, Reape0r bridge receipts written, Git status/diff receipts captured, and a bounded Cloudflare-backed vault upload completed. Read the Double Trouble proof.
Why this changes the operating model.
This is the difference between a codebase being present and a codebase being operationally useful. Vault and drive custody can hold the heavy project. Relay13 can show the command trail. Reape0r13 Relay can scan and select. Reape0r can receive the chosen file through the bridge. The live repo stays intentional.
I see this as one of the cleaner sovereignty upgrades in the 0S because it does not ask people to abandon tools they already know. GitHub can still be mirrored. Codespaces can still be useful. Local IDEs can still be where execution happens. The difference is that the vault and drive lane can also become a full control plane for source work, not just a backup shelf. That makes the pitch stronger because sovereignty stops sounding like a philosophy and starts acting like a workflow.