@hienlh/ppm 0.23.11 → 0.23.13

package/src/web/components/chat/chat-tab.tsx

@@ -2,17 +2,19 @@ import { useState, useCallback, useRef, useEffect, useMemo } from "react";
 import { Loader2, Upload, X } from "@/lib/icons";
 import { toast } from "sonner";
 import { api, projectUrl } from "@/lib/api-client";
+import { decodeReply, encodeReply, type ReplyReference } from "../../../shared/chat-reply";
 import { selectInlineImages } from "@/lib/image-resize-limits";
 import { splitAttachmentMarkers } from "@/lib/attachment-marker-split";
 import type { ChatAttemptEvent } from "@/lib/chat-attempt-lifecycle";
 import { useChat } from "@/hooks/use-chat";
+import { useChatPrewarm } from "@/hooks/use-chat-prewarm";
 import { useUsage } from "@/hooks/use-usage";
 import { useDesignSessionRedirect } from "@/hooks/use-design-session-redirect";
 import { useTabStore } from "@/stores/tab-store";
-import { useSettingsStore } from "@/stores/settings-store";
 import { usePanelStore } from "@/stores/panel-store";
 import { useNotificationStore } from "@/stores/notification-store";
-import { openBugReportPopup } from "@/lib/report-bug";
+import { useFileStore } from "@/stores/file-store";
+import { useRemoteFileSearch } from "@/hooks/use-remote-file-search";
 import { useChatAccountClaim } from "@/hooks/use-chat-account-claim";
 import { startPrepare, getPrepare, isPrepared, forgetPrepare } from "@/lib/new-chat-prepare-client";
 import { MessageList } from "./message-list";
@@ -20,6 +22,11 @@ import { BackgroundCommandBar } from "./background-command-bar";
 import { RunningAgentsBar } from "./running-agents-bar";
 import { AgentSessionProvider, normalizeProviderId } from "./agent-session-context";
 import { McpSignInBar } from "@/components/mcp-auth/mcp-sign-in-bar";
+import { SessionChangesBar } from "./session-changes-bar";
+import { CONTINUE_AFTER_STOP, TurnStopBar } from "./turn-stop-bar";
+import { SessionChangesContext, type SessionChangesValue } from "./session-changes-context";
+import { useSessionFileChanges } from "@/hooks/use-session-file-changes";
+import { openSessionReview } from "@/lib/session-file-changes-client";
 import { useTeamActivityFeed } from "@/hooks/use-team-activity-feed";
 import { MessageInput, type ChatAttachment, type MessagePriority } from "./message-input";
 import { SlashCommandPicker, type SlashItem } from "./slash-command-picker";
@@ -98,6 +105,7 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
    * metadata through the effect below, which is what makes the fix survive a
    * reload rather than only lasting the turn.
    */
+  const migrateComposerRef = useRef<(oldSessionId: string, newSessionId: string) => void>(() => {});
   const handleSessionMigrated = useCallback((newSessionId: string) => {
     // Read from the metadata ref, not the `projectName` const below — this
     // callback is created before that binding exists in this function body.
@@ -105,6 +113,7 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
     if (sessionIdRef.current && pn) {
       useSessionListStore.getState().replaceSessionId(projectRefForName(pn), sessionIdRef.current, newSessionId);
     }
+    if (sessionIdRef.current) migrateComposerRef.current(sessionIdRef.current, newSessionId);
     setSessionId(newSessionId);
   }, []);
   const [providerOverride, setProviderId] = useState<string>(
@@ -168,6 +177,7 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
     permissionMode?: string;
     images?: Array<{ data: string; mediaType: string }>;
     imagePaths?: string[];
+    replyTo?: ReplyReference | null;
   } | null>(null);
   const pendingSendTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 
@@ -238,7 +248,6 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
 
   useDesignSessionRedirect({ tabId, sessionId, designSlug, projectName, providerId });
   const updateTab = useTabStore((s) => s.updateTab);
-  const version = useSettingsStore((s) => s.version);
 
   // Usage runs independently — auto-refreshes on interval. Scoped to this session so the
   // account shown is the one bound to it, not whichever session ran most recently.
@@ -250,6 +259,51 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
   // Draft auto-save/restore
   const { draft, draftLoading, saveDraft, clearDraft, cancelPendingSave, moveDraft } = useDraft(projectName, sessionId, tabId);
 
+  const replyOwner = JSON.stringify([projectName, sessionId, providerId]);
+  // A fork opens with its message as stored. As with an edit, the body goes in the composer
+  // (`forkDraft`) and the quote becomes a reply in this conversation, which the fork copied the
+  // quoted message into.
+  const [replySelection, setReplySelection] = useState<{ owner: string; reply: ReplyReference | null } | null>(() => {
+    const forkedReply = decodeReply((metadata?.pendingMessage as string | undefined) ?? "").replyTo;
+    return forkedReply && sessionId ? { owner: replyOwner, reply: { ...forkedReply, sessionId } } : null;
+  });
+  const heldReply = replySelection?.owner === replyOwner ? replySelection.reply : draft?.replyTo ?? null;
+  // Only a reply into this conversation is one. The server refuses any other on every send,
+  // and each refusal hands it back to this composer, so a reply that reached a draft from
+  // another conversation would otherwise never let the text go out.
+  const replyTo = heldReply?.sessionId === sessionId && heldReply.providerId === providerId ? heldReply : null;
+  const replyToRef = useRef(replyTo);
+  replyToRef.current = replyTo;
+  const [replyChangeSignal, setReplyChangeSignal] = useState(0);
+  const composerDraftRef = useRef<{ owner: string; text: string; observed?: boolean; attachments?: DraftAttachment[] }>({ owner: replyOwner, text: "" });
+  const rejectedSendRef = useRef<(event: { content: string; replyTo?: ReplyReference | null; message: string }) => void>(() => {});
+  const replyTransportOptions = useMemo(() => ({
+    onMessageRejected: (event: { content: string; replyTo?: ReplyReference | null; message: string }) => rejectedSendRef.current(event),
+  }), []);
+  const selectReply = useCallback((reply: ReplyReference | null) => {
+    replyToRef.current = reply;
+    setReplySelection({ owner: replyOwner, reply });
+    setReplyChangeSignal((signal) => signal + 1);
+  }, [replyOwner]);
+  const handleReply = useCallback((reply: ReplyReference) => selectReply(reply), [selectReply]);
+  const handleCancelReply = useCallback(() => selectReply(null), [selectReply]);
+  migrateComposerRef.current = (oldSessionId, newSessionId) => {
+    if (oldSessionId === newSessionId) return;
+    const selected = replyToRef.current;
+    const migrated = selected?.sessionId === oldSessionId ? { ...selected, sessionId: newSessionId } : selected;
+    const nextOwner = JSON.stringify([projectName, newSessionId, providerId]);
+    const current = composerDraftRef.current;
+    if (current.owner === replyOwner && (current.text || current.attachments?.length || migrated)) {
+      saveDraft(current.observed ? current.text : draft?.content ?? current.text, current.attachments ?? draft?.attachments, migrated);
+      cancelPendingSave();
+    }
+    moveDraft(newSessionId);
+    replyToRef.current = migrated;
+    setReplySelection({ owner: nextOwner, reply: migrated });
+    composerDraftRef.current = { ...current, owner: nextOwner };
+  };
+
+
   // Persist sessionId, providerId, and permissionMode to tab metadata.
   //
   // The claimed account is dropped at the same moment: once a session exists, its binding
@@ -381,6 +435,10 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
     clearErrors,
     messagesLoading,
     versionMap,
+    hasOlderHistory,
+    loadOlderHistory,
+    userOrdinalOffset,
+    historyPredecessorId,
     isStreaming,
     phase,
     isReconnecting,
@@ -390,6 +448,7 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
     compactStatus,
     promptCache,
     mcpNeedsAuth,
+    turnStop,
     statusMessage,
     sessionTitle,
     liveAccount,
@@ -399,6 +458,7 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
     setEffort,
     thinking,
     setThinking,
+    turnSettings,
     sendMessage,
     respondToApproval,
     cancelStreaming,
@@ -411,7 +471,32 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
     bashPartialOutput,
     backgroundShells,
     killBackgroundShell,
-  } = useChat(sessionId, providerId, projectName, handleSessionMigrated, observeAttempt);
+  } = useChat(sessionId, providerId, projectName, handleSessionMigrated, observeAttempt, replyTransportOptions);
+
+  const sessionChanges = useSessionFileChanges({ projectName, sessionId, messages, isStreaming });
+  const openReview = useCallback((path?: string) => {
+    if (!sessionId) return;
+    openSessionReview({ projectName, sessionId, title: sessionTitle || undefined, providerId, paths: sessionChanges.paths, selectPath: path });
+  }, [projectName, sessionId, sessionTitle, providerId, sessionChanges.paths]);
+  // Each turn's change tray answers the same list the bar shows.
+  const sessionChangesValue = useMemo((): SessionChangesValue | null => (
+    projectName && sessionId
+      ? { projectName, sessionId, files: sessionChanges.files, refresh: sessionChanges.refresh, openReview }
+      : null
+  ), [projectName, sessionId, sessionChanges.files, sessionChanges.refresh, openReview]);
+
+  // `model`/`effort`/`thinking` are what change when a pick does; the picks sent are read
+  // through `turnSettings`, which leaves out whatever the user has not chosen.
+  const firstMessagePicks = useMemo(() => turnSettings(), [turnSettings, model, effort, thinking]);
+  const touchPrewarm = useChatPrewarm({
+    // Not while the provider is still being resolved: the process would start for a guess.
+    enabled: !sessionId && !designSlug && tourTabActive && !!projectName && !preparation.pending,
+    projectName,
+    providerId,
+    permissionMode,
+    accountId: claimMatchesProvider ? pickedAccountId : undefined,
+    picks: firstMessagePicks,
+  });
 
   useEffect(() => {
     if (!tabId || !tourTabActive || draftLoading || isStreaming) return;
@@ -492,7 +577,10 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
   }, [sessionTitle]); // eslint-disable-line react-hooks/exhaustive-deps
 
   // Pending fork message — show in input for user to edit, not auto-send
-  const [forkDraft, setForkDraft] = useState<string | undefined>(metadata?.pendingMessage as string | undefined);
+  const [forkDraft, setForkDraft] = useState<string | undefined>(() => {
+    const pending = metadata?.pendingMessage as string | undefined;
+    return pending === undefined ? undefined : decodeReply(pending).content;
+  });
 
   // "Build in new chat" hands a design screenshot over as a data URL on the tab's own
   // metadata (never a live event: there is no mounted composer yet for a brand new tab). It
@@ -532,7 +620,7 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
    * rather than the bare string: the text is often identical to the draft the
    * composer was prefilled with, and a value that does not change applies nothing.
    */
-  const [restore, setRestore] = useState<{ text: string; nonce: number } | null>(null);
+  const [restore, setRestore] = useState<{ text: string; nonce: number; replace?: boolean } | null>(null);
 
   /**
    * Give an unsent message back to the user.
@@ -555,9 +643,25 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
     firstSendContent.current = null;
     setFirstSendPreview(null);
     setFirstSendPending(false);
-    setRestore({ text: content, nonce: Date.now() });
+    const decoded = decodeReply(content);
+    replyToRef.current = decoded.replyTo;
+    setReplySelection({ owner: replyOwner, reply: decoded.replyTo });
+    saveDraft(decoded.content, undefined, decoded.replyTo);
+    setRestore({ text: decoded.content, nonce: Date.now() });
     toast.error("Message not sent", { description: `${reason} Your text is back in the input.` });
-  }, []);
+  }, [replyOwner, saveDraft]);
+
+  rejectedSendRef.current = (event) => {
+    const current = composerDraftRef.current;
+    const unsent = encodeReply(event.content, event.replyTo);
+    if ((current.owner !== replyOwner || (!current.text.trim() && !current.attachments?.length && !draft?.content.trim())) && !replyToRef.current) {
+      restoreUnsentMessage(unsent, event.message);
+    } else {
+      toast.error("Message not sent", { description: event.message, action: {
+        label: "Restore", onClick: () => restoreUnsentMessage(unsent, event.message),
+      } });
+    }
+  };
 
   /**
    * Drop a pending send that never got its socket; hand the text back.
@@ -581,7 +685,7 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
     }
     pendingSendRef.current = null;
     clearDraft(pending.draftId);
-    restoreUnsentMessage(pending.content, reason);
+    restoreUnsentMessage(encodeReply(pending.content, pending.replyTo), reason);
   }, [restoreUnsentMessage, clearDraft]);
 
   /**
@@ -601,10 +705,10 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
   // Flush pending message once WS connects (replaces unreliable setTimeout)
   useEffect(() => {
     if (isConnected && pendingSendRef.current) {
-      const { content, draftId, permissionMode: pm, images: pendingImages, imagePaths: pendingPaths } = pendingSendRef.current;
+      const { content, draftId, permissionMode: pm, images: pendingImages, imagePaths: pendingPaths, replyTo: pendingReply } = pendingSendRef.current;
       pendingSendRef.current = null;
       if (pendingSendTimerRef.current) { clearTimeout(pendingSendTimerRef.current); pendingSendTimerRef.current = null; }
-      sendMessage(content, { permissionMode: pm, ...(pendingImages?.length && { images: pendingImages }), ...(pendingPaths?.length && { imagePaths: pendingPaths }) });
+      sendMessage(content, { permissionMode: pm, replyTo: pendingReply ?? undefined, ...(pendingImages?.length && { images: pendingImages }), ...(pendingPaths?.length && { imagePaths: pendingPaths }) });
       firstSendLocked.current = false;
       firstSendContent.current = null;
       setFirstSendPreview(null);
@@ -682,6 +786,10 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
     // connect of the one picked here: `isConnected` is session-scoped, so the flush
     // would fire on the selected conversation and post it there.
     abandonPendingSend("You switched to another chat before it connected.");
+    setRestore(null);
+    setForkDraft(undefined);
+    setEditFork(null);
+    setClearInputSignal((signal) => signal + 1);
     setSessionId(session.id);
     setProviderId(session.providerId);
     if (tabId && !designSlug) updateTab(tabId, { title: session.title || "Chat" });
@@ -698,8 +806,10 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
         `${projectUrl(projectName)}/chat/sessions/${sessionId}/fork?providerId=${providerId}`,
         { messageId },
       );
+      // Titled by its body: the message as stored ends in its quote when it was a reply.
+      const body = decodeReply(userMessage).content;
       useSessionListStore.getState().upsertSession(projectRefForName(projectName), {
-        id: forked.id, providerId, title: userMessage.slice(0, 50), createdAt: new Date().toISOString(),
+        id: forked.id, providerId, title: body.slice(0, 50), createdAt: new Date().toISOString(),
         // A fork keeps its design, so a design tab's history list still shows it.
         ...(designSlug && { designSlug }),
       });
@@ -711,7 +821,7 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
       }
       useTabStore.getState().openTab({
         type: "chat",
-        title: `Fork: ${userMessage.slice(0, 30)}`,
+        title: `Fork: ${body.slice(0, 30)}`,
         metadata: { projectName, sessionId: forked.id, providerId, pendingMessage: userMessage },
         projectId: projectName || null,
         closable: true,
@@ -732,22 +842,31 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
 
   /** Edit a user message: prefill input + arm same-tab fork on next send */
   const handleEdit = useCallback((userMessage: string, messageId?: string, ownMsgId?: string) => {
-    setForkDraft(userMessage);
+    const decoded = decodeReply(userMessage);
+    // The edited message is in this conversation, and so is what it quotes — including a
+    // message copied in when this conversation was forked, whose quote names the one it came from.
+    const reply = decoded.replyTo && sessionId ? { ...decoded.replyTo, sessionId } : decoded.replyTo;
+    setForkDraft(decoded.content);
+    setRestore({ text: decoded.content, nonce: Date.now(), replace: true });
+    replyToRef.current = reply;
+    setReplySelection({ owner: replyOwner, reply });
     setEditFork({ anchorMsgId: messageId, ownMsgId });
-  }, []);
+  }, [replyOwner, sessionId]);
 
   /** Abandon an armed edit: disarm the fork, drop the prefill, clear the input. */
   const handleCancelEdit = useCallback(() => {
     setEditFork(null);
     setForkDraft(undefined);
+    replyToRef.current = null;
+    setReplySelection({ owner: replyOwner, reply: null });
     setEditForking(false);
     clearDraft();
     setClearInputSignal((n) => n + 1);
-  }, [clearDraft]);
+  }, [clearDraft, replyOwner]);
 
   /** Fork at the edit anchor, swap THIS tab to the forked session, queue the edited message */
   const handleEditSend = useCallback(
-    async (fullContent: string, anchorMsgId?: string) => {
+    async (fullContent: string, anchorMsgId?: string, reply?: ReplyReference | null) => {
       if (!fullContent.trim() || !sessionId || !projectName) return;
       // Surface a working indicator immediately — the fork API and the forked
       // session's codex connect can take ~10s; don't await in silence.
@@ -761,7 +880,7 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
           { signal: AbortSignal.timeout(SESSION_CREATE_TIMEOUT_MS) },
         );
         useSessionListStore.getState().upsertSession(projectRefForName(projectName), {
-          id: forked.id, providerId, title: fullContent.slice(0, 50), createdAt: new Date().toISOString(),
+          id: forked.id, providerId, title: decodeReply(fullContent).content.slice(0, 50), createdAt: new Date().toISOString(),
           ...(designSlug && { designSlug }),
         });
         // The tree gained a sibling. Swapping sessionId below refetches
@@ -769,8 +888,10 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
         // counts update without any cache to invalidate.
         // Queue the edited message — flushed by the connect effect once the WS
         // reconnects to the forked session. The draft was composed under the
-        // source session, so that is the one to clear when it goes.
-        queuePendingSend({ content: fullContent, draftId: sessionId, permissionMode });
+        // source session, so that is the one to clear when it goes. The edit continues in the
+        // fork, so its reply is the fork's — sent beside the text, where the server checks it,
+        // and handed back as the fork's if the queued message is dropped before it goes.
+        queuePendingSend({ content: fullContent, draftId: sessionId, permissionMode, replyTo: reply && { ...reply, sessionId: forked.id } });
         moveDraft(forked.id);
         // Swap the current tab to the forked session (no new tab).
         setStaleSwap(true);
@@ -787,10 +908,10 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
             : msg,
         });
         // The edited text was cleared from the composer on Enter — put it back.
-        setRestore({ text: fullContent, nonce: Date.now() });
+        restoreUnsentMessage(encodeReply(fullContent, reply), msg);
       }
     },
-    [sessionId, projectName, providerId, permissionMode, tabId, queuePendingSend, moveDraft, designSlug],
+    [sessionId, projectName, providerId, permissionMode, tabId, queuePendingSend, moveDraft, designSlug, restoreUnsentMessage],
   );
 
   /** Swap THIS tab to another version's session (version switcher prev/next) */
@@ -799,6 +920,10 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
       if (!targetSessionId || targetSessionId === sessionId) return;
       // Same as handleSelectSession: a queued edit must not land in the version switched to.
       abandonPendingSend("You switched to another version before it connected.");
+      setRestore(null);
+      setForkDraft(undefined);
+      setEditFork(null);
+      setClearInputSignal((signal) => signal + 1);
       setStaleSwap(true);
       if (tabId) patchTabMetadata(tabId, { sessionId: targetSessionId });
       setSessionId(targetSessionId);
@@ -855,7 +980,7 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
   );
 
   const handleSend = useCallback(
-    async (content: string, attachments: ChatAttachment[] = [], priority?: MessagePriority) => {
+    async (content: string, attachments: ChatAttachment[] = [], priority?: MessagePriority, selectedReply?: ReplyReference | null) => {
       const images = selectInlineImages(attachments);
       const fullContent = buildMessageWithAttachments(content, attachments, images);
       // Providers that take a file rather than a payload (codex) read these instead.
@@ -865,7 +990,7 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
       if (!sessionId) {
         if (firstSendLocked.current) return;
         firstSendLocked.current = true;
-        firstSendContent.current = fullContent;
+        firstSendContent.current = encodeReply(fullContent, selectedReply);
         const attempt = ++firstSendAttempt.current;
         setFirstSendPending(true);
         setFirstSendPreview({ content: fullContent, timestamp: new Date().toISOString() });
@@ -923,7 +1048,7 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
           setProviderId(session.providerId);
           // Queue message — will be sent by effect when WS reports isConnected. It was
           // composed under the new-tab draft, which is what to clear once it goes.
-          queuePendingSend({ content: fullContent, draftId: "__new__", permissionMode: selectedPermission, images, imagePaths });
+          queuePendingSend({ content: fullContent, draftId: "__new__", permissionMode: selectedPermission, images, imagePaths, replyTo: selectedReply });
           return;
         } catch (e) {
           if (attempt !== firstSendAttempt.current) return;
@@ -931,11 +1056,11 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
           const msg = (e as Error)?.name === "TimeoutError"
             ? "The server did not answer in time."
             : `Could not start the chat: ${(e as Error)?.message || "unknown error"}.`;
-          restoreUnsentMessage(fullContent, msg);
+          restoreUnsentMessage(encodeReply(fullContent, selectedReply), msg);
           return;
         }
       }
-      sendMessage(fullContent, { permissionMode, priority, ...(images.length > 0 && { images }), ...(imagePaths.length > 0 && { imagePaths }) });
+      sendMessage(fullContent, { permissionMode, priority, replyTo: selectedReply ?? undefined, ...(images.length > 0 && { images }), ...(imagePaths.length > 0 && { imagePaths }) });
       // Only now: the message is on (or queued for) a live session's socket.
       clearDraft();
     },
@@ -958,6 +1083,7 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
    */
   const handleInputSend = useCallback(
     (content: string, attachments: ChatAttachment[], priority?: MessagePriority) => {
+      const selectedReply = replyToRef.current;
       // Client-handled built-ins act on the UI, so they must not reach the SDK.
       const slash = content.trim().match(/^\/(\S+)(?:\s+([\s\S]+))?$/);
       if (slash) {
@@ -966,6 +1092,10 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
         );
         // This local action must also work before the lazily loaded picker
         // catalog arrives (for example, paste /clear and immediately submit).
+        if (selectedReply && (item || slash[1] === "clear" || slashItemsRef.current.some((i) => i.handler === "ppm" && i.name === slash[1]))) {
+          toast.error("Cancel reply before running this command");
+          return false;
+        }
         if (slash[1] === "clear" || item?.name === "clear") {
           clearDraft();
           handleNewSession(slash[2]?.trim(), sessionId ?? undefined);
@@ -976,17 +1106,20 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
       setForkDraft(undefined);
       // Save synchronously in this browser tab before the composer clears. A
       // recovery reload can happen before either the POST or draft debounce ends.
-      saveDraft(content, attachments.filter((a) => a.serverPath).map((a) => ({ name: a.name, path: a.serverPath! })));
+      saveDraft(content, attachments.filter((a) => a.serverPath).map((a) => ({ name: a.name, path: a.serverPath! })), selectedReply);
       cancelPendingSave();
+      replyToRef.current = null;
+      setReplySelection({ owner: replyOwner, reply: null });
+      composerDraftRef.current = { owner: replyOwner, text: "", observed: true };
       if (editFork && sessionId && projectName) {
         const anchor = editFork.anchorMsgId;
         setEditFork(null);
-        void handleEditSend(buildMessageWithAttachments(content, attachments), anchor);
+        void handleEditSend(buildMessageWithAttachments(content, attachments), anchor, selectedReply);
         return;
       }
-      void handleSend(content, attachments, priority);
+      void handleSend(content, attachments, priority, selectedReply);
     },
-    [handleSend, clearDraft, saveDraft, cancelPendingSave, editFork, sessionId, projectName, handleEditSend, buildMessageWithAttachments, handleNewSession],
+    [handleSend, clearDraft, saveDraft, cancelPendingSave, editFork, sessionId, projectName, handleEditSend, buildMessageWithAttachments, handleNewSession, replyOwner],
   );
 
   // Past user messages for the composer's ArrowUp/Down recall. Read through a ref
@@ -1005,9 +1138,11 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
   /** Draft auto-save callback — called by MessageInput on content change */
   const handleContentChange = useCallback(
     (content: string, attachments?: DraftAttachment[]) => {
-      saveDraft(content, attachments);
+      composerDraftRef.current = { owner: replyOwner, text: content, observed: true, attachments };
+      saveDraft(content, attachments, replyToRef.current);
+      touchPrewarm();
     },
-    [saveDraft],
+    [saveDraft, touchPrewarm, replyOwner],
   );
 
   /** Stable callback for slash items loaded — prevents MessageInput memo break */
@@ -1044,6 +1179,9 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
   }, []);
 
   // Stable callback: clear external paths once consumed (avoids inline lambda breaking MessageInput memo)
+  const handleContextsConsumed = useCallback(() => {
+    if (tabId) patchTabMetadata(tabId, { pendingContexts: undefined });
+  }, [tabId]);
   const handleExternalPathsConsumed = useCallback(() => setExternalPaths(null), []);
 
   // --- Disambiguation picker handler (OS drag resolve with multiple matches) ---
@@ -1057,6 +1195,14 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
   }, []);
 
   // --- File picker handlers ---
+  // An open @-picker keeps the file index current, like the palette — see `openIndexReader`.
+  useEffect(() => {
+    if (showFilePicker && projectName) return useFileStore.getState().openIndexReader(projectName);
+  }, [showFilePicker, projectName]);
+  // A project too long to send is searched on the server as the @-query changes.
+  const indexRemote = useFileStore((s) => s.indexRemote);
+  const remoteFileItems = useRemoteFileSearch(projectName, fileFilter, { enabled: showFilePicker && indexRemote, kind: "all" });
+
   const handleFileStateChange = useCallback((visible: boolean, filter: string) => {
     setShowFilePicker(visible);
     setFileFilter(filter);
@@ -1167,10 +1313,14 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
             <span>Starting conversation...</span>
           </div>
         </div>
-      ) : <MessageList
+      ) : <SessionChangesContext.Provider value={sessionChangesValue}><MessageList
         messages={renderedMessages}
         onExpandCompact={expandCompact}
         isCompactExpanded={isCompactExpanded}
+        hasOlderHistory={hasOlderHistory}
+        onLoadOlderHistory={loadOlderHistory}
+        userOrdinalOffset={userOrdinalOffset}
+        historyPredecessorId={historyPredecessorId}
         messagesLoading={messagesLoading}
         keepStaleWhileLoading={staleSwap}
         pendingApproval={pendingApproval}
@@ -1184,6 +1334,7 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
         projectName={projectName}
         onFork={!isStreaming ? handleFork : undefined}
         onEdit={!isStreaming ? handleEdit : undefined}
+        onReply={sessionId && !draftLoading && !editForking ? handleReply : undefined}
         editingMsgId={editFork?.ownMsgId}
         sessionId={sessionId ?? undefined}
         providerId={providerId}
@@ -1193,7 +1344,7 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
         onDismissMessage={dismissMessage}
         onClearErrors={clearErrors}
         bashPartialOutput={bashPartialOutput}
-      />}
+      /></SessionChangesContext.Provider>}
 
       {/* Agents still working — pinned here so it is the last thing under the conversation */}
       <RunningAgentsBar
@@ -1205,9 +1356,25 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
         teamMembers={teamMembers}
       />
 
+      {/* Why the last turn ended, when an error ended it */}
+      <TurnStopBar
+        stop={phase === "idle" ? turnStop : null}
+        onContinue={() => sendMessage(CONTINUE_AFTER_STOP, { permissionMode })}
+      />
+
       {/* MCP servers this session cannot use until someone signs in */}
       <McpSignInBar key={sessionId ?? "draft"} needsAuth={mcpNeedsAuth} projectName={projectName || undefined} />
 
+      {/* Every file this session has changed, across all its turns */}
+      <SessionChangesBar
+        files={sessionChanges.files}
+        projectName={projectName}
+        providerId={providerId}
+        onOpen={sessionChanges.refresh}
+        onSetReviewed={sessionChanges.setReviewed}
+        onReview={openReview}
+      />
+
       {/* Bottom toolbar */}
       <div className="border-t border-border bg-panel shrink-0">
         {/* Unified toolbar: History, Config, Usage, Bug report, Connection */}
@@ -1225,7 +1392,6 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
           onSelectAccount={!preparation.pending && !firstSendPending ? handleSelectAccount : undefined}
           onSelectSession={handleSelectSession}
           historyFilter={historyFilter}
-          onBugReport={sessionId ? () => openBugReportPopup(version, { sessionId, projectName }) : undefined}
           isConnected={isConnected}
           onReload={() => {
             if (!isConnected) reconnect();
@@ -1247,7 +1413,7 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
           projectName={projectName}
         />
         <FilePicker
-          items={fileItems}
+          items={indexRemote ? remoteFileItems : fileItems}
           filter={fileFilter}
           onSelect={handleFileSelect}
           onClose={handleFileClose}
@@ -1286,11 +1452,15 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
             configurationPending={preparation.pending}
             tabId={tabId}
             onSend={handleInputSend}
+            replyTo={replyTo}
+            onCancelReply={handleCancelReply}
+            replyChangeSignal={replyChangeSignal}
             disabled={firstSendPending}
             isStreaming={isStreaming}
             onCancel={cancelStreaming}
             autoFocus={!(metadata?.sessionId) || !!forkDraft}
-            initialValue={forkDraft ?? draft?.content}
+            initialValue={forkDraft ?? (!firstSendPending && !editForking ? draft?.content : undefined)}
+            initialAttachments={!firstSendPending && !editForking ? draft?.attachments : undefined}
             clearSignal={clearInputSignal}
             restore={restore}
             projectName={projectName}
@@ -1300,6 +1470,8 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
             onFileStateChange={handleFileStateChange}
             onFileItemsLoaded={setFileItems}
             fileSelected={fileSelected}
+            pendingContexts={metadata?.pendingContexts as Array<{ text: string; label?: string }> | undefined}
+            onContextsConsumed={handleContextsConsumed}
             externalFiles={externalFiles}
             externalPaths={externalPaths}
             onExternalPathsConsumed={handleExternalPathsConsumed}
@@ -1323,8 +1495,6 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
           />
         )}
       </div>
-
-      {/* Bug report popup is now global — see BugReportPopup in app.tsx */}
     </div>
     </AgentSessionProvider>
   );

package/src/web/components/chat/chat-toolbar-overflow-menu.tsx

@@ -1,4 +1,4 @@
-import { BellOff, Bug, Circle, MoreHorizontal } from "@/lib/icons";
+import { BellOff, Bug, Circle, MoreHorizontal, ScrollText } from "@/lib/icons";
 import {
   DropdownMenu,
   DropdownMenuContent,
@@ -18,10 +18,13 @@ export function ChatToolbarOverflowMenu({
   hasUnread,
   onToggleUnread,
   onOpenDebug,
+  onShowLogs,
 }: {
   hasUnread: boolean;
   onToggleUnread: () => void;
   onOpenDebug: () => void;
+  /** Opens Logs filtered to this chat's lines — where a bug in it is reported from. */
+  onShowLogs: () => void;
 }) {
   return (
     <DropdownMenu>
@@ -51,6 +54,9 @@ export function ChatToolbarOverflowMenu({
         <DropdownMenuItem onClick={onOpenDebug} className="max-md:py-3">
           <Bug className="size-3.5" /> Session debug info
         </DropdownMenuItem>
+        <DropdownMenuItem onClick={onShowLogs} className="max-md:py-3">
+          <ScrollText className="size-3.5" /> Show logs for this chat
+        </DropdownMenuItem>
       </DropdownMenuContent>
     </DropdownMenu>
   );

package/src/web/components/chat/message-action-bar.tsx

@@ -22,11 +22,13 @@ export function ActionButton({
   label,
   title,
   onClick,
+  touchTarget,
 }: {
   icon: ReactNode;
   label: string;
   title: string;
   onClick: () => void;
+  touchTarget?: boolean;
 }) {
   return (
     <button
@@ -34,7 +36,7 @@ export function ActionButton({
       onClick={onClick}
       title={title}
       aria-label={label}
-      className="inline-flex items-center justify-center gap-1 rounded-md px-1.5 py-1 text-text-subtle hover:text-text-primary hover:bg-surface transition-colors"
+      className={cn("inline-flex items-center justify-center gap-1 rounded-md px-1.5 py-1 text-text-subtle hover:text-text-primary hover:bg-surface transition-colors", touchTarget && "min-h-[44px] min-w-[44px] md:min-h-0 md:min-w-0")}
     >
       {icon}
       <span>{label}</span>