[BUG] No working mechanism to review previous context after compaction, plan-mode clear, or branch navigation — data preserved but UI inaccessible

Related: #26123 partially fixed but still broken (49 👍, closed prematurely)

#26123 (/resume broken) was closed as "completed" after v2.1.47 fixed the picker limit and Windows case sensitivity. But two of the original bugs remain unfixed as of v2.1.50:

Bug 1 — Index staleness: sessions-index.json is not updated for new sessions. @vbhavsar reports 68 .jsonl files on disk but only 25 indexed. The v2.1.47 workaround (scanning .jsonl directly up to 50) masks this, but users with 50+ sessions per project still can't find their work. Tracked separately in #25032.

Bug 4 — /rename names invisible in picker: @ThatDragonOverThere reports that custom session names set via /rename display correctly in terminal tab titles but do not appear in the resume picker — it shows auto-generated summaries instead. With 6+ concurrent sessions, there's no way to tell which session is which. Confirmed on v2.1.50.

These compound directly with the bugs in this issue:

| Layer | Problem | Issue |
|-------|---------|-------|
| Find sessions | Index staleness — sessions not indexed | #26123 Bug 1 |
| Identify sessions | /rename names missing from picker | #26123 Bug 4 |
| Navigate branches | Right-arrow does nothing in picker | This issue, Bug 3 |
| View history | No pre-compaction content in transcript mode | This issue, Bug 1 |
| Link plan sessions | No connection to predecessor session | This issue, Bug 2 |

The resume picker is the single entry point to all historical context, and it's degraded at every level. Even if you manage to find and open a session, you can't browse its branches or view what happened before compaction.

#26123 has 49 👍 and should be reopened — the partial fix in v2.1.47 didn't address the most user-visible symptoms. I attempted to reopen but the repo restricts this to maintainers.

Hey anyone who is coming to this thread please comment how its affecting you so we can get Anthropic to pay attention to this and solve the entire suite of these regressions once and for all rather than inconsistent whac-a-mole style

Just hit this tonight. 509-turn session died at context overflow during a save operation. The JSONL file is 24MB of perfectly preserved data — every tool call, every correction, every branch point. All sitting on disk. Zero way to access it through the UI.

I've built custom recovery tooling (session-rescue.sh) that parses the JSONL to extract last state, files written, and corrections from crashed sessions. It works, but the fact that I had to build it at all is the bug. The data layer is flawless. The access layer is missing.

My specific pain points, in order:

1. Post-compaction Ctrl+O shows nothing useful. I rely heavily on compaction for long creative sessions. After compact, the pre-compaction reasoning is gone from the UI. I've resorted to writing manual state summaries to disk before every compact — essentially reimplementing what the transcript viewer should do.

1. Crashed sessions are black boxes without custom tooling. When a session hits context overflow mid-operation, the only recovery path is grep/jq on raw JSONL. The data is all there. Branch trees intact. parentUuid linkage perfect. Just no way to see it.

1. Plan-mode context loss. When accepting a plan with "clear context," the exploration session that informed the plan becomes a separate, unlinkable JSONL. The architectural decisions that led to the plan are orphaned.

The poster is right — this is purely a UI/rendering gap. The data engineering is solid. Would love to see even a basic read-only transcript viewer that loads the full JSONL and renders it chronologically. That alone would eliminate hours of manual recovery work per week.

Thanks for reporting all this, appreciate the feedback. I'm going to raise these to the team.

Plan-mode context loss. When accepting a plan with "clear context," the exploration session that informed the plan becomes a separate, unlinkable JSONL. The architectural decisions that led to the plan are orphaned.

Minor correction here: "Clear context" is actually more like "implement plan in new conversation"—you can /resume to go back to the session in which you were iterating on the plan. I think the action naming could be clearer (should probably say "Implement plan in new conversation" or similar to avoid this frequent source of confusion).

I’m consistently loosing last 15 minutes of work, especially when there are multiple subagents in background

every... time... every time I update there are majors bugs and/or regressions. Claude Code has been steadily like this for year... idk what to say. Idk how people still have the patience to dig into minified JS and draft well-crafted issues like these when the devs constantly prove they have no regard for stability. They simply don't deserve these efforts.

reverting to 2.1.19 fixed it for me.

Adding another scenario to this: background agents doing web searches.

When background agents are running, they often keep searching well beyond what I believe is needed. I can see they've already visited enough sources and I'm ready to move forward, but there's no way to say "stop and give me what you have." If I interrupt, the main agent reports it has no results from those agents. All work is lost.

I just noticed this on 2.1.69 .. I was away from claude for a week; On return, I though ghostty lost my scrollback settings .. something changed as I could scrollback before compaction previously .. this creates an impossible situation to supervise claude. My claude-cli auto-updates in place .. what is the best way to roll-back avoiding the deprecated npx method?

Confirming on v2.1.69 — Windows (MSYS2/Git Bash)

Version: Claude Code v2.1.69, Windows 11 (MSYS_NT-10.0-26200), MSYS2/Bash shell, Node.js runtime

Ctrl+E and Ctrl+O do not show session history from before compaction. The keybindings either do nothing or toggle minor UI elements (timing badges), but pre-compaction conversation content is inaccessible.

Why this matters beyond convenience

This compounds with compaction's context loss (#9796). For users running long-lived sessions with complex state (in my case, a trading system with multi-phase build plans, custom hooks, and plan files), the failure chain is:

1. Compaction loses context — project instructions deprioritized, active plan state lost
2. Post-compact hooks deprioritized — even with a SessionStart hook that re-injects rules (plan file path, sub-agent workflow, RAM safety), the model treats hook output as lower priority than its compressed summary
3. Ctrl+E/O broken — user cannot manually review pre-compact state to verify what was lost or re-orient the session

The net effect is that after compaction, the user has no recovery path at all. The automated recovery (hooks) is unreliable, and the manual recovery (Ctrl+E/O history browsing) doesn't work. The only option is parsing raw JSONL, which is not practical mid-session.

Echoing @ianbmacdonald's comment above — this creates an impossible supervision situation for long-running sessions.

Thanks for reporting all this, appreciate the feedback. I'm going to raise these to the team. > Plan-mode context loss. When accepting a plan with "clear context," the exploration session that informed the plan becomes a separate, unlinkable JSONL. The architectural decisions that led to the plan are orphaned. Minor correction here: "Clear context" is actually more like "implement plan in new conversation"—you can /resume to go back to the session in which you were iterating on the plan. I think the action naming could be clearer (should probably say "Implement plan in new conversation" or similar to avoid this frequent source of confusion).

Sev2 issue existing for over a month now, clearly affecting a bunch of users, does anyone at Anthropic care? What is going on here this is an easy fix.

Thank you for detailing this bug, it's been the most frustrating one for me.

Another temporary workaround: Use /fork every time you need a session up to a specific point saved.
Assume by default that the branch of the session you see in front of you is the only branch that you can access again via the TUI. You won't have them all grouped in a tree like they should be, but you can still find it as a different session at the same location.

Unless I'm mistaken, I think this works.

Kinda stupid and annoying especially given how easy this seems to be to fix.

This is the worst possible time to clear the screen. The consequence is that, if Claude has forgotten something following the compact, the user cannot manually scroll to remind themself. A --no-clear-on-compact option would be a big improvement.

Hook workaround: export conversation to markdown before compaction
Until the TUI adds a way to browse pre-compaction history, a PreCompact hook can export the full conversation to a readable markdown file before compaction runs:
pre-compact-transcript-export.sh:

INPUT=$(cat)
TRANSCRIPT=$(echo "$INPUT" | jq -r '.transcript_path // empty' 2>/dev/null)
if [ -z "$TRANSCRIPT" ] || [ ! -f "$TRANSCRIPT" ]; then
    TRANSCRIPT=$(find ~/.claude/projects -name "transcript.jsonl" -mmin -60 2>/dev/null | tail -1)
fi
[ -z "$TRANSCRIPT" ] || [ ! -f "$TRANSCRIPT" ] && exit 0
SNAPSHOT_DIR="$HOME/.claude/conversation-snapshots"
mkdir -p "$SNAPSHOT_DIR"
OUTPUT="$SNAPSHOT_DIR/$(date -u +%Y%m%d-%H%M%S).md"
{
    echo "# Conversation Snapshot ($(date -u '+%Y-%m-%d %H:%M UTC'))"
    echo ""
    while IFS= read -r line; do
        ROLE=$(echo "$line" | jq -r '.message.role // empty' 2>/dev/null)
        case "$ROLE" in
            user)
                echo "## User"
                echo "$line" | jq -r '.message.content // empty' 2>/dev/null | head -20
                echo "" ;;
            assistant)
                echo "## Assistant"
                echo "$line" | jq -r '[.message.content[]? | select(.type=="text") | .text] | join("\n")' 2>/dev/null | head -50
                echo "" ;;
        esac
    done < "$TRANSCRIPT"
} > "$OUTPUT"
echo "Snapshot saved: $OUTPUT" >&2
exit 0

Install in .claude/settings.json:

{
  "hooks": {
    "PreCompact": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "bash /path/to/pre-compact-transcript-export.sh"
          }
        ]
      }
    ]
  }
}

Every time compaction fires, the full pre-compaction conversation gets saved as ~/.claude/conversation-snapshots/YYYYMMDD-HHMMSS.md. You can read these files anytime to review what was discussed before compaction.
This doesn't fix the TUI limitation, but it gives you a persistent, human-readable record that survives compaction.

Another subtle case is when compaction is immediately followed by reaching the session limit. You have no recourse (unless you buy extra credits) to go back and check the conversation history, and have to wait until the next session window to ask Claude for a summary or previous details.

Its silly this is an issue? Its compaction data should be sent to a simple backend folder, file or internal memory if its going to compact, chat data should just be held locally and what is seen in the editor/extension/cli is simply a copy of that in an interactive wrapper?

Fix for this is over at https://github.com/anthropics/claude-code/issues/44772

will this also fix the multiple claude remote issues of continuing history after disconnect that keep being closed? If so great :)