Edit tool changes to git-tracked files silently reverted during context compaction

[Ascendral]

Summary

When a long conversation triggers context compaction (message compression), uncommitted changes made via the Edit tool to git-tracked files are silently reverted to their git HEAD state. New files created with the Write tool are not affected.

Steps to Reproduce

1. Start a Claude Code session in a git repository
2. Make multiple Edit-tool changes to tracked src/ files across a long conversation
3. Continue working until context compaction triggers (conversation approaches context limit)
4. Check file contents after compaction — Edit-tool changes are gone

Observed Behavior

• Edit-tool changes to tracked files disappear between tool calls after compaction
• New files (untracked by git) survive compaction
• Bash-written changes (e.g., echo >> file) also survive
• Changes committed to git before compaction are never lost
• No git hooks, file watchers, or external processes are responsible (verified)

Expected Behavior

Edit-tool changes should persist regardless of context compaction. The file system should not be modified by the compaction process.

Workaround

Commit immediately after every Edit-tool change:

git add <file> && git commit -m "description"

Or for multi-file atomic changes, write a Node.js script to /tmp/ using fs.writeFileSync, then chain:

node /tmp/fix.js && git add <files> && git commit -m "description"

Environment

• Claude Code v2.1.74
• Claude Desktop (macOS)
• macOS 26 (Darwin 25.3.0)
• Model: claude-opus-4-6
• Plugins: typescript-lsp (not installed/running), pyright-lsp, others

[yurukusa]

Until this is fixed, you can protect against silent reverts with a PostToolUse hook that auto-commits after edits:

#!/bin/bash
# auto-checkpoint.sh — PostToolUse hook on Edit|Write
INPUT=$(cat)
TOOL=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null)

# Only checkpoint after Edit or Write
[[ "$TOOL" != "Edit" && "$TOOL" != "Write" ]] && exit 0

# Check if we're in a git repo
git rev-parse --git-dir &>/dev/null || exit 0

# Stage and create a checkpoint commit (only if there are changes)
DIRTY=$(git status --porcelain 2>/dev/null | head -1)
if [[ -n "$DIRTY" ]]; then
    git add -A 2>/dev/null
    git commit -m "checkpoint: auto-save before potential compaction" --no-verify 2>/dev/null
fi
exit 0

Settings:

{
  "hooks": {
    "PostToolUse": [{
      "matcher": "Edit|Write",
      "hooks": [{ "type": "command", "command": "~/.claude/hooks/auto-checkpoint.sh" }]
    }]
  }
}

This creates git commits after every edit, so even if compaction reverts the working tree, you can recover with git log and git cherry-pick.

Alternatively, a lighter approach is the auto-snapshot.sh example which saves file copies to ~/.claude/file-history/ before every edit — no git pollution.

[github-actions]

Closing for now — inactive for too long. Please open a new issue if this is still relevant.