Allow tools/skills to programmatically clear context and inject a continuation prompt

[peterdrier]

Context

When working on long, multi-step tasks, the context window fills up and performance degrades. The natural response is to clear and continue, but this destroys all accumulated context — decisions made, files identified, progress tracked, corrections given.

Problem / Motivation

There is no programmatic way for a skill or tool to:

1. Summarize the current session context
2. Clear the conversation
3. Inject a continuation prompt into the fresh session

This means the human must manually orchestrate the "save context → clear → restore context" bridge every time. It's error-prone, breaks flow, and is exactly the kind of repetitive task that should be automatable.

Real-world use case: A /cls skill that the user invokes when context is getting heavy. The skill gathers git state, conversation decisions, active tasks, and the user's gist of what's next — then clears the conversation and injects the summary so Claude picks up seamlessly. Today this is impossible because:

• Skills cannot invoke /clear
• There is no PostClear hook event
• SessionStart hooks cannot inject prompt content
• Hooks generally cannot submit text into the conversation

The workaround is for the skill to save a summary to a file, then the user manually runs /clear, then manually types "read the file and continue." This defeats the purpose of having a skill.

Related: #32861

Proposed Solution

Enable one or more of these mechanisms (in order of preference):

Option A: Tool-invocable clear with continuation

A tool like ClearContext that a skill can call programmatically:

ClearContext({ continuation_prompt: "I'm continuing from a previous session..." })

This clears the conversation and injects the continuation as the opening message.

Option B: PostClear hook with prompt injection

Add a PostClear hook event that fires after /clear. Allow hooks of type "prompt" to inject text into the fresh session:

{
  "hooks": {
    "PostClear": [{
      "hooks": [{ "type": "prompt", "promptTemplate": "Read {{file}} and continue" }]
    }]
  }
}

Option C: /clear --run <prompt-or-file>

A built-in flag that clears and then submits a prompt or reads a file:

/clear --run "read local/cls-prompt.md and continue"

This is the simplest to implement but limits automation to what the human types.

Any of these would unblock the use case. Option A is the most powerful (skills can fully orchestrate the flow). Option C is the simplest to ship.

Acceptance Criteria

• A skill or tool can programmatically trigger a context clear
• A continuation prompt can be injected into the fresh session without user action
• The user initiates the flow (not automatic) — this is a human-in-the-loop bridge action
• Works in both CLI and IDE integrations

[yurukusa]

A UserPromptSubmit hook can implement continuation prompts:

PROMPT=$(cat | jq -r '.userPrompt // empty' 2>/dev/null)
if echo "$PROMPT" | grep -qiE '(/continue|resume from|pick up where)'; then
    LAST_STATE="/tmp/cc-last-state.json"
    if [ -f "$LAST_STATE" ]; then
        STATE=$(cat "$LAST_STATE")
        jq -n --arg s "$STATE" '{"hookSpecificOutput":{"hookEventName":"UserPromptSubmit","additionalContext":"Continuation context from previous state: " + $s}}'
    fi
fi
exit 0

Save state before clear:

COUNTER="/tmp/cc-state-counter"
C=$(cat "$COUNTER" 2>/dev/null || echo 0); C=$((C+1)); echo $C > "$COUNTER"
[ $((C % 20)) -ne 0 ] && exit 0
jq -nc --arg b "$(git branch --show-current 2>/dev/null)" --arg f "$(git diff --name-only 2>/dev/null | head -5 | tr '\n' ',')" --arg l "$(git log --oneline -3 2>/dev/null)" '{branch:$b,files:$f,log:$l}' > /tmp/cc-last-state.json
exit 0

[peterdrier]

A UserPromptSubmit hook can implement continuation prompts:

How would that work? Is this basically a magic file that gets checked post a /clear for content to auto load? Interesting thought, but doesn't feel very stable in a multiple agent environment.

[mianamiana]

+1 on this. I'm building a custom /compact-d skill for discussion-heavy sessions (brainstorming, design decisions). It compresses the conversation into a structured XML handoff file, but then the user still has to manually type /clear 继续 to resume — which defeats the purpose of automating the flow.

My use case: As I create more skills that need to orchestrate context resets (not just compact-d, but potentially any skill that hits context limits), the number of manual steps the user must remember grows linearly. This is exactly the kind of thing that should be a single action.

What I've tried:

• Hook-based approaches: hooks run in subprocesses and have no IPC channel back to the CLI process — they can't invoke /clear
• Terminal keystroke injection (tmux send-keys, AppleScript): works but fragile and environment-dependent
• Behavioral clear (AI ignores old context): doesn't actually free context window space

Option A (tool-invocable clear with continuation) would fully solve my case. Option C (/clear --run) would also work as a pragmatic first step.

[tdurzynski]

+1 from an orchestration-setup angle (Claude Code as a sub-agent under a separate orchestrator + Telegram bot). Wanted to add a compute-economics framing the original doesn't make:

The current human-only /clear boundary is presumably a safety call (don't let agents nuke their own context loop). But the side effect is that long-running ship sessions sit on huge stale contexts the user can't prune in time. With the prompt cache capped at a ~5min TTL, a 200k-token stale context costs full input tokens on every turn — no cache benefit, model attention degrading over noise, and Anthropic serving more compute for negative product value. The economic incentive and the UX incentive point the same direction; only the safety argument cuts the other way.

Option A's AC "user initiates the flow (not automatic)" already preserves the human-in-the-loop boundary — the auth gate is "user explicitly invoked the skill," same trust model as any other skill the user invokes. Would unlock orchestration setups without weakening the safety story.