Android app: typed message is silently discarded when switching conversations (no draft persistence) — worse with long-running agent sessions

What happens

On the Claude Android app, text typed into the composer of a Claude Code
session is silently and permanently destroyed when you switch to another
conversation before sending it. There is no draft, no warning, and no way to
recover it — you retype it from memory on a phone keyboard.

This is reported before for the VS Code extension in #34596 (closed as *not
planned*, stale, zero comments) and #55578 (closed as a duplicate of it).
#31393 is the mobile app but a different trigger (message limit reached).
None of them covers the Android app, and none covers the case below, which
is what makes the loss routine rather than occasional.

Why it is much worse in this context than in the VS Code report

Those reports describe an optional context switch — the user chose to look at
another chat. On mobile, driving multiple long-running agent sessions, the
switch is not optional and the composer is the only queue you have:

1. A session is mid-run. An agent step takes minutes; a tool call can take

longer.

1. You already know what you want it to do next, so you type it while waiting.

This is the natural thing to do — the alternative is sitting and
watching a spinner with an idea you will forget.

1. Something needs attention in a second session, so you switch to it. On a

phone there is no second window; switching is the only way to look.

1. You come back. Everything you typed is gone.

So the app punishes exactly the workflow its own long-running agents create.
The longer an agent runs — which is the direction the product is going — the
more likely the user has queued something, and the more expensive the loss.

The frustrating part is that the text was never sent anywhere, so nothing
technically failed. It was simply discarded by the client.

Steps to reproduce

1. Android app, open a Claude Code session and start a task that runs for a

minute or more.

1. While it is running, type a multi-sentence instruction into the composer.

Do not send it.

1. Navigate back / switch to any other conversation.
2. Return to the first conversation.

Expected: the composer still holds the text, per-conversation, the way
every messaging app on the same phone behaves — Slack, WhatsApp, Telegram,
Gmail, Messages. Users have twenty years of trained expectation here.

Actual: the composer is empty. The text is unrecoverable.

Environment

• Claude Android app (remote-controlling Claude Code sessions)
• Multiple concurrent sessions, switched between while agents are running
• Reproduced repeatedly in normal daily use, not a one-off

Impact

Users running several agent sessions from a phone lose typed instructions
routinely. It also creates a bad incentive: to protect the text you must stop
multitasking and stare at one session until it finishes, which is the opposite
of what long-running background agents are for.

Suggested fixes, cheapest first

1. **Keep the draft in memory, keyed by conversation id, for the app's

lifetime.** No storage, no schema, no sync — this alone fixes the reported
case, because the switch happens within one app session.

1. Persist drafts to local storage so they also survive the app being

backgrounded and killed by Android, which is a normal event on a phone.

1. Restore on return, with the cursor position if that is cheap.
2. If a draft genuinely cannot be kept, at least warn before discarding

it — a destructive action taken silently is the part that turns an
inconvenience into a loss of trust.

(1) is small and would close the majority of the pain. The related VS Code
issue was closed as not planned with no discussion; I would gently suggest
the mobile case is stronger, because on a phone retyping is expensive and the
context switch is forced rather than chosen.

Happy to test a fix — this reproduces reliably for us.