The Fuse Box

The domain in five primitives

Every safety layer for autonomous work reduces to five verbs. Learn these and you can read any circuit breaker, anywhere:

1. Meter — measure what each action costs, pessimistically (an unpriced call is never free; it's charged the worst-case flat rate).
2. Retry — allow a bounded number of second chances (here: 2 retries = 3 attempts), never unbounded.
3. Trip — when the ceiling or the retry budget is exhausted, fail CLOSED: refuse all further work. A corrupt ledger also trips — if you can't prove what was spent, you stop.
4. Notify — deliver ONE decision window to the human: what happened, one decision, what success looks like. Never an open thread.
5. Recover — a human, and only a human, opens a new lap. The machine cannot un-trip itself.

Choose your door

• Builder — jump to the Builder Track. Trip the breaker and recover it with your own hands before reading anything.
• Architect — jump to the Architect Track. See the four modules and the one policy home first.
• Translator — start at the Bridge below: it's the electrical panel in your house.
• Validator — work the Gates at the bottom, one at a time, in order.

Builder Track (DO FIRST)

Do this first — it's free, it's real, do it on your machine:

py TEMP_SEED_SCRIPT.py            (seed the ledger to the ceiling)

py -m mesh.breaker drafter --file RESUME.md

Watch it refuse BEFORE spending anything: BREAKER TRIPPED ... decision window: <issue URL>. Then run the recovery move the issue tells you to run:

py -m mesh.breaker new-lap "post-trip"

py -m mesh.breaker status

Spend $0.0000, tripped: false. You just operated the whole safety layer with your own hands. Now read the Architect section to see what you actually did.

Architect Track (MODEL FIRST)

Four modules, one policy home:

• mesh/client.py talks to seats and deliberately has NO retry logic. A client that quietly retries quietly spends.
• mesh/breaker.py owns ALL retry and spend policy, in one enforced, testable place: the per-lap ledger (.mesh/ledger.json, gitignored), the $1.00 ceiling, the 3 attempts, the trip.
• mesh/notify.py owns the decision window: a GitHub issue in the chassis repo; GitHub's own notifier delivers the email — zero new secrets on the machine, and the window lives at a stable URL.
• mesh/sanitize.py owns untrusted input: CI logs and provider errors are stripped, length-bounded, fenced as data, and marker-spoofing is defanged before any agent reads them. A log can DESCRIBE a failure; it must never be able to INSTRUCT an agent.

One subtle ordering rule worth owning: the breaker charges the ledger BEFORE validating the response shape — a malformed 200 still spent real money, and a call is never silently free.

Translator Bridge

In your world this is like the electrical panel in your house. Every circuit (lap) has a budget; a surge (runaway spend or endless retries) flips the breaker; the whole circuit goes dark until a person walks to the panel and flips it back. The email is the alarm that tells you WHICH breaker flipped so you don't tour the house checking outlets.

Validator Gates

Confirm each before advancing; write each answer in your own words before checking it.

1. Gate 1: Why does a corrupt ledger trip the breaker instead of resetting to $0.00? (If you can't prove what was spent, the safe assumption is "too much." Fail closed.)
2. Gate 2: The mesh's PAT is my own identity. Why did the trip email never arrive on the first live test — and what are the two fixes? (GitHub doesn't notify you of your own actions. Interim: enable "include your own updates." Permanent: a machine-user account for the mesh — which also unlocks CODEOWNERS enforcement.)
3. Gate 3: A cloud response arrives priced at -$0.30. What does the meter record and why? (The pessimistic unpriced rate. Providers are untrusted input; a negative cost is a lie, not a refund.)
4. Gate 4: Why must decision windows be issues instead of comment threads? (An invariant user input window: one summary, one decision, success-looks-like — a stable URL a human can act on in a minute. Open threads invite negotiation with a machine that should be halted.)
5. Gate 5 (the honesty gate): Name one thing this safety layer does NOT protect against, from memory. (Any of: direct client calls, ledger deletion, cross-process races, a malicious agent — the wall for those is the chassis, not the fuse box.)

This module was smoke-tested LIVE on 2026-07-05: ledger seeded to ceiling → trip refused the call before spending → a decision-window issue filed → email landed (after the self-notification gotcha was found and fixed live) → new-lap recovery proved. The lesson sequence you just read is the lap that actually happened.