@mndrk/agx 2.0.19 → 2.0.21

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/components/DaemonBar.tsx

@@ -0,0 +1,127 @@
+"use client";
+
+import { useEffect, useState, useCallback } from "react";
+
+interface DaemonStatus {
+  running: boolean;
+  targetWorkers: number;
+  activeWorkers: number;
+  maxWorkers: number;
+  startedAt: string | null;
+}
+
+export default function DaemonBar() {
+  const [status, setStatus] = useState<DaemonStatus | null>(null);
+  const [loading, setLoading] = useState(false);
+
+  const fetchStatus = useCallback(async () => {
+    try {
+      const res = await fetch("/api/daemon");
+      if (res.ok) setStatus(await res.json());
+    } catch {
+      // silent
+    }
+  }, []);
+
+  useEffect(() => {
+    fetchStatus();
+    const interval = setInterval(fetchStatus, 10_000);
+    return () => clearInterval(interval);
+  }, [fetchStatus]);
+
+  const toggle = async () => {
+    setLoading(true);
+    try {
+      if (status?.running) {
+        await fetch("/api/daemon", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ action: "stop" }),
+        });
+      } else {
+        await fetch("/api/daemon", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ workers: 1 }),
+        });
+      }
+      await fetchStatus();
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const scale = async (delta: number) => {
+    if (!status) return;
+    const next = Math.max(1, Math.min(status.maxWorkers, status.targetWorkers + delta));
+    if (next === status.targetWorkers) return;
+    setLoading(true);
+    try {
+      await fetch("/api/daemon", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ workers: next }),
+      });
+      await fetchStatus();
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  if (!status) return null;
+
+  const running = status.running;
+
+  return (
+    <div className="flex items-center gap-3 py-2 text-xs text-slate-500">
+      {/* Status dot + label */}
+      <button
+        type="button"
+        onClick={toggle}
+        disabled={loading}
+        className="inline-flex items-center gap-1.5 px-2.5 py-1 rounded-full border border-slate-200 hover:border-slate-300 transition-colors disabled:opacity-50"
+      >
+        <span
+          className={`w-1.5 h-1.5 rounded-full ${running ? "bg-emerald-500" : "bg-slate-300"}`}
+        />
+        <span className="font-medium text-slate-600">
+          {loading ? "..." : running ? "Daemon running" : "Daemon stopped"}
+        </span>
+      </button>
+
+      {running && (
+        <>
+          {/* Worker count with +/- */}
+          <div className="inline-flex items-center rounded-full border border-slate-200 overflow-hidden">
+            <button
+              type="button"
+              onClick={() => scale(-1)}
+              disabled={loading || status.targetWorkers <= 1}
+              className="px-1.5 py-0.5 hover:bg-slate-100 transition-colors disabled:opacity-30 text-slate-400"
+            >
+              -
+            </button>
+            <span className="px-2 py-0.5 font-mono text-slate-600 border-x border-slate-200">
+              {status.activeWorkers}/{status.targetWorkers}w
+            </span>
+            <button
+              type="button"
+              onClick={() => scale(1)}
+              disabled={loading || status.targetWorkers >= status.maxWorkers}
+              className="px-1.5 py-0.5 hover:bg-slate-100 transition-colors disabled:opacity-30 text-slate-400"
+            >
+              +
+            </button>
+          </div>
+
+          {/* Uptime */}
+          {status.startedAt && (
+            <span className="text-slate-400">
+              up since {new Date(status.startedAt).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}
+            </span>
+          )}
+        </>
+      )}
+    </div>
+  );
+}

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/components/Layout.tsx

@@ -53,6 +53,12 @@ function LayoutContent({
               >
                 Open Chat
               </Link>
+              <Link
+                href="/automations"
+                className="text-sm font-medium text-[var(--muted-foreground)] hover:text-[var(--foreground)] transition-colors"
+              >
+                Automations
+              </Link>
               <Link
                 href="/settings"
                 className="text-sm font-medium text-[var(--muted-foreground)] hover:text-[var(--foreground)] transition-colors"

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/components/NowRunningPanel.tsx

@@ -2,11 +2,13 @@
 
 import { Task } from "./TaskCard";
 import { useEffect, useState, useMemo } from "react";
+import type { AgentProcessEntry } from "@/lib/agent-process-registry";
 
 const MAX_WORKERS = Number(process.env.NEXT_PUBLIC_AGX_MAX_WORKERS) || 10;
 
 interface NowRunningPanelProps {
   tasks: Task[];
+  processes?: AgentProcessEntry[];
   onTaskClick?: (task: Task) => void;
   onStop?: (taskId: string) => void;
   onRetry?: (taskId: string) => void;
@@ -15,11 +17,17 @@ interface NowRunningPanelProps {
 
 export default function NowRunningPanel({
   tasks,
+  processes = [],
   onTaskClick,
   onStop,
   onRetry,
   cancellingTaskId,
 }: NowRunningPanelProps) {
+  // Active processes (spawning or running)
+  const activeProcesses = useMemo(
+    () => processes.filter((p) => p.state === "spawning" || p.state === "running"),
+    [processes]
+  );
   const runningTasks = useMemo(() => tasks.filter((t) => t.status === "in_progress"), [tasks]);
   const [times, setTimes] = useState<Record<string, string>>({});
 
@@ -65,7 +73,7 @@ export default function NowRunningPanel({
               Now Running
             </h3>
             <span className="text-[10px] text-[var(--muted-foreground)] uppercase tracking-wider font-semibold">
-              {runningTasks.length} Active
+              {runningTasks.length} Active{activeProcesses.length > 0 ? ` · ${activeProcesses.length} process${activeProcesses.length > 1 ? "es" : ""}` : ""}
             </span>
           </div>
 

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

@@ -2,6 +2,7 @@
 
 import { useEffect, useRef, useState, useCallback, useMemo } from "react";
 import { useGroupChat } from "@/hooks/useGroupChat";
+import { useProcessPolling } from "@/hooks/useProcessPolling";
 import { useThreadState } from "@/hooks/useThreadState";
 import { WorkspaceSidebar } from "@/components/thread/WorkspaceSidebar";
 import "@/styles/workspaceSidebar.css";
@@ -9,7 +10,6 @@ import { MessageList } from "./MessageList";
 import { ThreadView } from "./ThreadView";
 import { SearchResults } from "./SearchResults";
 import { Composer } from "./Composer";
-import { LogPanel } from "./LogPanel";
 import {
   loadWorkspaceSidebarVisible,
   persistWorkspaceSidebarVisible,
@@ -27,7 +27,9 @@ import type { Participant, GroupMessage, MessageSearchResponse, MessageSearchRes
 import type { TaskDraftMessage } from "@/types/tasks";
 import { buildTasks } from "@/services/agxService";
 import { useTeams } from "@/hooks/useTeams";
-import { SquareTerminal, Search, ChevronLeft } from "lucide-react";
+import { useProjects } from "@/hooks/useProjects";
+import { Search, ChevronLeft, SquareTerminal } from "lucide-react";
+import { LogPanel } from "./LogPanel";
 import { StatusIndicator } from "./StatusIndicator";
 
 const LEGACY_THREAD_ID = "global";
@@ -139,7 +141,13 @@ function toMarkdown(
   return lines.join("\n").trim();
 }
 
-export function ChatContainer() {
+interface ChatContainerProps {
+  projectSlug?: string;
+  initialThreadId?: string;
+  initialRootMessageId?: string;
+}
+
+export function ChatContainer({ projectSlug, initialThreadId, initialRootMessageId }: ChatContainerProps = {}) {
   const {
     threads,
     activeThreadId,
@@ -157,9 +165,25 @@ export function ChatContainer() {
     updateThreadOutcomeNote,
     updateMessageThreadStatus,
     updateMessageOutcomeNote,
-  } = useThreadState();
-  const { messages, setMessages, streaming, loading, logs, sendMessage, loadHistory, clearLogs, stop, stopThread } =
+  } = useThreadState(initialThreadId);
+  const { messages, setMessages, logs, sendMessage, loadHistory, clearLogs, stop, stopThread } =
     useGroupChat(activeThreadId);
+  const { activeAgents: polledActiveAgents, processes: activeProcesses, streaming, poll } = useProcessPolling(
+    activeThreadId ? { workspaceId: activeThreadId } : null,
+    { messages, setMessages }
+  );
+  const loading = polledActiveAgents.size > 0;
+
+  // Wrap stop functions to immediately refresh polling state
+  const handleStop = useCallback(async () => {
+    await stop();
+    await poll();
+  }, [stop, poll]);
+
+  const handleStopThread = useCallback(async (rootMessageId: string) => {
+    await stopThread(rootMessageId);
+    await poll();
+  }, [stopThread, poll]);
   const {
     teams,
     createTeam,
@@ -170,18 +194,96 @@ export function ChatContainer() {
     reorderAgents,
     moveAgent,
   } = useTeams();
+  const { projects } = useProjects();
   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);
 
   // Sync sidebar visibility from localStorage after hydration to avoid SSR mismatch
   useEffect(() => {
     setWorkspaceSidebarVisible(loadWorkspaceSidebarVisible());
   }, []);
-  const [openThreadId, setOpenThreadId] = useState<string | null>(null);
+  const [logsOpen, setLogsOpen] = useState(false);
+  const [autoModeThreads, setAutoModeThreads] = useState<Set<string>>(new Set());
+  const [pendingAutoMode, setPendingAutoMode] = useState(false);
+  const [openThreadId, setOpenThreadId] = useState<string | null>(initialRootMessageId ?? null);
+  const autoMode = openThreadId ? autoModeThreads.has(openThreadId) : pendingAutoMode;
+
+  // Hydrate & poll ship mode from server when a thread is opened
+  useEffect(() => {
+    if (!openThreadId) return;
+    let cancelled = false;
+
+    const check = () => {
+      fetch(`/api/schedules?rootMessageId=${encodeURIComponent(openThreadId)}`)
+        .then((r) => r.json())
+        .then((data) => {
+          if (cancelled) return;
+          setAutoModeThreads((prev) => {
+            const has = prev.has(openThreadId);
+            if (data.active && !has) {
+              const next = new Set(prev); next.add(openThreadId); return next;
+            }
+            if (!data.active && has) {
+              const next = new Set(prev); next.delete(openThreadId); return next;
+            }
+            return prev;
+          });
+        })
+        .catch(() => {});
+    };
+
+    check();
+    const interval = setInterval(check, 10_000);
+    return () => { cancelled = true; clearInterval(interval); };
+  }, [openThreadId]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  // Hydrate all ship-mode threads for message list indicators
+  useEffect(() => {
+    let cancelled = false;
+    const check = () => {
+      fetch("/api/schedules")
+        .then((r) => r.json())
+        .then((data) => {
+          if (cancelled || !data.activeRootMessageIds) return;
+          setAutoModeThreads((prev) => {
+            const next = new Set(data.activeRootMessageIds as string[]);
+            // Preserve any locally-toggled entries not yet on server
+            for (const id of prev) next.add(id);
+            if (next.size === prev.size && [...next].every((id) => prev.has(id))) return prev;
+            return next;
+          });
+        })
+        .catch(() => {});
+    };
+    check();
+    const interval = setInterval(check, 15_000);
+    return () => { cancelled = true; clearInterval(interval); };
+  }, []); // eslint-disable-line react-hooks/exhaustive-deps
+
+  // Sync URL to reflect the currently open thread
+  useEffect(() => {
+    if (openThreadId) {
+      window.history.replaceState(null, "", `/thread/${openThreadId}`);
+    } else {
+      window.history.replaceState(null, "", "/");
+    }
+  }, [openThreadId, activeThreadId]);
+
+  // Resolve initialRootMessageId → workspace thread on mount
+  useEffect(() => {
+    if (!initialRootMessageId) return;
+    (async () => {
+      try {
+        const res = await fetch(`/api/messages/${initialRootMessageId}`);
+        if (!res.ok) return;
+        const { threadId } = await res.json();
+        if (threadId) selectThread(threadId);
+      } catch {}
+    })();
+  }, [initialRootMessageId, selectThread]);
   const [searchQuery, setSearchQuery] = useState("");
   const [searchResults, setSearchResults] = useState<MessageSearchResult[]>([]);
   const [searchTotal, setSearchTotal] = useState(0);
@@ -279,6 +381,10 @@ export function ChatContainer() {
     const activeSet = new Set(activeParticipantIds);
     return participants.filter((participant) => activeSet.has(participant.id));
   }, [participants, activeParticipantIds]);
+  const projectMentions = useMemo(
+    () => projects.map((project) => ({ id: project.id, name: project.name, slug: project.slug })),
+    [projects]
+  );
 
   const lastThreadUpdate = useMemo(() => {
     if (!openThreadId) return 0;
@@ -521,7 +627,7 @@ export function ChatContainer() {
   useEffect(() => {
     // Only stop active streams when actually switching threads, not on initial mount.
     if (prevActiveThreadIdRef.current !== null && prevActiveThreadIdRef.current !== activeThreadId) {
-      stop();
+      handleStop();
       if (pendingOpenThreadIdRef.current) {
         setOpenThreadId(pendingOpenThreadIdRef.current);
         pendingOpenThreadIdRef.current = null;
@@ -543,7 +649,7 @@ export function ChatContainer() {
         }
       })
       .catch(() => setTaskDraftsRaw({}));
-  }, [activeThreadId, loadHistory, stop]);
+  }, [activeThreadId, loadHistory, handleStop]);
 
   useEffect(() => {
     if (!activeThreadId) return;
@@ -561,10 +667,11 @@ export function ChatContainer() {
         rootMessageId,
         undefined,
         undefined,
-        activeParticipants.map((participant) => participant.id)
+        activeParticipants.map((participant) => participant.id),
+        projectSlug
       );
     },
-    [activeThreadId, sendMessage, activeParticipants]
+    [activeThreadId, sendMessage, activeParticipants, projectSlug]
   );
 
 
@@ -782,6 +889,16 @@ export function ChatContainer() {
         return;
       }
 
+      // User message turns off autonomous mode
+      if (autoMode && openThreadId) {
+        setAutoModeThreads((prev) => { const next = new Set(prev); next.delete(openThreadId); return next; });
+        fetch("/api/schedules", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ action: "stop", rootMessageId: openThreadId }),
+        }).catch((err) => console.error("Failed to deactivate schedule:", err));
+      }
+
       let threadId = activeThreadId;
       if (!threadId) {
         const created = await createThread();
@@ -802,34 +919,81 @@ export function ChatContainer() {
           openThreadId,
           attachmentIds,
           attachmentMetas,
-          selectedActiveIds
+          selectedActiveIds,
+          projectSlug
         );
         return;
       }
 
       // Every user message in main chat starts its own thread.
       // The user message ID becomes the rootMessageId — agents reply to it.
-      await sendMessage(
+      const newRootId = await sendMessage(
         prompt,
         maxRounds,
         threadId,
         null,
         attachmentIds,
         attachmentMetas,
-        selectedActiveIds
+        selectedActiveIds,
+        projectSlug
       );
+
+      // If ship mode was staged on the main composer, activate it for the new thread
+      if (pendingAutoMode && newRootId) {
+        setPendingAutoMode(false);
+        setAutoModeThreads((prev) => { const next = new Set(prev); next.add(newRootId); return next; });
+        fetch("/api/schedules", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ action: "activate", rootMessageId: newRootId }),
+        }).catch((err) => console.error("Failed to activate schedule for new thread:", err));
+      }
     },
     [
       activeThreadId,
+      autoMode,
+      pendingAutoMode,
       createThread,
       handleSearchCommand,
       handleSummarizeCommand,
       openThreadId,
       activeParticipants,
       sendMessage,
+      projectSlug,
     ]
   );
 
+  // ─── Autonomous mode ─────────────────────────────────────────────────────
+
+  const handleAutoModeChange = useCallback(
+    async (enabled: boolean) => {
+      const targetRootId = openThreadId;
+
+      // No thread open — just stage the flag for the next new thread
+      if (!targetRootId) {
+        setPendingAutoMode(enabled);
+        return;
+      }
+
+      setAutoModeThreads((prev) => {
+        const next = new Set(prev);
+        if (enabled) next.add(targetRootId); else next.delete(targetRootId);
+        return next;
+      });
+
+      try {
+        await fetch("/api/schedules", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ action: enabled ? "activate" : "stop", rootMessageId: targetRootId }),
+        });
+      } catch (err) {
+        console.error("Failed to toggle autonomous schedule:", err);
+      }
+    },
+    [openThreadId],
+  );
+
   const handleSelectSearchResult = useCallback(
     (result: MessageSearchResult) => {
       const targetRootId = result.rootMessageId || result.messageId;
@@ -856,10 +1020,10 @@ export function ChatContainer() {
 
   const handleDeleteThread = useCallback(
     async (threadId: string) => {
-      stop();
+      handleStop();
       await deleteThread(threadId);
     },
-    [deleteThread, stop]
+    [deleteThread, handleStop]
   );
 
   const handleDeleteThreadRoot = useCallback(
@@ -869,7 +1033,7 @@ export function ChatContainer() {
       if (!confirmed) return;
 
       setDeletingThreadRootId(rootMessageId);
-      stopThread(rootMessageId);
+      handleStopThread(rootMessageId);
 
       try {
         const params = new URLSearchParams({
@@ -896,7 +1060,7 @@ export function ChatContainer() {
         setDeletingThreadRootId((current) => (current === rootMessageId ? null : current));
       }
     },
-    [activeThreadId, loadHistory, messages, stopThread, updateThreadMessages]
+    [activeThreadId, loadHistory, messages, handleStopThread, updateThreadMessages]
   );
 
   const slashCommands: SlashCommand[] = useMemo(
@@ -933,16 +1097,19 @@ export function ChatContainer() {
     (rootMessageId: string) => (
       <Composer
         onSend={(message, maxRounds) => handleThreadReply(rootMessageId, message, maxRounds)}
-        onStop={() => stopThread(rootMessageId)}
+        onStop={() => handleStopThread(rootMessageId)}
         loading={Object.values(streaming).some((s) => s.rootMessageId === rootMessageId)}
         participants={activeParticipants}
         teams={workspaceTeams}
+        projects={projectMentions}
         messages={messages}
         commands={slashCommands}
         placeholder="Reply — @name to mention, /search, /summarize"
+        autoMode={autoMode}
+        onAutoModeChange={handleAutoModeChange}
       />
     ),
-    [handleThreadReply, stopThread, streaming, activeParticipants, workspaceTeams, slashCommands, messages]
+    [handleThreadReply, handleStopThread, streaming, activeParticipants, workspaceTeams, projectMentions, slashCommands, messages, autoMode, handleAutoModeChange]
   );
 
   const toggleWorkspaceSidebar = useCallback(() => {
@@ -1128,19 +1295,21 @@ export function ChatContainer() {
             View Boards
           </a>
           <StatusIndicator />
-          <button
-            type="button"
-            onClick={() => setLogsOpen(!logsOpen)}
-            aria-label={logsOpen ? "Hide logs" : `Show logs${logs.length > 0 ? ` (${logs.length})` : ""}`}
-            aria-pressed={logsOpen}
-            title={logsOpen ? "Hide logs" : `Show logs${logs.length > 0 ? ` (${logs.length})` : ""}`}
-            className={`inline-flex h-8 w-8 items-center justify-center rounded-md border transition-all focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-slate-400 ${logsOpen
-              ? "border-slate-300 bg-slate-50 text-slate-800"
-              : "border-slate-200 bg-white text-slate-500 hover:bg-slate-50 hover:text-slate-800"
-              }`}
-          >
-            <SquareTerminal className="h-4 w-4" strokeWidth={1.75} />
-          </button>
+          {openThreadId && (
+            <button
+              type="button"
+              onClick={() => setLogsOpen(!logsOpen)}
+              aria-label={logsOpen ? "Hide logs" : `Show logs${logs.length > 0 ? ` (${logs.length})` : ""}`}
+              aria-pressed={logsOpen}
+              title={logsOpen ? "Hide logs" : `Show logs${logs.length > 0 ? ` (${logs.length})` : ""}`}
+              className={`inline-flex h-8 w-8 items-center justify-center rounded-md border transition-all focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-slate-400 ${logsOpen
+                ? "border-slate-300 bg-slate-50 text-slate-800"
+                : "border-slate-200 bg-white text-slate-500 hover:bg-slate-50 hover:text-slate-800"
+                }`}
+            >
+              <SquareTerminal className="h-4 w-4" strokeWidth={1.75} />
+            </button>
+          )}
         </div>
 
 
@@ -1214,6 +1383,7 @@ export function ChatContainer() {
                     onDeleteThreadRoot={handleDeleteThreadRoot}
                     highlightedMessageId={highlightedMessageId || undefined}
                     renderReplyComposer={renderReplyComposer}
+                    activeProcesses={activeProcesses.filter(p => ["spawning", "running"].includes(p.state) && p.threadId === openThreadId)}
                   />
                 ) : (
                   <MessageList
@@ -1234,30 +1404,34 @@ export function ChatContainer() {
                     taskDrafts={taskDrafts}
                     deletingThreadRootId={deletingThreadRootId}
                     highlightedMessageId={highlightedMessageId}
+                    shipModeThreads={autoModeThreads}
                     onUpdateMessageThreadStatus={activeThreadId ? (messageId, status) => {
                       setMessages((prev) => prev.map((m) => m.id === messageId ? { ...m, threadStatus: status } : m));
                       void updateMessageThreadStatus(activeThreadId, messageId, status);
-                      void fetch("/api/history", { method: "PATCH", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ threadId: activeThreadId, messageId, threadStatus: status }) });
+                      void fetch("/api/threads", { method: "PATCH", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ rootMessageId: messageId, status }) });
                     } : undefined}
                     onUpdateMessageOutcomeNote={activeThreadId ? (messageId, note) => {
                       setMessages((prev) => prev.map((m) => m.id === messageId ? { ...m, outcomeNote: note } : m));
                       void updateMessageOutcomeNote(activeThreadId, messageId, note);
                       const msg = messages.find((m) => m.id === messageId);
-                      void fetch("/api/history", { method: "PATCH", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ threadId: activeThreadId, messageId, threadStatus: msg?.threadStatus ?? null, outcomeNote: note }) });
+                      void fetch("/api/threads", { method: "PATCH", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ rootMessageId: messageId, status: msg?.threadStatus ?? null, outcomeNote: note }) });
                     } : undefined}
                   />
                 )}
                 {!searchActive && !openThreadId && (
                   <Composer
                     onSend={handleSend}
-                    onStop={stop}
+                    onStop={handleStop}
                     loading={loading}
                     participants={activeParticipants}
+                    projects={projectMentions}
                     teams={workspaceTeams}
                     messages={messages}
                     commands={slashCommands}
                     pendingThreadInsert={pendingThreadInsert}
                     onClearPendingThread={() => setPendingThreadInsert(null)}
+                    autoMode={autoMode}
+                    onAutoModeChange={handleAutoModeChange}
                   />
                 )}
               </div>
@@ -1265,7 +1439,9 @@ export function ChatContainer() {
           )
         }
       </div >
-      <LogPanel logs={logs} participants={participants} onClear={() => void clearLogs(activeThreadId)} open={logsOpen} onToggle={() => setLogsOpen(false)} />
+      {initialRootMessageId && (
+        <LogPanel logs={logs} participants={participants} onClear={() => void clearLogs(activeThreadId)} open={logsOpen} onToggle={() => setLogsOpen(false)} />
+      )}
     </div >
   );
 }