Open operations

The Engine Room — the company that runs itself

SecuraCV is run by one human, GitHub, and Claude — the rest is systems. Each fact has one source, the tables and catalogs are generated from it, and a human steps in when a system raises its hand. This page shows that machinery; all of it is in the repos.

This is not the Lab. The Lab shows what the devices do; the Engine Room shows what the company does — how parts stay priced and docs stay true.

The doctrine

Five rules, borrowed from distributors and design tools that do this well. The full version is in the repo: 20-self-running-company.md.

1

One canonical source per fact

A part number, a price, a pin map — each lives in exactly one file. Every table and total is generated from it, so surfaces don't drift apart.

2

Facts are fetched, never typed

Anything the outside world knows better — distributor stock, prices, lifecycle — is pulled nightly by code and stamped with provenance. A human typing a distributor price is a bug.

3

Drift is a red X, not a habit

Every generated artifact is regenerated and diffed in CI; every hand-written schema has a lint. Stale data fails the build instead of quietly shipping.

4

Exceptions summon humans — schedules never do

No weekly reviews, no dashboards to remember. When a part goes out of stock or a price jumps, a system opens a GitHub issue. Silence means healthy.

5

The company fits in a context window

Every runbook and policy is written so an AI operator can execute it from the repo alone — exact commands, exact paths, explicit pass/fail. That's what makes “one person + Claude” real.

The system map

Every function of the company, the system that runs it, and its state. Each one links to the real code and the real CI runs — watch them fire.

Parts & sourcing — the BOM pipeline

running nightly

Humans state design intent in bom_*.csv (what part, how many, required or optional). Every night bom_pricing.py asks Digi-Key and Mouser for current SKUs, live stock, price breaks and lifecycle, snapshots them into pricing.json, and regenerates the Build-it tables. Out-of-stock, a >15% price move, or a part leaving production opens an issue automatically. The Build-it page's Order the parts panel turns any build into a distributor-ready list — copy, paste, and the cart prices itself, no account needed.

how it works nightly runs exception queue —

Hardware data — enclosures, options, firmware flags

drift-gated

The parametric OpenSCAD sources, the BOM CSVs and the firmware's own config.h flags are parsed into one catalog; CI re-renders and re-parses on every change and fails if any page went stale. A renamed part can't silently lie on the website.

catalog drift gate enclosure renders —

Software supply chain

per release

A CycloneDX SBOM for the Rust kernel, the Node tools and the ESP32 firmware is generated in CI; the firmware one is committed and schema-checked (CycloneDX 1.5) on every PR, and all three are attached to each new release.

SBOM workflow —

Documentation integrity

every PR

Every doc must be reachable from the index and every link must resolve — enforced by lint, so “add the doc, skip the map” is a red X instead of a habit. This website's claims are pinned by anti-rot fact tests against the real firmware and kernel.

repo lints site fact tests —

Storefront

preview by design

One file — store.json — is the whole catalog: kits, bundles, prices, batch caps. The store page renders it directly; going live is Stripe Payment Links with zero fixed cost and no tracking. The margin guard below checks every price nightly.

the store operations runbook

Fulfillment

systemized · human hands

Printing, flashing, kitting and shipping are physical. Once the store opens, they happen on a weekly batch evening, run from a written procedure, with the flashing jig and label pipeline doing the repetitive parts.

Margin guard — parts cost vs. kit price

running nightly

Every price in store.json carries a cost recipe; each night the guard checks its margin against the parts snapshot. Under the floor → an issue with three options: reprice, re-source, or lower the floor on the record. A PR that edits a price gets the same check.

nightly runs playbook —

The operator loop

How anything gets done here — from “a part went end-of-life” to “fixed, confirmed, forgotten”:

The world movesA part goes out of stock, a price jumps, CI breaks, an order lands.
↓
A system noticesA workflow catches it and opens a deduplicated GitHub issue with a specific, actionable signal.
↓
The human decides — or delegatesRead the issue, make the call, or point Claude at it. The repo carries every runbook an operator needs.
↓
Gates judge the fixLints, drift checks and tests decide whether it merges — not opinion, not memory.
↓
The systems check it themselvesThe next nightly run confirms the fix and goes quiet again. Silence means healthy.

What deliberately stays human

Self-running is not hands-off. Four things are never delegated to automation:

  • Money movement. Systems prepare carts and quotes; a human clicks buy. No machine spends money here.
  • Safety-critical choices. Battery chemistry and certification rows in the BOMs are marked safety-critical; no automation may substitute them.
  • Prices customers pay. Systems compute costs and flag drift; the number on the store page is a human decision, on the record.
  • The brand's word. Privacy promises, honesty copy, and this doctrine are written by the person accountable for them.

Honesty

What this page is not: a claim that everything is automated. Fulfillment is human hands, the store is in preview on purpose, and the distributor feeds go fully live when their API keys are configured — the pipeline says so itself rather than pretending. Each “running” badge links its real CI history. The “ran …” stamps come straight from GitHub's public API to your browser — nothing proxied, nothing stored — and show a dash if that call is blocked.