Sessions that share a machine take leases.

On 28 September Tristan left one engine session re-ingesting Continuum's documentation into its own memory, with Lightning extracting facts on the GPU, and opened a second to build the Dashboard's pipeline pages.

Both sessions reach the same stack on the same pinned ports, 5150 to 5156, the same card and whatever is loaded on it, the same Docker, the same working tree and each other's processes. Either can break the other without meaning to: an AppHost restarted under a benchmark, a model load that pushes another model's layers onto the CPU, a build over DLLs a running host holds. Earlier that morning, while the stack ran, its window's host process held the Terminal's binaries, and a solution build failed on MSB3021.

Before leases, keeping out of each other's way was glue. A session announced a build window before building, named its processes by id so the other wouldn't stop them, and asked before touching the other's stack, all by message.

Each lease records an owner, a purpose and an expiry, under continuum:lease:<resource>. The expiry is the key's TTL, so a holder that dies lets go when it runs out, and nothing has to notice the death. Taking and releasing are Lua scripts, so the owner check and the write are one step, and of two sessions taking at once only one wins.

• Cache files keyed by session_id. Every hook keeps its state in .claude/.cache/ under the session's id: the projects whose README a session has already seen, the messages saved before a compaction, the ledger of what instructions loaded.
• One journal entry per feature per day. Two sessions working on two features append to two files.
• Tests on isolated stores. The integration suite runs on stores of its own, empty each run, so a test can't corrupt the dev data another session is using. The ports are pinned, so a test run still needs the stack stopped, and that is what the stack lease is named for.
• Builds to a scratch folder. When another session's processes run from bin, a build goes elsewhere with -o. The 28 September lab ran from a Terminal built that way while the stack held the real one.

The journal is the handoff between sessions. A session writes its entry as it goes, with the questions, the decisions and the next steps, and a hook blocks the end of a turn once three of the person's messages are unrecorded, and saves them to disk before a compaction. The next session receives the catch-up as it starts.

Until 28 September the catch-up hook printed the last three entries whole, and the entries kept growing once they recorded every question and answer. Claude Code caps a hook's context at 10,000 characters. Past that it saves the text to a file, hands the model the path and the first 2,000 characters, and, in its own documentation, "doesn't ask Claude to read the file." From 19 to 28 September that happened on 93 session starts, to catch-ups of 14 to 135 KB.

On the morning of 28 September the 2,000 characters held the instruction check, the catch-up's heading, the line "This is your continuity context - do not re-read these files", and the start of the first entry's title, cut off inside its date. CLAUDE.md said the same: "That is your catch-up - do not re-read those files." It was written for a hook that worked, and it kept sessions from reading the entries the hook had failed to deliver. Across those nine days a session opened the saved copy three times.

The fix landed the same day. The hook now injects each of the last three entries' header and its open questions and next steps, with a line index of its sections, cut to an 8,000-byte budget, starting with the oldest entry's next steps. CLAUDE.md now says to read the rest when the work touches it. Run against that day's journal, the old hook would have injected 43,485 characters, and the new one injects 4,925.

An instruction that trusts a hook hides the hook's failure. So every hook that injects text has a budget, cuts to fit and says where the rest is, and in the kit below, the next session start reports any hook that had to cut.