File status and think block state (#2087)

* feat: add file processing status display in context manage modal.

* fix: preserve think block collapse state across streaming -> history transition.

# Conflicts:
#	src/components/chat-components/ChatSingleMessage.tsx

* fix: improve tool call root and think block state handling during streaming transitions

- Add container reference to ToolCallRootRecord for detecting container changes
- Handle container mismatch when streaming component unmounts and history mounts
- Use container.isConnected for stale cleanup instead of timestamp-only approach
- Prevent double toggle on think blocks by handling state in pointerdown

* fix: prevent current project file status from falling through to cached check

For the current project, if a file is not in processing/failed/success
real-time state, it should show "Not started" instead of incorrectly
showing "Processed" based on cached fileContexts entries.

Author: Emt-lin

src/components/Chat.tsx

@@ -46,6 +46,7 @@ import { arrayBufferToBase64 } from "@/utils/base64";
 import { Notice, TFile } from "obsidian";
 import { ContextManageModal } from "@/components/modals/project/context-manage-modal";
 import React, { useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { v4 as uuidv4 } from "uuid";
 import { ChatHistoryItem } from "@/components/chat-components/ChatHistoryPopover";
 import { useActiveWebTabState } from "@/components/chat-components/hooks/useActiveWebTabState";
 
@@ -81,14 +82,22 @@ const ChatInternal: React.FC<ChatProps & { chatInput: ReturnType<typeof useChatI
   const [inputMessage, setInputMessage] = useState("");
   const [latestTokenCount, setLatestTokenCount] = useState<number | null>(null);
   const abortControllerRef = useRef<AbortController | null>(null);
+  // Stable ID for streaming message, shared with final persisted message
+  // This allows collapsible UI state (think blocks) to persist across streaming -> history
+  const streamingMessageIdRef = useRef<string | null>(null);
 
-  // Wrapper for addMessage that tracks token usage from AI responses
+  // Wrapper for addMessage that attaches streaming ID and tracks token usage
   const addMessage = useCallback(
     (message: ChatMessage) => {
-      rawAddMessage(message);
-      // Track token usage from AI messages
-      if (message.sender === AI_SENDER && message.responseMetadata?.tokenUsage?.totalTokens) {
-        setLatestTokenCount(message.responseMetadata.tokenUsage.totalTokens);
+      // Attach streaming ID to final AI message so it shares the same ID as streaming placeholder
+      const streamingId = streamingMessageIdRef.current;
+      const shouldAttachId =
+        streamingId && message.sender === AI_SENDER && !message.isErrorMessage && !message.id;
+      const messageToAdd = shouldAttachId ? { ...message, id: streamingId } : message;
+
+      rawAddMessage(messageToAdd);
+      if (messageToAdd.sender === AI_SENDER && messageToAdd.responseMetadata?.tokenUsage?.totalTokens) {
+        setLatestTokenCount(messageToAdd.responseMetadata.tokenUsage.totalTokens);
       }
     },
     [rawAddMessage]
@@ -258,6 +267,7 @@ const ChatInternal: React.FC<ChatProps & { chatInput: ReturnType<typeof useChatI
       // Clear input and images
       setInputMessage("");
       setSelectedImages([]);
+      streamingMessageIdRef.current = `msg-${uuidv4()}`;
       safeSet.setLoading(true);
       safeSet.setLoadingMessage(LOADING_MESSAGES.DEFAULT);
 
@@ -304,6 +314,7 @@ const ChatInternal: React.FC<ChatProps & { chatInput: ReturnType<typeof useChatI
     } finally {
       safeSet.setLoading(false);
       safeSet.setLoadingMessage(LOADING_MESSAGES.DEFAULT);
+      streamingMessageIdRef.current = null;
     }
   };
 
@@ -363,6 +374,7 @@ const ChatInternal: React.FC<ChatProps & { chatInput: ReturnType<typeof useChatI
 
       // Clear current AI message and set loading state
       safeSet.setCurrentAiMessage("");
+      streamingMessageIdRef.current = `msg-${uuidv4()}`;
       safeSet.setLoading(true);
       try {
         const success = await chatUIState.regenerateMessage(
@@ -386,6 +398,7 @@ const ChatInternal: React.FC<ChatProps & { chatInput: ReturnType<typeof useChatI
         new Notice("Failed to regenerate message. Please try again.");
       } finally {
         safeSet.setLoading(false);
+        streamingMessageIdRef.current = null;
       }
     },
     [
@@ -429,6 +442,7 @@ const ChatInternal: React.FC<ChatProps & { chatInput: ReturnType<typeof useChatI
 
           // If there were AI responses, generate new ones
           if (hadAIResponses) {
+            streamingMessageIdRef.current = `msg-${uuidv4()}`;
             safeSet.setLoading(true);
             try {
               const llmMessage = chatUIState.getLLMMessage(messageToEdit.id!);
@@ -447,6 +461,7 @@ const ChatInternal: React.FC<ChatProps & { chatInput: ReturnType<typeof useChatI
               new Notice("Failed to regenerate AI response. Please try again.");
             } finally {
               safeSet.setLoading(false);
+              streamingMessageIdRef.current = null;
             }
           }
         }
@@ -751,6 +766,7 @@ const ChatInternal: React.FC<ChatProps & { chatInput: ReturnType<typeof useChatI
         <ChatMessages
           chatHistory={chatHistory}
           currentAiMessage={currentAiMessage}
+          streamingMessageId={streamingMessageIdRef.current}
           loading={loading}
           loadingMessage={loadingMessage}
           app={app}

src/components/chat-components/ChatMessages.tsx

@@ -11,6 +11,8 @@ import React, { memo, useEffect, useState } from "react";
 interface ChatMessagesProps {
   chatHistory: ChatMessage[];
   currentAiMessage: string;
+  /** Stable ID for streaming message, shared with final persisted message */
+  streamingMessageId?: string | null;
   loading?: boolean;
   loadingMessage?: string;
   app: App;
@@ -25,6 +27,7 @@ const ChatMessages = memo(
   ({
     chatHistory,
     currentAiMessage,
+    streamingMessageId,
     loading,
     loadingMessage,
     app,
@@ -118,8 +121,9 @@ const ChatMessages = memo(
               }}
             >
               <ChatSingleMessage
-                key="ai_message_streaming"
+                key={streamingMessageId ?? "ai_message_streaming"}
                 message={{
+                  id: streamingMessageId ?? undefined,
                   sender: "AI",
                   message: currentAiMessage || getLoadingMessage(),
                   isVisible: true,

src/components/chat-components/ChatSingleMessage.tsx

@@ -35,6 +35,13 @@ import { cleanMessageForCopy, extractYoutubeVideoId, insertIntoEditor } from "@/
 import { App, Component, MarkdownRenderer, MarkdownView, TFile } from "obsidian";
 import React, { useCallback, useEffect, useRef, useState } from "react";
 import { useSettingsValue } from "@/settings/model";
+import {
+  buildCopilotCollapsibleDomId,
+  captureCopilotCollapsibleOpenStates,
+  getCopilotCollapsibleDetailsFromEvent,
+  getMessageCollapsibleStates,
+  isEventWithinDetailsSummary,
+} from "@/components/chat-components/collapsibleStateUtils";
 
 const FOOTNOTE_SUFFIX_PATTERN = /^\d+-\d+$/;
 
@@ -204,6 +211,13 @@ const ChatSingleMessage: React.FC<ChatSingleMessageProps> = ({
     getMessageErrorBlockRoots(messageId.current)
   );
 
+  // Get the global collapsible state map for this message
+  // This persists across component lifecycles (streaming -> final message)
+  // Use ref to avoid triggering re-renders when map contents change
+  const collapsibleOpenStateMapRef = useRef(getMessageCollapsibleStates(messageId.current));
+  const collapsibleOpenStateMap = collapsibleOpenStateMapRef.current;
+
+  // Check if current model has reasoning capability
   const settings = useSettingsValue();
 
   const copyToClipboard = () => {
@@ -262,13 +276,20 @@ const ChatSingleMessage: React.FC<ChatSingleMessageProps> = ({
         const contentStyle = `margin-top: 0.75rem; padding: 0.75rem; border-radius: 4px; background-color: var(--background-primary)`;
 
         const openTag = `<${tagName}>`;
+        let sectionIndex = 0;
 
         // During streaming, if we find any tag that's either unclosed or being processed
         if (isStreaming && content.includes(openTag)) {
           // Replace any complete sections first
           const completeRegex = new RegExp(`<${tagName}>([\\s\\S]*?)<\\/${tagName}>`, "g");
           content = content.replace(completeRegex, (_match, sectionContent) => {
-            return `<details style="${detailsStyle}">
+            const sectionKey = `${tagName}-${sectionIndex}`;
+            sectionIndex += 1;
+            const domId = buildCopilotCollapsibleDomId(messageId.current, sectionKey);
+            // Check if user has explicitly set a state; if not, default to collapsed (original behavior)
+            const openAttribute = collapsibleOpenStateMap.get(domId) ? " open" : "";
+
+            return `<details id="${domId}"${openAttribute} style="${detailsStyle}">
               <summary style="${summaryStyle}">${summaryText}</summary>
               <div class="tw-text-muted" style="${contentStyle}">${sectionContent.trim()}</div>
             </details>\n\n`;
@@ -289,7 +310,13 @@ const ChatSingleMessage: React.FC<ChatSingleMessageProps> = ({
         // Not streaming, process all sections normally
         const regex = new RegExp(`<${tagName}>([\\s\\S]*?)<\\/${tagName}>`, "g");
         return content.replace(regex, (_match, sectionContent) => {
-          return `<details style="${detailsStyle}">
+          const sectionKey = `${tagName}-${sectionIndex}`;
+          sectionIndex += 1;
+          const domId = buildCopilotCollapsibleDomId(messageId.current, sectionKey);
+          // Restore open state from previous render
+          const openAttribute = collapsibleOpenStateMap.get(domId) ? " open" : "";
+
+          return `<details id="${domId}"${openAttribute} style="${detailsStyle}">
             <summary style="${summaryStyle}">${summaryText}</summary>
             <div class="tw-text-muted" style="${contentStyle}">${sectionContent.trim()}</div>
           </details>\n\n`;
@@ -428,9 +455,73 @@ const ChatSingleMessage: React.FC<ChatSingleMessageProps> = ({
 
       return processYouTubeEmbed(noteLinksProcessed);
     },
-    [app, isStreaming, settings.enableInlineCitations]
+    [app, isStreaming, settings.enableInlineCitations, collapsibleOpenStateMap]
   );
 
+  // Persist collapsible open/closed state during streaming in real time.
+  // Streaming updates can rebuild the markdown DOM between pointer down/up, preventing a click.
+  useEffect(() => {
+    const root = contentRef.current;
+    if (!root || message.sender === USER_SENDER || !isStreaming) {
+      return;
+    }
+
+    /**
+     * Handles user click on collapsible summary during streaming.
+     * Directly sets details.open to avoid race conditions where DOM rebuilds
+     * between pointerdown and click, causing double toggle that cancels user intent.
+     */
+    const handleSummaryPointerDown = (event: Event): void => {
+      // Only handle primary button (left click)
+      if (event instanceof PointerEvent && (event.button !== 0 || !event.isPrimary)) {
+        return;
+      }
+
+      const details = getCopilotCollapsibleDetailsFromEvent(event, root);
+      if (!details || !isEventWithinDetailsSummary(event, details)) {
+        return;
+      }
+
+      // Calculate and apply the next state immediately
+      const nextOpen = !details.open;
+      details.open = nextOpen;
+      collapsibleOpenStateMap.set(details.id, nextOpen);
+    };
+
+    /**
+     * Prevents native click from triggering another toggle on <details>.
+     * Since we already handled the state change in pointerdown, block the default behavior.
+     */
+    const handleSummaryClick = (event: Event): void => {
+      const details = getCopilotCollapsibleDetailsFromEvent(event, root);
+      if (!details || !isEventWithinDetailsSummary(event, details)) {
+        return;
+      }
+      event.preventDefault();
+    };
+
+    /**
+     * Captures actual open/closed state changes from native <details> interactions.
+     */
+    const handleDetailsToggle = (event: Event): void => {
+      const details = getCopilotCollapsibleDetailsFromEvent(event, root);
+      if (!details) {
+        return;
+      }
+      collapsibleOpenStateMap.set(details.id, details.open);
+    };
+
+    // Use capture phase and listen on root (not document) to minimize scope
+    root.addEventListener("pointerdown", handleSummaryPointerDown, true);
+    root.addEventListener("click", handleSummaryClick, true);
+    root.addEventListener("toggle", handleDetailsToggle, true);
+    return () => {
+      root.removeEventListener("pointerdown", handleSummaryPointerDown, true);
+      root.removeEventListener("click", handleSummaryClick, true);
+      root.removeEventListener("toggle", handleDetailsToggle, true);
+    };
+  }, [isStreaming, message.sender, collapsibleOpenStateMap]);
+
   useEffect(() => {
     // Reset unmounting flag when effect runs
     isUnmountingRef.current = false;
@@ -441,6 +532,14 @@ const ChatSingleMessage: React.FC<ChatSingleMessageProps> = ({
         componentRef.current = new Component();
       }
 
+      // Capture open states of collapsible sections before re-rendering
+      // During streaming, don't overwrite user's explicit state changes from pointerdown
+      captureCopilotCollapsibleOpenStates(
+        contentRef.current,
+        collapsibleOpenStateMap,
+        { overwriteExisting: !isStreaming }
+      );
+
       const originMessage = message.message;
       const processedMessage = preprocess(originMessage);
       const parsedMessage = parseToolCallMarkers(processedMessage, messageId.current);
@@ -599,7 +698,7 @@ const ChatSingleMessage: React.FC<ChatSingleMessageProps> = ({
     return () => {
       isUnmountingRef.current = true;
     };
-  }, [message, app, componentRef, isStreaming, preprocess]);
+  }, [message, app, componentRef, isStreaming, preprocess, collapsibleOpenStateMap]);
 
   // Cleanup effect that only runs on component unmount
   useEffect(() => {
@@ -629,8 +728,9 @@ const ChatSingleMessage: React.FC<ChatSingleMessageProps> = ({
           currentComponentRef.current = null;
         }
 
-        // Only clean up roots if this is a temporary message (streaming message)
-        // Permanent messages keep their roots to preserve tool call banners and error blocks
+        // Only clean up roots if this is a temporary message (streaming message with temp- prefix).
+        // For shared messageId (msg-xxx), container changes are handled by ensureToolCallRoot/ensureErrorBlockRoot
+        // which detect container mismatch and recreate roots as needed.
         if (currentMessageId.startsWith("temp-")) {
           cleanupMessageToolCallRoots(currentMessageId, messageRootsSnapshot, "component cleanup");
           cleanupMessageErrorBlockRoots(currentMessageId, errorRootsSnapshot, "component cleanup");