What actually survives a long Claude Code session

A long session fails four different ways

The common advice online treats “context surviving long sessions” as a single problem with a single class of fix: tune your prompts, run /compact, lean on CLAUDE.md, target 60 percent window utilization. That advice is fine, but it only addresses one failure mode. Here are all four, sorted by whether a prompt can touch them.

The scoreboard: one prompt problem, three host problems. If your whole strategy for keeping context alive is prompt hygiene, you have a fix for 25 percent of the ways a long session fails. The deeper treatment of mode 01 lives in the auto-compacting write-up; modes 02 and 03 get their own page in the persistent-sessions guide.

What a host can do that a prompt cannot

Fazm is a native macOS app that runs the real Claude Code agent loop through the Agent Client Protocol. It does not change the model, your subscription, or the tools. What it changes is what happens around the SDK’s events. Three concrete mechanisms close the three host-problem modes, and they are all in the open-source bridge, so you can read them.

A session map that survives restarts and ID rolls

The bridge writes one row per session to ~/.fazm/acp-sessions.json, capped to the 200 most recent (PERSISTED_MAX = 200 in acp-bridge/src/index.ts). Each row records the directory the session belongs to, so a resume after a reboot, or after a rate limit rolled the upstream ID, targets the session that is actually on disk instead of a stale ID you happened to remember.

// ~/.fazm/acp-sessions.json  -  one row per session, newest 200 kept
{
  "sessionId":  "a1b2c3d4-...-e5f6",
  "sessionKey": "floating",
  "cwd":        "/Users/you/project",
  "model":      "claude-sonnet-4-6",
  "updatedAt":  1715731200000
}

On launch the app reopens every window with its conversation intact, so closing the lid stops being a recovery task. That is modes 02, 03, and 04 handled by a file, not a flag.

The compaction boundary, surfaced instead of swallowed

Mode 01 is not solvable: the SDK still owns when compaction fires. But it does not have to be silent. When Claude Code decides to compact, the SDK emits a compact_boundary system event carrying a pre_tokens count. The stock ACP agent drops that event. Fazm runs a patched entry point (acp-bridge/src/patched-acp-entry.mjs) that forwards it verbatim:

// patched-acp-entry.mjs forwards the system event the stock ACP agent drops
{
  "sessionUpdate": "compact_boundary",
  "trigger":       "auto",
  "preTokens":     161240   // example: tokens live the instant compaction fired
}

A boundary that fires with preTokens near 200k means the summarizer is about to flatten close to the whole window into a paragraph. Seeing that number is the difference between deciding to fork now and finding out 40 turns later that the model forgot the file path you set at the start.

One-click fork, so you branch before the boundary

Every chat has a fork button. It calls the ACP session/fork RPC (exposed by @agentclientprotocol/claude-agent-acp as unstable_forkSession). The new branch starts at the end of the current conversation with the full prior context; the original stays intact and resumable. When you can see compaction coming, forking at a known-good point turns the boundary from an accident into a choice.

A three-hour session, raw versus wrapped

The distinction that trips people up

Three things get conflated under the word “context,” and keeping them separate explains every behavior on this page. The transcript on disk is the JSONL file. It is durable. It almost never goes away. The restored window is what a host shows you when you reopen the app: it can be the full thread or nothing, depending entirely on whether the host bothered to record it. The model’s live context is the only one the model can actually reason over, and after a compaction it is the summary plus your recent turns, not the originals.

“My context did not survive” almost always means the third one shrank while the first one was fine the whole time. The transcript persisting and the model still seeing your early decisions are two different guarantees. Most advice online optimizes the first and quietly hopes for the second.

Common questions