[Feature]: Native /clear for a fresh context in the same thread, like Claude Code

[bathan]

Problem

There is no way to start over inside a thread. To get a clean context and a clean scrollback I have to settle the thread and create a new one, which means a new title, re-picking model and mode, and losing the place I was working in.

Claude Code in the terminal has /clear. One command, the transcript is gone, and I am in a fresh conversation in the same working directory. In T3 the same thing takes several UI steps and leaves a pile of settled threads behind.

Current behavior

/clear is not a T3 command, so it gets forwarded to the provider as plain text. The model usually replies that the context was cleared, but nothing changed. See #7402, where the event log shows /clear persisted as an ordinary thread.message-sent followed by a normal turn. An assistant that answers "done" while keeping everything is worse than an error.

Proposal

Make /clear a native T3 command, alongside /model and /plan:

• Start a fresh provider session for the thread, with no resume cursor and no transcript.
• Collapse or hide the previous messages in the thread view. A divider saying "Context cleared" is enough, and the old messages can stay retrievable.
• Keep thread id, title, project, worktree, model selection, and permission mode.
• Until this exists, reject /clear and other unsupported reset commands with a visible "not supported" message instead of sending them to the model.

Why

Long-lived threads pinned to a worktree are the natural unit of work in T3. Being able to reset context without abandoning the thread keeps the sidebar sane and matches what every provider CLI already offers.

[LukasFB]

+1, we need a function like that. I've been missing this in Codex since switching over from CC too.

Alternative approach with the same result: A function "Settle & start new task"
-> Settles the current task
-> Creates a new task with the same UI (repo, model, sidebar status, browser tabs, ...) but a fresh context

This would simplify this feature to just UI work inside T3, without any provider specific logic, since codex app-server does not have /clear support

[nicolasfishman]

Adding a data point that splits this proposal cleanly in two, because on the Claude provider the context half already works and only the transcript half is missing.

What happens today with Claude Code as the provider: /clear is forwarded to the CLI, and the CLI handles it natively, so the context really is reset. But the T3 transcript keeps every message from before the reset fully visible, with nothing marking the boundary. The thread reads as one continuous conversation while the session behind it has no memory of anything above the cut. That is a different failure from #7402 (Codex/Cursor never reset at all): here the reset is real and only invisible.

T3 already receives the signal for it. The Claude Agent SDK emits a conversation_reset frame carrying new_conversation_id. #9135 added that type to the adapter's switch and deliberately consumes it silently:

// apps/server/src/provider/Layers/ClaudeAdapter.ts
// Composer prompt suggestions have no T3 surface; consumed deliberately.
// `conversation_reset` announces a CLI-side conversation id swap
// (e.g. /clear); T3 keeps its own thread identity and resume cursor.
case "prompt_suggestion":
case "conversation_reset":
  return;

The comment is right about identity — T3 should keep its own thread id and resume cursor across a CLI-side conversation swap. The gap is that this frame is the only evidence the reset happened, and nothing downstream ever hears about it.

Possible fix, following the shape of the paths already there:

1. Stop discarding the frame: give conversation_reset its own case that emits a thread event carrying new_conversation_id, instead of falling into the silent return.
2. Persist it as a marker in the thread timeline, the same way other lifecycle events are stored.
3. Render it as the divider this proposal already asks for — "Context cleared" — with the messages above it collapsed by default and still expandable.

That delivers the visible half of the proposal for the Claude provider without touching session lifecycle at all: no new provider session, no resume-cursor change, no thread identity change. The harder half in #7402 (actually resetting Codex and Cursor sessions) stays independent, and when it lands it can emit the same marker rather than inventing a second one.