[FEATURE] /nudge — send an ephemeral one-turn instruction that doesn't persist in conversation context

Preflight Checklist

• [x] I have searched existing requests and this feature hasn't been requested yet
• [x] This is a single feature request (not multiple features)

Problem Statement

Mid-session, I frequently want to send a small one-off steering instruction — "focus on the failing test first", "stop adding comments", "try the other approach instead" — that is only relevant for the very next turn.

Once acted on, that exchange becomes dead weight in the context window for the rest of the session:

• It consumes tokens on every subsequent request even though it will never be relevant again
• It dilutes the signal of the instructions that do matter for the session (the model may keep over-weighting a stale nudge)
• Over a long session, accumulated throwaway nudges bring auto-compaction forward, which can compress away earlier context that actually mattered

There's currently no way to express "act on this, but don't remember it" at send time. Focus here is on the problem: temporary steering instructions and durable context are treated identically by the conversation history, and they shouldn't be.

Proposed Solution

A /nudge <instruction> slash command (or equivalently a modifier on send, e.g. Alt+Enter) that marks a user message as ephemeral:

1. The message is included in the request for the current turn only — Claude acts on it normally
2. After the turn completes, the message is dropped from the persisted conversation history and does not count toward context in subsequent turns
3. The assistant's response and its effects (file edits, tool results) are kept as usual — the point is to discard the instruction, not the work

Design consideration: to avoid the model later seeing an assistant turn with no visible cause, the dropped nudge could be replaced with a short placeholder (e.g. [ephemeral instruction]) or folded into the adjacent turn on the next request. Either would be fine from a user perspective.

Ideally the UI transcript still shows the nudge (greyed out / marked), so the human-visible history is complete even though the model-visible context is not.

Alternative Solutions

• /rewind → "Restore conversation" after the turn completes. This works but also discards Claude's response and reasoning from that exchange, and it's a manual multi-step dance for what should be a send-time decision. It also requires remembering to do it after every nudge.
• Post-hoc selective message deletion (requested in #64371) would solve cleanup after the fact, but not the send-time intent, and adds friction per nudge.
• Related but distinct: #45849 and #40216 ask for ephemeral/request-scoped hook output (additionalContext accumulating in history). This request is the same principle applied to user messages, opted into per-message at send time.

Priority

Medium - Would be very helpful

Feature Category

CLI commands and flags

Use Case Example

1. I'm 2 hours into a long refactoring session with lots of accumulated, valuable context (design decisions, constraints, file layout).
2. Claude starts a turn by rewriting a test I didn't ask about. I send: /nudge leave the tests alone for now, just finish the interface change
3. Claude complies and finishes the interface change. The file edits and its response stay in the session.
4. On the next turn, the nudge itself is gone from context. Twenty turns later, I've sent ~10 such nudges over the session — none of them are burning tokens, none of them are being over-weighted as standing instructions, and auto-compaction triggers later than it otherwise would, preserving the design discussion from hour one.

Additional Context

• The name /nudge is a suggestion; the core ask is "ephemeral user message, decided at send time".
• Conceptually similar to request-scoped context that already exists internally (system-reminder style injections that aren't meant to accumulate), but user-triggered.
• No security implications; purely a context/history management feature.