# The Discipline Budget

Part III: Your Own Hand

## You are here if

Nothing is failing, and the work is still not moving. The session is healthy, the checks are passing, and you have somehow become the bottleneck in your own fleet: every routine operation arrives at your elbow as a request for permission that nothing would have denied. A surprise in some tool's output, a color you have not seen before, an unfamiliar status line, is halfway to an incident report with not one byte of evidence behind it. You approved a change in writing an hour ago and the machinery is still negotiating the syntax of asking you again. The invoice for a tiny scheduled job reads like the invoice for a working day. A whole session went to process, and no artifact came out the other end.

You are also here, ideally, before any of that: about to add a gate, a checklist, a second review, a confirmation step, and wondering whether it is worth what it will cost every day after today. That is the right moment to read this chapter, because the failure it owns is almost invisible after the fact.

You are in the wrong chapter if a control actually fired: a guard blocked a call, a gate rejected you, and the question is what to do about the control itself. That is chapter 8. If a surprising number turned out to be real when you checked it against raw evidence, the instrument chapter, chapter 4, owns what happens next. And if what worries you is that you verify too little, this is the one chapter in the manual that cannot help you; the other ten are waiting.

## The mechanism

Every other chapter in this book hands you a discipline, and every one of those disciplines is locally cheap and locally justified. Read the bytes. Reconcile the record. Probe the switch. Stress the instrument. Each check, taken alone, is obviously worth it, and nothing inside any of them says stop. Apply them uniformly, without a price on the other side of the ledger, and they aggregate into fixed ceremony: the same ritual for a status line as for a production deletion. Ceremony has a failure mode of its own, and it fails quietly in exactly one direction. Under-verification fails loudly; it produces incidents, and incidents produce ledger entries. Over-verification produces only round-trips, latency, and spend, and every unit of it books itself as diligence. It is a system that goes wrong without saying so, and what the going-wrong looks like from inside is being careful.

The second driver is that ceremony is usually raised by an assumption, and assumptions raise it whether or not they are true. The type specimen: an entire session once routed every git operation in the harness's own configuration directory through the operator. Commit, branch, diff, each one packaged as a command for a human to run, each one a round-trip wait, on the belief that the directory's guards would block them. The belief was never tested. The guards there were aimed at raw file mutations to protected paths and at recursive deletes; ordinary git operations had never been blocked at all. One cheap probe at the top of the session would have collapsed the whole performance. Instead the caution compounded for hours, and nothing ever failed, which is precisely the trap: the transcript reads as prudence. The failure only becomes visible if you price the waits.

Book One spends its whole arc teaching you to buy checks, assembling verification capital one discipline at a time, and its own developmental edit named the one thing the doctrine states only in passing and never argues: the stopping rule, the point at which a check is not worth what it costs. This chapter is that argument. The other ten chapters are about applying discipline; this one is the only chapter about applying them too much. A manual that cannot say when not to apply itself is a liturgy. This chapter is what makes it a tool.

## The discipline

Ceremony scales with blast radius: verify in proportion to what a failure would cost, and treat over-verification as a failure with its own ledger line.

The ritual:

1. **Price the failure before you price the check.** Name what a wrong outcome would actually cost, in outcomes you could point to afterward: a revert, a re-run, an apology, a lost file, a public artifact you cannot recall. Pass: the cost is stated in concrete consequences, not in unease.

2. **Probe the assumption that raised the ceremony.** If the ritual exists because you believe an operation is blocked, gated, or dangerous, test that belief once, cheaply, against the live system. Pass: the belief was tested this session, and the test is something you ran, not something you remembered or inherited.

3. **Demand a byte before escalating a surprise.** A surprise in tool output earns an integrity probe only on concrete evidence: a hash that does not match, output that is malformed, a state that contradicts an action you just took. Pass: you can name the byte. A color, a status line, or an unfamiliar note is not a byte.

4. **Check whether the approval already exists.** Before re-entering a gate, look for the operator's explicit written approval of this exact change. If it exists, take the direct path the approval already authorizes and say so plainly in the report. Pass: the report names the approval and the path taken, and nothing about the shortcut is silent.

5. **Match the instrument to the question.** Take the cheapest tool that can actually answer: a local review with real repository access before an external advisory session, the default model before the premium one, current prices before remembered ones. Pass: you can say what the next cheaper option would miss, and what the spend you kept is buying.

6. **Scope the machinery to the job.** A small scheduled task gets a minimal tool surface and an explicit allowlist, not everything the machine owns. Pass: the job's loaded surface is an enumerated list, and every item on it earns its place against the job's cost cap.

7. **When you overspend, write the ledger line.** Over-verification is recorded like any other failure: what the ceremony cost, what untested assumption drove it, what the one cheap probe would have been. Pass: the line exists, dated, in the same ledger as everything else.

## The case ledger

Seven entries. An operator notices under-verification every time it burns them; over-verification books its cost as diligence, so nothing forces the noticing. A class that hides from its own author will under-report in any ledger the author keeps, and this ledger carries one dated instance of exactly that: E129 below was first filed under chapter 10 by the look of its subject, a repository and personal data, until a later reading recognized the mechanism as ceremony out of proportion to a repo that had never shipped, and moved it here. Whether the class is rare or merely hidden, this dossier cannot say; the preface already conceded it has no denominators. What it can say is that the eighth entry is the one the ritual's last step asks you to write.

**[E006] Headless job cost blowout from full tool surface** (2026-06-19)
Receipt: a small scheduled headless job blew its tiny cost cap because it loaded the full tool and skill surface on startup, regardless of task size.
Rule: headless and scheduled jobs run with a strict minimal tool configuration and an explicit allowlist; the surface is scoped to the task, not to the machine.

**[E035] Routine git operations escalated on an untested assumption** (undated)
Receipt: an entire session routed every git operation in the harness's own configuration directory through operator-run commands on the assumption they would be blocked; they never were, and the round-trips were the only cost anyone paid.
Rule: run ordinary git operations directly in the harness's own directory; escalate to the operator only for a raw file mutation to a protected path or a recursive delete.

**[E118] Cosmetic surprises are not integrity evidence** (2026-05-30)
Receipt: cosmetic surprises in tool output, a color, a status line, a dedup note, were nearly escalated as integrity concerns without any concrete evidence behind them.
Rule: trust harness and plugin tool output by default; escalate to an integrity probe only on concrete evidence such as a hash mismatch or malformed output that contradicts an action just taken.

**[E121] The token dance for a change already approved in writing** (2026-07-03)
Receipt: operator-pasted confirmation tokens failed in both attempted inline forms for a dependency-lockfile gate, burning round-trips on syntax retries for a change the operator had already approved in writing.
Rule: once the operator has explicitly approved a specific dependency change in writing, take the direct ungated edit path and state the workaround transparently in the report.

**[E129] The full rewrite for a repo that never shipped** (2026-06-21)
Receipt: the reflex to scrub personal data with a full history rewrite and a fresh repository was reached for on a project that had never been published, where an in-place clean was all the blast radius called for.
Rule: set the scrub strategy by publication state; an unpublished repo is cleaned in place, and only an already-public one earns the fuller rewrite-and-replace.

**[E135] The premium spend and the stale multiple** (2026-04-12 / 2026-05-29 / 2026-04-14)
Receipt: cost analysis showed one premium model taking the large majority of a multi-day burst's spend despite a stated default of routing implementation to a cheaper model, and the cost multiple everyone was reasoning from was several times larger than the real one.
Rule: default implementation to the cheaper model, escalate to the premium one only when its edge clearly earns it or the cheaper model has failed twice, and keep the cost multiple current rather than reasoning from an outdated pricing memory.

**[E139] A session spent fighting a classifier a local review would have answered** (2026-07-03)
Receipt: an alternate model's safety classifier kept rerouting a legitimate question about hardening the operator's own systems even after rewording, wasting an advisory-only session for no benefit.
Rule: for a code-grounded question, run a local review by the harness's own strongest model with real repository access instead of arguing with an external model's guardrail.

## Adjacent doors

**If a mechanism actually refused you**, a guard blocked the call, a gate spat back the token, then you are not overspending, you are dealing with the control plane, and that is chapter 8. The dividing question is whether anything fired. An untested assumption that you would be blocked is this chapter; a real block is that one, and the two failures are corrected in opposite directions.

**If the cheap probe comes back positive**, the hash truly does not match, the surprising number survives a re-check against raw evidence, then the ceremony just earned itself, and you belong wherever the evidence points: chapter 1 if a success signal is lying, chapter 4 if the instrument is. This chapter governs the price of the probe, not what you owe when it hits.

**If the operation in front of you is wide, destructive, or public**, a batch across sixty repos, a deletion, a first push to a public remote, then spend without guilt. Chapters 9 and 10 are where the budget this chapter defends is meant to go, and proportionality cuts both ways: the same rule that strips the ritual from a status line is the rule that piles it onto a one-way door.
