diff --git a/plane-src/apps/web/core/components/ai-workspace/global-control.tsx b/plane-src/apps/web/core/components/ai-workspace/global-control.tsx
index 4cd8014..d0c04a3 100644
--- a/plane-src/apps/web/core/components/ai-workspace/global-control.tsx
+++ b/plane-src/apps/web/core/components/ai-workspace/global-control.tsx
@@ -4,23 +4,13 @@
  * See the LICENSE file for details.
  */
 
-import { useCallback, useEffect, useState } from "react";
+import { useEffect, useState } from "react";
 import { createPortal } from "react-dom";
-import useSWR from "swr";
 import { MessageCircle } from "lucide-react";
 // plane imports
 import { Tooltip } from "@plane/propel/tooltip";
 // components
-import { AIWorkspaceProductSettingsModal } from "@/components/ai-workspace/product-settings-modal";
-// services
-import { WorkspaceAIWorkspaceService } from "@/services/workspace-ai-workspace.service";
-import type {
-  TAIWorkspaceExecutor,
-  TAIWorkspaceExecutorInput,
-  TAIWorkspaceExecutorListResponse,
-} from "@/services/workspace-ai-workspace.service";
-
-const workspaceAIWorkspaceService = new WorkspaceAIWorkspaceService();
+import { AIWorkspaceProductConsole } from "@/components/ai-workspace/product-console";
 
 type TAIWorkspaceGlobalControlProps = {
   workspaceSlug: string;
@@ -29,15 +19,6 @@ type TAIWorkspaceGlobalControlProps = {
 export function AIWorkspaceGlobalControl({ workspaceSlug }: TAIWorkspaceGlobalControlProps) {
   const [isOpen, setIsOpen] = useState(false);
   const [dockSlot, setDockSlot] = useState<Element | null>(null);
-  const [busyId, setBusyId] = useState("");
-  const [notice, setNotice] = useState("");
-  const [actionError, setActionError] = useState("");
-
-  const { data, error, isLoading, mutate } = useSWR(
-    isOpen && workspaceSlug ? `AI_WORKSPACE_EXECUTORS_${workspaceSlug}` : null,
-    () => workspaceAIWorkspaceService.listExecutors(workspaceSlug),
-    { refreshInterval: isOpen ? 10000 : 0 }
-  );
 
   useEffect(() => {
     if (typeof document === "undefined") return;
@@ -58,98 +39,6 @@ export function AIWorkspaceGlobalControl({ workspaceSlug }: TAIWorkspaceGlobalCo
     };
   }, []);
 
-  const handleClose = useCallback(() => {
-    setIsOpen(false);
-    setNotice("");
-    setActionError("");
-  }, []);
-
-  const runMutation = useCallback(
-    async <T,>(id: string, action: () => Promise<T>, successText: string): Promise<T | null> => {
-      setBusyId(id);
-      setActionError("");
-      setNotice("");
-      try {
-        const result = await action();
-        setNotice(successText);
-        return result;
-      } catch (mutationError: any) {
-        setActionError(
-          String(mutationError?.message || mutationError?.error || mutationError || "AI Workspace request failed")
-        );
-        return null;
-      } finally {
-        setBusyId("");
-      }
-    },
-    []
-  );
-
-  const updateRegistry = useCallback(
-    async (payload: TAIWorkspaceExecutorListResponse) => {
-      await mutate(payload, { revalidate: false });
-      return payload;
-    },
-    [mutate]
-  );
-
-  const selectExecutor = useCallback(
-    async (executor: TAIWorkspaceExecutor) =>
-      runMutation(
-        `select:${executor.id}`,
-        async () => updateRegistry(await workspaceAIWorkspaceService.selectExecutor(workspaceSlug, executor.id)),
-        "Устройство выбрано"
-      ),
-    [runMutation, updateRegistry, workspaceSlug]
-  );
-
-  const createExecutor = useCallback(
-    async (input: TAIWorkspaceExecutorInput) =>
-      runMutation(
-        "save",
-        async () => updateRegistry(await workspaceAIWorkspaceService.createExecutor(workspaceSlug, input)),
-        "Устройство создано"
-      ),
-    [runMutation, updateRegistry, workspaceSlug]
-  );
-
-  const updateExecutor = useCallback(
-    async (executorId: string, input: TAIWorkspaceExecutorInput) =>
-      runMutation(
-        "save",
-        async () => updateRegistry(await workspaceAIWorkspaceService.updateExecutor(workspaceSlug, executorId, input)),
-        "Устройство сохранено"
-      ),
-    [runMutation, updateRegistry, workspaceSlug]
-  );
-
-  const deleteExecutor = useCallback(
-    async (executorId: string) =>
-      runMutation(
-        `delete:${executorId}`,
-        async () => updateRegistry(await workspaceAIWorkspaceService.deleteExecutor(workspaceSlug, executorId)),
-        "Устройство удалено"
-      ),
-    [runMutation, updateRegistry, workspaceSlug]
-  );
-
-  const downloadAgent = useCallback(
-    async (executorId: string, input: TAIWorkspaceExecutorInput, port: string) => {
-      await runMutation(
-        "download",
-        async () => {
-          const payload = await workspaceAIWorkspaceService.updateExecutor(workspaceSlug, executorId, input);
-          await updateRegistry(payload);
-          window.location.href = workspaceAIWorkspaceService.getWindowsAgentInstallerUrl(workspaceSlug, executorId, {
-            port,
-          });
-        },
-        "Installer подготовлен"
-      );
-    },
-    [runMutation, updateRegistry, workspaceSlug]
-  );
-
   return (
     <>
       {dockSlot
@@ -168,26 +57,7 @@ export function AIWorkspaceGlobalControl({ workspaceSlug }: TAIWorkspaceGlobalCo
           )
         : null}
 
-      <AIWorkspaceProductSettingsModal
-        isOpen={isOpen}
-        executors={data?.executors ?? []}
-        selectedExecutorId={data?.selectedExecutorId ?? null}
-        isLoading={isLoading}
-        error={error}
-        notice={notice}
-        actionError={actionError}
-        busyId={busyId}
-        onClose={handleClose}
-        onReload={() => mutate()}
-        onSelect={selectExecutor}
-        onCreate={createExecutor}
-        onUpdate={updateExecutor}
-        onDelete={deleteExecutor}
-        onDownloadAgent={downloadAgent}
-        getWindowsAgentInstallerUrl={(executorId, options) =>
-          workspaceAIWorkspaceService.getWindowsAgentInstallerUrl(workspaceSlug, executorId, options)
-        }
-      />
+      <AIWorkspaceProductConsole open={isOpen} workspaceSlug={workspaceSlug} onClose={() => setIsOpen(false)} />
     </>
   );
 }
diff --git a/plane-src/apps/web/core/components/ai-workspace/product-console.tsx b/plane-src/apps/web/core/components/ai-workspace/product-console.tsx
new file mode 100644
index 0000000..b325de6
--- /dev/null
+++ b/plane-src/apps/web/core/components/ai-workspace/product-console.tsx
@@ -0,0 +1,1111 @@
+/**
+ * Copyright (c) 2023-present Plane Software, Inc. and contributors
+ * SPDX-License-Identifier: AGPL-3.0-only
+ * See the LICENSE file for details.
+ */
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import type { CSSProperties, FormEvent, PointerEvent as ReactPointerEvent } from "react";
+import { createPortal } from "react-dom";
+// components
+import { AIWorkspaceProductSettingsModal } from "@/components/ai-workspace/product-settings-modal";
+// services
+import { WorkspaceAIWorkspaceService } from "@/services/workspace-ai-workspace.service";
+import type {
+  TAIWorkspaceExecutor,
+  TAIWorkspaceExecutorInput,
+  TAIWorkspaceExecutorListResponse,
+  TAIWorkspaceThread,
+  TAIWorkspaceThreadMessage,
+  TAIWorkspaceThreadResponse,
+} from "@/services/workspace-ai-workspace.service";
+
+const workspaceAIWorkspaceService = new WorkspaceAIWorkspaceService();
+const AI_CONSOLE_THREADS_WIDTH_KEY = "nodedc.ops.aiWorkspace.threadsWidth";
+const AI_CONSOLE_GEOMETRY_KEY = "nodedc.ops.aiWorkspace.consoleGeometry.v1";
+const AI_CONSOLE_VIEWPORT_MARGIN = 18;
+const AI_CONSOLE_FULLSCREEN_TOP = 88;
+const AI_CONSOLE_MIN_WIDTH = 960;
+const AI_CONSOLE_MIN_HEIGHT = 420;
+const LOCAL_THREAD_ID = "local:ops-default";
+
+type TAIWorkspaceProductConsoleProps = {
+  open: boolean;
+  workspaceSlug: string;
+  onClose: () => void;
+};
+
+type TConsoleGeometry = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+
+type TConsoleMessage = {
+  id: string;
+  role: "system" | "user" | "assistant" | "tool";
+  text: string;
+  createdAt?: string | null;
+};
+
+type TConsoleThread = {
+  id: string;
+  title: string;
+  meta: string;
+  local?: boolean;
+  selectedExecutorId?: string | null;
+  updatedAt?: string | null;
+};
+
+function makeId() {
+  try {
+    if (crypto && "randomUUID" in crypto) return crypto.randomUUID();
+  } catch {}
+  return `ai-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+function getConsoleViewport() {
+  if (typeof window === "undefined") return { width: 1280, height: 820 };
+  return {
+    width: Math.max(320, window.innerWidth || 1280),
+    height: Math.max(320, window.innerHeight || 820),
+  };
+}
+
+function defaultGeometry(): TConsoleGeometry {
+  const viewport = getConsoleViewport();
+  const width = Math.min(1080, Math.max(AI_CONSOLE_MIN_WIDTH, viewport.width - 104));
+  const height = Math.min(620, Math.max(AI_CONSOLE_MIN_HEIGHT, viewport.height - 128));
+  return {
+    x: Math.max(AI_CONSOLE_VIEWPORT_MARGIN, Math.round((viewport.width - width) / 2)),
+    y: Math.max(AI_CONSOLE_FULLSCREEN_TOP, Math.round((viewport.height - height) / 2)),
+    width,
+    height,
+  };
+}
+
+function normalizeGeometry(input: TConsoleGeometry): TConsoleGeometry {
+  const viewport = getConsoleViewport();
+  const maxWidth = Math.max(AI_CONSOLE_MIN_WIDTH, viewport.width - AI_CONSOLE_VIEWPORT_MARGIN * 2);
+  const maxHeight = Math.max(
+    AI_CONSOLE_MIN_HEIGHT,
+    viewport.height - AI_CONSOLE_FULLSCREEN_TOP - AI_CONSOLE_VIEWPORT_MARGIN
+  );
+  const width = Math.max(AI_CONSOLE_MIN_WIDTH, Math.min(maxWidth, Number(input.width) || AI_CONSOLE_MIN_WIDTH));
+  const height = Math.max(AI_CONSOLE_MIN_HEIGHT, Math.min(maxHeight, Number(input.height) || AI_CONSOLE_MIN_HEIGHT));
+  const x = Math.max(
+    AI_CONSOLE_VIEWPORT_MARGIN,
+    Math.min(viewport.width - width - AI_CONSOLE_VIEWPORT_MARGIN, Number(input.x) || 0)
+  );
+  const y = Math.max(
+    AI_CONSOLE_FULLSCREEN_TOP,
+    Math.min(viewport.height - height - AI_CONSOLE_VIEWPORT_MARGIN, Number(input.y) || AI_CONSOLE_FULLSCREEN_TOP)
+  );
+  return {
+    x: Math.round(x),
+    y: Math.round(y),
+    width: Math.round(width),
+    height: Math.round(height),
+  };
+}
+
+function readGeometry(): TConsoleGeometry {
+  if (typeof window === "undefined") return defaultGeometry();
+  try {
+    const parsed = JSON.parse(window.localStorage?.getItem(AI_CONSOLE_GEOMETRY_KEY) || "");
+    if (parsed && typeof parsed === "object") return normalizeGeometry(parsed);
+  } catch {}
+  return defaultGeometry();
+}
+
+function statusLabel(status: string | null | undefined) {
+  if (status === "online") return "Online";
+  if (status === "offline") return "Offline";
+  if (status === "checking") return "Checking";
+  if (status === "error") return "Error";
+  return "Unknown";
+}
+
+function formatMessageTime(value: string | null | undefined) {
+  if (!value) return "";
+  const time = Date.parse(value);
+  if (!Number.isFinite(time)) return "";
+  return new Date(time).toLocaleString("ru-RU", {
+    day: "2-digit",
+    month: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+}
+
+function titleFromMessage(text: string) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (!normalized) return "Ops задача";
+  return normalized.length > 64 ? `${normalized.slice(0, 61)}...` : normalized;
+}
+
+function threadFromApi(thread: TAIWorkspaceThread): TConsoleThread {
+  return {
+    id: thread.id,
+    title: thread.title || "Ops задача",
+    meta: thread.selectedExecutorId ? "Ops · Codex worker" : "Ops",
+    selectedExecutorId: thread.selectedExecutorId || null,
+    updatedAt: thread.updatedAt,
+  };
+}
+
+function messageFromApi(message: TAIWorkspaceThreadMessage): TConsoleMessage {
+  return {
+    id: message.id,
+    role: message.role || "user",
+    text: message.content || "",
+    createdAt: message.createdAt,
+  };
+}
+
+function localThread(): TConsoleThread {
+  return {
+    id: LOCAL_THREAD_ID,
+    title: "Ops Assistant",
+    meta: "Ops",
+    local: true,
+    selectedExecutorId: null,
+  };
+}
+
+function localMessages(): TConsoleMessage[] {
+  return [
+    {
+      id: "local-system",
+      role: "system",
+      text: "Опиши задачу для Ops. Подключение Codex worker и устройство настраиваются через кнопку настроек в шапке.",
+      createdAt: new Date().toISOString(),
+    },
+  ];
+}
+
+function errorText(error: unknown) {
+  return String((error as any)?.message || (error as any)?.error || error || "AI Workspace request failed");
+}
+
+function isInteractiveDragTarget(target: EventTarget | null) {
+  if (!(target instanceof Element)) return false;
+  return Boolean(target.closest("button,input,textarea,select,a,[contenteditable='true'],[role='button']"));
+}
+
+function CloseMark() {
+  return <span className="nodedc-glass-modal__close-mark" aria-hidden="true" />;
+}
+
+function ResizeHandles({
+  geometry,
+  fullscreen,
+  onGeometryChange,
+}: {
+  geometry: TConsoleGeometry;
+  fullscreen: boolean;
+  onGeometryChange: (geometry: TConsoleGeometry) => void;
+}) {
+  if (fullscreen) return null;
+
+  const startResize = (direction: string) => (event: ReactPointerEvent<HTMLDivElement>) => {
+    event.preventDefault();
+    event.stopPropagation();
+    const start = {
+      geometry,
+      pointerX: event.clientX,
+      pointerY: event.clientY,
+    };
+    const previousCursor = document.body.style.cursor;
+    const previousUserSelect = document.body.style.userSelect;
+    document.body.style.cursor = direction.includes("left") || direction.includes("right") ? "ew-resize" : "ns-resize";
+    if (
+      (direction.includes("top") || direction.includes("bottom")) &&
+      (direction.includes("left") || direction.includes("right"))
+    ) {
+      document.body.style.cursor =
+        direction === "top-left" || direction === "bottom-right" ? "nwse-resize" : "nesw-resize";
+    }
+    document.body.style.userSelect = "none";
+
+    const move = (moveEvent: PointerEvent) => {
+      const dx = moveEvent.clientX - start.pointerX;
+      const dy = moveEvent.clientY - start.pointerY;
+      let { x, y, width, height } = start.geometry;
+      if (direction.includes("right")) width += dx;
+      if (direction.includes("bottom")) height += dy;
+      if (direction.includes("left")) {
+        width -= dx;
+        x += dx;
+      }
+      if (direction.includes("top")) {
+        height -= dy;
+        y += dy;
+      }
+      onGeometryChange(normalizeGeometry({ x, y, width, height }));
+    };
+    const up = () => {
+      document.body.style.cursor = previousCursor;
+      document.body.style.userSelect = previousUserSelect;
+      window.removeEventListener("pointermove", move);
+      window.removeEventListener("pointerup", up);
+      window.removeEventListener("pointercancel", up);
+    };
+    window.addEventListener("pointermove", move, { passive: false });
+    window.addEventListener("pointerup", up, { passive: false });
+    window.addEventListener("pointercancel", up, { passive: false });
+  };
+
+  return (
+    <div className="ai-console-window-resize-layer" aria-hidden="true">
+      {["top", "right", "bottom", "left", "top-left", "top-right", "bottom-right", "bottom-left"].map((direction) => (
+        <div
+          key={direction}
+          className={`ai-console-window-resize ai-console-window-resize--${direction}`}
+          onPointerDown={startResize(direction)}
+        />
+      ))}
+    </div>
+  );
+}
+
+export function AIWorkspaceProductConsole({ open, workspaceSlug, onClose }: TAIWorkspaceProductConsoleProps) {
+  const [settingsOpen, setSettingsOpen] = useState(false);
+  const [logsOpen, setLogsOpen] = useState(false);
+  const [fullscreen, setFullscreen] = useState(false);
+  const [geometry, setGeometry] = useState<TConsoleGeometry>(() => readGeometry());
+  const [threadsWidth, setThreadsWidth] = useState(() => {
+    if (typeof window === "undefined") return 330;
+    const saved = Number(window.localStorage?.getItem(AI_CONSOLE_THREADS_WIDTH_KEY) || 0);
+    return Number.isFinite(saved) && saved > 0 ? Math.max(280, Math.min(560, saved)) : 330;
+  });
+  const [executors, setExecutors] = useState<TAIWorkspaceExecutor[]>([]);
+  const [selectedExecutorId, setSelectedExecutorId] = useState<string | null>(null);
+  const [threads, setThreads] = useState<TConsoleThread[]>(() => [localThread()]);
+  const [activeThreadId, setActiveThreadId] = useState(LOCAL_THREAD_ID);
+  const [messagesByThread, setMessagesByThread] = useState<Record<string, TConsoleMessage[]>>(() => ({
+    [LOCAL_THREAD_ID]: localMessages(),
+  }));
+  const [draft, setDraft] = useState("");
+  const [registryError, setRegistryError] = useState("");
+  const [registryNotice, setRegistryNotice] = useState("");
+  const [actionError, setActionError] = useState("");
+  const [busyId, setBusyId] = useState("");
+  const [threadError, setThreadError] = useState("");
+  const [sending, setSending] = useState(false);
+  const [editingThreadId, setEditingThreadId] = useState("");
+  const [editingThreadTitle, setEditingThreadTitle] = useState("");
+  const shellRef = useRef<HTMLElement | null>(null);
+  const messagesRef = useRef<HTMLDivElement | null>(null);
+  const zIndexRef = useRef(26000);
+
+  const activeExecutor = useMemo(
+    () => executors.find((executor) => executor.id === selectedExecutorId) || executors[0] || null,
+    [executors, selectedExecutorId]
+  );
+  const activeThread = useMemo(
+    () => threads.find((thread) => thread.id === activeThreadId) || threads[0] || localThread(),
+    [activeThreadId, threads]
+  );
+  const activeMessages = messagesByThread[activeThread.id] || [];
+  const activityLines = useMemo(
+    () =>
+      [
+        registryError ? `registry error: ${registryError}` : "",
+        actionError ? `action error: ${actionError}` : "",
+        threadError ? `thread error: ${threadError}` : "",
+        registryNotice ? `registry: ${registryNotice}` : "",
+        activeExecutor
+          ? `executor: ${activeExecutor.name} · ${statusLabel(activeExecutor.status)}`
+          : "executor: not selected",
+        `thread: ${activeThread.title}`,
+      ].filter(Boolean),
+    [actionError, activeExecutor, activeThread.title, registryError, registryNotice, threadError]
+  );
+
+  const updateGeometry = useCallback((next: TConsoleGeometry) => {
+    setGeometry(normalizeGeometry(next));
+  }, []);
+
+  const consoleStageStyle = useMemo(() => {
+    const shared = {
+      "--ai-threads-width": `${threadsWidth}px`,
+      zIndex: zIndexRef.current,
+    } as CSSProperties;
+    if (fullscreen) {
+      return {
+        ...shared,
+        left: `${AI_CONSOLE_VIEWPORT_MARGIN}px`,
+        top: `${AI_CONSOLE_FULLSCREEN_TOP}px`,
+        width: `calc(100vw - ${AI_CONSOLE_VIEWPORT_MARGIN * 2}px)`,
+        height: `calc(100vh - ${AI_CONSOLE_FULLSCREEN_TOP + AI_CONSOLE_VIEWPORT_MARGIN}px)`,
+      } as CSSProperties;
+    }
+    const normalized = normalizeGeometry(geometry);
+    return {
+      ...shared,
+      left: `${normalized.x}px`,
+      top: `${normalized.y}px`,
+      width: `${normalized.width}px`,
+      height: `${normalized.height}px`,
+    } as CSSProperties;
+  }, [fullscreen, geometry, threadsWidth]);
+
+  const runRegistryAction = useCallback(
+    async <T,>(id: string, action: () => Promise<T>, successText: string): Promise<T | null> => {
+      setBusyId(id);
+      setRegistryError("");
+      setRegistryNotice("");
+      setActionError("");
+      try {
+        const result = await action();
+        setRegistryNotice(successText);
+        return result;
+      } catch (error) {
+        setActionError(errorText(error));
+        return null;
+      } finally {
+        setBusyId("");
+      }
+    },
+    []
+  );
+
+  const applyExecutorsPayload = useCallback((payload: TAIWorkspaceExecutorListResponse) => {
+    const nextExecutors = payload.executors || [];
+    setExecutors(nextExecutors);
+    setSelectedExecutorId((current) => {
+      if (current && nextExecutors.some((executor) => executor.id === current)) return current;
+      if (payload.selectedExecutorId && nextExecutors.some((executor) => executor.id === payload.selectedExecutorId)) {
+        return payload.selectedExecutorId;
+      }
+      return nextExecutors[0]?.id || null;
+    });
+  }, []);
+
+  const loadRegistry = useCallback(async () => {
+    try {
+      setRegistryError("");
+      applyExecutorsPayload(await workspaceAIWorkspaceService.listExecutors(workspaceSlug));
+    } catch (error) {
+      setRegistryError(errorText(error));
+    }
+  }, [applyExecutorsPayload, workspaceSlug]);
+
+  const loadThreadMessages = useCallback(
+    async (threadId: string) => {
+      if (!threadId || threadId === LOCAL_THREAD_ID) return;
+      try {
+        setThreadError("");
+        const payload = await workspaceAIWorkspaceService.listThreadMessages(workspaceSlug, threadId, { limit: 200 });
+        setMessagesByThread((current) => ({
+          ...current,
+          [threadId]: (payload.messages || []).map(messageFromApi),
+        }));
+      } catch (error) {
+        setThreadError(errorText(error));
+      }
+    },
+    [workspaceSlug]
+  );
+
+  const loadThreads = useCallback(async () => {
+    try {
+      setThreadError("");
+      const payload = await workspaceAIWorkspaceService.listThreads(workspaceSlug, { surface: "ops", limit: 100 });
+      const nextThreads = (payload.threads || [])
+        .filter((thread) => thread.lifecycleState !== "archived")
+        .map(threadFromApi);
+      const resolvedThreads = nextThreads.length ? nextThreads : [localThread()];
+      setThreads(resolvedThreads);
+      setActiveThreadId((current) =>
+        resolvedThreads.some((thread) => thread.id === current) ? current : resolvedThreads[0].id
+      );
+      if (resolvedThreads[0]?.id && resolvedThreads[0].id !== LOCAL_THREAD_ID)
+        void loadThreadMessages(resolvedThreads[0].id);
+      if (!nextThreads.length) {
+        setMessagesByThread((current) => ({
+          ...current,
+          [LOCAL_THREAD_ID]: current[LOCAL_THREAD_ID] || localMessages(),
+        }));
+      }
+    } catch (error) {
+      setThreadError(errorText(error));
+      setThreads((current) => (current.length ? current : [localThread()]));
+    }
+  }, [loadThreadMessages, workspaceSlug]);
+
+  useEffect(() => {
+    if (!open) return;
+    void loadRegistry();
+    void loadThreads();
+  }, [loadRegistry, loadThreads, open]);
+
+  useEffect(() => {
+    if (!open) return;
+    const timer = window.setInterval(() => {
+      void loadRegistry();
+      void loadThreads();
+    }, 30000);
+    return () => window.clearInterval(timer);
+  }, [loadRegistry, loadThreads, open]);
+
+  useEffect(() => {
+    if (!open || activeThread.id === LOCAL_THREAD_ID) return;
+    if (messagesByThread[activeThread.id]) return;
+    void loadThreadMessages(activeThread.id);
+  }, [activeThread.id, loadThreadMessages, messagesByThread, open]);
+
+  useEffect(() => {
+    if (!open) return;
+    window.requestAnimationFrame(() => {
+      const node = messagesRef.current;
+      if (node) node.scrollTop = node.scrollHeight;
+    });
+  }, [activeMessages.length, activeThread.id, open]);
+
+  useEffect(() => {
+    if (fullscreen) return;
+    try {
+      window.localStorage?.setItem(AI_CONSOLE_GEOMETRY_KEY, JSON.stringify(normalizeGeometry(geometry)));
+    } catch {}
+  }, [fullscreen, geometry]);
+
+  useEffect(() => {
+    const handleResize = () => setGeometry((current) => normalizeGeometry(current));
+    window.addEventListener("resize", handleResize);
+    return () => window.removeEventListener("resize", handleResize);
+  }, []);
+
+  const handleHeaderPointerDown = (event: ReactPointerEvent<HTMLElement>) => {
+    if (fullscreen || event.button !== 0 || isInteractiveDragTarget(event.target)) return;
+    event.preventDefault();
+    event.stopPropagation();
+    const start = {
+      geometry: normalizeGeometry(geometry),
+      x: event.clientX,
+      y: event.clientY,
+    };
+    const previousCursor = document.body.style.cursor;
+    const previousUserSelect = document.body.style.userSelect;
+    document.body.style.cursor = "move";
+    document.body.style.userSelect = "none";
+    const move = (moveEvent: PointerEvent) => {
+      updateGeometry({
+        ...start.geometry,
+        x: start.geometry.x + moveEvent.clientX - start.x,
+        y: start.geometry.y + moveEvent.clientY - start.y,
+      });
+    };
+    const up = () => {
+      document.body.style.cursor = previousCursor;
+      document.body.style.userSelect = previousUserSelect;
+      window.removeEventListener("pointermove", move);
+      window.removeEventListener("pointerup", up);
+      window.removeEventListener("pointercancel", up);
+    };
+    window.addEventListener("pointermove", move, { passive: false });
+    window.addEventListener("pointerup", up, { passive: false });
+    window.addEventListener("pointercancel", up, { passive: false });
+  };
+
+  const startThreadsResize = (event: ReactPointerEvent<HTMLDivElement>) => {
+    const shell = shellRef.current;
+    if (!shell) return;
+    event.preventDefault();
+    const rect = shell.getBoundingClientRect();
+    const minWidth = 280;
+    const maxWidth = Math.max(minWidth, Math.min(560, rect.width - 430));
+    let latest = threadsWidth;
+    const move = (moveEvent: PointerEvent) => {
+      latest = Math.max(minWidth, Math.min(maxWidth, moveEvent.clientX - rect.left));
+      setThreadsWidth(latest);
+    };
+    const up = () => {
+      document.removeEventListener("pointermove", move);
+      document.removeEventListener("pointerup", up);
+      try {
+        window.localStorage?.setItem(AI_CONSOLE_THREADS_WIDTH_KEY, String(Math.round(latest)));
+      } catch {}
+    };
+    document.addEventListener("pointermove", move);
+    document.addEventListener("pointerup", up, { once: true });
+  };
+
+  const updateRegistry = useCallback(
+    async (payload: TAIWorkspaceExecutorListResponse) => {
+      applyExecutorsPayload(payload);
+      return payload;
+    },
+    [applyExecutorsPayload]
+  );
+
+  const selectExecutor = useCallback(
+    async (executor: TAIWorkspaceExecutor) =>
+      runRegistryAction(
+        `select:${executor.id}`,
+        async () => updateRegistry(await workspaceAIWorkspaceService.selectExecutor(workspaceSlug, executor.id)),
+        "Устройство выбрано"
+      ),
+    [runRegistryAction, updateRegistry, workspaceSlug]
+  );
+
+  const createExecutor = useCallback(
+    async (input: TAIWorkspaceExecutorInput) =>
+      runRegistryAction(
+        "save",
+        async () => updateRegistry(await workspaceAIWorkspaceService.createExecutor(workspaceSlug, input)),
+        "Устройство создано"
+      ),
+    [runRegistryAction, updateRegistry, workspaceSlug]
+  );
+
+  const updateExecutor = useCallback(
+    async (executorId: string, input: TAIWorkspaceExecutorInput) =>
+      runRegistryAction(
+        "save",
+        async () => updateRegistry(await workspaceAIWorkspaceService.updateExecutor(workspaceSlug, executorId, input)),
+        "Устройство сохранено"
+      ),
+    [runRegistryAction, updateRegistry, workspaceSlug]
+  );
+
+  const deleteExecutor = useCallback(
+    async (executorId: string) =>
+      runRegistryAction(
+        `delete:${executorId}`,
+        async () => updateRegistry(await workspaceAIWorkspaceService.deleteExecutor(workspaceSlug, executorId)),
+        "Устройство удалено"
+      ),
+    [runRegistryAction, updateRegistry, workspaceSlug]
+  );
+
+  const downloadAgent = useCallback(
+    async (executorId: string, input: TAIWorkspaceExecutorInput, port: string) => {
+      await runRegistryAction(
+        "download",
+        async () => {
+          const payload = await workspaceAIWorkspaceService.updateExecutor(workspaceSlug, executorId, input);
+          await updateRegistry(payload);
+          window.location.href = workspaceAIWorkspaceService.getWindowsAgentInstallerUrl(workspaceSlug, executorId, {
+            port,
+          });
+        },
+        "Installer подготовлен"
+      );
+    },
+    [runRegistryAction, updateRegistry, workspaceSlug]
+  );
+
+  const createThread = async () => {
+    try {
+      setThreadError("");
+      const payload = await workspaceAIWorkspaceService.createThread(workspaceSlug, {
+        title: "Новая тема",
+        selectedExecutorId: activeExecutor?.id || null,
+        activeContext: { surface: "ops", workspaceSlug },
+        metadata: {},
+      });
+      const next = threadFromApi(payload.thread);
+      setThreads((current) => [next, ...current.filter((thread) => !thread.local)]);
+      setActiveThreadId(next.id);
+      setMessagesByThread((current) => ({ ...current, [next.id]: [] }));
+    } catch (error) {
+      setThreadError(errorText(error));
+    }
+  };
+
+  const ensureServerThread = async (messageText: string): Promise<TConsoleThread | null> => {
+    if (!activeThread.local) return activeThread;
+    try {
+      const payload: TAIWorkspaceThreadResponse = await workspaceAIWorkspaceService.createThread(workspaceSlug, {
+        title: titleFromMessage(messageText),
+        selectedExecutorId: activeExecutor?.id || null,
+        activeContext: { surface: "ops", workspaceSlug },
+        metadata: {},
+      });
+      const next = threadFromApi(payload.thread);
+      setThreads((current) => [next, ...current.filter((thread) => thread.id !== LOCAL_THREAD_ID)]);
+      setMessagesByThread((current) => ({ ...current, [next.id]: [] }));
+      setActiveThreadId(next.id);
+      return next;
+    } catch (error) {
+      setThreadError(errorText(error));
+      return null;
+    }
+  };
+
+  const submitMessage = async (event?: FormEvent) => {
+    event?.preventDefault();
+    const text = draft.trim();
+    if (!text || sending) return;
+    setDraft("");
+    setSending(true);
+    setThreadError("");
+    try {
+      const thread = await ensureServerThread(text);
+      if (!thread) return;
+      const optimistic: TConsoleMessage = {
+        id: makeId(),
+        role: "user",
+        text,
+        createdAt: new Date().toISOString(),
+      };
+      setMessagesByThread((current) => ({ ...current, [thread.id]: [...(current[thread.id] || []), optimistic] }));
+      const payload = await workspaceAIWorkspaceService.createThreadMessage(workspaceSlug, thread.id, {
+        role: "user",
+        content: text,
+        payload: {
+          surface: "ops",
+          selectedExecutorId: activeExecutor?.id || null,
+          workspaceSlug,
+        },
+      });
+      setMessagesByThread((current) => ({
+        ...current,
+        [thread.id]: [
+          ...(current[thread.id] || []).filter((message) => message.id !== optimistic.id),
+          messageFromApi(payload.message),
+        ],
+      }));
+      setThreads((current) =>
+        current.map((item) =>
+          item.id === thread.id
+            ? { ...item, title: item.title === "Новая тема" ? titleFromMessage(text) : item.title }
+            : item
+        )
+      );
+    } catch (error) {
+      setThreadError(errorText(error));
+      setDraft(text);
+    } finally {
+      setSending(false);
+    }
+  };
+
+  const beginRenameThread = (thread: TConsoleThread) => {
+    setEditingThreadId(thread.id);
+    setEditingThreadTitle(thread.title);
+  };
+
+  const commitRenameThread = async (thread: TConsoleThread) => {
+    const title = editingThreadTitle.trim();
+    setEditingThreadId("");
+    if (!title || title === thread.title) return;
+    setThreads((current) => current.map((item) => (item.id === thread.id ? { ...item, title } : item)));
+    if (thread.local) return;
+    try {
+      await workspaceAIWorkspaceService.updateThread(workspaceSlug, thread.id, { title });
+    } catch (error) {
+      setThreadError(errorText(error));
+    }
+  };
+
+  const removeThread = async (thread: TConsoleThread) => {
+    setThreads((current) => {
+      const next = current.filter((item) => item.id !== thread.id);
+      return next.length ? next : [localThread()];
+    });
+    setActiveThreadId((current) =>
+      current === thread.id ? threads.find((item) => item.id !== thread.id)?.id || LOCAL_THREAD_ID : current
+    );
+    if (thread.local) return;
+    try {
+      await workspaceAIWorkspaceService.updateThread(workspaceSlug, thread.id, { lifecycleState: "archived" });
+    } catch (error) {
+      setThreadError(errorText(error));
+    }
+  };
+
+  if (!open || typeof document === "undefined") return null;
+
+  const consoleNode = (
+    <>
+      <section
+        className="ai-console-stage nodedc-ai-workspace-console"
+        data-side={logsOpen ? "true" : undefined}
+        data-fullscreen={fullscreen ? "true" : undefined}
+        style={consoleStageStyle}
+      >
+        <section
+          ref={shellRef}
+          className="ai-console-shell"
+          role="dialog"
+          aria-label="AI Workspace Console"
+          onMouseDown={(event) => event.stopPropagation()}
+          onPointerDown={(event) => event.stopPropagation()}
+          onWheel={(event) => event.stopPropagation()}
+        >
+          <header
+            className="ai-console-header ai-console-topbar"
+            data-draggable={fullscreen ? undefined : "true"}
+            onPointerDown={handleHeaderPointerDown}
+          >
+            <div className="ai-console-title-block">
+              <div className="ai-console-kicker">
+                {activeExecutor
+                  ? `${activeExecutor.name} · Codex Remote · ${statusLabel(activeExecutor.status)}`
+                  : "Устройство не выбрано"}
+              </div>
+              <h2>AI Workspace Console</h2>
+            </div>
+            <div className="ai-console-actions">
+              <button
+                type="button"
+                className="ai-console-icon-button"
+                data-active={logsOpen ? "true" : undefined}
+                aria-label={logsOpen ? "Скрыть логи AI Workspace Console" : "Показать логи AI Workspace Console"}
+                title="Логи"
+                onClick={() => setLogsOpen((current) => !current)}
+              >
+                <svg viewBox="0 0 24 24" width="18" height="18" aria-hidden="true">
+                  <path
+                    d="M6 7h12M6 12h12M6 17h7"
+                    fill="none"
+                    stroke="currentColor"
+                    strokeWidth="1.8"
+                    strokeLinecap="round"
+                  />
+                </svg>
+              </button>
+              <button
+                type="button"
+                className="ai-console-icon-button"
+                data-active={fullscreen ? "true" : undefined}
+                aria-label={fullscreen ? "Вернуть размер AI Workspace Console" : "Развернуть AI Workspace Console"}
+                title={fullscreen ? "Вернуть размер" : "Развернуть"}
+                onClick={() => setFullscreen((current) => !current)}
+              >
+                <svg viewBox="0 0 24 24" width="18" height="18" aria-hidden="true">
+                  {fullscreen ? (
+                    <>
+                      <path
+                        d="M9 4v5H4M4 9l6-6"
+                        fill="none"
+                        stroke="currentColor"
+                        strokeWidth="1.75"
+                        strokeLinecap="round"
+                        strokeLinejoin="round"
+                      />
+                      <path
+                        d="M15 20v-5h5M20 15l-6 6"
+                        fill="none"
+                        stroke="currentColor"
+                        strokeWidth="1.75"
+                        strokeLinecap="round"
+                        strokeLinejoin="round"
+                      />
+                    </>
+                  ) : (
+                    <>
+                      <path
+                        d="M14 4h6v6M20 4l-7 7"
+                        fill="none"
+                        stroke="currentColor"
+                        strokeWidth="1.75"
+                        strokeLinecap="round"
+                        strokeLinejoin="round"
+                      />
+                      <path
+                        d="M10 20H4v-6M4 20l7-7"
+                        fill="none"
+                        stroke="currentColor"
+                        strokeWidth="1.75"
+                        strokeLinecap="round"
+                        strokeLinejoin="round"
+                      />
+                    </>
+                  )}
+                </svg>
+              </button>
+              <button
+                type="button"
+                className="ai-console-icon-button"
+                aria-label="Настройки AI Workspace Console"
+                title="Настройки"
+                onClick={() => setSettingsOpen(true)}
+              >
+                <svg viewBox="0 0 24 24" width="18" height="18" aria-hidden="true">
+                  <path
+                    d="M4 7h3m10 0h3M10 7a3 3 0 1 0 6 0 3 3 0 0 0-6 0ZM4 17h9m6 0h1M13 17a3 3 0 1 0 6 0 3 3 0 0 0-6 0Z"
+                    fill="none"
+                    stroke="currentColor"
+                    strokeWidth="1.75"
+                    strokeLinecap="round"
+                  />
+                </svg>
+              </button>
+              <button
+                type="button"
+                className="ai-console-icon-button"
+                aria-label="Закрыть AI Workspace Console"
+                title="Закрыть"
+                onClick={onClose}
+              >
+                <CloseMark />
+              </button>
+            </div>
+          </header>
+
+          <aside className="ai-console-threads" aria-label="AI sessions">
+            <div className="ai-console-threads__head">
+              <div>
+                <div className="ai-console-kicker">AI Space</div>
+                <div className="ai-console-threads__title">Темы</div>
+              </div>
+              <button
+                type="button"
+                className="ai-console-icon-button"
+                aria-label="Новая тема"
+                title="Новая тема"
+                onClick={() => void createThread()}
+              >
+                <span aria-hidden="true">+</span>
+              </button>
+            </div>
+            <div className="ai-console-thread-list">
+              {threads.map((thread) => {
+                const isEditing = editingThreadId === thread.id;
+                return (
+                  <div
+                    key={thread.id}
+                    role="button"
+                    tabIndex={0}
+                    className="ai-console-thread"
+                    data-active={thread.id === activeThread.id ? "true" : undefined}
+                    data-editing={isEditing ? "true" : undefined}
+                    onClick={() => {
+                      if (!isEditing) setActiveThreadId(thread.id);
+                    }}
+                    onDoubleClick={(event) => {
+                      event.stopPropagation();
+                      beginRenameThread(thread);
+                    }}
+                    onKeyDown={(event) => {
+                      if (isEditing) return;
+                      if (event.key === "Enter" || event.key === " ") {
+                        event.preventDefault();
+                        setActiveThreadId(thread.id);
+                      }
+                    }}
+                  >
+                    <span className="ai-console-thread__row">
+                      {isEditing ? (
+                        <input
+                          className="ai-console-thread__title-input"
+                          value={editingThreadTitle}
+                          onChange={(event) => setEditingThreadTitle(event.target.value)}
+                          onBlur={() => void commitRenameThread(thread)}
+                          onClick={(event) => event.stopPropagation()}
+                          onKeyDown={(event) => {
+                            if (event.key === "Enter") {
+                              event.preventDefault();
+                              void commitRenameThread(thread);
+                            } else if (event.key === "Escape") {
+                              event.preventDefault();
+                              setEditingThreadId("");
+                            }
+                          }}
+                          autoFocus
+                        />
+                      ) : (
+                        <span className="ai-console-thread__title">{thread.title}</span>
+                      )}
+                      {sending && thread.id === activeThread.id ? (
+                        <i className="ai-console-thread__status" aria-hidden="true" />
+                      ) : null}
+                      {isEditing ? (
+                        <button
+                          type="button"
+                          className="ai-console-thread__delete"
+                          aria-label="Удалить тему"
+                          title="Удалить тему"
+                          onMouseDown={(event) => event.preventDefault()}
+                          onClick={(event) => {
+                            event.stopPropagation();
+                            void removeThread(thread);
+                          }}
+                        >
+                          ×
+                        </button>
+                      ) : null}
+                    </span>
+                    <small>{thread.meta}</small>
+                  </div>
+                );
+              })}
+            </div>
+          </aside>
+
+          <div
+            className="ai-console-resizer"
+            role="separator"
+            aria-label="Изменить ширину тем"
+            title="Изменить ширину тем"
+            onPointerDown={startThreadsResize}
+          />
+
+          <main className="ai-console-main">
+            <div ref={messagesRef} className="ai-console-messages" aria-live="polite">
+              {activeMessages.map((message) => (
+                <article key={message.id} className="ai-console-message" data-role={message.role}>
+                  <div className="ai-console-message__role">
+                    <span>
+                      {message.role === "user"
+                        ? "Вы"
+                        : message.role === "assistant"
+                          ? "AI"
+                          : message.role === "tool"
+                            ? "Tool"
+                            : "System"}
+                    </span>
+                    {formatMessageTime(message.createdAt) ? (
+                      <time dateTime={message.createdAt || undefined}>{formatMessageTime(message.createdAt)}</time>
+                    ) : null}
+                  </div>
+                  <div className="ai-console-message__text ai-console-rich">
+                    <p>{message.text}</p>
+                  </div>
+                </article>
+              ))}
+              {sending ? (
+                <article className="ai-console-process" aria-label="Сохранение">
+                  <div className="ai-console-process__head">
+                    <span>Сохранение</span>
+                    <i aria-hidden="true" />
+                  </div>
+                </article>
+              ) : null}
+            </div>
+
+            <form className="ai-console-composer" onSubmit={submitMessage}>
+              <textarea
+                value={draft}
+                rows={1}
+                placeholder={sending ? "Сохранение..." : "Сообщение..."}
+                disabled={sending}
+                onChange={(event) => setDraft(event.target.value)}
+                onKeyDown={(event) => {
+                  if (event.key === "Enter" && !event.shiftKey) {
+                    event.preventDefault();
+                    void submitMessage();
+                  }
+                }}
+              />
+              <button
+                type="submit"
+                className="ai-console-send"
+                disabled={sending || !draft.trim()}
+                aria-label="Отправить"
+                title="Отправить"
+              >
+                <svg viewBox="0 0 24 24" width="17" height="17" aria-hidden="true">
+                  <path
+                    d="M4 12 20 4l-5.1 16-3.2-6.2L4 12Zm7.7 1.8 3.2 6.2"
+                    fill="none"
+                    stroke="currentColor"
+                    strokeWidth="1.8"
+                    strokeLinecap="round"
+                    strokeLinejoin="round"
+                  />
+                </svg>
+              </button>
+              {sending ? (
+                <div className="ai-console-thinking" aria-label="Сохранение" title="Сохранение">
+                  <span aria-hidden="true" />
+                </div>
+              ) : null}
+            </form>
+          </main>
+        </section>
+
+        {logsOpen ? (
+          <aside
+            className="ai-console-side-activity"
+            aria-label="Remote run diagnostics"
+            onMouseDown={(event) => event.stopPropagation()}
+            onPointerDown={(event) => event.stopPropagation()}
+          >
+            <header className="ai-console-side-activity__header">
+              <div>
+                <div className="ai-console-kicker">Remote diagnostics</div>
+                <h3>Логи</h3>
+              </div>
+              <div className="ai-console-side-activity__actions">
+                <button
+                  type="button"
+                  className="ai-console-icon-button ai-console-icon-button--sm"
+                  aria-label="Скопировать логи"
+                  title="Скопировать логи"
+                  onClick={() => void navigator.clipboard?.writeText(activityLines.join("\n"))}
+                >
+                  <svg viewBox="0 0 24 24" width="16" height="16" aria-hidden="true">
+                    <path
+                      d="M8 8V5.8C8 4.8 8.8 4 9.8 4h8.4c1 0 1.8.8 1.8 1.8v8.4c0 1-.8 1.8-1.8 1.8H16M5.8 8h8.4c1 0 1.8.8 1.8 1.8v8.4c0 1-.8 1.8-1.8 1.8H5.8c-1 0-1.8-.8-1.8-1.8V9.8C4 8.8 4.8 8 5.8 8Z"
+                      fill="none"
+                      stroke="currentColor"
+                      strokeWidth="1.65"
+                      strokeLinejoin="round"
+                    />
+                  </svg>
+                </button>
+                <button
+                  type="button"
+                  className="ai-console-icon-button ai-console-icon-button--sm"
+                  aria-label="Закрыть логи"
+                  title="Закрыть логи"
+                  onClick={() => setLogsOpen(false)}
+                >
+                  <CloseMark />
+                </button>
+              </div>
+            </header>
+            <section className="ai-console-activity" data-running={sending ? "true" : undefined}>
+              <div className="ai-console-activity__head">
+                <span>Ops assistant</span>
+                <small>{sending ? "running" : activeExecutor?.status || "offline"}</small>
+              </div>
+              <div className="ai-console-activity__log" aria-live="polite">
+                {activityLines.map((line, index) => (
+                  <div key={`${line}-${index}`} className="ai-console-activity__line">
+                    <span>{line.includes("error") ? "error" : "info"}</span>
+                    <code>{line}</code>
+                  </div>
+                ))}
+              </div>
+            </section>
+          </aside>
+        ) : null}
+
+        <ResizeHandles
+          geometry={normalizeGeometry(geometry)}
+          fullscreen={fullscreen}
+          onGeometryChange={updateGeometry}
+        />
+      </section>
+
+      <AIWorkspaceProductSettingsModal
+        isOpen={settingsOpen}
+        executors={executors}
+        selectedExecutorId={selectedExecutorId}
+        error={registryError}
+        notice={registryNotice}
+        actionError={actionError}
+        busyId={busyId}
+        onClose={() => setSettingsOpen(false)}
+        onReload={loadRegistry}
+        onSelect={selectExecutor}
+        onCreate={createExecutor}
+        onUpdate={updateExecutor}
+        onDelete={deleteExecutor}
+        onDownloadAgent={downloadAgent}
+        getWindowsAgentInstallerUrl={(executorId, options) =>
+          workspaceAIWorkspaceService.getWindowsAgentInstallerUrl(workspaceSlug, executorId, options)
+        }
+      />
+    </>
+  );
+
+  return createPortal(consoleNode, document.body);
+}
diff --git a/plane-src/apps/web/core/services/workspace-ai-workspace.service.ts b/plane-src/apps/web/core/services/workspace-ai-workspace.service.ts
index 9a12632..2251be1 100644
--- a/plane-src/apps/web/core/services/workspace-ai-workspace.service.ts
+++ b/plane-src/apps/web/core/services/workspace-ai-workspace.service.ts
@@ -50,6 +50,64 @@ export type TAIWorkspaceExecutorInput = {
   status?: TAIWorkspaceExecutorStatus;
 };
 
+export type TAIWorkspaceThread = {
+  id: string;
+  title: string;
+  originSurface: "engine" | "ops" | "global" | string;
+  activeContext?: Record<string, any>;
+  enabledToolPacks?: string[];
+  linkedArtifacts?: Record<string, any>[];
+  selectedExecutorId?: string | null;
+  lifecycleState?: "active" | "archived" | string;
+  metadata?: Record<string, any>;
+  createdAt?: string | null;
+  updatedAt?: string | null;
+};
+
+export type TAIWorkspaceThreadMessageRole = "system" | "user" | "assistant" | "tool";
+
+export type TAIWorkspaceThreadMessage = {
+  id: string;
+  threadId: string;
+  sequence?: number;
+  role: TAIWorkspaceThreadMessageRole;
+  content: string;
+  payload?: Record<string, any>;
+  createdAt?: string | null;
+};
+
+export type TAIWorkspaceThreadListResponse = {
+  ok: boolean;
+  threads: TAIWorkspaceThread[];
+};
+
+export type TAIWorkspaceThreadResponse = {
+  ok: boolean;
+  thread: TAIWorkspaceThread;
+};
+
+export type TAIWorkspaceThreadMessagesResponse = {
+  ok: boolean;
+  threadId: string;
+  messages: TAIWorkspaceThreadMessage[];
+};
+
+export type TAIWorkspaceThreadMessageResponse = {
+  ok: boolean;
+  message: TAIWorkspaceThreadMessage;
+};
+
+export type TAIWorkspaceThreadInput = {
+  title: string;
+  originSurface?: "engine" | "ops" | "global";
+  activeContext?: Record<string, any>;
+  enabledToolPacks?: string[];
+  linkedArtifacts?: Record<string, any>[];
+  selectedExecutorId?: string | null;
+  lifecycleState?: "active" | "archived";
+  metadata?: Record<string, any>;
+};
+
 export class WorkspaceAIWorkspaceService extends APIService {
   constructor() {
     super(API_BASE_URL);
@@ -63,10 +121,15 @@ export class WorkspaceAIWorkspaceService extends APIService {
       });
   }
 
-  async createExecutor(workspaceSlug: string, input: TAIWorkspaceExecutorInput): Promise<TAIWorkspaceExecutorListResponse> {
-    await this.post(`/api/workspaces/${workspaceSlug}/ai-workspace/executors/`, { ...input, select: true }).catch((error) => {
-      throw error?.response?.data ?? error;
-    });
+  async createExecutor(
+    workspaceSlug: string,
+    input: TAIWorkspaceExecutorInput
+  ): Promise<TAIWorkspaceExecutorListResponse> {
+    await this.post(`/api/workspaces/${workspaceSlug}/ai-workspace/executors/`, { ...input, select: true }).catch(
+      (error) => {
+        throw error?.response?.data ?? error;
+      }
+    );
     return this.listExecutors(workspaceSlug);
   }
 
@@ -101,4 +164,68 @@ export class WorkspaceAIWorkspaceService extends APIService {
     if (port) params.set("port", port);
     return `${API_BASE_URL}/api/workspaces/${workspaceSlug}/ai-workspace/executors/${executorId}/agent/windows.ps1?${params.toString()}`;
   }
+
+  async listThreads(
+    workspaceSlug: string,
+    options: { surface?: "ops" | "engine" | "global"; limit?: number } = {}
+  ): Promise<TAIWorkspaceThreadListResponse> {
+    const params = new URLSearchParams();
+    params.set("surface", options.surface || "ops");
+    params.set("limit", String(options.limit || 100));
+    return this.get(`/api/workspaces/${workspaceSlug}/ai-workspace/threads/?${params.toString()}`)
+      .then((response) => response?.data)
+      .catch((error) => {
+        throw error?.response?.data ?? error;
+      });
+  }
+
+  async createThread(workspaceSlug: string, input: TAIWorkspaceThreadInput): Promise<TAIWorkspaceThreadResponse> {
+    return this.post(`/api/workspaces/${workspaceSlug}/ai-workspace/threads/`, {
+      originSurface: "ops",
+      enabledToolPacks: ["ops"],
+      ...input,
+    })
+      .then((response) => response?.data)
+      .catch((error) => {
+        throw error?.response?.data ?? error;
+      });
+  }
+
+  async updateThread(
+    workspaceSlug: string,
+    threadId: string,
+    input: Partial<TAIWorkspaceThreadInput>
+  ): Promise<TAIWorkspaceThreadResponse> {
+    return this.patch(`/api/workspaces/${workspaceSlug}/ai-workspace/threads/${threadId}/`, input)
+      .then((response) => response?.data)
+      .catch((error) => {
+        throw error?.response?.data ?? error;
+      });
+  }
+
+  async listThreadMessages(
+    workspaceSlug: string,
+    threadId: string,
+    options: { limit?: number } = {}
+  ): Promise<TAIWorkspaceThreadMessagesResponse> {
+    const params = new URLSearchParams();
+    params.set("limit", String(options.limit || 200));
+    return this.get(`/api/workspaces/${workspaceSlug}/ai-workspace/threads/${threadId}/messages/?${params.toString()}`)
+      .then((response) => response?.data)
+      .catch((error) => {
+        throw error?.response?.data ?? error;
+      });
+  }
+
+  async createThreadMessage(
+    workspaceSlug: string,
+    threadId: string,
+    input: { role: TAIWorkspaceThreadMessageRole; content: string; payload?: Record<string, any> }
+  ): Promise<TAIWorkspaceThreadMessageResponse> {
+    return this.post(`/api/workspaces/${workspaceSlug}/ai-workspace/threads/${threadId}/messages/`, input)
+      .then((response) => response?.data)
+      .catch((error) => {
+        throw error?.response?.data ?? error;
+      });
+  }
 }
diff --git a/plane-src/apps/web/styles/globals.css b/plane-src/apps/web/styles/globals.css
index e1f9d56..0d4f66a 100644
--- a/plane-src/apps/web/styles/globals.css
+++ b/plane-src/apps/web/styles/globals.css
@@ -1307,6 +1307,787 @@
     }
   }
 
+  .nodedc-ai-workspace-console {
+    --ai-console-control-h: 46px;
+    --wf-share-control-h: var(--ai-console-control-h);
+    --brand: rgb(var(--nodedc-card-active-rgb));
+    --brand-rgb: var(--nodedc-card-active-rgb);
+    --brand-contrast: rgb(var(--nodedc-on-card-active-rgb));
+    --nodedc-glass-panel-bg:
+      linear-gradient(180deg, rgba(255, 255, 255, 0.038) 0%, rgba(255, 255, 255, 0.012) 100%), rgba(8, 9, 10, 0.9);
+    --nodedc-glass-control-bg: rgba(255, 255, 255, 0.045);
+    --nodedc-glass-control-hover: rgba(255, 255, 255, 0.078);
+    --nodedc-glass-control-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.055), 0 10px 28px rgba(0, 0, 0, 0.22);
+    --nodedc-glass-panel-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.06), 0 28px 78px rgba(0, 0, 0, 0.48);
+    --nodedc-glass-outline-gradient: linear-gradient(180deg, rgba(255, 255, 255, 0.08), rgba(255, 255, 255, 0.025));
+    position: fixed;
+    z-index: 26000;
+    display: grid;
+    width: min(1080px, calc(100vw - 104px));
+    height: min(620px, calc(100vh - 84px));
+    min-height: 420px;
+    min-width: 960px;
+    pointer-events: none;
+  }
+
+  .nodedc-ai-workspace-console[data-fullscreen="true"] {
+    min-width: 0;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-shell {
+    position: relative;
+    isolation: isolate;
+    z-index: 1;
+    display: grid;
+    width: 100%;
+    height: 100%;
+    min-width: 0;
+    min-height: 0;
+    grid-template-columns: var(--ai-threads-width, 330px) 10px minmax(0, 1fr);
+    grid-template-rows: auto minmax(0, 1fr);
+    overflow: hidden;
+    border-radius: 22px;
+    background: var(--nodedc-glass-panel-bg);
+    color: rgba(255, 255, 255, 0.92);
+    pointer-events: auto;
+    box-shadow: var(--nodedc-glass-panel-shadow);
+    -webkit-backdrop-filter: blur(64px) saturate(150%) brightness(1.08);
+    backdrop-filter: blur(64px) saturate(150%) brightness(1.08);
+  }
+
+  .nodedc-ai-workspace-console .ai-console-shell::after,
+  .nodedc-ai-workspace-console .ai-console-side-activity::after {
+    position: absolute;
+    inset: 0;
+    z-index: 2;
+    border-radius: inherit;
+    padding: 1px;
+    background: var(--nodedc-glass-outline-gradient);
+    content: "";
+    pointer-events: none;
+    -webkit-mask:
+      linear-gradient(#000 0 0) content-box,
+      linear-gradient(#000 0 0);
+    -webkit-mask-composite: xor;
+    mask-composite: exclude;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-header,
+  .nodedc-ai-workspace-console .ai-console-actions,
+  .nodedc-ai-workspace-console .ai-console-threads__head,
+  .nodedc-ai-workspace-console .ai-console-composer,
+  .nodedc-ai-workspace-console .ai-console-side-activity__header,
+  .nodedc-ai-workspace-console .ai-console-side-activity__actions {
+    display: flex;
+    align-items: center;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-header {
+    min-height: var(--ai-console-control-h);
+    justify-content: space-between;
+    gap: 16px;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-topbar {
+    grid-column: 1 / -1;
+    grid-row: 1;
+    padding: 18px;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-header[data-draggable="true"] {
+    cursor: move;
+    touch-action: none;
+    user-select: none;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-title-block {
+    min-width: 0;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-title-block h2 {
+    margin: 7px 0 0;
+    min-width: 0;
+    overflow: hidden;
+    color: rgba(255, 255, 255, 0.96);
+    font-size: 18px;
+    font-weight: 760;
+    letter-spacing: 0;
+    line-height: 1.15;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-kicker {
+    color: rgba(255, 255, 255, 0.48);
+    font-size: 10px;
+    font-weight: 760;
+    letter-spacing: 0;
+    line-height: 1;
+    text-transform: uppercase;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-actions {
+    flex: 0 0 auto;
+    gap: 8px;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-icon-button {
+    display: inline-grid;
+    width: var(--ai-console-control-h);
+    height: var(--ai-console-control-h);
+    flex: 0 0 var(--ai-console-control-h);
+    place-items: center;
+    border: 0;
+    border-radius: 15px;
+    background: var(--nodedc-glass-control-bg);
+    color: rgba(255, 255, 255, 0.82);
+    cursor: pointer;
+    outline: none !important;
+    padding: 0;
+    box-shadow: var(--nodedc-glass-control-shadow) !important;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-icon-button:hover {
+    background: var(--nodedc-glass-control-hover);
+    color: #ffffff;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-icon-button[data-active="true"] {
+    background: var(--brand);
+    color: var(--brand-contrast);
+  }
+
+  .nodedc-ai-workspace-console .ai-console-icon-button--sm {
+    width: 38px;
+    height: 38px;
+    flex-basis: 38px;
+    border-radius: 13px;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-icon-button > span:not(.nodedc-glass-modal__close-mark) {
+    font-size: 19px;
+    font-weight: 560;
+    line-height: 1;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-threads,
+  .nodedc-ai-workspace-console .ai-console-main {
+    min-width: 0;
+    min-height: 0;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-threads {
+    display: grid;
+    grid-column: 1;
+    grid-row: 2;
+    grid-template-rows: auto minmax(0, 1fr);
+    gap: 14px;
+    padding: 0 12px 18px;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-threads__head {
+    min-height: var(--ai-console-control-h);
+    justify-content: space-between;
+    gap: 10px;
+    padding-left: 8px;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-threads__title {
+    margin-top: 7px;
+    color: rgba(255, 255, 255, 0.94);
+    font-size: 15px;
+    font-weight: 760;
+    line-height: 1.1;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-thread-list {
+    display: grid;
+    min-height: 0;
+    align-content: start;
+    gap: 8px;
+    overflow: auto;
+    padding-right: 2px;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-thread-list::-webkit-scrollbar,
+  .nodedc-ai-workspace-console .ai-console-messages::-webkit-scrollbar,
+  .nodedc-ai-workspace-console .ai-console-activity__log::-webkit-scrollbar {
+    width: 0;
+    height: 0;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-thread {
+    position: relative;
+    display: grid;
+    min-height: 52px;
+    min-width: 0;
+    gap: 6px;
+    border: 0;
+    border-radius: 14px;
+    background: var(--nodedc-glass-control-bg);
+    color: rgba(255, 255, 255, 0.72);
+    cursor: pointer;
+    outline: none !important;
+    padding: 10px 13px;
+    text-align: left;
+    box-shadow: var(--nodedc-glass-control-shadow) !important;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-thread[data-editing="true"] {
+    padding-right: 38px;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-thread:hover,
+  .nodedc-ai-workspace-console .ai-console-thread[data-active="true"] {
+    background: var(--nodedc-glass-control-hover);
+    color: rgba(255, 255, 255, 0.96);
+  }
+
+  .nodedc-ai-workspace-console .ai-console-thread[data-active="true"] {
+    background: var(--brand);
+    color: var(--brand-contrast);
+    box-shadow: none !important;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-thread__row,
+  .nodedc-ai-workspace-console .ai-console-thread small,
+  .nodedc-ai-workspace-console .ai-console-thread__title {
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-thread__row {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-size: 13px;
+    font-weight: 760;
+    line-height: 1.1;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-thread__title-input {
+    width: 100%;
+    min-width: 0;
+    border: 0;
+    border-radius: 0;
+    background: transparent;
+    color: inherit;
+    font: inherit;
+    outline: none !important;
+    padding: 0;
+    caret-color: currentColor;
+    box-shadow: none !important;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-thread__delete {
+    position: absolute;
+    top: 0;
+    right: 12px;
+    bottom: 0;
+    display: inline-grid;
+    width: 18px;
+    height: 18px;
+    margin: auto 0;
+    place-items: center;
+    border: 0;
+    border-radius: 0;
+    background: transparent;
+    color: inherit;
+    cursor: pointer;
+    font-size: 0;
+    line-height: 0;
+    opacity: 0.82;
+    outline: none !important;
+    padding: 0;
+    box-shadow: none !important;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-thread__delete::before,
+  .nodedc-ai-workspace-console .ai-console-thread__delete::after {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    width: 10px;
+    height: 1.5px;
+    border-radius: 999px;
+    background: currentColor;
+    content: "";
+    transform: translate(-50%, -50%) rotate(45deg);
+  }
+
+  .nodedc-ai-workspace-console .ai-console-thread__delete::after {
+    transform: translate(-50%, -50%) rotate(-45deg);
+  }
+
+  .nodedc-ai-workspace-console .ai-console-thread small {
+    color: rgba(255, 255, 255, 0.44);
+    font-size: 11px;
+    line-height: 1;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-thread[data-active="true"] small {
+    color: rgba(11, 17, 23, 0.68);
+  }
+
+  .nodedc-ai-workspace-console .ai-console-thread__status,
+  .nodedc-ai-workspace-console .ai-console-thinking span,
+  .nodedc-ai-workspace-console .ai-console-process__head i {
+    display: inline-block;
+    width: 7px;
+    height: 7px;
+    flex: 0 0 7px;
+    border-radius: 999px;
+    background: currentColor;
+    opacity: 0.9;
+    animation: ai-console-thinking-pulse 1.55s ease-in-out infinite;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-resizer {
+    position: relative;
+    grid-column: 2;
+    grid-row: 2;
+    width: 10px;
+    min-width: 10px;
+    height: 100%;
+    cursor: col-resize;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-resizer::before {
+    position: absolute;
+    top: 18px;
+    bottom: 18px;
+    left: 50%;
+    width: 1px;
+    border-radius: 999px;
+    background: rgba(255, 255, 255, 0.08);
+    content: "";
+    transform: translateX(-50%);
+  }
+
+  .nodedc-ai-workspace-console .ai-console-resizer:hover::before {
+    width: 3px;
+    background: rgba(255, 255, 255, 0.16);
+  }
+
+  .nodedc-ai-workspace-console .ai-console-main {
+    display: grid;
+    grid-column: 3;
+    grid-row: 2;
+    grid-template-rows: minmax(0, 1fr) auto;
+    gap: 14px;
+    padding: 0 18px 18px;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-messages {
+    display: flex;
+    min-height: 0;
+    flex-direction: column;
+    gap: 10px;
+    overflow: auto;
+    padding: 4px 2px;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-message,
+  .nodedc-ai-workspace-console .ai-console-process {
+    display: grid;
+    width: min(76%, 560px);
+    min-width: 0;
+    gap: 8px;
+    align-self: flex-start;
+    border-radius: 18px;
+    background: var(--nodedc-glass-control-bg);
+    padding: 12px 14px;
+    box-shadow: var(--nodedc-glass-control-shadow);
+  }
+
+  .nodedc-ai-workspace-console .ai-console-message[data-role="user"] {
+    align-self: flex-end;
+    background: rgba(var(--nodedc-card-active-rgb), 0.16);
+  }
+
+  .nodedc-ai-workspace-console .ai-console-message__role,
+  .nodedc-ai-workspace-console .ai-console-process__head {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 8px;
+    color: rgba(255, 255, 255, 0.46);
+    font-size: 10px;
+    font-weight: 760;
+    line-height: 1;
+    text-transform: uppercase;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-message__role time {
+    color: rgba(255, 255, 255, 0.34);
+    font: inherit;
+    text-transform: none;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-message__text {
+    color: rgba(255, 255, 255, 0.86);
+    font-size: 13px;
+    line-height: 1.4;
+    overflow-wrap: anywhere;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-rich {
+    display: grid;
+    gap: 9px;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-rich p {
+    margin: 0;
+    white-space: pre-line;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-process__head {
+    border-bottom: 1px solid rgba(255, 255, 255, 0.075);
+    padding-bottom: 9px;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-process__head i {
+    background: var(--brand);
+    color: var(--brand);
+  }
+
+  .nodedc-ai-workspace-console .ai-console-composer {
+    position: relative;
+    min-height: 54px;
+    gap: 10px;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-composer textarea {
+    width: 100%;
+    min-width: 0;
+    height: 54px;
+    min-height: 54px;
+    max-height: 128px;
+    resize: none;
+    border: 0 !important;
+    border-radius: 18px;
+    background: var(--nodedc-glass-control-bg);
+    color: rgba(255, 255, 255, 0.92);
+    font: inherit;
+    font-size: 13px;
+    line-height: 1.2;
+    outline: none !important;
+    padding: 18px 16px;
+    box-shadow: var(--nodedc-glass-control-shadow) !important;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-composer textarea::placeholder {
+    color: rgba(255, 255, 255, 0.34);
+  }
+
+  .nodedc-ai-workspace-console .ai-console-composer textarea:disabled {
+    color: rgba(255, 255, 255, 0.46);
+    cursor: default;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-send {
+    display: inline-grid;
+    width: 54px;
+    height: 54px;
+    flex: 0 0 54px;
+    place-items: center;
+    border: 0;
+    border-radius: 18px;
+    background: var(--brand);
+    color: var(--brand-contrast);
+    cursor: pointer;
+    outline: none !important;
+    padding: 0;
+    box-shadow: var(--nodedc-glass-control-shadow) !important;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-send:disabled {
+    background: var(--nodedc-glass-control-bg);
+    color: rgba(255, 255, 255, 0.32);
+    cursor: default;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-thinking {
+    display: inline-grid;
+    width: 22px;
+    height: 54px;
+    flex: 0 0 22px;
+    place-items: center;
+    pointer-events: none;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-thinking span {
+    background: var(--brand);
+    color: var(--brand);
+  }
+
+  .nodedc-ai-workspace-console .ai-console-side-activity {
+    position: absolute;
+    top: 0;
+    left: calc(100% + 16px);
+    isolation: isolate;
+    z-index: 1;
+    display: grid;
+    width: 330px;
+    height: 100%;
+    min-width: 0;
+    grid-template-rows: auto minmax(0, 1fr);
+    gap: 14px;
+    overflow: hidden;
+    border-radius: 22px;
+    background: var(--nodedc-glass-panel-bg);
+    color: rgba(255, 255, 255, 0.92);
+    pointer-events: auto;
+    padding: 18px 16px 16px;
+    box-shadow: var(--nodedc-glass-panel-shadow);
+    -webkit-backdrop-filter: blur(64px) saturate(150%) brightness(1.08);
+    backdrop-filter: blur(64px) saturate(150%) brightness(1.08);
+  }
+
+  .nodedc-ai-workspace-console .ai-console-side-activity__header {
+    min-width: 0;
+    justify-content: space-between;
+    gap: 14px;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-side-activity__header h3 {
+    margin: 6px 0 0;
+    color: rgba(255, 255, 255, 0.94);
+    font-size: 16px;
+    font-weight: 760;
+    line-height: 1.1;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-side-activity__actions {
+    gap: 8px;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-activity {
+    display: grid;
+    min-height: 0;
+    grid-template-rows: auto minmax(0, 1fr);
+    gap: 8px;
+    overflow: hidden;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-activity__head {
+    display: flex;
+    min-width: 0;
+    align-items: center;
+    justify-content: space-between;
+    gap: 12px;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-activity__head span {
+    min-width: 0;
+    overflow: hidden;
+    color: rgba(var(--nodedc-card-active-rgb), 0.96);
+    font-size: 10px;
+    font-weight: 800;
+    line-height: 1.25;
+    text-overflow: ellipsis;
+    text-transform: uppercase;
+    white-space: nowrap;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-activity__head small {
+    color: rgba(255, 255, 255, 0.42);
+    font-size: 10px;
+    font-weight: 760;
+    line-height: 1.25;
+    text-transform: uppercase;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-activity__log {
+    display: grid;
+    min-height: 0;
+    align-content: start;
+    gap: 5px;
+    overflow: auto;
+    padding-right: 2px;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-activity__line {
+    display: grid;
+    min-width: 0;
+    grid-template-columns: 72px minmax(0, 1fr);
+    align-items: start;
+    gap: 9px;
+    color: rgba(255, 255, 255, 0.72);
+    font-size: 11px;
+    line-height: 1.35;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-activity__line span {
+    overflow: hidden;
+    color: rgba(255, 255, 255, 0.42);
+    font-weight: 760;
+    text-overflow: ellipsis;
+    text-transform: uppercase;
+    white-space: nowrap;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-activity__line code {
+    min-width: 0;
+    overflow: hidden;
+    color: rgba(255, 255, 255, 0.76);
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
+    text-overflow: ellipsis;
+    white-space: pre-wrap;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-window-resize-layer {
+    position: absolute;
+    inset: -6px;
+    z-index: 4;
+    pointer-events: none;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-window-resize {
+    position: absolute;
+    pointer-events: auto;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-window-resize--top,
+  .nodedc-ai-workspace-console .ai-console-window-resize--bottom {
+    right: 14px;
+    left: 14px;
+    height: 12px;
+    cursor: ns-resize;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-window-resize--top {
+    top: 0;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-window-resize--bottom {
+    bottom: 0;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-window-resize--left,
+  .nodedc-ai-workspace-console .ai-console-window-resize--right {
+    top: 14px;
+    bottom: 14px;
+    width: 12px;
+    cursor: ew-resize;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-window-resize--left {
+    left: 0;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-window-resize--right {
+    right: 0;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-window-resize--top-left,
+  .nodedc-ai-workspace-console .ai-console-window-resize--top-right,
+  .nodedc-ai-workspace-console .ai-console-window-resize--bottom-right,
+  .nodedc-ai-workspace-console .ai-console-window-resize--bottom-left {
+    width: 18px;
+    height: 18px;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-window-resize--top-left {
+    top: 0;
+    left: 0;
+    cursor: nwse-resize;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-window-resize--top-right {
+    top: 0;
+    right: 0;
+    cursor: nesw-resize;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-window-resize--bottom-right {
+    right: 0;
+    bottom: 0;
+    cursor: nwse-resize;
+  }
+
+  .nodedc-ai-workspace-console .ai-console-window-resize--bottom-left {
+    bottom: 0;
+    left: 0;
+    cursor: nesw-resize;
+  }
+
+  @keyframes ai-console-thinking-pulse {
+    0%,
+    100% {
+      transform: scale(0.72);
+      box-shadow: 0 0 0 0 rgba(var(--nodedc-card-active-rgb), 0.22);
+      opacity: 0.58;
+    }
+
+    48% {
+      transform: scale(1.75);
+      box-shadow: 0 0 0 9px rgba(var(--nodedc-card-active-rgb), 0.04);
+      opacity: 1;
+    }
+  }
+
+  @media (max-width: 1040px) {
+    .nodedc-ai-workspace-console {
+      left: 12px !important;
+      top: 72px !important;
+      width: calc(100vw - 24px) !important;
+      height: calc(100vh - 88px) !important;
+      min-width: 0;
+    }
+
+    .nodedc-ai-workspace-console .ai-console-shell {
+      grid-template-columns: minmax(190px, 35vw) 8px minmax(0, 1fr);
+    }
+  }
+
+  @media (max-width: 760px) {
+    .nodedc-ai-workspace-console .ai-console-shell {
+      grid-template-columns: minmax(0, 1fr);
+      grid-template-rows: auto 148px minmax(0, 1fr);
+    }
+
+    .nodedc-ai-workspace-console .ai-console-topbar {
+      grid-column: 1;
+      grid-row: 1;
+      padding: 12px;
+    }
+
+    .nodedc-ai-workspace-console .ai-console-threads {
+      grid-column: 1;
+      grid-row: 2;
+      padding: 0 12px 10px;
+    }
+
+    .nodedc-ai-workspace-console .ai-console-resizer {
+      display: none;
+    }
+
+    .nodedc-ai-workspace-console .ai-console-main {
+      grid-column: 1;
+      grid-row: 3;
+      padding: 0 12px 12px;
+    }
+
+    .nodedc-ai-workspace-console .ai-console-title-block h2 {
+      max-width: 42vw;
+    }
+
+    .nodedc-ai-workspace-console .ai-console-side-activity {
+      right: 0;
+      left: 0;
+      width: 100%;
+      height: min(280px, calc(100vh - 96px));
+      transform: translateY(calc(-100% - 12px));
+    }
+
+    .nodedc-ai-workspace-console .ai-console-window-resize-layer {
+      display: none;
+    }
+  }
+
   .nodedc-bottom-dock-aware-padding {
     padding-bottom: calc(var(--nodedc-quick-add-reserve, 2.5rem) + 0.5rem);
   }