Recovering from session loss — with AIR

A framework that promises continuity should be able to prove it the day a session dies without warning — not in theory, but on a real project, reported honestly. This site, its brand, and the kit behind it were built across several sessions. Twice, a working session stopped before it could hand off. Both times the project resumed in a new session with nothing lost. This is an account of how that worked — and where it would not have.

The setup

AIR carries a project across sessions with a handoff card: a structured snapshot of where the work stands — the active step, the open decisions, the blockers, the working agreement. The intended flow is to run the handoff command before a session ends, save the card, and boot the next session from it. This project ran on a frontier model — Anthropic's Claude (Opus) — while I steered. Twice, that tidy plan did not survive contact with reality.

Two ways a session died

The two failures were different, which is what makes them worth reporting rather than just retelling.

• A hard context cap. The first build session reached the limit of what it could hold and stopped — before it had emitted a handoff card.
• A silent stall. The second was stranger: no error, no warning. The session would trigger and then immediately stop, producing nothing. That symptom — start, then nothing — is what a context window looks like when it is too full to generate a reply. It reads like a crash; it is really exhaustion.

In both cases the session was effectively gone, and in both cases it had died before saving a card. The ideal flow had not happened. What mattered was whether the project could be recovered anyway.

How it recovered

It could. A fresh session read the framework files — the card template and the runtime rules — then reconstructed the handoff card from the dead session's own history: the project state, the exact active step, the open items, the agreements. The new session booted from that card and carried on — no restart, no re-litigating settled decisions, no lost work. The second recovery is the one you are reading now: this page was written in the session that the second card brought back.

Where the structure mattered

• The card schema gave reconstruction a shape. Rebuilding state from a long transcript is hard to do well from a blank page. The template defined exactly which fields to recover, so the new card captured the real stopping point instead of a vague impression of it.
• The honesty rules held under reconstruction. Each rebuilt card was marked as reconstructed-from-history, not as a live capture — so a careful reconstruction was never mistaken for a perfect recording.
• It guarded against stale memory. In the second recovery, the saved summary of the dead session was out of date. The reconstruction noticed, pulled the true latest state, and corrected the active step rather than confidently restoring the wrong one. That was the difference between resuming and resuming correctly.

Not a vendor feature

Both recoveries happened to use the model's ability to search past sessions, which made them smooth. But that feature is not the mechanism. The same recovery works without it: paste the dead session's transcript into a file and run the handoff flow against it. The card, the template, and the runtime are plain prompt files — the method travels to any model that can read them.

The honest limits

This is a discipline, not a guarantee. Recovery depends on the dead session still being reachable — through retrievable history, or a transcript you kept. If the conversation is gone and nothing was saved, there is nothing to reconstruct from. And the cleanest path is still the intended one: emit a card before the session dies. These recoveries worked because the work was reconstructable after the fact — not because loss is impossible.

The takeaway

A multi-session project hit two unplanned failures, in two different ways, and finished anyway — coherent, auditable, and resumable each time. That is what the handoff structure bought: not immortality for any one session, but continuity for the project that outlives them. Sessions are disposable; the work does not have to be.

The mechanism is in the open kit — read how handoff works, or boot a session and put it to the same test.