On 12 July 2026 a run of six tasks reported 639 file reads. In the same decision, my authorizer rejected the run's answer because there was
"no evidence of reading the design document" Both statements were wrong, in opposite directions. Eleven weeks later I got the same counter wrong again, the other way round.
Six tasks do not read 639 files. The counter behind read_ops scanned a whole evidence store, and the store was created lazily and never cleared between runs. Indexing and context syncing wrote rows into the same store with no task attached. read_ops counted every row anyone had ever written there. The number measured the age of the process, not the work of the run.
The rejection had the opposite problem. The authorizer, the model checking the final answer against the record, got counters and no paths. A count of 639 gives no way to check a claim about one document. The authorizer was asked a question about a file and handed a number. The model reasoned from what I gave the model, which is the only thing a model ever does.
I fixed both halves the same day. read_ops counts only rows tied to a task in the current run. The packet now carries the paths, up to 16 records of which task read which file, so a claim about a file is checked against the record of the same file. And the authorizer's instructions gained a rule: a path in the list is evidence the file was read.
On 27 September the counter misled me again. A later change put a task identifier on every row the analysis recorder writes, including every grep match and every directory listing. "Tied to a task" stopped meaning "read". In session 64c902e0 one child reported 1,107 reads against 34 files with real content. 944 of those rows came from a single search:
grep "package org.example" The one file the packet named as evidence had matched the grep and was never opened.
The second fix is the one I would keep. The code writing each row now stamps how the file was reached: read, grep match or listing. Only a read counts. The kind is a typed field set at the moment the row is written, never inferred later from the row's text.
This reminds me of another incident where we spent a month trying to understand why performance had all of a sudden tanked on a franchise ordering application. The app had run for 2 years without a problem, 30,000 logins per hour without a single issue for 2 years, and then one day it couldn't handle 1,000 logins. Everything read fine, every dashboard counter read normal. We finally noticed that there was one log line that read 0 for in-memory cache battery life. The battery life on an HP storage unit had a hardcoded in-service lifespan, and whether the battery was good or not, the HP storage manager would bypass the cache if the battery had reached its end of life. No one would know that a counter of 0 for a cache battery meant bypass the cache altogether, and in those days it was about accessing spinning disks.
The first time the number was too big because nothing was attributed. The second time the number was too big because everything was. Neither time did anyone change the counter. Somebody changed what wrote into the table behind the counter, and the meaning moved without a single line of the counter's code changing. Both times a model downstream made a sensible decision on a number nobody owned. A number nobody owns is a number everybody trusts.
The test: for every number your system uses to accept or reject work, name every writer of the table behind the number. If you cannot name them all, the number already means something you did not choose.
Source: Spec 004, AC-004-006-13, written 12 July and amended 27 September. The July run's logs have aged out of my log store. The specification entry written the same day records the numbers.
