The Field Manual

The Stale Record

Part I: The World, Misreported

You are here if

Something you are executing was written before now, and the world has had time to move. You are three steps into a handoff checklist and step four is already done, or the file it names does not exist. The command you just ran failed, and you typed it exactly as documented. You are about to write the words the fix is missing, and the checkout you are reasoning from has not been pulled today. You are about to build something you cannot quite believe does not already exist. An update ran overnight and this morning the tooling is subtly off. Other sessions are working the same ground, and the bug you are holding may already be dead.

You are also here, inverted, if the file you are about to change carries a comment telling you not to change it that way, and you are deciding whether the comment still counts.

The dividing question between this chapter and the last one is whether the claim was ever a fact. A signal that was born false is chapter 1. A record that was true the day it was written and describes nothing today is this chapter. And if you changed something and nothing changed, no record is involved; your write never landed, and that is chapter 3.

The mechanism

A record is written once, by one hand, at one moment. The target it describes keeps accepting writes forever: upgrades, renames, deploys, housekeeping daemons, and every other session working the same ground. The world has more writers than any record has editors, so drift is not a failure mode of records; it is their resting state. Keeping the target current is always somebody's job. Updating the record that describes it is almost nobody's.

The drift stays dangerous because records do not age visibly. Text does not yellow. A checklist asserts in the present tense on the day it is written and asserts in the same present tense six weeks later, confidence frozen at authoring while the truth underneath decays. Worse, stale records corroborate each other, because copies agree with copies. Two documents describing the same dead moment look like two pieces of evidence, and they are one source, quoted twice.

The type specimen. A handoff note said a component had a real performance problem. A static-analysis script agreed. On the strength of two agreeing sources, a session went a long way into designing the fix before anyone bought the cheap check: a live probe of the actual behavior, minutes of work, which showed the behavior was already correct and the fix unnecessary. Neither source was lying. Each described a moment that had since closed, and their agreement measured their shared ancestry, not the system. The redesign cost hours, the probe cost minutes, and the only real error was the order they ran in.

This is the heaviest ledger in the manual: twenty-two entries out of the hundred and forty-seven the eleven classes account for, the largest single class. Over a year of operating, the most common way the world lied was not a signal born false or an instrument reading wrong. It was a true statement kept past its expiry.

Book One's fourth chapter earns the full argument, that a dossier is a lead and never ground truth, and that the regress of checking the checker terminates at reproduction against live state; this chapter inherits that whole and adds only the clock. One more thing before the rule, because the rule's wording depends on it: the discipline says reconcile, not discard. One entry in this ledger is a record that was right and was nearly overridden anyway. The reconciling move has to be able to come back with the other verdict: the record survives, and now it binds you.

The discipline

Reconcile every record against the live target before executing it; a record is a hypothesis with a timestamp.

The ritual:

  1. Date the record. Find when it was authored: the commit date, the file's modification time, the session it came from. Pass: you can state the record's age, and an undated record is handled as stale until proven live, not live until proven stale.
  1. Name the live target. Identify the actual state the record claims to describe: the thing itself, not another record of it. Pass: what you name is a remote ref, a running process, a deployed page, or source code, and not a second document that could be equally stale.
  1. Fetch before you reason. Read the target through the least-cached channel available: fetch the remote before any merged-state claim, read the CLI source instead of the README, probe the running behavior instead of the note about it. Pass: the evidence in front of you is newer than the record it is checking.
  1. Diff the record against the world, item by item. Mark every claim in the record confirmed, drifted, or already done. Pass: every item carries one of the three marks before anything executes, and only the confirmed residue gets executed.
  1. Verify absences across idioms. A record claiming that something is missing, a gap, an unshipped feature, an unfixed bug, needs a live search across the plausible namings and the canonical index, not one grep of one phrasing. Pass: an absence claim has survived at least a second, differently worded search before you build anything on it.
  1. Obey the record that survives. Reconciliation is symmetric. A record confirmed against the live target is binding, and overriding it now requires a flagged conflict, not silent judgment. Pass: any surviving record you still intend to override is escalated in writing, with the record's claim named and the reason for overriding stated next to it.

The case ledger

The ledger splits along a visible seam: records written down, and records merely held. Both halves fall to the same reconciling move, which is why they share a chapter.

The record on paper. Fourteen entries where the stale record was an authored artifact: a checklist, a doc, a path literal, a flag, a call site.

[E087] A claim validated only after the fix was designed (2026-05-16 / 2026-06-12) Receipt: a handoff note and a static-analysis script both claimed a real performance problem, and a session went deep into a redesign before a live probe showed the behavior was already correct. Rule: treat handoff notes and static findings as hypotheses; buy the cheap live probe before designing any fix.

[E109] The documentation claimed a layer was skipped (2026-05-30 / 2026-06-12 / 2026-06-19) Receipt: documentation claimed one permission layer was skipped entirely under a bypass mode, but a live probe proved the opposite, that the layer is still a real floor. Rule: trust a live probe over the documentation when reasoning about what a permission or enforcement layer actually blocks.

[E031] The documented invocation was subtly wrong (2026-06-02) Receipt: the documented invocation for a feature failed three times over a flag-placement quirk and a stale command mirror, while matching the README exactly. Rule: when the README and the source disagree, use the verified flags-first invocation from the source, not the packaged wrapper form.

[E062] The two-remote repo defaults to the stale archive (2026-06-02 / 2026-05-18) Receipt: a push defaulted to a stale archived remote instead of the active one, and the PR tool failed on disjoint history. Rule: in a dual-remote repo, push and open PRs against the named active remote explicitly, never the bare default.

[E011] The hardcoded versioned install path (2026-06-10) Receipt: a launcher hardcoded a versioned package-manager install path, and the next upgrade deleted it, silently breaking an MCP connection. Rule: point launchers at the stable version-tracking symlink, never at the versioned install path.

[E083] The handoff checklist reflects authoring time (2026-06-12) Receipt: a handoff checklist described state at authoring time, not execution time, and executing it blindly against the drifted system risked redoing and skipping real work. Rule: reconcile each claimed-pending item against the live target first, and apply only the genuine residue.

[E133] Three candidate data sources, one true one (2026-06-28) Receipt: a site's live data lived only in a gitignored ephemeral database, and at deploy time three candidate data sources sat on disk, only one matching what had shipped. Rule: before redeploying, confirm which candidate matches the committed snapshot, and surface ambiguity instead of guessing which to rebuild from.

[E082] Stale premises in a delegated work order (2026-07-03) Receipt: a work order asserted stale factual premises about the current state of a system, and a delegate executing it confidently would do confident damage. Rule: live-check every premise a dispatch spec asserts before handing it off, and give the spec a flag-first option so a stale premise becomes a caught signal instead of a bad edit.

[E094] Index one-liners describe finished missions (2026-07-03 / 2026-06-19) Receipt: a memory index's one-line summaries and cross-session handoff prompts described point-in-time state that other sessions had since completed, inviting a redundant re-execution. Rule: before executing a publish, wire, or upload instruction, read the full underlying file and probe the live registry, not the index line.

[E040] The stale branch is usually already subsumed (undated) Receipt: a flagged branch's real payload was a handful of source changes buried under hundreds of thousands of lines of stale generated diff, and most flagged branches were already merged. Rule: check whether a stale branch is already subsumed on the current head before touching it; for a genuine delta, extract the source contribution and rebuild rather than merging the divergent history.

[E050] The renamed repo re-points old clones (undated) Receipt: after a rename freed a repo's old name and a new repo took it, every local clone still holding the old URL silently resolved to the new repo. Rule: repoint a renamed repo's local remotes to the new URL before creating anything at the freed name, never after.

[E095] The by-hand list was already applied (undated) Receipt: a list of apply-these-by-hand follow-up edits had already been fully applied by an earlier automated step, so executing it blind was a no-op at best and a double edit at worst. Rule: read each target file first and cross off anything already in place before touching it.

[E097] The rollback note names a command that does not exist (undated) Receipt: a rollback note referenced a CLI subcommand that did not exist, twice, across different feature graduations, because the doc and the command name had silently diverged. Rule: before committing a rollback note, grep the CLI source to confirm the referenced command and its flags exist.

[E147] The call sites outlive the interface (undated) Receipt: after a shared tool's parameters changed, two consumer skills kept calling with the old parameter set and silently fell back to a default that misrepresented the operation's context. Rule: after any shared interface change, grep every consumer for call sites of that tool and audit each one for the new parameter.

The record in a running head. Seven entries where nothing on disk was wrong. The stale record was a premise held live in memory, the session's or yours.

[E078] A parallel session may have already fixed it (2026-06-07 / 2026-06-12 / 2026-06-14) Receipt: with multiple sessions running in parallel, a documented bug or proposed fix can already be shipped by another session by the time it is acted on. Rule: before drafting a fix, check recent commits and cross-session pickup notes to confirm the issue is still open.

[E088] The brainstormed gap is often filled (2026-06-19) Receipt: brainstorm-driven critiques of a mature codebase assumed gaps that were already addressed, and a single grep missed an existing implementation written in a different idiom than searched. Rule: confirm a gap against live code or a rendered view, searching the concept across plausible idioms, before building the slice.

[E079] The requested feature is already shipped (2026-06-20 / 2026-06-28) Receipt: a requested feature nearly got rebuilt from scratch even though the session's own start-of-session commit snapshot already named it as shipped. Rule: scan recent commits and the default branch's log for the named deliverable before any nontrivial build; it may only need review or extension.

[E059] The stale local main (2026-06-21) Receipt: reasoning about what was actually merged ran on a stale, unpulled local checkout and nearly produced a false claim that already-merged code was missing. Rule: fetch and read the remote's default branch before reasoning about merged state, and branch fix-forward work off that fetched reference.

[E081] The live connection enforces dead rules (2026-06-21) Receipt: a shared context store's per-owner write gate was removed without warning, and a live client connection kept holding the old ownership rules in memory. Rule: reconnect the client session after any policy change; a live connection can hold stale in-memory behavior indefinitely.

[E004] The session predates the update (2026-06-24 / 2026-06-26) Receipt: right after a harness auto-update, a session showed a stale model handshake, and deny rules naming a renamed tool threw harmless startup warnings. Rule: restart the session first after any harness update before treating odd behavior as a real bug, and clean dead deny entries as cosmetic, not urgent.

[E103] The trend-shaped gap (2026-06-26) Receipt: reasoning from general industry trends instead of the actual published corpus manufactured a content gap that did not exist. Rule: check the canonical published index and the local project list first, and propose a build only once its absence is verified.

The record that was right. One entry, and the reason the rule says reconcile instead of distrust.

[E143] The design-intent comment was right (2026-07-07) Receipt: two page templates carried leading comments stating a deliberate design constraint, and a broader visual treatment was nearly imposed over both, which would have quietly violated the exact honesty the pages were built on. Rule: before restyling any component, read its template's leading comment; a record that survives reconciliation is binding, so honor it or flag the conflict, never silently override it.

Adjacent doors

If you walk the record back to its authoring moment and it was wrong then too, time is not your problem. A checklist that was false the day it was written, a success signal that never described the world, is chapter 1, and the distrust it installs is the one this chapter assumed you already had.

If the live target you reconciled against was itself read through something, an index, a cache, a convenience endpoint, a scanner, and the probe's answer is now the thing you doubt, that is chapter 4: the record was fine, the world was fine, and the lens between them was not.

If the record is going stale while you watch, because another writer is live in the same tree right now, the branch pointer moving under you, files changing between your read and your write, then reconciliation will not converge and a fresher read is not the fix. That is chapter 5, and its first correct move is one this chapter never needs: yield.