diff --git a/src-tauri/src/bin/codex_monitor_daemon.rs b/src-tauri/src/bin/codex_monitor_daemon.rs
index a77b5c954..6a5f9596f 100644
--- a/src-tauri/src/bin/codex_monitor_daemon.rs
+++ b/src-tauri/src/bin/codex_monitor_daemon.rs
@@ -126,12 +126,20 @@ impl DaemonState {
         result
     }
 
+    async fn is_workspace_path_dir(&self, path: String) -> bool {
+        PathBuf::from(&path).is_dir()
+    }
+
     async fn add_workspace(
         &self,
         path: String,
         codex_bin: Option<String>,
         client_version: String,
     ) -> Result<WorkspaceInfo, String> {
+        if !PathBuf::from(&path).is_dir() {
+            return Err("Workspace path must be a folder.".to_string());
+        }
+
         let name = PathBuf::from(&path)
             .file_name()
             .and_then(|s| s.to_str())
@@ -1499,6 +1507,11 @@ async fn handle_rpc_request(
             let workspaces = state.list_workspaces().await;
             serde_json::to_value(workspaces).map_err(|err| err.to_string())
         }
+        "is_workspace_path_dir" => {
+            let path = parse_string(&params, "path")?;
+            let is_dir = state.is_workspace_path_dir(path).await;
+            serde_json::to_value(is_dir).map_err(|err| err.to_string())
+        }
         "add_workspace" => {
             let path = parse_string(&params, "path")?;
             let codex_bin = parse_optional_string(&params, "codex_bin");
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index badcb3cb5..1509f0a0e 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -66,6 +66,7 @@ pub fn run() {
             menu::menu_set_accelerators,
             codex::codex_doctor,
             workspaces::list_workspaces,
+            workspaces::is_workspace_path_dir,
             workspaces::add_workspace,
             workspaces::add_clone,
             workspaces::add_worktree,
diff --git a/src-tauri/src/workspaces.rs b/src-tauri/src/workspaces.rs
index 029f5a5b3..fba6be496 100644
--- a/src-tauri/src/workspaces.rs
+++ b/src-tauri/src/workspaces.rs
@@ -415,6 +415,25 @@ pub(crate) async fn list_workspaces(
     Ok(result)
 }
 
+#[tauri::command]
+pub(crate) async fn is_workspace_path_dir(
+    path: String,
+    state: State<'_, AppState>,
+    app: AppHandle,
+) -> Result<bool, String> {
+    if remote_backend::is_remote_mode(&*state).await {
+        let response = remote_backend::call_remote(
+            &*state,
+            app,
+            "is_workspace_path_dir",
+            json!({ "path": path }),
+        )
+        .await?;
+        return serde_json::from_value(response).map_err(|err| err.to_string());
+    }
+    Ok(PathBuf::from(&path).is_dir())
+}
+
 #[tauri::command]
 pub(crate) async fn add_workspace(
     path: String,
@@ -433,6 +452,10 @@ pub(crate) async fn add_workspace(
         return serde_json::from_value(response).map_err(|err| err.to_string());
     }
 
+    if !PathBuf::from(&path).is_dir() {
+        return Err("Workspace path must be a folder.".to_string());
+    }
+
     let name = PathBuf::from(&path)
         .file_name()
         .and_then(|s| s.to_str())
diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json
index 547c79bee..1b4c35126 100644
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -18,7 +18,7 @@
         "height": 700,
         "minWidth": 360,
         "minHeight": 600,
-        "dragDropEnabled": false,
+        "dragDropEnabled": true,
         "titleBarStyle": "Overlay",
         "hiddenTitle": true,
         "transparent": true,
diff --git a/src/App.tsx b/src/App.tsx
index c7c74cdfb..d7db6625a 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -30,6 +30,7 @@ import { AppLayout } from "./features/app/components/AppLayout";
 import { AppModals } from "./features/app/components/AppModals";
 import { MainHeaderActions } from "./features/app/components/MainHeaderActions";
 import { useLayoutNodes } from "./features/layout/hooks/useLayoutNodes";
+import { useWorkspaceDropZone } from "./features/workspaces/hooks/useWorkspaceDropZone";
 import { useThreads } from "./features/threads/hooks/useThreads";
 import { useWindowDrag } from "./features/layout/hooks/useWindowDrag";
 import { useGitPanelController } from "./features/app/hooks/useGitPanelController";
@@ -154,6 +155,7 @@ function MainApp() {
     activeWorkspaceId,
     setActiveWorkspaceId,
     addWorkspace,
+    addWorkspaceFromPath,
     addCloneAgent,
     addWorktreeAgent,
     connectWorkspace,
@@ -1040,6 +1042,7 @@ function MainApp() {
 
   const {
     handleAddWorkspace,
+    handleAddWorkspaceFromPath,
     handleAddAgent,
     handleAddWorktreeAgent,
     handleAddCloneAgent,
@@ -1047,6 +1050,7 @@ function MainApp() {
     activeWorkspace,
     isCompact,
     addWorkspace,
+    addWorkspaceFromPath,
     connectWorkspace,
     startThreadForWorkspace,
     setActiveThreadId,
@@ -1059,6 +1063,32 @@ function MainApp() {
     onDebug: addDebugEntry,
   });
 
+  const handleDropWorkspacePaths = useCallback(
+    async (paths: string[]) => {
+      const uniquePaths = Array.from(
+        new Set(paths.filter((path) => path.length > 0)),
+      );
+      if (uniquePaths.length === 0) {
+        return;
+      }
+      uniquePaths.forEach((path) => {
+        void handleAddWorkspaceFromPath(path);
+      });
+    },
+    [handleAddWorkspaceFromPath],
+  );
+
+  const {
+    dropTargetRef: workspaceDropTargetRef,
+    isDragOver: isWorkspaceDropActive,
+    handleDragOver: handleWorkspaceDragOver,
+    handleDragEnter: handleWorkspaceDragEnter,
+    handleDragLeave: handleWorkspaceDragLeave,
+    handleDrop: handleWorkspaceDrop,
+  } = useWorkspaceDropZone({
+    onDropPaths: handleDropWorkspacePaths,
+  });
+
   const {
     handleSelectPullRequest,
     resetPullRequestSelection,
@@ -1201,6 +1231,8 @@ function MainApp() {
   useMenuAcceleratorController({ appSettings, onDebug: addDebugEntry });
 
   const isDefaultScale = Math.abs(uiScale - 1) < 0.001;
+  const dropOverlayActive = isWorkspaceDropActive;
+  const dropOverlayText = "Drop Project Here";
   const appClassName = `app ${isCompact ? "layout-compact" : "layout-desktop"}${
     isPhone ? " layout-phone" : ""
   }${isTablet ? " layout-tablet" : ""}${
@@ -1550,6 +1582,13 @@ function MainApp() {
       setCenterMode("chat");
     },
     onGoProjects: () => setActiveTab("projects"),
+    workspaceDropTargetRef,
+    isWorkspaceDropActive: dropOverlayActive,
+    workspaceDropText: dropOverlayText,
+    onWorkspaceDragOver: handleWorkspaceDragOver,
+    onWorkspaceDragEnter: handleWorkspaceDragEnter,
+    onWorkspaceDragLeave: handleWorkspaceDragLeave,
+    onWorkspaceDrop: handleWorkspaceDrop,
   });
 
   const desktopTopbarLeftNodeWithToggle = !isCompact ? (
diff --git a/src/features/app/components/Sidebar.tsx b/src/features/app/components/Sidebar.tsx
index 2c2de098d..2186ad48d 100644
--- a/src/features/app/components/Sidebar.tsx
+++ b/src/features/app/components/Sidebar.tsx
@@ -1,6 +1,8 @@
 import type { RateLimitSnapshot, ThreadSummary, WorkspaceInfo } from "../../../types";
 import { createPortal } from "react-dom";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import type { RefObject } from "react";
+import { FolderOpen } from "lucide-react";
 import { SidebarCornerActions } from "./SidebarCornerActions";
 import { SidebarFooter } from "./SidebarFooter";
 import { SidebarHeader } from "./SidebarHeader";
@@ -67,6 +69,13 @@ type SidebarProps = {
   onDeleteWorktree: (workspaceId: string) => void;
   onLoadOlderThreads: (workspaceId: string) => void;
   onReloadWorkspaceThreads: (workspaceId: string) => void;
+  workspaceDropTargetRef: RefObject<HTMLElement | null>;
+  isWorkspaceDropActive: boolean;
+  workspaceDropText: string;
+  onWorkspaceDragOver: (event: React.DragEvent<HTMLElement>) => void;
+  onWorkspaceDragEnter: (event: React.DragEvent<HTMLElement>) => void;
+  onWorkspaceDragLeave: (event: React.DragEvent<HTMLElement>) => void;
+  onWorkspaceDrop: (event: React.DragEvent<HTMLElement>) => void;
 };
 
 export function Sidebar({
@@ -106,6 +115,13 @@ export function Sidebar({
   onDeleteWorktree,
   onLoadOlderThreads,
   onReloadWorkspaceThreads,
+  workspaceDropTargetRef,
+  isWorkspaceDropActive,
+  workspaceDropText,
+  onWorkspaceDragOver,
+  onWorkspaceDragEnter,
+  onWorkspaceDragLeave,
+  onWorkspaceDrop,
 }: SidebarProps) {
   const [expandedWorkspaces, setExpandedWorkspaces] = useState(
     new Set<string>(),
@@ -264,8 +280,32 @@ export function Sidebar({
   }, [addMenuAnchor]);
 
   return (
-    <aside className="sidebar">
+    <aside
+      className="sidebar"
+      ref={workspaceDropTargetRef}
+      onDragOver={onWorkspaceDragOver}
+      onDragEnter={onWorkspaceDragEnter}
+      onDragLeave={onWorkspaceDragLeave}
+      onDrop={onWorkspaceDrop}
+    >
       <SidebarHeader onSelectHome={onSelectHome} onAddWorkspace={onAddWorkspace} />
+      <div
+        className={`workspace-drop-overlay${
+          isWorkspaceDropActive ? " is-active" : ""
+        }`}
+        aria-hidden
+      >
+        <div
+          className={`workspace-drop-overlay-text${
+            workspaceDropText === "Adding Project..." ? " is-busy" : ""
+          }`}
+        >
+          {workspaceDropText === "Drop Project Here" && (
+            <FolderOpen className="workspace-drop-overlay-icon" aria-hidden />
+          )}
+          {workspaceDropText}
+        </div>
+      </div>
       <div
         className={`sidebar-body${scrollFade.top ? " fade-top" : ""}${
           scrollFade.bottom ? " fade-bottom" : ""
diff --git a/src/features/app/hooks/useWorkspaceActions.ts b/src/features/app/hooks/useWorkspaceActions.ts
index 0becb5c13..640ca9b07 100644
--- a/src/features/app/hooks/useWorkspaceActions.ts
+++ b/src/features/app/hooks/useWorkspaceActions.ts
@@ -7,6 +7,7 @@ type Params = {
   activeWorkspace: WorkspaceInfo | null;
   isCompact: boolean;
   addWorkspace: () => Promise<WorkspaceInfo | null>;
+  addWorkspaceFromPath: (path: string) => Promise<WorkspaceInfo | null>;
   connectWorkspace: (workspace: WorkspaceInfo) => Promise<void>;
   startThreadForWorkspace: (workspaceId: string) => Promise<string | null>;
   setActiveThreadId: (threadId: string | null, workspaceId: string) => void;
@@ -23,6 +24,7 @@ export function useWorkspaceActions({
   activeWorkspace,
   isCompact,
   addWorkspace,
+  addWorkspaceFromPath,
   connectWorkspace,
   startThreadForWorkspace,
   setActiveThreadId,
@@ -34,14 +36,21 @@ export function useWorkspaceActions({
   composerInputRef,
   onDebug,
 }: Params) {
+  const handleWorkspaceAdded = useCallback(
+    (workspace: WorkspaceInfo) => {
+      setActiveThreadId(null, workspace.id);
+      if (isCompact) {
+        setActiveTab("codex");
+      }
+    },
+    [isCompact, setActiveTab, setActiveThreadId],
+  );
+
   const handleAddWorkspace = useCallback(async () => {
     try {
       const workspace = await addWorkspace();
       if (workspace) {
-        setActiveThreadId(null, workspace.id);
-        if (isCompact) {
-          setActiveTab("codex");
-        }
+        handleWorkspaceAdded(workspace);
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -54,7 +63,29 @@ export function useWorkspaceActions({
       });
       alert(`Failed to add workspace.\n\n${message}`);
     }
-  }, [addWorkspace, isCompact, onDebug, setActiveTab, setActiveThreadId]);
+  }, [addWorkspace, handleWorkspaceAdded, onDebug]);
+
+  const handleAddWorkspaceFromPath = useCallback(
+    async (path: string) => {
+      try {
+        const workspace = await addWorkspaceFromPath(path);
+        if (workspace) {
+          handleWorkspaceAdded(workspace);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        onDebug({
+          id: `${Date.now()}-client-add-workspace-error`,
+          timestamp: Date.now(),
+          source: "error",
+          label: "workspace/add error",
+          payload: message,
+        });
+        alert(`Failed to add workspace.\n\n${message}`);
+      }
+    },
+    [addWorkspaceFromPath, handleWorkspaceAdded, onDebug],
+  );
 
   const handleAddAgent = useCallback(
     async (workspace: WorkspaceInfo) => {
@@ -107,6 +138,7 @@ export function useWorkspaceActions({
 
   return {
     handleAddWorkspace,
+    handleAddWorkspaceFromPath,
     handleAddAgent,
     handleAddWorktreeAgent,
     handleAddCloneAgent,
diff --git a/src/features/composer/components/ComposerInput.attachments.test.tsx b/src/features/composer/components/ComposerInput.attachments.test.tsx
index 8e8f9ea1e..7aa54981c 100644
--- a/src/features/composer/components/ComposerInput.attachments.test.tsx
+++ b/src/features/composer/components/ComposerInput.attachments.test.tsx
@@ -5,10 +5,8 @@ import { describe, expect, it, vi } from "vitest";
 import { useComposerImages } from "../hooks/useComposerImages";
 import { ComposerInput } from "./ComposerInput";
 
-vi.mock("@tauri-apps/api/window", () => ({
-  getCurrentWindow: () => ({
-    onDragDropEvent: vi.fn().mockResolvedValue(() => {}),
-  }),
+vi.mock("../../../services/dragDrop", () => ({
+  subscribeWindowDragDrop: vi.fn(() => () => {}),
 }));
 
 vi.mock("@tauri-apps/api/core", () => ({
diff --git a/src/features/composer/hooks/useComposerImageDrop.test.ts b/src/features/composer/hooks/useComposerImageDrop.test.ts
index 45f7e487d..4f1972721 100644
--- a/src/features/composer/hooks/useComposerImageDrop.test.ts
+++ b/src/features/composer/hooks/useComposerImageDrop.test.ts
@@ -9,18 +9,16 @@ let mockOnDragDropEvent:
       payload: {
         type: "enter" | "over" | "leave" | "drop";
         position: { x: number; y: number };
-        paths: string[];
+        paths?: string[];
       };
     }) => void)
   | null = null;
 
-vi.mock("@tauri-apps/api/window", () => ({
-  getCurrentWindow: () => ({
-    onDragDropEvent: (handler: typeof mockOnDragDropEvent) => {
-      mockOnDragDropEvent = handler;
-      return Promise.resolve(() => {});
-    },
-  }),
+vi.mock("../../../services/dragDrop", () => ({
+  subscribeWindowDragDrop: (handler: typeof mockOnDragDropEvent) => {
+    mockOnDragDropEvent = handler;
+    return () => {};
+  },
 }));
 
 type HookResult = ReturnType<typeof useComposerImageDrop>;
diff --git a/src/features/composer/hooks/useComposerImageDrop.ts b/src/features/composer/hooks/useComposerImageDrop.ts
index 12c1fc371..74a79b999 100644
--- a/src/features/composer/hooks/useComposerImageDrop.ts
+++ b/src/features/composer/hooks/useComposerImageDrop.ts
@@ -1,5 +1,5 @@
 import { useEffect, useRef, useState } from "react";
-import { getCurrentWindow } from "@tauri-apps/api/window";
+import { subscribeWindowDragDrop } from "../../../services/dragDrop";
 
 const imageExtensions = [
   ".png",
@@ -43,6 +43,30 @@ function readFilesAsDataUrls(files: File[]) {
   ).then((items) => items.filter(Boolean));
 }
 
+function getDragPosition(position: { x: number; y: number }) {
+  return position;
+}
+
+function normalizeDragPosition(
+  position: { x: number; y: number },
+  lastClientPosition: { x: number; y: number } | null,
+) {
+  const scale = window.devicePixelRatio || 1;
+  if (scale === 1 || !lastClientPosition) {
+    return getDragPosition(position);
+  }
+  const logicalDistance = Math.hypot(
+    position.x - lastClientPosition.x,
+    position.y - lastClientPosition.y,
+  );
+  const scaled = { x: position.x / scale, y: position.y / scale };
+  const scaledDistance = Math.hypot(
+    scaled.x - lastClientPosition.x,
+    scaled.y - lastClientPosition.y,
+  );
+  return scaledDistance < logicalDistance ? scaled : position;
+}
+
 type UseComposerImageDropArgs = {
   disabled: boolean;
   onAttachImages?: (paths: string[]) => void;
@@ -54,53 +78,49 @@ export function useComposerImageDrop({
 }: UseComposerImageDropArgs) {
   const [isDragOver, setIsDragOver] = useState(false);
   const dropTargetRef = useRef<HTMLDivElement | null>(null);
+  const lastClientPositionRef = useRef<{ x: number; y: number } | null>(null);
 
   useEffect(() => {
     let unlisten: (() => void) | null = null;
-    const register = async () => {
-      try {
-        const appWindow = getCurrentWindow();
-        unlisten = await appWindow.onDragDropEvent((event) => {
-          if (disabled || !dropTargetRef.current) {
-            return;
-          }
-          if (event.payload.type === "leave") {
-            setIsDragOver(false);
-            return;
-          }
-          const position = event.payload.position;
-          const scale = window.devicePixelRatio || 1;
-          const x = position.x / scale;
-          const y = position.y / scale;
-          const rect = dropTargetRef.current.getBoundingClientRect();
-          const isInside =
-            x >= rect.left &&
-            x <= rect.right &&
-            y >= rect.top &&
-            y <= rect.bottom;
-          if (event.payload.type === "over" || event.payload.type === "enter") {
-            setIsDragOver(isInside);
-            return;
-          }
-          if (event.payload.type === "drop") {
-            setIsDragOver(false);
-            if (!isInside) {
-              return;
-            }
-            const imagePaths = event.payload.paths
-              .map((path) => path.trim())
-              .filter(Boolean)
-              .filter(isImagePath);
-            if (imagePaths.length > 0) {
-              onAttachImages?.(imagePaths);
-            }
-          }
-        });
-      } catch {
-        unlisten = null;
+    if (disabled) {
+      return undefined;
+    }
+    unlisten = subscribeWindowDragDrop((event) => {
+      if (!dropTargetRef.current) {
+        return;
       }
-    };
-    void register();
+      if (event.payload.type === "leave") {
+        setIsDragOver(false);
+        return;
+      }
+      const position = normalizeDragPosition(
+        event.payload.position,
+        lastClientPositionRef.current,
+      );
+      const rect = dropTargetRef.current.getBoundingClientRect();
+      const isInside =
+        position.x >= rect.left &&
+        position.x <= rect.right &&
+        position.y >= rect.top &&
+        position.y <= rect.bottom;
+      if (event.payload.type === "over" || event.payload.type === "enter") {
+        setIsDragOver(isInside);
+        return;
+      }
+      if (event.payload.type === "drop") {
+        setIsDragOver(false);
+        if (!isInside) {
+          return;
+        }
+        const imagePaths = (event.payload.paths ?? [])
+          .map((path) => path.trim())
+          .filter(Boolean)
+          .filter(isImagePath);
+        if (imagePaths.length > 0) {
+          onAttachImages?.(imagePaths);
+        }
+      }
+    });
     return () => {
       if (unlisten) {
         unlisten();
@@ -113,6 +133,7 @@ export function useComposerImageDrop({
       return;
     }
     if (isDragFileTransfer(event.dataTransfer?.types)) {
+      lastClientPositionRef.current = { x: event.clientX, y: event.clientY };
       event.preventDefault();
       setIsDragOver(true);
     }
@@ -125,6 +146,7 @@ export function useComposerImageDrop({
   const handleDragLeave = () => {
     if (isDragOver) {
       setIsDragOver(false);
+      lastClientPositionRef.current = null;
     }
   };
 
@@ -134,6 +156,7 @@ export function useComposerImageDrop({
     }
     event.preventDefault();
     setIsDragOver(false);
+    lastClientPositionRef.current = null;
     const files = Array.from(event.dataTransfer?.files ?? []);
     const items = Array.from(event.dataTransfer?.items ?? []);
     const itemFiles = items
diff --git a/src/features/layout/hooks/useLayoutNodes.tsx b/src/features/layout/hooks/useLayoutNodes.tsx
index 9ecfef47c..b60d7686d 100644
--- a/src/features/layout/hooks/useLayoutNodes.tsx
+++ b/src/features/layout/hooks/useLayoutNodes.tsx
@@ -1,4 +1,4 @@
-import type { MouseEvent, ReactNode, RefObject } from "react";
+import type { DragEvent, MouseEvent, ReactNode, RefObject } from "react";
 import ArrowLeft from "lucide-react/dist/esm/icons/arrow-left";
 import { Sidebar } from "../../app/components/Sidebar";
 import { Home } from "../../home/components/Home";
@@ -131,6 +131,13 @@ type LayoutNodesOptions = {
   onDeleteWorktree: (workspaceId: string) => void;
   onLoadOlderThreads: (workspaceId: string) => void;
   onReloadWorkspaceThreads: (workspaceId: string) => void;
+  workspaceDropTargetRef: RefObject<HTMLElement | null>;
+  isWorkspaceDropActive: boolean;
+  workspaceDropText: string;
+  onWorkspaceDragOver: (event: DragEvent<HTMLElement>) => void;
+  onWorkspaceDragEnter: (event: DragEvent<HTMLElement>) => void;
+  onWorkspaceDragLeave: (event: DragEvent<HTMLElement>) => void;
+  onWorkspaceDrop: (event: DragEvent<HTMLElement>) => void;
   updaterState: UpdateState;
   onUpdate: () => void;
   onDismissUpdate: () => void;
@@ -411,6 +418,13 @@ export function useLayoutNodes(options: LayoutNodesOptions): LayoutNodesResult {
       onDeleteWorktree={options.onDeleteWorktree}
       onLoadOlderThreads={options.onLoadOlderThreads}
       onReloadWorkspaceThreads={options.onReloadWorkspaceThreads}
+      workspaceDropTargetRef={options.workspaceDropTargetRef}
+      isWorkspaceDropActive={options.isWorkspaceDropActive}
+      workspaceDropText={options.workspaceDropText}
+      onWorkspaceDragOver={options.onWorkspaceDragOver}
+      onWorkspaceDragEnter={options.onWorkspaceDragEnter}
+      onWorkspaceDragLeave={options.onWorkspaceDragLeave}
+      onWorkspaceDrop={options.onWorkspaceDrop}
     />
   );
 
diff --git a/src/features/threads/hooks/useThreads.ts b/src/features/threads/hooks/useThreads.ts
index 462842952..3f36452ff 100644
--- a/src/features/threads/hooks/useThreads.ts
+++ b/src/features/threads/hooks/useThreads.ts
@@ -1002,6 +1002,7 @@ export function useThreads({
       getCustomName,
       handleWorkspaceConnected,
       handleItemUpdate,
+      handleTerminalInteraction,
       handleToolOutputDelta,
       handleTerminalInteraction,
       markProcessing,
diff --git a/src/features/workspaces/hooks/useWorkspaceDropZone.test.ts b/src/features/workspaces/hooks/useWorkspaceDropZone.test.ts
new file mode 100644
index 000000000..87c277baa
--- /dev/null
+++ b/src/features/workspaces/hooks/useWorkspaceDropZone.test.ts
@@ -0,0 +1,111 @@
+/** @vitest-environment jsdom */
+import React, { act } from "react";
+import { createRoot } from "react-dom/client";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { useWorkspaceDropZone } from "./useWorkspaceDropZone";
+
+let mockOnDragDropEvent:
+  | ((event: {
+      payload: {
+        type: "enter" | "over" | "leave" | "drop";
+        position: { x: number; y: number };
+        paths?: string[];
+      };
+    }) => void)
+  | null = null;
+
+vi.mock("../../../services/dragDrop", () => ({
+  subscribeWindowDragDrop: (handler: typeof mockOnDragDropEvent) => {
+    mockOnDragDropEvent = handler;
+    return () => {};
+  },
+}));
+
+type HookResult = ReturnType<typeof useWorkspaceDropZone>;
+
+type RenderedHook = {
+  result: HookResult;
+  unmount: () => void;
+};
+
+function renderDropHook(options: {
+  disabled?: boolean;
+  onDropPaths: (paths: string[]) => void | Promise<void>;
+}): RenderedHook {
+  let result: HookResult | undefined;
+
+  function Test() {
+    result = useWorkspaceDropZone(options);
+    return null;
+  }
+
+  const container = document.createElement("div");
+  document.body.appendChild(container);
+  const root = createRoot(container);
+
+  act(() => {
+    root.render(React.createElement(Test));
+  });
+
+  return {
+    get result() {
+      if (!result) {
+        throw new Error("Hook not rendered");
+      }
+      return result;
+    },
+    unmount: () => {
+      act(() => {
+        root.unmount();
+      });
+      container.remove();
+    },
+  };
+}
+
+describe("useWorkspaceDropZone", () => {
+  beforeEach(() => {
+    mockOnDragDropEvent = null;
+  });
+
+  it("tracks drag over state for file transfers", () => {
+    const hook = renderDropHook({ onDropPaths: () => {} });
+    const preventDefault = vi.fn();
+
+    act(() => {
+      hook.result.handleDragOver({
+        dataTransfer: { types: ["Files"], items: [] },
+        preventDefault,
+      } as unknown as React.DragEvent<HTMLElement>);
+    });
+
+    expect(preventDefault).toHaveBeenCalled();
+    expect(hook.result.isDragOver).toBe(true);
+
+    act(() => {
+      hook.result.handleDragLeave({} as React.DragEvent<HTMLElement>);
+    });
+
+    expect(hook.result.isDragOver).toBe(false);
+
+    hook.unmount();
+  });
+
+  it("emits file paths on drop when available", () => {
+    const onDropPaths = vi.fn();
+    const hook = renderDropHook({ onDropPaths });
+    const file = new File(["data"], "project", { type: "application/octet-stream" });
+    (file as File & { path?: string }).path = "/tmp/project";
+
+    act(() => {
+      hook.result.handleDrop({
+        dataTransfer: { files: [file], items: [] },
+        preventDefault: () => {},
+      } as unknown as React.DragEvent<HTMLElement>);
+    });
+
+    expect(onDropPaths).toHaveBeenCalledWith(["/tmp/project"]);
+
+    hook.unmount();
+  });
+});
diff --git a/src/features/workspaces/hooks/useWorkspaceDropZone.ts b/src/features/workspaces/hooks/useWorkspaceDropZone.ts
new file mode 100644
index 000000000..155cc82ac
--- /dev/null
+++ b/src/features/workspaces/hooks/useWorkspaceDropZone.ts
@@ -0,0 +1,208 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import type { DragEvent } from "react";
+import { subscribeWindowDragDrop } from "../../../services/dragDrop";
+
+function isDragFileTransfer(types: readonly string[] | undefined) {
+  if (!types || types.length === 0) {
+    return false;
+  }
+  return (
+    types.includes("Files") ||
+    types.includes("public.file-url") ||
+    types.includes("application/x-moz-file")
+  );
+}
+
+function getDragPosition(position: { x: number; y: number }) {
+  return position;
+}
+
+function normalizeDragPosition(
+  position: { x: number; y: number },
+  lastClientPosition: { x: number; y: number } | null,
+) {
+  const scale = window.devicePixelRatio || 1;
+  if (scale === 1 || !lastClientPosition) {
+    return getDragPosition(position);
+  }
+  const logicalDistance = Math.hypot(
+    position.x - lastClientPosition.x,
+    position.y - lastClientPosition.y,
+  );
+  const scaled = { x: position.x / scale, y: position.y / scale };
+  const scaledDistance = Math.hypot(
+    scaled.x - lastClientPosition.x,
+    scaled.y - lastClientPosition.y,
+  );
+  return scaledDistance < logicalDistance ? scaled : position;
+}
+
+type DropPathsHandler = (paths: string[]) => void | Promise<void>;
+
+type UseWorkspaceDropZoneArgs = {
+  disabled?: boolean;
+  onDropPaths: DropPathsHandler;
+};
+
+export function useWorkspaceDropZone({
+  disabled = false,
+  onDropPaths,
+}: UseWorkspaceDropZoneArgs) {
+  const [isDragOver, setIsDragOver] = useState(false);
+  const dropTargetRef = useRef<HTMLElement | null>(null);
+  const dragDepthRef = useRef(0);
+  const lastClientPositionRef = useRef<{ x: number; y: number } | null>(null);
+  const lastDropRef = useRef<{
+    at: number;
+    paths: string[];
+  } | null>(null);
+
+  const emitPaths = useCallback(
+    (paths: string[]) => {
+      if (paths.length === 0) {
+        return;
+      }
+      const now = Date.now();
+      const previous = lastDropRef.current;
+      if (
+        previous &&
+        now - previous.at < 750 &&
+        previous.paths.length === paths.length &&
+        previous.paths.every((value, index) => value === paths[index])
+      ) {
+        return;
+      }
+      lastDropRef.current = { at: now, paths };
+      try {
+        const result = onDropPaths(paths);
+        void Promise.resolve(result).catch((error) => {
+          console.error("Failed to handle workspace drop paths", error);
+        });
+      } catch (error) {
+        console.error("Failed to handle workspace drop paths", error);
+      }
+    },
+    [onDropPaths],
+  );
+
+  useEffect(() => {
+    let unlisten: (() => void) | null = null;
+    if (disabled) {
+      return undefined;
+    }
+    unlisten = subscribeWindowDragDrop((event) => {
+      if (!dropTargetRef.current) {
+        return;
+      }
+      const payload = event.payload;
+      if (payload.type === "leave") {
+        setIsDragOver(false);
+        return;
+      }
+      if (payload.type === "over" || payload.type === "enter") {
+        const position = normalizeDragPosition(
+          payload.position,
+          lastClientPositionRef.current,
+        );
+        const rect = dropTargetRef.current.getBoundingClientRect();
+        const isInside =
+          position.x >= rect.left &&
+          position.x <= rect.right &&
+          position.y >= rect.top &&
+          position.y <= rect.bottom;
+        setIsDragOver(isInside);
+        return;
+      }
+      if (payload.type === "drop") {
+        setIsDragOver(false);
+        const position = normalizeDragPosition(
+          payload.position,
+          lastClientPositionRef.current,
+        );
+        const rect = dropTargetRef.current.getBoundingClientRect();
+        const isInside =
+          position.x >= rect.left &&
+          position.x <= rect.right &&
+          position.y >= rect.top &&
+          position.y <= rect.bottom;
+        if (!isInside) {
+          return;
+        }
+        const paths = (payload.paths ?? [])
+          .map((path) => path.trim())
+          .filter(Boolean);
+        emitPaths(paths);
+      }
+    });
+    return () => {
+      if (unlisten) {
+        unlisten();
+      }
+    };
+  }, [disabled, emitPaths]);
+
+  const handleDragOver = (event: DragEvent<HTMLElement>) => {
+    if (disabled) {
+      return;
+    }
+    if (isDragFileTransfer(event.dataTransfer?.types)) {
+      lastClientPositionRef.current = { x: event.clientX, y: event.clientY };
+      event.preventDefault();
+      setIsDragOver(true);
+    }
+  };
+
+  const handleDragEnter = (event: DragEvent<HTMLElement>) => {
+    if (disabled) {
+      return;
+    }
+    dragDepthRef.current += 1;
+    handleDragOver(event);
+  };
+
+  const handleDragLeave = (event: DragEvent<HTMLElement>) => {
+    if (disabled) {
+      return;
+    }
+    const relatedTarget = event.relatedTarget as Node | null;
+    if (relatedTarget && event.currentTarget.contains(relatedTarget)) {
+      return;
+    }
+    dragDepthRef.current = Math.max(0, dragDepthRef.current - 1);
+    if (dragDepthRef.current === 0 && isDragOver) {
+      setIsDragOver(false);
+      lastClientPositionRef.current = null;
+    }
+  };
+
+  const handleDrop = (event: DragEvent<HTMLElement>) => {
+    if (disabled) {
+      return;
+    }
+    dragDepthRef.current = 0;
+    if (isDragFileTransfer(event.dataTransfer?.types)) {
+      event.preventDefault();
+    }
+    setIsDragOver(false);
+    lastClientPositionRef.current = null;
+    const files = Array.from(event.dataTransfer?.files ?? []);
+    const items = Array.from(event.dataTransfer?.items ?? []);
+    const itemFiles = items
+      .filter((item) => item.kind === "file")
+      .map((item) => item.getAsFile())
+      .filter((file): file is File => Boolean(file));
+    const paths = [...files, ...itemFiles]
+      .map((file) => (file as File & { path?: string }).path ?? "")
+      .filter(Boolean);
+    emitPaths(paths);
+  };
+
+  return {
+    dropTargetRef,
+    isDragOver,
+    handleDragOver,
+    handleDragEnter,
+    handleDragLeave,
+    handleDrop,
+  };
+}
diff --git a/src/features/workspaces/hooks/useWorkspaces.test.tsx b/src/features/workspaces/hooks/useWorkspaces.test.tsx
index fb785cf43..87a0f9792 100644
--- a/src/features/workspaces/hooks/useWorkspaces.test.tsx
+++ b/src/features/workspaces/hooks/useWorkspaces.test.tsx
@@ -3,6 +3,7 @@ import { act, renderHook } from "@testing-library/react";
 import { describe, expect, it, vi } from "vitest";
 import type { WorkspaceInfo } from "../../../types";
 import {
+  addWorkspace,
   listWorkspaces,
   renameWorktree,
   renameWorktreeUpstream,
@@ -17,6 +18,7 @@ vi.mock("../../../services/tauri", () => ({
   addWorkspace: vi.fn(),
   addWorktree: vi.fn(),
   connectWorkspace: vi.fn(),
+  isWorkspacePathDir: vi.fn(),
   pickWorkspacePath: vi.fn(),
   removeWorkspace: vi.fn(),
   removeWorktree: vi.fn(),
@@ -147,3 +149,35 @@ describe("useWorkspaces.renameWorktree", () => {
     );
   });
 });
+
+describe("useWorkspaces.addWorkspaceFromPath", () => {
+  it("adds a workspace and sets it active", async () => {
+    const listWorkspacesMock = vi.mocked(listWorkspaces);
+    const addWorkspaceMock = vi.mocked(addWorkspace);
+    listWorkspacesMock.mockResolvedValue([]);
+    addWorkspaceMock.mockResolvedValue({
+      id: "workspace-1",
+      name: "repo",
+      path: "/tmp/repo",
+      connected: true,
+      kind: "main",
+      parentId: null,
+      worktree: null,
+      settings: { sidebarCollapsed: false },
+    });
+
+    const { result } = renderHook(() => useWorkspaces());
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    await act(async () => {
+      await result.current.addWorkspaceFromPath("/tmp/repo");
+    });
+
+    expect(addWorkspaceMock).toHaveBeenCalledWith("/tmp/repo", null);
+    expect(result.current.workspaces).toHaveLength(1);
+    expect(result.current.activeWorkspaceId).toBe("workspace-1");
+  });
+});
diff --git a/src/features/workspaces/hooks/useWorkspaces.ts b/src/features/workspaces/hooks/useWorkspaces.ts
index 207d691c9..418b7dd29 100644
--- a/src/features/workspaces/hooks/useWorkspaces.ts
+++ b/src/features/workspaces/hooks/useWorkspaces.ts
@@ -12,6 +12,7 @@ import {
   addWorkspace as addWorkspaceService,
   addWorktree as addWorktreeService,
   connectWorkspace as connectWorkspaceService,
+  isWorkspacePathDir as isWorkspacePathDirService,
   listWorkspaces,
   pickWorkspacePath,
   removeWorkspace as removeWorkspaceService,
@@ -208,34 +209,59 @@ export function useWorkspaces(options: UseWorkspacesOptions = {}) {
     [getWorkspaceGroupId, workspaceById, workspaceGroupById],
   );
 
-  async function addWorkspace() {
+  const addWorkspaceFromPath = useCallback(
+    async (path: string) => {
+      const selection = path.trim();
+      if (!selection) {
+        return null;
+      }
+      onDebug?.({
+        id: `${Date.now()}-client-add-workspace`,
+        timestamp: Date.now(),
+        source: "client",
+        label: "workspace/add",
+        payload: { path: selection },
+      });
+      try {
+        const workspace = await addWorkspaceService(selection, defaultCodexBin ?? null);
+        setWorkspaces((prev) => [...prev, workspace]);
+        setActiveWorkspaceId(workspace.id);
+        return workspace;
+      } catch (error) {
+        onDebug?.({
+          id: `${Date.now()}-client-add-workspace-error`,
+          timestamp: Date.now(),
+          source: "error",
+          label: "workspace/add error",
+          payload: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+      }
+    },
+    [defaultCodexBin, onDebug],
+  );
+
+  const addWorkspace = useCallback(async () => {
     const selection = await pickWorkspacePath();
     if (!selection) {
       return null;
     }
-    onDebug?.({
-      id: `${Date.now()}-client-add-workspace`,
-      timestamp: Date.now(),
-      source: "client",
-      label: "workspace/add",
-      payload: { path: selection },
-    });
-    try {
-      const workspace = await addWorkspaceService(selection, defaultCodexBin ?? null);
-      setWorkspaces((prev) => [...prev, workspace]);
-      setActiveWorkspaceId(workspace.id);
-      return workspace;
-    } catch (error) {
-      onDebug?.({
-        id: `${Date.now()}-client-add-workspace-error`,
-        timestamp: Date.now(),
-        source: "error",
-        label: "workspace/add error",
-        payload: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
+    return addWorkspaceFromPath(selection);
+  }, [addWorkspaceFromPath]);
+
+  const filterWorkspacePaths = useCallback(async (paths: string[]) => {
+    const trimmed = paths.map((path) => path.trim()).filter(Boolean);
+    if (trimmed.length === 0) {
+      return [];
     }
-  }
+    const checks = await Promise.all(
+      trimmed.map(async (path) => ({
+        path,
+        isDir: await isWorkspacePathDirService(path),
+      })),
+    );
+    return checks.filter((entry) => entry.isDir).map((entry) => entry.path);
+  }, []);
 
   async function addWorktreeAgent(parent: WorkspaceInfo, branch: string) {
     const trimmed = branch.trim();
@@ -778,6 +804,8 @@ export function useWorkspaces(options: UseWorkspacesOptions = {}) {
     activeWorkspaceId,
     setActiveWorkspaceId,
     addWorkspace,
+    addWorkspaceFromPath,
+    filterWorkspacePaths,
     addCloneAgent,
     addWorktreeAgent,
     connectWorkspace,
diff --git a/src/services/dragDrop.ts b/src/services/dragDrop.ts
new file mode 100644
index 000000000..7c17b68d4
--- /dev/null
+++ b/src/services/dragDrop.ts
@@ -0,0 +1,76 @@
+import { getCurrentWindow } from "@tauri-apps/api/window";
+
+export type DragDropPayload = {
+  type: "enter" | "over" | "leave" | "drop";
+  position: { x: number; y: number };
+  paths?: string[];
+};
+
+export type DragDropEvent = {
+  payload: DragDropPayload;
+};
+
+type Listener = (event: DragDropEvent) => void;
+
+type SubscriptionOptions = {
+  onError?: (error: unknown) => void;
+};
+
+let unlisten: (() => void) | null = null;
+let listenPromise: Promise<() => void> | null = null;
+const listeners = new Set<Listener>();
+
+function start(options?: SubscriptionOptions) {
+  if (unlisten || listenPromise) {
+    return;
+  }
+  listenPromise = getCurrentWindow()
+    .onDragDropEvent((event) => {
+      for (const listener of listeners) {
+        try {
+          listener(event as DragDropEvent);
+        } catch (error) {
+          console.error("[drag-drop] listener failed", error);
+        }
+      }
+    }) as Promise<() => void>;
+  listenPromise
+    .then((handler) => {
+      listenPromise = null;
+      if (listeners.size === 0) {
+        handler();
+        return;
+      }
+      unlisten = handler;
+    })
+    .catch((error) => {
+      listenPromise = null;
+      options?.onError?.(error);
+    });
+}
+
+function stop() {
+  if (!unlisten) {
+    return;
+  }
+  try {
+    unlisten();
+  } catch {
+    // Ignore double-unlisten when tearing down.
+  }
+  unlisten = null;
+}
+
+export function subscribeWindowDragDrop(
+  onEvent: Listener,
+  options?: SubscriptionOptions,
+) {
+  listeners.add(onEvent);
+  start(options);
+  return () => {
+    listeners.delete(onEvent);
+    if (listeners.size === 0) {
+      stop();
+    }
+  };
+}
diff --git a/src/services/tauri.ts b/src/services/tauri.ts
index e2893eaa3..97c55eaeb 100644
--- a/src/services/tauri.ts
+++ b/src/services/tauri.ts
@@ -56,6 +56,10 @@ export async function addWorkspace(
   return invoke<WorkspaceInfo>("add_workspace", { path, codex_bin });
 }
 
+export async function isWorkspacePathDir(path: string): Promise<boolean> {
+  return invoke<boolean>("is_workspace_path_dir", { path });
+}
+
 export async function addClone(
   sourceWorkspaceId: string,
   copiesFolder: string,
diff --git a/src/styles/sidebar.css b/src/styles/sidebar.css
index 3c6fa197f..708cfb8d7 100644
--- a/src/styles/sidebar.css
+++ b/src/styles/sidebar.css
@@ -14,6 +14,63 @@
   transition: opacity 200ms ease, transform 200ms ease;
 }
 
+.workspace-drop-overlay {
+  position: absolute;
+  inset: 0;
+  z-index: 8;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: rgba(10, 12, 16, 0.4);
+  backdrop-filter: blur(10px);
+  opacity: 0;
+  pointer-events: none;
+  transition: opacity 0.2s ease;
+}
+
+.workspace-drop-overlay.is-active {
+  opacity: 1;
+}
+
+.workspace-drop-overlay-text {
+  font-size: 16px;
+  font-weight: 600;
+  letter-spacing: 0.02em;
+  color: var(--text-strong);
+  display: inline-flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.workspace-drop-overlay-icon {
+  width: 18px;
+  height: 18px;
+  opacity: 0.8;
+}
+
+.workspace-drop-overlay-text.is-busy {
+  color: transparent;
+  background: linear-gradient(
+    90deg,
+    rgba(255, 255, 255, 0.25),
+    rgba(255, 255, 255, 0.85),
+    rgba(255, 255, 255, 0.25)
+  );
+  background-size: 200% 100%;
+  background-clip: text;
+  -webkit-background-clip: text;
+  animation: drop-text-shimmer 1.2s ease-in-out infinite;
+}
+
+@keyframes drop-text-shimmer {
+  0% {
+    background-position: 200% 0;
+  }
+  100% {
+    background-position: -200% 0;
+  }
+}
+
 .sidebar-header {
   display: flex;
   justify-content: space-between;