When context pressure reaches critical levels (80%+), invoke this skill to:
Save current session state
Delegate continuation to a fresh subagent
Continue work without manual intervention
Skill(conserve:clear-context)
When To Use
Proactively: Before starting large multi-chained tasks
Reactively: When context warning indicates 80%+ usage
Automatically: Integrated into long-running workflows
When NOT To Use
Context usage is under 50% - continue working normally
Mid-critical-operation where handoff would lose state
Consider "Summarize from here" first (Claude Code 2.1.32+): Before full auto-clear,
try partial summarization via the message selector. This compresses older context while
preserving recent work, often sufficient to relieve pressure without a full handoff.
The Auto-Clear Pattern
Since /clear requires user action, we achieve automatic context clearing without interruption through subagent delegation:
Main Agent (high context)
↓
Saves state to .claude/session-state.md
↓
Spawns continuation subagent (fresh context)
↓
Subagent reads state, continues work
Thresholds
Level
Threshold
Action
WARNING
40%
Monitor, plan optimization
CRITICAL
50%
Prepare for handoff
EMERGENCY
80%
Execute auto-clear now
Configuration (environment variables):
CONSERVE_EMERGENCY_THRESHOLD: Override 80% default (e.g., for 75%)
Important: Before saving state or spawning a continuation agent, reconcile the task list:
Review all tasks via TaskList
Mark completed tasks as completed via TaskUpdate: do NOT leave done work as in_progress
Record existing task IDs: collect all task IDs (pending and in_progress) to pass in the session state so the continuation agent references them instead of creating duplicates
Include task IDs in session state under the existing_task_ids field (see Step 2)
This prevents the continuation agent from creating duplicate tasks.
Step 2: Save Session State
Important: If .claude/session-state.md already exists, always Read it first before writing (Claude Code requires reading existing files before overwriting). Create the .claude/ directory if it doesn't exist.
Write to .claude/session-state.md (or $CONSERVE_SESSION_STATE_PATH):
# Session State Checkpoint
state_version: 1
Generated: [timestamp]
Reason: Context threshold exceeded (80%+)
## Execution Mode
**Mode**: [unattended | interactive | dangerous]
**Auto-Continue**: [true | false]
**Source Command**: [do-issue | execute-plan | etc.]
**Remaining Tasks**: [list of pending items]
> **Important**: If `auto_continue: true` or mode is `dangerous`/`unattended`,
> the continuation agent should not pause for user confirmation.> Continue executing all remaining tasks until completion.## Current Task
[What we're trying to accomplish]
## Progress Summary
[What's been done so far]
## Key Decisions- Decision 1: [rationale]
- Decision 2: [rationale]
## Active Files- path/to/file1.py - [status]
- path/to/file2.md - [status]
## Pending TodoWrite Items- [ ] Item 1
- [ ] Item 2
## Existing Task IDs
[List task IDs from TaskList so the continuation agent can reference them
instead of creating duplicates. Example:]
- Task #1: "Implement feature X" (in_progress)
- Task #2: "Write tests for feature X" (pending)
## Continuation Instructions
[Specific next steps for the continuation agent]
Step 2.5: Verify Session-State Clarity Before Handoff
A continuation agent inherits only what session-state.md says. If
the draft is ambiguous, the new agent starts from corrupted task
state. Before spawning, gate the handoff on the belief-clarity check
(the belief-clarity module of Skill(conserve:context-optimization)),
which asks two anchor questions against the draft state:
Progress probe: what is the current task progress: what is
done, and what state is the task in now?
Gap probe: what information is still needed to finish: a
bounded list of concrete open items, not generic categories.
Gate logic:
Both answers specific and bounded: save and proceed to Step 3.
Gap probe open-ended or progress probe hedging: append the failing
probe's answer to session-state.md as explicit Current state:
and Still needed: bullets, then re-score.
Progress probe vague or empty: do not hand off. Confirm current
state with the user (or imbue:proof-of-work in unattended mode)
before writing state and retrying.
When memory-palace:memory-clarity-probe is installed, delegate the
dual-probe evaluation to it and use its "Proceed" composite as the
gate. This check is qualitative: it catches drift and omission, not
confidently-wrong state, so pair it with task-state verification for
high-stakes handoffs.
Step 3: Spawn Continuation Agent
Use the Task tool to delegate. Important: Include execution mode in the task prompt:
Task: Continue the work from session checkpoint
Instructions:
1. Read .claude/session-state.md for full context
2. Check the "Execution Mode" section FIRST
3. If `auto_continue: true` or mode is `dangerous`/`unattended`:
- DO NOT pause for user confirmation
- Continue executing ALL remaining tasks until completion
- Only stop on actual errors or when all work is done
4. **TASK LIST**: Do NOT create new tasks via TaskCreate. The parent agent
already created the task list. Use TaskList to see existing tasks, and
TaskUpdate to mark them in_progress/completed. Check the "Existing Task IDs"
section in the session state for the authoritative list.
5. Verify understanding of current task and progress
6. Continue from where the previous agent left off
7. If you also approach 80% context, repeat this handoff process
- PRESERVE the execution mode when creating your own checkpoint
The session state file contains all necessary context to continue without interruption.
**Execution mode inheritance**: Always inherit and propagate the execution
mode from the session state. If the parent was in dangerous/unattended mode,
you are also in that mode. Do not ask the user for confirmation.
**Task deduplication**: Do not create duplicate tasks. The parent has already
populated the task list. Use TaskUpdate on existing task IDs only.
For batch/multi-issue workflows (e.g., /do-issue 42 43 44):
Task: Continue batch processing from session checkpoint
Instructions:
1. Read .claude/session-state.md for full context
2. EXECUTION MODE: This is a batch operation with auto_continue=true
3. Process ALL remaining tasks in the queue:
- Remaining: [issue #43, issue #44]
4. DO NOT stop between tasks - continue until all are complete
5. If you hit 80% context, hand off with the same execution mode
6. Only pause for:
- Actual errors requiring human judgment
- Completion of ALL tasks
This is an unattended batch operation. Continue without user prompts.
Task Tool Details:
Spawns subagent with fresh 1M context window
Up to 10 parallel agents supported
~20k token overhead per subagent
Step 3 Fallback: Graceful Wrap-Up
If Task tool is unavailable (permissions, context restrictions):
Complete current in-progress work (finish edits, commits)
Summarize remaining tasks in your response
Let auto-compact handle continuation - Claude Code compresses context automatically
Manual continuation options:
claude --continue to resume session
New session and /catchup to understand changes
Read .claude/session-state.md for saved context
Fixed in 2.1.63: /clear now properly resets cached skills. Previously, stale skill content could persist into the new conversation. The /clear and /catchup pattern is now fully reliable.
Fixed in 2.1.72: /clear now only clears foreground tasks. Background agent and bash tasks continue running. Previously, /clear would kill all tasks including background ones, which was problematic for long-running background agents that should survive context resets.
Integration with Existing Hooks
This skill works with context_warning.py hook:
Hook fires on PreToolUse
At 80%+ threshold, hook injects emergency guidance
Guidance recommends invoking this skill
Skill executes auto-clear workflow
Module Loading
For detailed session state format and examples:
See modules/session-state.md for checkpoint format and handoff patterns
See modules/session-state-schema.md for versioned schema and migration logic
Self-Monitoring Pattern
For workflows that might exceed context, add periodic checks:
# Pseudocode for context-aware workflowdeflong_running_task():
for step in task_steps:
execute_step(step)
# Check context after each major stepif estimate_context_usage() > 0.80:
invoke_skill("conserve:clear-context")
return# Continuation agent takes over
Context Measurement Methods
Precise (Headless/Batch)
For accurate token breakdown in automation:
claude -p "/context" --verbose --output-format json
See /conserve:optimize-context for full headless documentation.
## Brainstorm Session with Context Management1. Before starting, note current context level
2. Set checkpoint after each brainstorm phase:
- Problem definition checkpoint
- Constraints checkpoint
- Approaches checkpoint
- Selection checkpoint
3. If context exceeds 80% at any checkpoint:
- Save brainstorm state
- Delegate to continuation agent
- Agent continues from checkpoint
Best Practices
Checkpoint Frequently: During long tasks, save state at natural breakpoints
