Make Self size each cut against Hands' context budget

Operator direction, 2026-09-25: moderate inference spend mainly by making
cuts smaller, so each Hands agent carries less context. Sonnet degrades at
about 0.5M tokens.

SKILL.md step 3 now owns cut sizing: Self estimates the brief, the source
Hands must read, one verification and one fix round, and the item count,
treats 0.5M as the danger line, splits when the estimate passes about half
of it, and checks the reported token total afterwards. The Self-owned
clauses ("Self sizes a cut", one fix batch per file) moved out of the Hands
brief template into step 3; the Imagination template's split clause names
the budget. Section 5 no longer frames the 2026-09-23 spend as misplaced:
the operator counts it as legitimate work, the regret being the model.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

SKILL.md

@@ -188,6 +188,29 @@ question mattered, the operator said not at all.
 
 ### 3. Hands executes one cut
 
+**Size the cut against Hands' context budget before dispatch.** Self owns this,
+for map cuts and fix batches alike. Sonnet degrades at about 0.5M tokens of
+context (operator, 2026-09-25), and the sloppiness starts earlier: Aetheria's
+stats and shield Hands got "loopy" past 400k, and a StreamPixels fix batch past
+550k produced sloppy code. Treat 0.5M as the danger line, never the target.
+Before dispatch, Self estimates what the run will carry:
+
+- the brief, with the cut quoted inline;
+- the source Hands must read to edit safely: the files it touches and their
+  direct callers, not the repo;
+- one verification round at the end and one fix round, with their output;
+  test and mutation logs are usually the largest items;
+- the number of separate items. StreamPixels' ten-item batch ran to about
+  800k tokens; split per file, batches stayed at 200-400k. So a fix batch is
+  one file's findings by default.
+
+Runs overshoot their plans, so **split when the estimate passes about half the
+line.** Split by file or by deliverable, each part with its own verification.
+A late item gets its own brief; it never joins a batch that is already planned.
+Splitting a cut always beats a bloated brief. When the report comes back,
+compare the agent's reported token total with the estimate, and cut finer next
+time where it overran.
+
 Brief Hands with the cut's section of the map, the standing rulings restated
 briefly, and the verification. The brief says:
 
@@ -324,13 +347,15 @@ cut.** In the CultCache migration, Cuts 6 and 6b each needed four Soul passes, a
 the later passes still found real defects. Stop when a pass finds nothing that
 blocks, or only findings the operator chooses to record.
 
-**Quota is spent through scope, not through the number of passes.** On
-2026-09-23 the operator flagged that 60% of the weekly quota had gone in one
-day with little of it on the StreamPixels critical path. After that, Self ran
-one full Soul gate per cut. A fix batch went only to findings on the critical
-path, and the rest were recorded as follow-ups. Every later Soul pass covers
-only the fix batch's diff, as the second-pass clause in `briefs.md` says, and a
-small delta gets a narrow Sonnet pass. This does not cap the loop on a
+**Quota is spent through scope and cut size, not through the number of
+passes.** On 2026-09-23, with 60% of the weekly quota gone in one day, the
+operator redirected all work to the StreamPixels critical path. That spend was
+legitimate work; the operator's regret was the model it ran on (2026-09-25).
+Since then Self has run one full Soul gate per cut. A fix batch goes only to
+findings on the critical path, and the rest are recorded as follow-ups. Every
+later Soul pass covers only the fix batch's diff, as the second-pass clause in
+`briefs.md` says, and a small delta gets a narrow Sonnet pass. Hands' share is
+governed by the context budget in step 3. None of this caps the loop on a
 foundation cut. It keeps each pass the right size.
 
 When the same kind of finding recurs, the brief was missing context. Fix the

references/briefs.md

@@ -73,8 +73,8 @@ Spec standard, matching the existing cuts:
 - verification: builds, tests with the rule each one pins, Unity or other
   runtimes, negative greps, and the operator checks
 
-If the cut is too large for one Hands pass, split it with an explicit order and
-a verification step for each part.
+If a cut would not fit one Hands pass under <Self's context budget, SKILL.md
+step 3>, split it with an explicit order and a verification step for each part.
 
 Where only the operator can decide, list an explicit question with a
 recommended option.
@@ -150,8 +150,8 @@ Context is a budget, and a worker that fills it gets careless before it gets
 stuck. Aetheria's stats and shield cuts ran Hands past 400k tokens and the late
 work in those runs is where the sloppy claims appeared: a mutation reported
 against code that had moved, a failure called environmental without a check, a
-table printing numbers the old code never produced. So Self sizes a cut to fit
-one worker's head, and the brief says how:
+table printing numbers the old code never produced. Self sized this cut to fit
+one head (SKILL.md, step 3); keep it fitting:
 
 - **Verify once, at the end.** Not after every edit. A full mutation sweep and
   a batchmode compile per edit is most of a long run's spend and proves nothing
@@ -159,13 +159,6 @@ one worker's head, and the brief says how:
 - **Carry the cut inline.** Quote the cut's own section in the brief instead of
   pointing at a long map; a worker that reads 900 lines to find 60 has spent
   its budget before it starts.
-- **One fix batch per file.** A batch that packs many findings, a
-  subtraction, two hosts and a late addition does not fit in one head. On
-  StreamPixels on 2026-09-23, one batch of about ten items ran to about 800k
-  tokens over 2.6 hours, and another passed 550k and produced sloppy code.
-  After the findings were split per file, batches stayed at about 200-400k. A
-  late item gets its own brief. Do not add it to a batch that is already
-  planned.
 - **Keep expensive scaffolding alive across cuts** (a pinned dependency
   worktree, a warm build) rather than creating and removing it per pass.
 - **Hand back rather than push through.** A worker that finds itself far past

references/changelog.md

@@ -1039,3 +1039,27 @@ StreamPixels `2d4215c`):
   was stopped from holding a slot lock through an inherited file descriptor
   (`dbe594e`). The commits and the script header record the details.
 
+## 2026-09-25: Self sizes each cut against Hands' context budget
+
+Operator direction, 2026-09-25: Self should spend real attention on inference
+spend, mainly by making cuts smaller so each Hands agent carries less context.
+Hands runs often grow past about 0.5M tokens, which is where Sonnet starts
+behaving badly. The operator's reading of the 2026-09-23 quota spend (about
+60% of a week in one day; the 2026-09-24 entry above) is that it was
+legitimate work; the regret was running it on a more expensive, more verbose
+model just as Opus 5.5 released. Model choice already has an owner in Self's discipline ("name the
+model on every dispatch"); this entry is about context.
+
+The context-budget rule of 2026-09-18 said "Self sizes a cut to fit one
+worker's head" but named no number, and it lived inside the Hands brief
+template, which is text Self sends to Hands rather than a decision Self makes
+before sending it. So did "one fix batch per file", which is also Self's call.
+
+- SKILL.md step 3 now owns cut sizing: Self estimates the brief, the source
+  Hands must read, one verification and one fix round, and the item count,
+  against a 0.5M danger line, and splits when the estimate passes about half
+  of it. It compares the reported token total with the estimate afterwards.
+- `briefs.md`: the Hands template keeps the Hands-facing clauses and points at
+  step 3; "one fix batch per file" moved out of it into step 3. The Imagination
+  template's split clause names the budget as a placeholder Self fills in.
+- SKILL.md section 5 no longer describes the 2026-09-23 spend as misplaced.