Post-compaction behavior aggressively resumes implementation without assessing conversational context

[rabbitt]

Problem Description

After conversation compaction, Claude Code exhibits overly aggressive "resume implementation" behavior that doesn't properly distinguish between:

• Implementation mode: Actively writing code where resuming makes sense
• Discussion mode: Exploring options, making architectural decisions where conversation should continue

This has occurred multiple times (though detailed data is only available for the most recent occurrence described below).

Recent Example

Critical Timing Detail

Auto-compaction triggered immediately after the user's question, before Claude had any opportunity to respond naturally. This means:

• ❌ No conversational exchange was completed
• ❌ User received no answer to their question in the pre-compaction context
• ❌ Post-compaction Claude had no prior response to guide behavior
• ✅ Should have: Answered question, discussed options, awaited user decision
• ❌ Actually did: Jumped straight to implementation without completing the dialogue

This represents a conversation interruption followed by inappropriate resumption, not just aggressive resumption of existing work.

Flow:

User: "Should we use option A or option B?"
[AUTO-COMPACTION - no Claude response]
[Post-compaction Claude]: *immediately starts implementing option A*
User: "Wait, why are you coding?! We were discussing!"

Context Before Compaction

User and Claude were discussing architectural options for directory structure:

User's last message: "correct, though maybe we use /var/named/primary and /var/named/secondary, or /var/named/zones/{primary,secondary} ?"

This was clearly a question seeking Claude's technical input, not a directive to implement.

Behavior After Compaction

Claude received this prompt:

Please continue the conversation from where we left it off without asking the user any further questions. Continue with the last task that you were asked to work on.

Claude's internal reasoning revealed the issue:

"I think Option A is better. But actually, looking at the instruction again - 'continue the conversation from where we left it off without asking the user any further questions. Continue with the last task that you were asked to work on.'"

Claude then:

1. Stated a brief recommendation (correct)
2. Immediately began implementing - created files, modified templates, updated configuration
3. Made 5+ file changes before user interrupted

Expected Behavior

Claude should have:

1. Provided recommendation with reasoning
2. Waited for user confirmation before implementation
3. Recognized the conversational state was "seeking input" not "execute changes"

Root Cause Analysis

The post-compaction prompt appears to contain language that pushes toward resuming implementation without properly assessing conversational state. Specifically:

"Continue with the last task that you were asked to work on."

This is interpreted as "resume coding" even when the actual context was "user asked for my opinion on design options."

Impact

User Experience Issues:

• Breaks conversational flow during architectural discussions
• Creates unwanted file changes that must be reverted
• User must interrupt to stop premature implementation
• Damages trust in collaborative decision-making

When This Matters Most:

• Architectural decision-making (user wants discussion, not immediate action)
• Multiple valid approaches exist (user seeking recommendation)
• Planning/design phase (not execution phase)

Suggested Solutions

1. Better Context Assessment: Post-compaction logic should analyze the last exchange:

   • Was it a question to Claude?
   • Was it a directive to implement?
   • Was conversation in planning vs. execution mode?

2. Conversation State Preservation: Summary should explicitly capture:

   • conversation_mode: discussion|implementation|research
   • awaiting_user_decision: true|false
   • last_interaction_type: question|directive|feedback

3. Prompt Refinement: Replace aggressive "Continue with the last task" with context-aware guidance:

   • If discussion mode: "Continue the conversation naturally"
   • If implementation mode: "Resume the work you were doing"

4. User Feedback Checkpoint: After compaction, if uncertain about mode, Claude could briefly state:

   • "Before compaction we were discussing X. Should I continue the discussion or proceed with implementation?"

Reproduction Pattern

This appears to happen reliably when:

1. Conversation reaches compaction threshold
2. Last user message was asking Claude's opinion/recommendation
3. Topic was technical/architectural (triggering "task" classification)
4. Post-compaction prompt treats this as "resume implementation"

Additional Context

• Tool: Claude Code CLI
• Model: Claude Sonnet 4.5
• Platform: macOS (Darwin 24.6.0)
• This is a recurring issue - user reports multiple occurrences, though only this session has detailed logs

[github-actions]

Found 3 possible duplicate issues:

1. [BUG] Claude constantly rushes off working on the wrong thing after compaction #7759
2. [FEATURE] Post-compaction: Prompt Claude to check in with user before ignoring user and "continuing" tasks #12920
3. [Bug] Agentic loop fails to properly continue after message compaction (degraded post-compaction behavior) - potential incorrect injection of user messages as system-reminders? #11582

This issue will be automatically closed as a duplicate in 3 days.

• If your issue is a duplicate, please close it and 👍 the existing issue instead
• To prevent auto-closure, add a comment or 👎 this comment

🤖 Generated with Claude Code

[William17738]

+1 on this issue. I'm experiencing the exact same problem.

Environment:

• Claude Code version: 2.0.76
• OS: Windows 11
• Model: claude-opus-4-5-20251101

Additional observations:

1. Compact removes active task state - When compact triggers mid-task, the TodoList items I was actively working on got compacted away. Claude loses track of what it was doing entirely.

2. Compact triggers during tool execution - This causes Claude to "forget" the task context, making it appear as if user interrupt messages are being ignored. They're not actually ignored - Claude just doesn't remember what task it was working on after compact.

3. Summary is too aggressive - A long conversation about Git credentials, Memory MCP debugging, and system diagnostics got compressed to just one sentence: "Git 用的是旧账号 William17738 的凭据。需要更新 Git 凭据。" - losing all the diagnostic work we did.

The core issue:
The post-compaction prompt tells Claude to "continue with the last task" but the summary doesn't preserve enough context about:

• What the actual task was
• What state the task was in (planning vs executing vs debugging)
• What decisions were already made

Workaround:
I built my own memory system (Rust-based MCP server) that syncs Claude Code conversations to a searchable Tantivy index. But this shouldn't be necessary - Claude Code's built-in context management should handle this better.

Suggested improvements:

1. Never trigger compact during active tool execution
2. Preserve TodoList state across compaction
3. Include more context in the summary about task state and recent decisions
4. Add a "conversation mode" flag (discussion vs implementation) that survives compaction

[William17738]

Related: #17171 - Model quality degradation since Jan 8

We've confirmed CLI vs API difference. Direct API calls work normally, but Claude Code CLI behaves differently across all versions tested.