fix(mobile): follow the conversation when it moves, and never eat a question

Two things a question could fall through.

A question typed before `enterChat` finished found no chat, and `say` returned
the identifier it was given as though it had asked. The composer had already
emptied, so the question was gone with nothing on screen to say so. It now
waits for the open, and a chat that is genuinely not there raises rather than
reporting success — which puts the question back on screen with a Retry under
it, the same as one whose answer never arrived.

A queued question asked on another model clones the conversation, and `drain`
ignored the new identifier: the transcript moved to a session the screen was
not watching. The chat that was left now points at the one it became, and
`useChat` follows that, so `say` and `retryChat` hand nothing back. The screen
is not always the mover, which is why the return value was the wrong seam.

Author: iscekic

apps/mobile/AGENTS.md

@@ -93,6 +93,8 @@ Add narrow temporary logs at the real boundaries. Reproduce. Read the tmux servi
 
 The Chat tab runs `@kilocode/harness-sdk` on the device. `src/lib/chat/` holds the registry (the conversations that are running), the layers (the plugins they run on) and the store (the list and its CRUD). The SDK saves one conversation; this app owns the list, the ordering, the titles, the deleting and the scoping.
 
+**A conversation can move, and the screen follows the state rather than a return value.** Switching models clones the conversation onto a new session, and the mover is not always the screen: a question typed on another model while an answer was arriving moves the chat from inside the registry. So the chat that was left points at the one it became, and `useChat` follows that.
+
 A chat is opened with the SDK's `time` tool and no other. A model has no clock, so it answers a dated question from its training date, confidently and wrong. The other three tools the SDK ships stay off: the composer is already how a person is asked something, a subagent costs a second session, and a to-do list is working memory for a run a chat does not have.
 
 **Prove a chat change against the same eleven models the SDK's live runs use.** The list is in `packages/harness-sdk/e2e/setup.ts`, and `pnpm --filter @kilocode/harness-sdk test:e2e:time full` is the sweep across all of them. Take one of those models through the app itself on the simulator as well: the sweep proves what the models do, the simulator proves this app's wiring, and neither proves the other. Both cost real money, so run the sweep when the tool set or the system prompt changes, not for a change to a screen.

apps/mobile/src/lib/chat/registry.test.ts

@@ -74,7 +74,7 @@ vi.mock('./store', () => ({
   touchChat: () => undefined,
 }));
 
-const { releaseChat, say, startChat, stopChat } = await import('./registry');
+const { enterChat, releaseChat, say, startChat, stopChat } = await import('./registry');
 const { snapshotOf } = await import('./state');
 
 const place = { chatScope: 'me:personal', org: { kind: 'personal' } } as const;
@@ -156,3 +156,50 @@ describe('a second question while the first is being answered', () => {
     expect(asked.map(one => one.text)).toEqual(['first']);
   });
 });
+
+describe('a chat that moved', () => {
+  it('leaves the chat it moved off pointing at the one it became', async () => {
+    await say(opened, 'first', 'kilo/one');
+    await settled();
+    await say(opened, 'second', 'kilo/two');
+    await settled();
+
+    finish?.();
+    await settled();
+
+    /* The queued question moved the conversation, and nobody handed the new
+       identifier back to the screen. The chat it left says where it went, so a
+       screen watching the old one follows without being told. */
+    expect(snapshotOf(opened).sessionId).toBe('s2');
+  });
+});
+
+describe('a question asked before the session has opened', () => {
+  it('waits for the open rather than vanishing', async () => {
+    await releaseChat(opened);
+    asked.length = 0;
+
+    /* No await: this is a person typing while the screen is still opening the
+       chat, which is exactly the window the question used to be dropped in. */
+    const entering = enterChat(place, 'later');
+    await say('later', 'typed early', 'kilo/one');
+    await entering;
+    await settled();
+
+    expect(asked).toEqual([{ sessionId: 'later', text: 'typed early' }]);
+  });
+
+  it('says so rather than reporting success when the chat is not there', async () => {
+    await releaseChat(opened);
+    asked.length = 0;
+
+    await say(opened, 'into nothing', 'kilo/one');
+    await settled();
+
+    expect(asked).toEqual([]);
+    /* The question is on screen with a Retry under it, which is what every
+       other question that never reached the model gets. */
+    expect(snapshotOf(opened)).toMatchObject({ status: 'idle', asked: 'into nothing' });
+    expect(snapshotOf(opened).failed).not.toBeNull();
+  });
+});

apps/mobile/src/lib/chat/registry.ts

@@ -192,37 +192,43 @@ async function reopen(place: ChatPlace, sessionId: string): Promise<void> {
  *
  * A model that is not the one the session was opened on moves the conversation
  * first, because a session freezes its model. The identifier changes when it
- * does, which is why this answers with the one to carry on with.
+ * does, and the state of the chat it moved off says where it went, so whoever
+ * is watching follows without being told.
  */
-export async function say(sessionId: string, text: string, model: string): Promise<string> {
-  const held = chats.get(sessionId);
-  if (held?.answering !== undefined) {
-    /* A session answers one question at a time, and the composer stays open
-       while it works. So a second question joins the line rather than racing
-       the first, and it is on screen while it waits. It is held in memory
-       only: an answer that is still arriving is not written down either. */
-    held.waiting.push({ text, model });
-    change(sessionId, { waiting: held.waiting.map(one => one.text) });
-    return sessionId;
-  }
+export async function say(sessionId: string, text: string, model: string): Promise<void> {
+  /* Where the failure below belongs. It is the chat the move landed on, not
+     the one it started from, or the report goes to a chat nobody is watching. */
+  let current = sessionId;
   try {
-    const moved = await ontoModel(sessionId, model);
-    const chat = chats.get(moved);
+    /* A person can type before the session has finished opening, and a
+       question asked of a chat that is not there yet used to vanish with the
+       composer reporting success. It waits for the open instead. */
+    await opening.get(sessionId);
+    const held = chats.get(sessionId);
+    if (held?.answering !== undefined) {
+      /* A session answers one question at a time, and the composer stays open
+         while it works. So a second question joins the line rather than racing
+         the first, and it is on screen while it waits. It is held in memory
+         only: an answer that is still arriving is not written down either. */
+      held.waiting.push({ text, model });
+      change(sessionId, { waiting: held.waiting.map(one => one.text) });
+      return;
+    }
+    current = await ontoModel(sessionId, model);
+    const chat = chats.get(current);
     if (chat === undefined) {
-      return moved;
+      throw new Error('the chat is not open');
     }
     const runtime = await runtimeFor(chat);
-    await rememberAsked(moved, text);
-    touchChat(await open(), moved, Date.now());
-    change(moved, { status: 'working', answering: '', asked: text, failed: null });
-    chat.answering = runtime.runFork(reading(moved, text, runtime));
-    return moved;
+    await rememberAsked(current, text);
+    touchChat(await open(), current, Date.now());
+    change(current, { status: 'working', answering: '', asked: text, failed: null });
+    chat.answering = runtime.runFork(reading(current, text, runtime));
   } catch (error) {
-    /* The move, or the write that remembers the question, failed. The question
-       is not lost: it stays on screen with a Retry under it, the same as one
-       whose answer never arrived. */
-    change(sessionId, { status: 'idle', answering: '', asked: text, failed: reason(error) });
-    return sessionId;
+    /* The open, the move, or the write that remembers the question failed. The
+       question is not lost: it stays on screen with a Retry under it, the same
+       as one whose answer never arrived. */
+    change(current, { status: 'idle', answering: '', asked: text, failed: reason(error) });
   }
 }
 
@@ -231,13 +237,11 @@ const reason = (error: unknown): string =>
   error instanceof Error ? error.message : 'the question could not be sent';
 
 /** Asks again what was asked and never answered. */
-export async function retryChat(sessionId: string): Promise<string> {
+export async function retryChat(sessionId: string): Promise<void> {
   const { asked, model } = snapshotOf(sessionId);
-  if (asked === null) {
-    return sessionId;
+  if (asked !== null) {
+    await say(sessionId, asked, model);
   }
-  const moved = await say(sessionId, asked, model);
-  return moved;
 }
 
 /** Reads one answer to the end, however it ends. */
@@ -363,9 +367,13 @@ async function ontoModel(sessionId: string, model: string): Promise<string> {
   await moveAsked(sessionId, handle.id);
   const turns = await runtime.runPromise(handle.history);
   chats.delete(sessionId);
-  forgetState(sessionId);
   chats.set(handle.id, { ...chat, handle, scope, answering: undefined });
   change(handle.id, { ...held, sessionId: handle.id, model, turns });
+  /* The chat it moved off is left pointing at the one it became, rather than
+     forgotten. Whoever asked for the move is not always the screen — a question
+     queued on another model moves the chat from inside the registry — so the
+     state is what says where the conversation went. */
+  change(sessionId, { sessionId: handle.id });
   await runtime.runPromise(Scope.close(chat.scope, Exit.void));
   forgetSession(database, sessionId);
   return handle.id;

apps/mobile/src/lib/chat/use-chat.ts

@@ -125,16 +125,26 @@ export function useChat(place: ChatPlace | null, opened: string): OpenChat {
     useCallback(() => snapshotOf(sessionId), [sessionId])
   );
 
+  // Switching models clones the conversation onto a new session, and the screen
+  // has to follow it. It is not always this screen that asks: a question typed
+  // on another model while an answer was arriving moves the chat when it is
+  // finally asked. The state says where it went, so the screen reads that
+  // rather than every mover having to hand the identifier back.
+  const moved = state.sessionId;
+  useEffect(() => {
+    setSessionId(moved);
+  }, [moved]);
+
   return {
     state,
     send: async (text, model) => {
-      setSessionId(await say(sessionId, text, model));
+      await say(sessionId, text, model);
     },
     stop: async () => {
       await stopChat(sessionId);
     },
     retry: async () => {
-      setSessionId(await retryChat(sessionId));
+      await retryChat(sessionId);
     },
   };
 }