What does Claude Code forget when it compacts?

What survives depends on how each piece of context was loaded. What Claude Code loads from disk at startup comes back, and anything that lived only in the conversation is reduced to what the summary says. Anthropic's docs list each mechanism (what survives compaction):

Anthropic's troubleshooting page says an instruction that disappeared after compaction was given only in conversation, sits in a nested CLAUDE.md that has not reloaded yet, or is a path-scoped rule that has not matched a file since (Claude Code docs: memory). The fix is to move anything that must last into the project-root CLAUDE.md.

Tell Claude Code what to keep before it compacts, and keep the state of the work in files it reloads:

1. Compact with a focus before a long new task, for example /compact keep the failing test names and the migration plan. The summary keeps what you name instead of what the automatic pass guesses (context window docs).
2. Compact only part of the conversation. Run /rewind, pick a message and choose Summarize from here or Summarize up to here. The original messages stay in the session transcript (checkpointing docs).
3. Add a # Compact instructions section to the project-root CLAUDE.md to tell compaction what to keep (costs docs).
4. Add a SessionStart hook with the compact matcher. Whatever its command prints is added to the context after every compaction (hooks guide).
5. Keep the plan and progress in a file, such as docs/plan.md, and point to it from the root CLAUDE.md. The file survives on disk, and the root CLAUDE.md that names it is re-read after every compaction. The same file carries the work into a new session (a handoff file).
6. Run /clear between unrelated tasks. Anthropic's docs say old conversation crowds out the files you need next and costs tokens on every message (context window docs).
7. Send large reads to a subagent, so the file contents stay in its own context window instead of the one that gets compacted (context window docs).
8. Put a skill's key instructions near the top of its SKILL.md. After compaction a large skill body is cut to fit the per-skill cap, and the cut keeps the start of the file (what survives compaction).
9. Run /context to see what is loaded and what fills the window, including which CLAUDE.md and auto memory files loaded (context window docs).

# Compact instructions

Keep the current plan, the decisions we made and why, the exact commands
that reproduce the failing tests, and any rule I gave in chat.

{
  "hooks": {
    "SessionStart": [
      {
        "matcher": "compact",
        "hooks": [{ "type": "command", "command": "cat docs/plan.md" }]
      }
    ]
  }
}

Three settings control when Claude Code compacts on its own, and /compact keeps working by hand whichever you change:

• Idle compaction: set idleCompaction to false (Claude Code v2.1.290 or later). It fires after about 54 minutes idle, shortly before the prompt cache expires. It needs an interactive terminal session on the one-hour cache, at least 200,000 tokens of context by default (CLAUDE_CODE_IDLE_COMPACT_MIN_TOKENS moves this), autoCompactEnabled on, and access to Anthropic's feature flags (settings reference).
• When it fires: run /autocompact 500k, or set autoCompactWindow in a settings file, to choose how full the context gets first. Since v2.1.288 /autocompact saves the window for the current model under modelSettings in your user settings, and for that model it takes precedence over an autoCompactWindow in the same settings file. Values run from 100k to 1M tokens, capped at the model's window (model configuration).
• Whether it fires: set autoCompactEnabled to false, or DISABLE_AUTO_COMPACT for one session. This turns idle compaction off too (settings reference).

{
  "idleCompaction": false,
  "autoCompactWindow": 500000
}

A bug report filed on 1 October 2026 dates idle compaction to Claude Code 2.1.286, when it had no setting. Its author found sessions left idle overnight with a summary in place of their exact instructions and agreed methods, and other users reported the same after shorter breaks. The idleCompaction setting came in 2.1.290, and the report was closed on 6 October 2026 (issue #98747).

On a 1M-token window, models that run with it by default compact at about 967k tokens unless you set a window (default thresholds). Idle compaction applies from 200,000 tokens, so a 1M session left idle can compact when it is about a fifth full. If a 1M session compacted much earlier than you expected, check idleCompaction first, then a per-model window under modelSettings (where /autocompact saves it since v2.1.288), autoCompactWindow, a --autocompact launch flag, and the CLAUDE_CODE_AUTO_COMPACT_WINDOW variable, which takes precedence over the command, the flag and autoCompactWindow (it does not change idle compaction). CLAUDE_CODE_DISABLE_1M_CONTEXT=1 also holds a 1M model to a 200k window (turn off 1M context).

With automatic compaction off, a session held to a 200k window stops at the 200k boundary with a context-limit error instead of compacting, Anthropic's docs say (turn off 1M context). Separately, users have reported auto-compaction not firing at 100% on some versions (#63015, opened 28 May 2026, where /compact by hand still worked, and #66144, opened 8 June 2026, both open as of 23 October 2026).

Nested CLAUDE.md files and rules with paths: frontmatter load into the conversation when Claude reads, writes or edits a matching file, so compaction summarizes them away with everything else. They come back only when Claude touches a matching file again (what survives compaction). Anthropic's advice is to drop the paths: frontmatter or move a rule that must last into the project-root CLAUDE.md.

An open report from August 2026, #90450, found that file reads done through Bash in Auto Mode did not load nested rules at all. Commenters quote a 2.1.293 fix for single-file cat, head, tail, sed -n and grep reads. A commenter's test on 2.1.296, posted on 13 October 2026, found that such reads load rules even inside a command list joined by && or a semicolon, while pipes, redirects, cd dir && cat, grep -r and every Bash write still loaded nothing. To see what loaded and why, log it with the InstructionsLoaded hook (Claude Code docs: memory).

A compaction is one large request. Claude Code sends the conversation it summarizes, so its cost depends on whether that history is still in the prompt cache (prompt caching docs). While the cache is warm, the request reads the history at the cache-read rate. After a break longer than the cache lifetime, the whole history is processed again as uncached input, which is why /compact costs most on a resumed old session.

Anthropic lists compaction among the reasons usage climbs in a long session, beside long context, since Claude Code sends the full conversation with every request (costs docs). When you want a fresh start instead of continuity, /clear costs nothing. To choose when a compaction happens, run /compact at a natural break instead of letting it fire mid-task.

Yes, on disk. Claude Code writes the full transcript of each session, every message, tool call and tool result, to ~/.claude/projects/<project>/<session>.jsonl, and deletes it after cleanupPeriodDays, 30 days by default (.claude directory docs).

Inside Claude Code it is harder. An open report, #27242, filed in February 2026 on Claude Code 2.1.47 to 2.1.50, says the transcript view shows only messages after the compaction. Workarounds named there are reading the file with jq and a PreCompact hook that saves a copy before each compaction. You can also ask Claude to read the part it needs from that file.

{
  "hooks": {
    "PreCompact": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "mkdir -p ~/claude-transcripts && jq -r .transcript_path | xargs -I{} cp {} ~/claude-transcripts/"
          }
        ]
      }
    ]
  }
}