Replace hold-to-copy sheet with native text selection, and keep the turn summary across a resume

Author: KenKaiii

packages/app/App.tsx

@@ -60,7 +60,6 @@ import { pickFiles, pickPhotos, takePhoto } from "./src/ui/attachmentPicker";
 import { useDictation } from "./src/ui/useDictation";
 import { ApprovalSheet } from "./src/ui/ApprovalSheet";
 import { ThoughtSheet } from "./src/ui/ThoughtSheet";
-import { MessageSheet } from "./src/ui/MessageSheet";
 import { applyCommand, type SlashCommand } from "./src/slashCommands";
 import { CircleButton, Pill } from "./src/ui/controls";
 import { haptics } from "./src/ui/haptics";
@@ -521,8 +520,6 @@ function Pew2({ pairing, onUnpair }: { pairing: Pairing; onUnpair: () => void })
   // so the sheet lives outside the recycling list — a cell scrolled off screen
   // must not take the sheet down with it.
   const [thought, setThought] = useState<string | null>(null);
-  /** The held message, open for copying and hand selection. */
-  const [message, setMessage] = useState<string | null>(null);
   // The draft lives inside the dock, not here.
   //
   // Holding it at the root meant every keystroke re-rendered the entire app,
@@ -1111,17 +1108,6 @@ function Pew2({ pairing, onUnpair }: { pairing: Pairing; onUnpair: () => void })
   }, []);
   const closeThought = useCallback(() => setThought(null), []);
 
-  // Stable for the same reason as `openThought`. The pulse is the whole
-  // confirmation that a hold was recognised: the finger is still down and the
-  // sheet has not arrived yet, so without it a long press reads as a dead spot
-  // in the transcript.
-  const openMessage = useCallback((text: string) => {
-    haptics.tap();
-    Keyboard.dismiss();
-    setMessage(text);
-  }, []);
-  const closeMessage = useCallback(() => setMessage(null), []);
-
   const answerPermission = useCallback(
     (requestId: string, optionId: string, deny: boolean) => {
       if (deny) haptics.warned();
@@ -1318,7 +1304,6 @@ function Pew2({ pairing, onUnpair }: { pairing: Pairing; onUnpair: () => void })
             indicatorBottom={dockHeight}
             onAtBottomChange={setAtBottom}
             onOpenThought={openThought}
-            onCopyMessage={openMessage}
           />
         ) : !daemon.loadingSession ? (
           // Cancels half the pane's lift, so the greeting settles in the middle
@@ -1483,7 +1468,6 @@ function Pew2({ pairing, onUnpair }: { pairing: Pairing; onUnpair: () => void })
       <AttachmentSheet visible={attachOpen} onSelect={pickAttachment} onClose={closeAttach} />
 
       <ThoughtSheet visible={thought !== null} text={thought ?? ""} onClose={closeThought} />
-      <MessageSheet visible={message !== null} text={message ?? ""} onClose={closeMessage} />
 
       {/* One picker, pointed at whichever pill opened it. The mode selector is
           excluded from the model menu so each pill owns exactly one list. */}

packages/app/src/agentHistory.test.ts

@@ -9,6 +9,7 @@ import {
   agentSessionKey,
   isAgentSessionStub,
   needsResume,
+  replaceAgentSessionStub,
 } from "./agentHistory";
 import type { Session } from "./useDaemon";
 
@@ -178,3 +179,36 @@ test("nothing to add returns the same array, so no re-render is queued", () => {
   expect(mergeAgentSessions(before, "claude-code", [], true, NOW)).toBe(before);
   expect(mergeAgentSessions(before, undefined, undefined, true, NOW)).toBe(before);
 });
+
+test("a resumed conversation keeps what the phone knew about it", () => {
+  const stub: Session = {
+    id: "agent:claude-code:s1",
+    providerId: "claude-code",
+    title: "Fix the build",
+    startedAt: NOW,
+    turns: [],
+    configOptions: [],
+    agentSessionId: "s1",
+    cwd: "/repo",
+    messageCount: 12,
+    receipt: { verb: "Answered", duration: "5s", tools: 0, failed: 0 },
+  };
+  const live: Session = {
+    id: "claude-code-live",
+    providerId: "claude-code",
+    title: "Fix the build",
+    startedAt: NOW + 1,
+    turns: [],
+    configOptions: [],
+    agentSessionId: "s1",
+  };
+
+  const [resumed] = replaceAgentSessionStub([stub], live);
+
+  expect(resumed!.id).toBe("claude-code-live");
+  expect(resumed!.cwd).toBe("/repo");
+  expect(resumed!.messageCount).toBe(12);
+  // The turn this device timed before the daemon forgot the session. Losing it
+  // here is why "Answered in 5s" vanished on every reopen that resumes.
+  expect(resumed!.receipt).toEqual({ verb: "Answered", duration: "5s", tools: 0, failed: 0 });
+});

packages/app/src/agentHistory.ts

@@ -68,6 +68,11 @@ export function replaceAgentSessionStub(existing: Session[], live: Session): Ses
       ...live,
       cwd: live.cwd ?? stub?.cwd,
       messageCount: live.messageCount ?? stub?.messageCount,
+      // The last turn this device timed in this conversation. `session.started`
+      // carries no such thing, so without this a resume swapped the row for one
+      // that had never heard of it and "Answered in 5s" was gone for good — the
+      // state every conversation is in once the daemon has been restarted.
+      receipt: live.receipt ?? stub?.receipt,
     },
     ...existing.filter((session) => session.agentSessionId !== live.agentSessionId),
   ];

packages/app/src/turnReceipts.test.ts

@@ -1,6 +1,6 @@
 import { expect, test } from "bun:test";
 import type { TurnReceipt } from "./activity";
-import { receiptOnOpen, recordReceipt } from "./turnReceipts";
+import { receiptOnOpen, receiptOnReplay, recordReceipt } from "./turnReceipts";
 import type { Session } from "./useDaemon";
 
 const answered: TurnReceipt = { verb: "Answered", duration: "3s", tools: 0, failed: 0 };
@@ -57,6 +57,31 @@ test("a conversation still working shows no summary, since none is measured yet"
   expect(running.receipt).toEqual(answered);
 });
 
+test("a resumed conversation gets its summary back with its transcript", () => {
+  // Resuming marks the session working on the way in, so the flag says nothing
+  // about whether a turn is being timed; only `running` does.
+  const sessions = recordReceipt([session({ busy: true })], "s1", answered);
+
+  expect(receiptOnReplay(sessions, "s1", false)).toEqual(answered);
+});
+
+test("a replay that lands mid-turn names no finished turn", () => {
+  const sessions = recordReceipt([session()], "s1", answered);
+
+  // The live activity line is what belongs under a running turn; a summary here
+  // would date-stamp a reply that has not been given yet.
+  expect(receiptOnReplay(sessions, "s1", true)).toBeUndefined();
+});
+
+test("a replay never borrows the summary of another conversation", () => {
+  const sessions = recordReceipt([session()], "s1", answered);
+
+  // The reason the old code cleared on replay: screen state belongs to the
+  // thread being left. Reading from the session makes that impossible.
+  expect(receiptOnReplay(sessions, "s2", false)).toBeUndefined();
+  expect(receiptOnReplay(sessions, undefined, false)).toBeUndefined();
+});
+
 test("a summary for a conversation the drawer does not hold changes nothing", () => {
   const before = [session()];
 

packages/app/src/turnReceipts.ts

@@ -46,3 +46,28 @@ export function recordReceipt(
 export function receiptOnOpen(session: Pick<Session, "busy" | "receipt">): TurnReceipt | undefined {
   return session.busy === true ? undefined : session.receipt;
 }
+
+/**
+ * The summary to show once a resumed conversation's transcript lands.
+ *
+ * A resume rebuilds the thread from the agent's own copy, and that frame used to
+ * clear the line unconditionally — correct when the summary was screen state
+ * (it described the conversation being left), wrong now that it is stored on the
+ * conversation. Reopening anything the daemon had forgotten therefore lost it
+ * again, which is every conversation after a daemon restart.
+ *
+ * Read from the session rather than from what is on screen, for the reason the
+ * old clear existed: the value on screen may belong to the previous thread.
+ * `busy` is not consulted — the open marks a resuming conversation working on
+ * the way in, and `running` is the honest question: is a turn being timed by
+ * *this* device right now, in which case there is a live activity line to show
+ * and no finished turn to name.
+ */
+export function receiptOnReplay(
+  sessions: readonly Session[],
+  sessionId: string | undefined,
+  running: boolean,
+): TurnReceipt | undefined {
+  if (running || !sessionId) return undefined;
+  return sessions.find((session) => session.id === sessionId)?.receipt;
+}

packages/app/src/ui/ChatThread.harness.tsx

@@ -54,7 +54,6 @@ export default function ChatThreadHarness() {
           indicatorBottom={DOCK_HEIGHT}
           onAtBottomChange={setAtBottom}
           onOpenThought={() => {}}
-          onCopyMessage={() => {}}
         />
 
         {/* Stand-in for the real dock: same job, obvious edge. Anything visible

packages/app/src/ui/ChatThread.tsx

@@ -60,8 +60,6 @@ type Props = {
   onAtBottomChange: (atBottom: boolean) => void;
   /** Opens a thinking turn's full text. Must be stable: cells memo on it. */
   onOpenThought: (text: string) => void;
-  /** Opens a held message for copying. Must be stable, for the same reason. */
-  onCopyMessage: (text: string) => void;
 };
 
 function ChatThreadView(
@@ -76,7 +74,6 @@ function ChatThreadView(
     indicatorBottom,
     onAtBottomChange,
     onOpenThought,
-    onCopyMessage,
   }: Props,
   ref: React.Ref<ChatThreadRef>,
 ) {
@@ -91,11 +88,11 @@ function ChatThreadView(
       // padding on the scroll content is not part of the list's layout math.
       return (
         <View style={index === 0 ? styles.firstRow : styles.row}>
-          <Turn turn={item} onOpenThought={onOpenThought} onCopyMessage={onCopyMessage} />
+          <Turn turn={item} onOpenThought={onOpenThought} />
         </View>
       );
     },
-    [onOpenThought, onCopyMessage],
+    [onOpenThought],
   );
 
   // Mirrored into a ref so the inset effect below can read "is the reader at the

packages/app/src/ui/Dock.harness.tsx

@@ -134,7 +134,6 @@ function Screen() {
         indicatorBottom={dockHeight}
         onAtBottomChange={noop}
         onOpenThought={noop}
-        onCopyMessage={noop}
       />
       {/* What a wrapped line actually costs, where it can be read while typing.
           The root count is the one that matters: it should not move at all as

packages/app/src/ui/MarkdownText.tsx

@@ -160,17 +160,35 @@ const renderImage: RenderFunction = (node) => {
 };
 
 const markdownRules: Partial<RenderRules> = {
+  // Every inline run that is *not* a paragraph — a heading, a list item, a table
+  // cell — bottoms out here, and this is the outermost Text of those blocks.
+  //
+  // That is why `selectable` is said twice, here and on the paragraph below.
+  // Nested Text is virtual on both platforms: it is flattened into the one
+  // native text view its top-level Text creates, and the native selection
+  // gesture belongs to that view. So the flag only does anything on the
+  // outermost Text of a block, and there are two kinds of those.
+  textgroup: (node, children, _parents, styles) =>
+    createElement(
+      Text,
+      { ["key"]: node.key, selectable: true, style: styles.text as never },
+      children,
+    ),
   // A paragraph must be one measured Text block. The library's default uses a
   // wrapping row of Text children; inside a list that row reports one-line
   // height while its text paints several lines, so following items overlap it.
   // One exception: a paragraph holding an image becomes a column, because
   // nesting a View in text layout collapses a percentage-width picture on iOS.
+  // Only the Text branch is selectable — a View is not text and `selectable`
+  // means nothing on it.
   paragraph: (node, children, _parents, styles) =>
-    createElement(
-      hasImageChild(node) ? View : Text,
-      { ["key"]: node.key, style: styles.paragraph as never },
-      children,
-    ),
+    hasImageChild(node)
+      ? createElement(View, { ["key"]: node.key, style: styles.paragraph as never }, children)
+      : createElement(
+          Text,
+          { ["key"]: node.key, selectable: true, style: styles.paragraph as never },
+          children,
+        ),
   code_block: renderCodeBlock,
   fence: renderCodeBlock,
   image: renderImage,