The memory machinery

The model at the centre of this practice retains nothing from one session to the next. Everything that behaves like memory is built outside it, as ordinary files with rules about who writes them, when, and what may never be silently dropped. What follows is that machinery: what loads into a session at its start, the two records every session writes, the chain that carries unfinished work across the gap between sessions, and the bindings that hold it all together. The curated base, the deepest of the memories, has its machinery on this level's other pages: the gate that admits documents, and the grounding that ties their claims to sources.

The map

Four memories touch a session, at three different moments. One is read at the start. Two are written as the work happens and at its close. The last writes itself. The figure places them around one session, with the two bindings that hold the records together.

What loads at the start

A session begins empty, so its first memory is whatever is put in front of it. That selection is governed by one criterion with two halves: a document is imported into every session only if it is needed in every session, and only if it is canonical in one place. The calibration files pass both halves and load every time. Everything else fails at least one half and is read on demand instead: the session reads the latest handover because a pointer names it, and follows pointers onward only as far as the work at hand requires.

The criterion is stingy on purpose, for two reasons that pull the same way. The context a model works in is finite, and everything loaded at the start competes with the work for it. And loaded is not the same as active. Material sitting in context does not reliably steer behaviour by being there, which this practice measured on its own calibration: a standing line loaded into every session against one drift class bought a modest drop, and a model generation change did the rest. A rule that must actually hold gets a mechanism instead. What the boot load is for is calibration and orientation: how to engage, what the current state is, where everything else lives.

The boot load is also versioned like everything else. The calibration is ordinary files in the base, so what a session starts from is itself under the change record, and a calibration edit is a deliberate, recorded act rather than a preference drifting between sessions.

The change record

Every change to the base leaves through a commit, and the commit has a fixed shape. The subject is one short line: the lane the work belongs to, then the act. The body carries what the diff cannot: what changed and why, written by the party that made the change while the reasons were still present. Then the trailers: one line per thread of work the commit advanced, naming the thread's key. A message outside the shape is refused on the clone and again at the record, the same two-sided arrangement the write gate uses.

The shape exists because the record drifted once. For a stretch, the working state migrated into commit messages: handovers grew rare while commit subjects grew to paragraph length, and nothing tied a commit to the thread it advanced. Both records were degraded at once, each doing the other's job badly. The fixed shape gives each its job back. The subject is for scanning, the body is for the reasoning, and the trailers are for the machine: they are what binds this record to the chain.

The chain that cannot drop an item

Unfinished work survives the gap between sessions in a chain of handover documents, and the chain's design answers one measured failure. When the record was read end to end, roughly one listed thread in four had vanished at the next handover with nothing saying it had closed, most of them at a change of subject, and one item rode for months through that gap while its reminder fired twice. A thread had no stable identity, so nothing could tell a resolved thread from a dropped one.

So a thread gets a key: a short slug, born once, carried verbatim by every later handover for as long as the thread lives. Wording may change as the state changes. The key never does. And a thread leaves the chain only through a closing entry: the key, a date, and a one-line disposition saying what closed it. There is no other exit.

The checks make the exit rule structural. A new handover is checked at write time and again at the record: every key the previous handover carried must appear, open or closed, and every thread key named by a commit trailer since the previous handover must appear too. A handover that would silently lose a thread is refused. Silent drops stop being a discipline and become an impossibility, and a thread that rides unresolved for months is at least visible, which is the honest version of the problem.

Two properties complete it. The head of the chain is structural: it is the document nobody follows, a new close follows the head that exists, and a state with two heads is refused. And the chain is reconstructable sideways. Because trailers name keys, a search over the commit record rebuilds everything that happened to a thread between two handovers. The chain holds the state, the commits hold the story, and the binding means neither can quietly diverge from the other.

The record nobody writes

Underneath all of it runs the one memory that is not curated at all. Every session's full transcript is kept as it happened: every instruction, every reply, every tool call and its result. Nobody authors it, nobody tidies it, and nothing depends on anyone remembering to write it. It is the only record in the system whose completeness costs no discipline.

Its value is that it answers questions the curated records were never designed for. The measured series this practice keeps about its own working interface, corrections, offers, reading load, are all read from this record long after the fact, and no curated store could produce them, because nobody knew at the time which questions would matter. The discipline for reading it is its own subject: a pattern search over a record like this is a guess until its precision is measured, and that method lives on where the human sits.

The shape of the whole: three memories curated by different hands at different moments, and one not curated by anyone. The context is selected before the work, the commit is written in the moment of the change, the handover is written at the close under a gate that refuses forgetting, and the transcript accrues untouched. What the machine keeps maps what each memory can answer. This page is how each one is made.