@mndrk/agx 2.0.0 → 2.0.2

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/components/chat-ui/ChatContainer.tsx

@@ -1,10 +1,9 @@
 "use client";
 
 import { useEffect, useRef, useState, useCallback, useMemo } from "react";
-import { useRouter, useParams } from "next/navigation";
 import { useGroupChat } from "@/hooks/useGroupChat";
-import { useWorkspaceState } from "@/hooks/useThreadState";
-import { WorkspaceSidebar } from "@/components/thread/ThreadSidebar";
+import { useThreadState } from "@/hooks/useThreadState";
+import { ThreadSidebar } from "@/components/thread/ThreadSidebar";
 import "@/styles/threadSidebar.css";
 import { MessageList } from "./MessageList";
 import { ThreadView } from "./ThreadView";
@@ -12,8 +11,8 @@ import { SearchResults } from "./SearchResults";
 import { Composer } from "./Composer";
 import { LogPanel } from "./LogPanel";
 import {
-  loadWorkspaceSidebarVisible,
-  persistWorkspaceSidebarVisible,
+  loadThreadSidebarVisible,
+  persistThreadSidebarVisible,
 } from "@/state/uiSettings";
 import {
   loadStoredActiveParticipantIds,
@@ -30,7 +29,7 @@ import { buildTasks } from "@/services/agxService";
 import { SquareTerminal, Search, ChevronLeft } from "lucide-react";
 import { StatusIndicator } from "./StatusIndicator";
 
-const LEGACY_WORKSPACE_ID = "global";
+const LEGACY_THREAD_ID = "global";
 const SUMMARY_MARKER = "<!-- thread-summary -->";
 const TASK_DRAFT_MARKER = "<!-- task-draft -->";
 
@@ -139,51 +138,35 @@ function toMarkdown(
   return lines.join("\n").trim();
 }
 
-interface ChatContainerProps {
-  /** Workspace ID from URL (/w/<id>) */
-  workspaceId?: string;
-  /** Root message ID to open as a sub-thread view (/w/<id>/<threadId>) */
-  openRootMessageId?: string;
-}
-
-export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId }: ChatContainerProps = {}) {
-  const router = useRouter();
-  const params = useParams();
-  // Read from URL params so navigating /w/<id> <-> /w/<id>/<threadId> doesn't remount
-  const urlWorkspaceId = (params?.workspaceId as string | undefined) ?? propWorkspaceId;
-  const urlThreadId = (params?.threadId as string | undefined) ?? openRootMessageId ?? null;
+export function ChatContainer() {
   const {
-    workspaces,
-    activeWorkspaceId,
-    selectWorkspace,
-    createWorkspace,
-    deleteWorkspace,
-    updateWorkspaceMessages,
+    threads,
+    activeThreadId,
+    selectThread,
+    createThread,
+    deleteThread,
+    updateThreadMessages,
     isCreating,
-    deletingWorkspaceId,
-    renamingWorkspaceId,
-    isLoading: workspacesLoading,
-    isRestoringActiveWorkspace,
-    renameWorkspace,
-  } = useWorkspaceState();
+    deletingThreadId,
+    renamingThreadId,
+    isLoading: threadsLoading,
+    isRestoringActiveThread,
+    renameThread,
+  } = useThreadState();
   const { messages, streaming, loading, logs, sendMessage, loadHistory, clearLogs, stop, stopThread } =
-    useGroupChat(activeWorkspaceId);
+    useGroupChat(activeThreadId);
   const [participants, setParticipants] = useState<Participant[]>([]);
   const [participantsLoaded, setParticipantsLoaded] = useState(false);
   const [activeParticipantIds, setActiveParticipantIds] = useState<string[]>([]);
   const [copied, setCopied] = useState(false);
   const [logsOpen, setLogsOpen] = useState(false);
-  const [workspaceSidebarVisible, setWorkspaceSidebarVisible] = useState(false);
+  const [threadSidebarVisible, setThreadSidebarVisible] = useState(false);
 
   // Sync sidebar visibility from localStorage after hydration to avoid SSR mismatch
   useEffect(() => {
-    setWorkspaceSidebarVisible(loadWorkspaceSidebarVisible());
+    setThreadSidebarVisible(loadThreadSidebarVisible());
   }, []);
-  const [openThreadId, setOpenThreadId] = useState<string | null>(urlThreadId);
-  // Sync openThreadId with URL changes (navigating between /w/<id> and /w/<id>/<threadId>)
-  useEffect(() => {
-    setOpenThreadId(urlThreadId);
-  }, [urlThreadId]);
+  const [openThreadId, setOpenThreadId] = useState<string | null>(null);
   const [searchQuery, setSearchQuery] = useState("");
   const [searchResults, setSearchResults] = useState<MessageSearchResult[]>([]);
   const [searchTotal, setSearchTotal] = useState(0);
@@ -197,20 +180,20 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
     setTaskDraftsRaw((prev) => {
       const next = typeof update === "function" ? update(prev) : update;
       // persist each changed draft
-      if (activeWorkspaceId) {
+      if (activeThreadId) {
         for (const [msgId, draft] of Object.entries(next)) {
           if (prev[msgId] !== draft) {
             fetch("/api/task-drafts", {
               method: "POST",
               headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({ threadId: activeWorkspaceId, messageId: msgId, draft }),
+              body: JSON.stringify({ threadId: activeThreadId, messageId: msgId, draft }),
             }).catch(() => { });
           }
         }
       }
       return next;
     });
-  }, [activeWorkspaceId]);
+  }, [activeThreadId]);
   const [extractingTasks, setExtractingTasks] = useState<Set<string>>(new Set());
   const [buildingDrafts, setBuildingDrafts] = useState<Set<string>>(new Set());
   const searchInputRef = useRef<HTMLInputElement | null>(null);
@@ -235,9 +218,9 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
     []
   );
 
-  const persistWorkspaceSidebarPreferenceRemotely = useCallback(async (visible: boolean) => {
+  const persistThreadSidebarPreferenceRemotely = useCallback(async (visible: boolean) => {
     try {
-      await updateUserPreferences({ workspaceSidebarVisible: visible });
+      await updateUserPreferences({ threadSidebarVisible: visible });
     } catch (error) {
       console.error("Unable to persist thread sidebar preference", error);
     }
@@ -245,20 +228,20 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
 
   const persistSidebarPreference = useCallback(
     (visible: boolean) => {
-      persistWorkspaceSidebarVisible(visible);
-      void persistWorkspaceSidebarPreferenceRemotely(visible);
+      persistThreadSidebarVisible(visible);
+      void persistThreadSidebarPreferenceRemotely(visible);
     },
-    [persistWorkspaceSidebarPreferenceRemotely]
+    [persistThreadSidebarPreferenceRemotely]
   );
 
   const normalizedSearchQuery = searchQuery.trim();
   const searchActive = normalizedSearchQuery.length > 0;
-  const workspaceTitleById = useMemo(
+  const threadTitleById = useMemo(
     () =>
       Object.fromEntries(
-        workspaces.map((workspace) => [workspace.id, workspace.title?.trim() || "Untitled workspace"])
+        threads.map((thread) => [thread.id, thread.title?.trim() || "Untitled workspace"])
       ),
-    [workspaces]
+    [threads]
   );
 
   const activeThreadParticipants = useMemo(() => {
@@ -389,12 +372,12 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
     const participantIds = participants.map((participant) => participant.id);
     const participantIdSet = new Set(participantIds);
 
-    if (!activeWorkspaceId) {
+    if (!activeThreadId) {
       setActiveParticipantIds(participantIds);
       return;
     }
 
-    const storedIds = loadStoredActiveParticipantIds(activeWorkspaceId);
+    const storedIds = loadStoredActiveParticipantIds(activeThreadId);
     if (storedIds === null) {
       setActiveParticipantIds(participantIds);
       return;
@@ -402,10 +385,10 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
 
     const reconciled = storedIds.filter((id) => participantIdSet.has(id));
     if (reconciled.length !== storedIds.length) {
-      persistStoredActiveParticipantIds(activeWorkspaceId, reconciled);
+      persistStoredActiveParticipantIds(activeThreadId, reconciled);
     }
     setActiveParticipantIds(reconciled);
-  }, [activeWorkspaceId, participants, participantsLoaded]);
+  }, [activeThreadId, participants, participantsLoaded]);
 
   useEffect(() => {
     let cancelled = false;
@@ -413,12 +396,12 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
       try {
         const preferences = await fetchUserPreferences();
         if (cancelled) return;
-        setWorkspaceSidebarVisible((current) => {
-          if (current === preferences.workspaceSidebarVisible) {
+        setThreadSidebarVisible((current) => {
+          if (current === preferences.threadSidebarVisible) {
             return current;
           }
-          persistWorkspaceSidebarVisible(preferences.workspaceSidebarVisible);
-          return preferences.workspaceSidebarVisible;
+          persistThreadSidebarVisible(preferences.threadSidebarVisible);
+          return preferences.threadSidebarVisible;
         });
       } catch (error) {
         console.error("Failed to load user preferences", error);
@@ -427,49 +410,13 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
     return () => {
       cancelled = true;
     };
-  }, [fetchUserPreferences, persistWorkspaceSidebarVisible]);
-
-  useEffect(() => {
-    if (!workspacesLoading && !isCreating && workspaces.length === 0) {
-      void createWorkspace({ id: LEGACY_WORKSPACE_ID, title: "General" });
-    }
-  }, [workspacesLoading, isCreating, workspaces.length, createWorkspace]);
-
-  // Select workspace from URL param on mount
-  const urlWorkspaceHandledRef = useRef(false);
-  useEffect(() => {
-    if (!urlWorkspaceId || workspacesLoading || urlWorkspaceHandledRef.current) return;
-    urlWorkspaceHandledRef.current = true;
-    const existing = workspaces.find((w) => w.id === urlWorkspaceId);
-    if (existing) {
-      selectWorkspace(urlWorkspaceId);
-    } else {
-      void createWorkspace({ id: urlWorkspaceId });
-    }
-  }, [urlWorkspaceId, workspacesLoading, workspaces, selectWorkspace, createWorkspace]);
+  }, [fetchUserPreferences, persistThreadSidebarVisible]);
 
-  // Redirect bare / to /w/<activeWorkspaceId>
-  const hasRedirectedRef = useRef(false);
   useEffect(() => {
-    if (urlWorkspaceId || hasRedirectedRef.current || !activeWorkspaceId || workspacesLoading) return;
-    hasRedirectedRef.current = true;
-    router.replace(`/w/${activeWorkspaceId}`);
-  }, [urlWorkspaceId, activeWorkspaceId, workspacesLoading, router]);
-
-  // Sync URL when active workspace changes (only when already on /w/ route)
-  const prevActiveWorkspaceIdForUrlRef = useRef<string | null>(null);
-  useEffect(() => {
-    if (!urlWorkspaceId || !activeWorkspaceId) return;
-    if (prevActiveWorkspaceIdForUrlRef.current === null) {
-      prevActiveWorkspaceIdForUrlRef.current = activeWorkspaceId;
-      return;
+    if (!threadsLoading && !isCreating && threads.length === 0) {
+      void createThread({ id: LEGACY_THREAD_ID, title: "General" });
     }
-    if (activeWorkspaceId !== prevActiveWorkspaceIdForUrlRef.current) {
-      prevActiveWorkspaceIdForUrlRef.current = activeWorkspaceId;
-      router.replace(`/w/${activeWorkspaceId}`);
-    }
-  }, [urlWorkspaceId, activeWorkspaceId, router]);
-
+  }, [threadsLoading, isCreating, threads.length, createThread]);
 
   useEffect(() => {
     return () => {
@@ -555,10 +502,10 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
     };
   }, [normalizedSearchQuery]);
 
-  const prevActiveWorkspaceIdRef = useRef<string | null>(null);
+  const prevActiveThreadIdRef = useRef<string | null>(null);
   useEffect(() => {
-    // Only stop active streams when actually switching workspaces, not on initial mount.
-    if (prevActiveWorkspaceIdRef.current !== null && prevActiveWorkspaceIdRef.current !== activeWorkspaceId) {
+    // Only stop active streams when actually switching threads, not on initial mount.
+    if (prevActiveThreadIdRef.current !== null && prevActiveThreadIdRef.current !== activeThreadId) {
       stop();
       if (pendingOpenThreadIdRef.current) {
         setOpenThreadId(pendingOpenThreadIdRef.current);
@@ -567,11 +514,11 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
         setOpenThreadId(null);
       }
     }
-    prevActiveWorkspaceIdRef.current = activeWorkspaceId;
-    if (!activeWorkspaceId) return;
-    void loadHistory(activeWorkspaceId);
+    prevActiveThreadIdRef.current = activeThreadId;
+    if (!activeThreadId) return;
+    void loadHistory(activeThreadId);
     // Load persisted task drafts
-    fetch(`/api/task-drafts?threadId=${encodeURIComponent(activeWorkspaceId)}`)
+    fetch(`/api/task-drafts?threadId=${encodeURIComponent(activeThreadId)}`)
       .then((r) => r.json())
       .then((data) => {
         if (data.drafts && Object.keys(data.drafts).length > 0) {
@@ -581,33 +528,33 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
         }
       })
       .catch(() => setTaskDraftsRaw({}));
-  }, [activeWorkspaceId, loadHistory, stop]);
+  }, [activeThreadId, loadHistory, stop]);
 
   useEffect(() => {
-    if (!activeWorkspaceId) return;
-    void updateWorkspaceMessages(activeWorkspaceId, messages);
-  }, [activeWorkspaceId, messages, updateWorkspaceMessages]);
+    if (!activeThreadId) return;
+    void updateThreadMessages(activeThreadId, messages);
+  }, [activeThreadId, messages, updateThreadMessages]);
 
   const handleThreadReply = useCallback(
     (rootMessageId: string, content: string, maxRounds: number = 10) => {
-      if (!activeWorkspaceId) return;
+      if (!activeThreadId) return;
       if (activeParticipants.length === 0) return;
       void sendMessage(
         content,
         maxRounds,
-        activeWorkspaceId,
+        activeThreadId,
         rootMessageId,
         undefined,
         undefined,
         activeParticipants.map((participant) => participant.id)
       );
     },
-    [activeWorkspaceId, sendMessage, activeParticipants]
+    [activeThreadId, sendMessage, activeParticipants]
   );
 
 
   const handleSummarize = useCallback(async (rootMessageId: string) => {
-    if (!activeWorkspaceId) return;
+    if (!activeThreadId) return;
     if (activeParticipants.length === 0) {
       window.alert("Enable at least one agent in this workspace.");
       return;
@@ -618,13 +565,13 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
-          threadId: activeWorkspaceId,
+          threadId: activeThreadId,
           rootMessageId,
           activeParticipantIds: activeParticipants.map((participant) => participant.id),
         }),
       });
       if (res.ok) {
-        await loadHistory(activeWorkspaceId);
+        await loadHistory(activeThreadId);
       } else {
         console.error("Summarize failed:", await res.text());
       }
@@ -637,10 +584,10 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
         return next;
       });
     }
-  }, [activeWorkspaceId, loadHistory, activeParticipants]);
+  }, [activeThreadId, loadHistory, activeParticipants]);
 
   const handleExtractTasks = useCallback(async (rootMessageId: string) => {
-    if (!activeWorkspaceId) return;
+    if (!activeThreadId) return;
     if (activeParticipants.length === 0) {
       window.alert("Enable at least one agent in this workspace.");
       return;
@@ -651,7 +598,7 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
-          threadId: activeWorkspaceId,
+          threadId: activeThreadId,
           rootMessageId,
           activeParticipantIds: activeParticipants.map((participant) => participant.id),
         }),
@@ -677,14 +624,14 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
         return next;
       });
     }
-  }, [activeWorkspaceId, activeParticipants]);
+  }, [activeThreadId, activeParticipants]);
 
   const handleUpdateTaskDraft = useCallback((rootMessageId: string, draft: TaskDraftMessage) => {
     setTaskDrafts((prev) => ({ ...prev, [rootMessageId]: draft }));
   }, []);
 
   const handleBuildTasks = useCallback(async (rootMessageId: string, draft: TaskDraftMessage, projectId: string, projectName: string) => {
-    if (!activeWorkspaceId) return;
+    if (!activeThreadId) return;
     setBuildingDrafts((prev) => new Set(prev).add(draft.draftId));
     setTaskDrafts((prev) => ({
       ...prev,
@@ -729,10 +676,10 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
         return next;
       });
     }
-  }, [activeWorkspaceId]);
+  }, [activeThreadId]);
 
   const handleCreateTasksCommand = useCallback(() => {
-    if (!activeWorkspaceId) return;
+    if (!activeThreadId) return;
     const targetRootId = (() => {
       if (openThreadId) return openThreadId;
       const replyRoots = new Set(
@@ -753,17 +700,15 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
       return;
     }
     void handleExtractTasks(targetRootId);
-  }, [activeWorkspaceId, handleExtractTasks, messages, openThreadId]);
+  }, [activeThreadId, handleExtractTasks, messages, openThreadId]);
 
   const handleReplyToMessage = useCallback((messageId: string) => {
     setOpenThreadId(messageId);
   }, []);
 
   const handleOpenThread = useCallback((rootMessageId: string) => {
-    if (activeWorkspaceId) {
-      router.push(`/w/${activeWorkspaceId}/${rootMessageId}`);
-    }
-  }, [activeWorkspaceId, router]);
+    setOpenThreadId(rootMessageId);
+  }, []);
 
   const handleSearchCommand = useCallback((query?: string) => {
     const normalized = query?.trim() ?? "";
@@ -779,7 +724,7 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
   }, []);
 
   const handleSummarizeCommand = useCallback(() => {
-    if (!activeWorkspaceId) return;
+    if (!activeThreadId) return;
 
     const targetRootId = (() => {
       if (openThreadId) return openThreadId;
@@ -802,7 +747,7 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
       return;
     }
     void handleSummarize(targetRootId);
-  }, [activeWorkspaceId, handleSummarize, messages, openThreadId]);
+  }, [activeThreadId, handleSummarize, messages, openThreadId]);
 
   const handleSend = useCallback(
     async (prompt: string, maxRounds: number, attachmentIds?: string[], attachmentMetas?: import("@/lib/types").Attachment[]) => {
@@ -822,10 +767,10 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
         return;
       }
 
-      let workspaceId = activeWorkspaceId;
-      if (!workspaceId) {
-        const created = await createWorkspace();
-        workspaceId = created.id;
+      let threadId = activeThreadId;
+      if (!threadId) {
+        const created = await createThread();
+        threadId = created.id;
       }
 
       const selectedActiveIds = activeParticipants.map((participant) => participant.id);
@@ -838,7 +783,7 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
         await sendMessage(
           prompt,
           maxRounds,
-          workspaceId,
+          threadId,
           openThreadId,
           attachmentIds,
           attachmentMetas,
@@ -852,7 +797,7 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
       await sendMessage(
         prompt,
         maxRounds,
-        workspaceId,
+        threadId,
         null,
         attachmentIds,
         attachmentMetas,
@@ -860,8 +805,8 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
       );
     },
     [
-      activeWorkspaceId,
-      createWorkspace,
+      activeThreadId,
+      createThread,
       handleSearchCommand,
       handleSummarizeCommand,
       openThreadId,
@@ -873,9 +818,9 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
   const handleSelectSearchResult = useCallback(
     (result: MessageSearchResult) => {
       const targetRootId = result.rootMessageId || result.messageId;
-      if (result.threadId !== activeWorkspaceId) {
+      if (result.threadId !== activeThreadId) {
         pendingOpenThreadIdRef.current = targetRootId;
-        selectWorkspace(result.threadId);
+        selectThread(result.threadId);
       } else {
         setOpenThreadId(targetRootId);
       }
@@ -891,20 +836,20 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
       });
       clearSearch();
     },
-    [activeWorkspaceId, clearSearch, selectWorkspace]
+    [activeThreadId, clearSearch, selectThread]
   );
 
-  const handleDeleteWorkspace = useCallback(
-    async (workspaceId: string) => {
+  const handleDeleteThread = useCallback(
+    async (threadId: string) => {
       stop();
-      await deleteWorkspace(workspaceId);
+      await deleteThread(threadId);
     },
-    [deleteWorkspace, stop]
+    [deleteThread, stop]
   );
 
-  const handleDeleteWorkspaceRoot = useCallback(
+  const handleDeleteThreadRoot = useCallback(
     async (rootMessageId: string) => {
-      if (!activeWorkspaceId || !rootMessageId) return;
+      if (!activeThreadId || !rootMessageId) return;
       const confirmed = window.confirm("Delete this thread and all of its replies?");
       if (!confirmed) return;
 
@@ -913,7 +858,7 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
 
       try {
         const params = new URLSearchParams({
-          threadId: activeWorkspaceId,
+          threadId: activeThreadId,
           rootMessageId,
         });
         const response = await fetch(`/api/history?${params.toString()}`, { method: "DELETE" });
@@ -928,15 +873,15 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
         const nextMessages = messages.filter(
           (message) => message.id !== rootMessageId && message.rootMessageId !== rootMessageId
         );
-        void updateWorkspaceMessages(activeWorkspaceId, nextMessages);
-        await loadHistory(activeWorkspaceId);
+        void updateThreadMessages(activeThreadId, nextMessages);
+        await loadHistory(activeThreadId);
       } catch (error) {
         console.error("Failed to delete message thread", error);
       } finally {
         setDeletingThreadRootId((current) => (current === rootMessageId ? null : current));
       }
     },
-    [activeWorkspaceId, loadHistory, messages, stopThread, updateWorkspaceMessages]
+    [activeThreadId, loadHistory, messages, stopThread, updateThreadMessages]
   );
 
   const slashCommands: SlashCommand[] = useMemo(
@@ -978,8 +923,8 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
     [handleThreadReply, stopThread, streaming, activeParticipants, slashCommands, messages]
   );
 
-  const toggleWorkspaceSidebar = useCallback(() => {
-    setWorkspaceSidebarVisible((prev) => {
+  const toggleThreadSidebar = useCallback(() => {
+    setThreadSidebarVisible((prev) => {
       const next = !prev;
       persistSidebarPreference(next);
       return next;
@@ -1016,10 +961,10 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
     });
     if (res.ok) {
       setParticipants((prev) => prev.filter((p) => p.id !== id));
-      if (activeWorkspaceId) {
+      if (activeThreadId) {
         setActiveParticipantIds((prev) => {
           const next = prev.filter((participantId) => participantId !== id);
-          persistStoredActiveParticipantIds(activeWorkspaceId, next);
+          persistStoredActiveParticipantIds(activeThreadId, next);
           return next;
         });
       }
@@ -1058,14 +1003,14 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
           .map((participant) => participant.id)
           .filter((id) => nextSet.has(id));
 
-        if (activeWorkspaceId) {
-          persistStoredActiveParticipantIds(activeWorkspaceId, next);
+        if (activeThreadId) {
+          persistStoredActiveParticipantIds(activeThreadId, next);
         }
 
         return next;
       });
     },
-    [activeWorkspaceId, participants]
+    [activeThreadId, participants]
   );
 
   const searchInputBar = (
@@ -1108,31 +1053,27 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
 
   return (
     <div className="flex h-screen bg-white text-zinc-900">
-      <WorkspaceSidebar
-        workspaces={workspaces}
+      <ThreadSidebar
+        threads={threads}
         participants={participants}
-        activeWorkspaceId={activeWorkspaceId}
-        isLoading={workspacesLoading}
-        isRestoringActiveWorkspace={isRestoringActiveWorkspace}
+        activeThreadId={activeThreadId}
+        isLoading={threadsLoading}
+        isRestoringActiveThread={isRestoringActiveThread}
         isCreating={isCreating}
-        deletingWorkspaceId={deletingWorkspaceId}
-        renamingWorkspaceId={renamingWorkspaceId}
-        onSelectWorkspace={(workspaceId: string) => {
-          setOpenThreadId(null);
-          selectWorkspace(workspaceId);
-          router.push(`/w/${workspaceId}`);
-        }}
-        onCreateWorkspace={createWorkspace}
-        onRenameWorkspace={renameWorkspace}
-        onDeleteWorkspace={handleDeleteWorkspace}
+        deletingThreadId={deletingThreadId}
+        renamingThreadId={renamingThreadId}
+        onSelectThread={selectThread}
+        onCreateThread={createThread}
+        onRenameThread={renameThread}
+        onDeleteThread={handleDeleteThread}
         onAddParticipant={handleAdd}
         onUpdateParticipant={handleUpdate}
         onRemoveParticipant={handleRemove}
         activeParticipantIds={activeParticipantIds}
         onToggleParticipantActive={handleToggleParticipantActive}
         onReorderParticipants={handleReorderParticipants}
-        visible={workspaceSidebarVisible}
-        onToggle={toggleWorkspaceSidebar}
+        visible={threadSidebarVisible}
+        onToggle={toggleThreadSidebar}
 
       />
       <div className="flex flex-col flex-1 min-w-0 relative">
@@ -1160,11 +1101,13 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
           </button>
         </div>
 
+
+
         {openThreadId && (
           <header className="border-b border-slate-200 px-6 py-4 flex items-center h-16 pr-14">
             <div className="flex items-center gap-3 min-w-0">
               <button
-                onClick={() => router.push(activeWorkspaceId ? `/w/${activeWorkspaceId}` : "/")}
+                onClick={() => setOpenThreadId(null)}
                 className="p-1.5 text-slate-400 hover:text-indigo-600 hover:bg-zinc-100 rounded-lg transition-all active:scale-95 flex-shrink-0"
                 title="Back to main feed"
               >
@@ -1197,7 +1140,7 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
           </header>
         )}
         {
-          isRestoringActiveWorkspace ? (
+          isRestoringActiveThread ? (
             <div className="flex-1 flex items-center justify-center px-4 text-sm text-zinc-500">
               Loading your last workspace…
             </div>
@@ -1212,7 +1155,7 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
                     results={searchResults}
                     total={searchTotal}
                     participants={participants}
-                    threadTitleById={workspaceTitleById}
+                    threadTitleById={threadTitleById}
                     isLoading={searchLoading}
                     error={searchError}
                     onSelectResult={handleSelectSearchResult}
@@ -1223,10 +1166,10 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
                     streaming={streaming}
                     participants={participants}
                     rootMessageId={openThreadId}
-                    onClose={() => router.push(activeWorkspaceId ? `/w/${activeWorkspaceId}` : "/")}
+                    onClose={() => setOpenThreadId(null)}
                     onCopyThread={handleCopyThread}
                     onAddToChat={handleAddToChat}
-                    onDeleteThreadRoot={handleDeleteWorkspaceRoot}
+                    onDeleteThreadRoot={handleDeleteThreadRoot}
                     highlightedMessageId={highlightedMessageId || undefined}
                     renderReplyComposer={renderReplyComposer}
                   />
@@ -1238,7 +1181,7 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
                     onOpenThread={handleOpenThread}
                     onCopyThread={handleCopyThread}
                     onAddToChat={handleAddToChat}
-                    onDeleteThreadRoot={handleDeleteWorkspaceRoot}
+                    onDeleteThreadRoot={handleDeleteThreadRoot}
                     onSummarize={handleSummarize}
                     onCreateTasks={handleExtractTasks}
                     onUpdateTaskDraft={handleUpdateTaskDraft}
@@ -1268,7 +1211,7 @@ export function ChatContainer({ workspaceId: propWorkspaceId, openRootMessageId
           )
         }
       </div >
-      <LogPanel logs={logs} participants={participants} onClear={() => void clearLogs(activeWorkspaceId)} open={logsOpen} onToggle={() => setLogsOpen(false)} />
+      <LogPanel logs={logs} participants={participants} onClear={() => void clearLogs(activeThreadId)} open={logsOpen} onToggle={() => setLogsOpen(false)} />
     </div >
   );
 }