@hienlh/ppm 0.17.57 → 0.18.1

package/src/services/host-info/pinned-windows-quick-access.ts

@@ -0,0 +1,87 @@
+/** Windows Quick Access pinned folders via the Shell COM `Namespace`
+ *  (`shell:::{679f85cb-...}`), verified live: ~150ms enumeration, and
+ *  `System.Home.IsPinned` reliably separates pinned entries from "frequent"
+ *  ones. Shell COM reports `.zip`/`.rar` archives as `IsFolder=true`, so
+ *  every candidate is re-checked with a real directory stat before it ships. */
+import * as fsp from "node:fs/promises";
+import type { PinnedFolder } from "../../types/system.ts";
+import { defaultRunner, type Runner } from "./spawn-runner.ts";
+
+export interface QuickAccessDeps {
+  run: Runner;
+  isDirectory: (path: string) => Promise<boolean>;
+}
+
+const defaultDeps: QuickAccessDeps = {
+  run: defaultRunner,
+  isDirectory: async (p) => {
+    try {
+      return (await fsp.stat(p)).isDirectory();
+    } catch {
+      return false;
+    }
+  },
+};
+
+// `@($result)` forces an array even for 0/1 items — ConvertTo-Json unwraps a
+// single-element pipeline input into a bare object otherwise.
+const QUICK_ACCESS_SCRIPT = `
+$items = (New-Object -ComObject Shell.Application).Namespace('shell:::{679f85cb-0220-4080-b29b-5540cc05aab6}').Items()
+$result = foreach ($i in $items) {
+  if ($i.IsFolder) {
+    [PSCustomObject]@{ Name = $i.Name; Path = $i.Path; Pinned = $i.ExtendedProperty('System.Home.IsPinned') }
+  }
+}
+$arr = @($result)
+$json = $arr | ConvertTo-Json -Compress
+if ($arr.Count -le 1) { $json = '[' + $json + ']' }
+Write-Output $json
+`.trim();
+
+interface RawItem {
+  Name?: string;
+  Path?: string;
+  Pinned?: boolean | string | null;
+}
+
+function isPinned(v: RawItem["Pinned"]): boolean {
+  return v === true || v === "True" || v === "true";
+}
+
+/** Read Quick Access pinned folders, appending any failure to the shared `warnings` array (never throws). */
+export async function getWindowsQuickAccessPinned(
+  warnings: string[],
+  overrides: Partial<QuickAccessDeps> = {},
+): Promise<PinnedFolder[]> {
+  const deps: QuickAccessDeps = { ...defaultDeps, ...overrides };
+  try {
+    const res = await deps.run(
+      ["powershell.exe", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", QUICK_ACCESS_SCRIPT],
+      5000,
+    );
+    if (res.timedOut || res.code !== 0) {
+      warnings.push(`pinned: Quick Access ${res.timedOut ? "timed out" : `exited ${res.code}`}`);
+      return [];
+    }
+
+    let raw: RawItem[];
+    try {
+      const parsed = JSON.parse(res.stdout.trim() || "[]");
+      raw = (Array.isArray(parsed) ? parsed : [parsed]).filter((x): x is RawItem => x != null);
+    } catch (e) {
+      warnings.push(`pinned: Quick Access JSON parse failed (${(e as Error)?.message ?? e})`);
+      return [];
+    }
+
+    const pinned: PinnedFolder[] = [];
+    for (const item of raw) {
+      if (!item.Name || !item.Path || !isPinned(item.Pinned)) continue;
+      if (!(await deps.isDirectory(item.Path))) continue; // drops archive-as-folder (.zip/.rar) and stale entries
+      pinned.push({ name: item.Name, path: item.Path, source: "quick-access" });
+    }
+    return pinned;
+  } catch (e) {
+    warnings.push(`pinned: Quick Access failed (${(e as Error)?.message ?? e})`);
+    return [];
+  }
+}

package/src/services/host-info/spawn-runner.ts

@@ -0,0 +1,41 @@
+/** Shared argv-array shell-out for host-info providers. Every provider that
+ *  needs PowerShell/plutil/findmnt/xdg-user-dir injects a `Runner` so unit
+ *  tests never spawn a real process — only `defaultRunner` touches `Bun.spawn`. */
+export interface RunResult {
+  stdout: string;
+  stderr: string;
+  /** Process exit code, or null when killed by the timeout. */
+  code: number | null;
+  timedOut: boolean;
+}
+
+export type Runner = (argv: string[], timeoutMs?: number) => Promise<RunResult>;
+
+const DEFAULT_TIMEOUT_MS = 5000;
+
+/** Real implementation: argv array only (never string-interpolated into a shell), bounded by timeoutMs. */
+export const defaultRunner: Runner = async (argv, timeoutMs = DEFAULT_TIMEOUT_MS) => {
+  const proc = Bun.spawn(argv, { stdout: "pipe", stderr: "pipe", stdin: "ignore", windowsHide: true });
+  let timedOut = false;
+  const killTimer = setTimeout(() => {
+    timedOut = true;
+    try {
+      proc.kill();
+    } catch {
+      // Process already exited between the timer firing and the kill call.
+    }
+  }, timeoutMs);
+
+  try {
+    const [stdout, stderr, code] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ]);
+    return { stdout, stderr, code, timedOut };
+  } catch (e: any) {
+    return { stdout: "", stderr: e?.message ?? String(e), code: null, timedOut };
+  } finally {
+    clearTimeout(killTimer);
+  }
+};

package/src/services/sqlite-types.ts

@@ -0,0 +1,26 @@
+/** Shapes returned by the SQLite viewer service, shared by both of its doors. */
+
+export interface TableInfo {
+  name: string;
+  rowCount: number;
+}
+
+export interface ColumnInfo {
+  cid: number;
+  name: string;
+  type: string;
+  notnull: boolean;
+  pk: boolean;
+  dflt_value: string | null;
+  fk: { table: string; column: string } | null;
+}
+
+export interface QueryResult {
+  columns: string[];
+  rows: Record<string, unknown>[];
+  rowsAffected: number;
+  changeType: "select" | "modify";
+  executionTimeMs: number;
+  /** True when a row cap cut the result short. */
+  truncated?: boolean;
+}

package/src/services/sqlite.service.ts

@@ -1,29 +1,14 @@
 import { Database } from "bun:sqlite";
 import { resolve } from "node:path";
 import { existsSync } from "node:fs";
+import { isPpmDirPath } from "./fs-path-guard.service.ts";
+import { assertNoAttachStatement } from "./fs-ops/sql-statement-guard.ts";
+import { readRows } from "./fs-ops/sql-row-reader.ts";
 
-export interface TableInfo {
-  name: string;
-  rowCount: number;
-}
-
-export interface ColumnInfo {
-  cid: number;
-  name: string;
-  type: string;
-  notnull: boolean;
-  pk: boolean;
-  dflt_value: string | null;
-  fk: { table: string; column: string } | null;
-}
+import type { ColumnInfo, QueryResult, TableInfo } from "./sqlite-types.ts";
 
-export interface QueryResult {
-  columns: string[];
-  rows: Record<string, unknown>[];
-  rowsAffected: number;
-  changeType: "select" | "modify";
-  executionTimeMs: number;
-}
+// Re-exported so existing importers keep using the service as one entry point.
+export type { ColumnInfo, QueryResult, TableInfo };
 
 /** Auto-close idle databases after 5 minutes */
 const IDLE_TIMEOUT_MS = 5 * 60 * 1000;
@@ -36,12 +21,24 @@ interface CachedDb {
 class SqliteService {
   private cache = new Map<string, CachedDb>();
 
-  /** Resolve db path — supports both project-relative and absolute paths */
+  /**
+   * Resolve db path — supports both project-relative and absolute paths.
+   *
+   * Absolute paths are not probed with `existsSync`: they come from the
+   * filesystem door, which can point at a dead network mount and would block
+   * the event loop here. That door stats the file asynchronously before
+   * calling in, and `open()` refuses to create a missing database, so nothing
+   * is silently brought into existence either way.
+   */
   private resolvePath(projectPath: string, dbRelPath: string): string {
     const isAbsolute = /^(\/|[A-Za-z]:[/\\])/.test(dbRelPath);
     const abs = isAbsolute ? dbRelPath : resolve(projectPath, dbRelPath);
     if (!isAbsolute && !abs.startsWith(projectPath)) throw new Error("Access denied: path outside project");
-    if (!existsSync(abs)) throw new Error(`Database not found: ${dbRelPath}`);
+    // The PPM directory holds the config database with provider credentials and
+    // the auth token. Absolute paths are accepted here, so this door has to
+    // refuse it explicitly or a viewer could read the whole secret store.
+    if (isPpmDirPath(resolve(abs))) throw new Error("Access denied: PPM directory is not browsable");
+    if (!isAbsolute && !existsSync(abs)) throw new Error(`Database not found: ${dbRelPath}`);
     return abs;
   }
 
@@ -53,7 +50,11 @@ class SqliteService {
       cached.timer = setTimeout(() => this.close(absPath), IDLE_TIMEOUT_MS);
       return cached.db;
     }
-    const db = new Database(absPath);
+    // `create: false` — a viewer must never bring a database file into
+    // existence, least of all at a path the caller chose. `readwrite` has to
+    // be spelled out alongside it: the two flags are passed straight to
+    // sqlite3_open_v2, which rejects the combination that omits it.
+    const db = new Database(absPath, { readwrite: true, create: false });
     db.exec("PRAGMA journal_mode = WAL");
     // SQLite defaults FK enforcement off per connection, which would let the
     // viewer delete rows other clients reject and leave orphaned children.
@@ -122,8 +123,13 @@ class SqliteService {
     return { columns, rows, total, page, limit };
   }
 
-  /** Execute arbitrary SQL */
-  executeQuery(projectPath: string, dbPath: string, sql: string): QueryResult {
+  /**
+   * Execute arbitrary SQL. `maxRows` caps a SELECT result — a foreign database
+   * opened through the filesystem door can be arbitrarily large, and reading
+   * every row into memory to answer one request is a denial of service.
+   */
+  executeQuery(projectPath: string, dbPath: string, sql: string, maxRows?: number): QueryResult {
+    assertNoAttachStatement(sql);
     const abs = this.resolvePath(projectPath, dbPath);
     const db = this.open(abs);
     const trimmed = sql.trim().toUpperCase();
@@ -132,11 +138,13 @@ class SqliteService {
 
     const start = performance.now();
     if (isSelect) {
-      const stmt = db.query(sql);
-      const rows = stmt.all() as Record<string, unknown>[];
+      const { rows, truncated } = readRows(db.query(sql), maxRows);
       const executionTimeMs = Math.round(performance.now() - start);
       const columns = rows.length > 0 ? Object.keys(rows[0]!) : [];
-      return { columns, rows, rowsAffected: 0, changeType: "select", executionTimeMs };
+      return {
+        columns, rows, rowsAffected: 0, changeType: "select", executionTimeMs,
+        ...(truncated ? { truncated: true } : {}),
+      };
     }
 
     const result = db.run(sql);
@@ -146,6 +154,7 @@ class SqliteService {
 
   /** Execute multi-statement SQL script (no result rows returned) */
   executeScript(projectPath: string, dbPath: string, sql: string): { executionTimeMs: number } {
+    assertNoAttachStatement(sql);
     const abs = this.resolvePath(projectPath, dbPath);
     const db = this.open(abs);
     const start = performance.now();

package/src/services/subagent-transcript-merger.ts

@@ -15,7 +15,7 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import type { ChatEvent } from "../types/api.ts";
+import type { ChatEvent } from "../types/chat.ts";
 import { parseSessionMessage } from "./jsonl-transcript-parser.ts";
 
 /**

package/src/types/system.ts

@@ -0,0 +1,50 @@
+/** Server-side host facts the frontend cannot learn on its own: OS, path
+ *  separator, home dir, drives/volumes, resolved known folders, and the
+ *  user's OS-pinned folders (Windows Quick Access, Finder Favorites,
+ *  GTK/KDE bookmarks). Backs `GET /api/system/host`. */
+export interface HostInfo {
+  platform: "win32" | "darwin" | "linux";
+  sep: "\\" | "/";
+  homedir: string;
+  hostname: string;
+  drives: Drive[];
+  knownFolders: KnownFolder[];
+  pinned: PinnedFolder[];
+  /** Non-fatal provider failures — a failure never becomes a 500, it becomes text here. */
+  warnings: string[];
+}
+
+export type DriveKind = "fixed" | "removable" | "network" | "unknown";
+
+export interface Drive {
+  /** Display label for the mount, e.g. "C:" or "Macintosh HD". */
+  name: string;
+  /** Filesystem path to browse into, e.g. "C:\\" or "/Volumes/External". */
+  path: string;
+  kind: DriveKind;
+  /** Volume label when the OS reports one (Windows CIM `VolumeName`). */
+  label?: string;
+}
+
+export type KnownFolderKey =
+  | "desktop"
+  | "documents"
+  | "downloads"
+  | "pictures"
+  | "music"
+  | "videos"
+  | "icloud";
+
+export interface KnownFolder {
+  key: KnownFolderKey;
+  name: string;
+  path: string;
+}
+
+export type PinnedSource = "quick-access" | "finder-favorites" | "gtk" | "kde";
+
+export interface PinnedFolder {
+  name: string;
+  path: string;
+  source: PinnedSource;
+}

package/src/web/app.tsx

@@ -1,10 +1,11 @@
-import { useEffect, useState, useCallback, useRef } from "react";
+import { useEffect, useState, useCallback, useRef, lazy, Suspense } from "react";
 import { Toaster } from "@/components/ui/sonner";
 import { TooltipProvider } from "@/components/ui/tooltip";
 import { PanelLayout } from "@/components/layout/panel-layout";
 import { TabPool } from "@/components/layout/tab-pool";
 import { Sidebar } from "@/components/layout/sidebar";
 import { StatusBar } from "@/components/layout/status-bar";
+import { WindowLayer } from "@/components/floating-window/window-layer";
 import { MobileNav } from "@/components/layout/mobile-nav";
 import { MobileDrawer } from "@/components/layout/mobile-drawer";
 import { ProjectBottomSheet } from "@/components/layout/project-bottom-sheet";
@@ -36,6 +37,13 @@ import { useExtensionWs } from "@/hooks/use-extension-ws";
 import { useIsMobile } from "@/hooks/use-is-mobile";
 import { cn } from "@/lib/utils";
 
+// Lazy: the explorer feature (views, actions, skins, icon map) is the same heavy bundle the
+// desktop floating window already keeps out of the initial chunk (see `WINDOW_CONTENT`) —
+// a static import here would pull all of it into every user's boot, mobile or not.
+const MobileExplorerSheet = lazy(() =>
+  import("@/components/os-explorer/mobile/mobile-explorer-sheet").then((m) => ({ default: m.MobileExplorerSheet })),
+);
+
 type AuthState = "checking" | "authenticated" | "unauthenticated";
 
 export function App() {
@@ -284,8 +292,9 @@ export function App() {
           {/* Desktop unified nav rail (wordmark + project switcher + section rail + panel) */}
           <Sidebar />
 
-          {/* Content area — keep-alive per project */}
-          <div className="flex-1 flex flex-col overflow-hidden">
+          {/* Content area — keep-alive per project. `relative` is the positioning context
+              the floating window layer measures and clamps its windows against. */}
+          <div className="relative flex-1 flex flex-col overflow-hidden">
             {[...mountedProjects].map((projectName) => (
               <div
                 key={projectName}
@@ -303,6 +312,8 @@ export function App() {
             {/* Desktop status bar — spans the working area only (not under the sidebar).
                 Self-gated to desktop via `hidden md:flex`. */}
             <StatusBar />
+            {/* Floating windows — desktop only, self-gated; covers the working area. */}
+            <WindowLayer />
           </div>
         </div>
 
@@ -331,6 +342,11 @@ export function App() {
         {/* Compare Files picker (Mod+Alt+D, palette, context menus) — singleton */}
         <ComparePicker />
 
+        {/* Mobile full-screen file explorer sheet — lazy + self-gated, loads nothing until opened */}
+        <Suspense fallback={null}>
+          <MobileExplorerSheet />
+        </Suspense>
+
         {/* Global bug report popup */}
         <BugReportPopup />
 

package/src/web/components/editor/code-editor.tsx

@@ -19,6 +19,9 @@ import { useConnections, type Connection } from "../database/use-connections";
 import { GlideDataGrid } from "../database/glide-data-grid";
 import type { GridColumnSchema } from "../database/glide-grid-types";
 import type { DbQueryResult } from "../database/use-database";
+// Single source of truth: the explorer decides whether a double-click can open a file at
+// all from these very sets, so they must not be redeclared here.
+import { AUDIO_EXTS, IMAGE_EXTS, SQLITE_EXTS, VIDEO_EXTS } from "@/components/os-explorer/can-open-in-ppm";
 
 const MarkdownRenderer = lazy(() =>
   import("@/components/shared/markdown-renderer").then((m) => ({ default: m.MarkdownRenderer }))
@@ -30,15 +33,6 @@ const VideoPreview = lazy(() => import("./video-preview").then((m) => ({ default
 const AudioPreview = lazy(() => import("./audio-preview").then((m) => ({ default: m.AudioPreview })));
 const DocxPreview = lazy(() => import("./docx-preview").then((m) => ({ default: m.DocxPreview })));
 
-/** Image extensions renderable inline */
-const IMAGE_EXTS = new Set(["png", "jpg", "jpeg", "gif", "webp", "svg", "ico"]);
-/** Video extensions playable inline */
-const VIDEO_EXTS = new Set(["mp4", "webm", "mov", "ogg", "avi", "mkv"]);
-/** Audio extensions playable inline */
-const AUDIO_EXTS = new Set(["mp3", "wav", "flac", "aac", "m4a", "wma"]);
-/** SQLite extensions — redirect to sqlite viewer */
-const SQLITE_EXTS = new Set(["db", "sqlite", "sqlite3"]);
-
 function getFileExt(filename: string): string {
   return filename.split(".").pop()?.toLowerCase() ?? "";
 }

package/src/web/components/explorer/file-tree.tsx

@@ -16,7 +16,10 @@ import {
 import { SidebarHeader } from "@/components/ui/sidebar-header";
 import { copyToClipboard } from "@/lib/clipboard";
 import { useShallow } from "zustand/react/shallow";
-import { useFileStore, loadPersistedExpanded, savePersistedExpanded, type FileNode } from "@/stores/file-store";
+import {
+  useFileStore, loadPersistedExpanded, savePersistedExpanded,
+  absoluteProjectPath, relativeProjectPath, type FileNode,
+} from "@/stores/file-store";
 import { useProjectStore } from "@/stores/project-store";
 import { useTabStore } from "@/stores/tab-store";
 import { useCompareStore } from "@/stores/compare-store";
@@ -37,12 +40,23 @@ import { InlineTreeInput } from "./inline-tree-input";
 import { flattenVisibleTree, type InputRow } from "./flatten-visible-tree";
 import { downloadFile, downloadFolder } from "@/lib/file-download";
 import { api, projectUrl } from "@/lib/api-client";
+import { openExplorer } from "@/components/os-explorer/open-explorer";
+import { fsChanged, onFsChanged } from "@/components/os-explorer/explorer-store";
+import { dirnameOf } from "@/components/os-explorer/format-file-meta";
+import { useDragAutoScroll } from "@/components/os-explorer/dnd/use-drag-auto-scroll";
+import { useDropTransfer } from "@/components/os-explorer/dnd/use-drop-transfer";
+import { usePathDropTarget } from "@/components/os-explorer/dnd/use-path-drop-target";
 import { useFileUploadDrag } from "./use-file-upload-drag";
 import { useTreeKeyboardNav } from "./use-tree-keyboard-nav";
 
 /** Synthetic root node for creating files/folders at project root */
 const ROOT_NODE: FileNode = { name: "", path: "", type: "directory" };
 
+/** Parent directory of a project-relative path; "" is the project root. */
+function parentDirOfRelative(path: string): string {
+  return path.includes("/") ? path.slice(0, path.lastIndexOf("/")) : "";
+}
+
 interface FileTreeProps {
   onFileOpen?: () => void;
 }
@@ -116,26 +130,58 @@ export function FileTree({ onFileOpen }: FileTreeProps = {}) {
     setFocusedPath(filePath);
   }, [activeProject, setExpanded, loadChildren, setFocusedPath]);
 
-  /** Paste clipboard files into a target directory */
+  /**
+   * Paste clipboard entries into a target directory.
+   *
+   * The clipboard holds absolute paths and may have been filled by an explorer window, so
+   * the source decides the route: entries that live inside this project keep the
+   * project-scoped endpoints (relative paths, gitignore-aware), anything else goes through
+   * the host filesystem API with a fully-composed destination.
+   */
   const pasteFiles = useCallback(async (targetDir: string) => {
     if (!activeProject || !clipboard) return;
     const projectName = activeProject.name;
+    const root = activeProject.path;
+    // Every source path is an absolute host path (the clipboard is shared with explorer
+    // windows), so the host separator implied by the project root also splits them correctly.
+    const sep = root.includes("\\") ? "\\" : "/";
     const endpoint = clipboard.operation === "cut" ? "move" : "copy";
+    const touched = new Set<string>([absoluteProjectPath(root, targetDir)]);
     for (const source of clipboard.paths) {
-      const name = source.includes("/") ? source.slice(source.lastIndexOf("/") + 1) : source;
-      const destination = targetDir ? `${targetDir}/${name}` : name;
+      const name = source.split(/[/\\]/).filter(Boolean).pop() ?? source;
+      const relativeSource = relativeProjectPath(root, source);
+      touched.add(dirnameOf(source, sep));
       try {
-        await api.post(`${projectUrl(projectName)}/files/${endpoint}`, { source, destination });
+        if (relativeSource != null) {
+          const destination = targetDir ? `${targetDir}/${name}` : name;
+          await api.post(`${projectUrl(projectName)}/files/${endpoint}`, { source: relativeSource, destination });
+        } else {
+          const destination = absoluteProjectPath(root, targetDir ? `${targetDir}/${name}` : name);
+          await api.post(`/api/fs/${endpoint}`, { source, destination });
+        }
       } catch (err) {
         toast.error(err instanceof Error ? err.message : `Failed to ${endpoint}`);
       }
     }
     if (clipboard.operation === "cut") setClipboard(null);
+    // Any explorer window showing the source or destination directory must refresh too.
+    fsChanged(...touched);
     reloadTree();
   }, [activeProject, clipboard, setClipboard, reloadTree]);
 
   const treeContainerRef = useRef<HTMLDivElement>(null);
 
+  /** Absolutise before publishing: the clipboard is shared with the explorer windows. */
+  const copyToTreeClipboard = useCallback((relativePaths: string[], operation: "cut" | "copy") => {
+    if (!activeProject) return;
+    const root = activeProject.path;
+    setClipboard({
+      paths: relativePaths.map((p) => absoluteProjectPath(root, p)),
+      operation,
+      origin: { projectName: activeProject.name, root },
+    });
+  }, [activeProject, setClipboard]);
+
   /** Ctrl+X / Ctrl+C / Ctrl+V — scoped to file tree container focus */
   const handleClipboardKeyDown = useCallback((e: React.KeyboardEvent) => {
     if (!activeProject) return;
@@ -145,12 +191,9 @@ export function FileTree({ onFileOpen }: FileTreeProps = {}) {
     const mod = e.metaKey || e.ctrlKey;
     if (!mod) return;
 
-    if (e.key === "x" && selectedFiles.length > 0) {
-      e.preventDefault();
-      setClipboard({ paths: [...selectedFiles], operation: "cut" });
-    } else if (e.key === "c" && selectedFiles.length > 0) {
+    if ((e.key === "x" || e.key === "c") && selectedFiles.length > 0) {
       e.preventDefault();
-      setClipboard({ paths: [...selectedFiles], operation: "copy" });
+      copyToTreeClipboard(selectedFiles, e.key === "x" ? "cut" : "copy");
     } else if (e.key === "v" && clipboard) {
       e.preventDefault();
       pasteFiles("");
@@ -221,17 +264,46 @@ export function FileTree({ onFileOpen }: FileTreeProps = {}) {
     };
   }, [activeProject]);
 
+  // Symmetric with the fsChanged(...) calls this file emits after its own mutations: an
+  // explorer window mutating a directory inside this project must invalidate the matching
+  // tree node too.
+  useEffect(() => {
+    if (!activeProject) return;
+    const projectName = activeProject.name;
+    const root = activeProject.path;
+    return onFsChanged((absoluteDir) => {
+      const relative = relativeProjectPath(root, absoluteDir);
+      if (relative == null) return; // outside this project — not the tree's concern
+      const store = useFileStore.getState();
+      store.invalidateIndex();
+      store.loadIndex(projectName);
+      store.invalidateFolder(projectName, relative);
+    });
+  }, [activeProject]);
+
   const {
     uploadFiles, isRootDragOver,
     handleRootDragEnter, handleRootDragLeave, handleRootDragOver, handleRootDrop,
   } = useFileUploadDrag({ projectName: activeProject?.name, setExpanded });
 
+  // Cross-surface entry drops (from an explorer window, or another project's tree) onto the
+  // tree's own empty background — the project root. Uses the same collision-prompt transfer
+  // as a paste; separate from `useFileUploadDrag` above, which only ever reacts to OS files.
+  const treeRootSep = activeProject?.path.includes("\\") ? "\\" : "/";
+  const { run: transferRun, prompts: transferPrompts } = useDropTransfer(treeRootSep);
+  const backgroundDrop = usePathDropTarget({
+    targetDir: activeProject?.path ?? null,
+    run: transferRun,
+    disabled: !activeProject,
+  });
+
   // Virtualized flat rows: only visible rows are mounted (large dirs stay cheap)
   const rows = useMemo(
     () => flattenVisibleTree(tree, expandedPaths, inlineAction),
     [tree, expandedPaths, inlineAction],
   );
   const scrollRef = useRef<HTMLDivElement>(null);
+  useDragAutoScroll(scrollRef);
   const isMobile = useIsMobile();
   const rowVirtualizer = useVirtualizer({
     count: rows.length,
@@ -265,6 +337,7 @@ export function FileTree({ onFileOpen }: FileTreeProps = {}) {
       store.invalidateIndex();
       store.loadIndex(projectName);
       store.invalidateFolder(projectName, parentPath);
+      fsChanged(absoluteProjectPath(activeProject!.path, parentPath));
     } else {
       const type = row.inline.type === "new-file" ? "file" : "directory";
       const fullPath = row.targetPath ? `${row.targetPath}/${value}` : value;
@@ -273,6 +346,7 @@ export function FileTree({ onFileOpen }: FileTreeProps = {}) {
       store.invalidateIndex();
       store.loadIndex(projectName);
       store.invalidateFolder(projectName, row.targetPath);
+      fsChanged(absoluteProjectPath(activeProject!.path, row.targetPath));
     }
   }, [activeProject, clearInlineAction]);
 
@@ -294,14 +368,14 @@ export function FileTree({ onFileOpen }: FileTreeProps = {}) {
       onFileOpen?.();
       return;
     }
-    if (action === "cut") {
+    if (action === "cut" || action === "copy-file") {
       const paths = selectedFiles.length > 0 && selectedFiles.includes(node.path) ? [...selectedFiles] : [node.path];
-      setClipboard({ paths, operation: "cut" });
+      copyToTreeClipboard(paths, action === "cut" ? "cut" : "copy");
       return;
     }
-    if (action === "copy-file") {
-      const paths = selectedFiles.length > 0 && selectedFiles.includes(node.path) ? [...selectedFiles] : [node.path];
-      setClipboard({ paths, operation: "copy" });
+    if (action === "open-in-file-explorer") {
+      const target = node.type === "directory" ? node.path : parentDirOfRelative(node.path);
+      void openExplorer(absoluteProjectPath(activeProject!.path, target));
       return;
     }
     if (action === "paste" && node.type === "directory") {
@@ -417,13 +491,16 @@ export function FileTree({ onFileOpen }: FileTreeProps = {}) {
   return (
     <div
       ref={treeContainerRef}
-      className={cn("flex flex-col h-full outline-none", isRootDragOver && "bg-primary/5")}
+      className={cn("flex flex-col h-full outline-none", (isRootDragOver || backgroundDrop.isOver) && "bg-primary/5")}
       tabIndex={0}
       onKeyDown={(e) => { handleClipboardKeyDown(e); handleTreeKeyDown(e); }}
-      onDragEnter={handleRootDragEnter}
-      onDragLeave={handleRootDragLeave}
-      onDragOver={handleRootDragOver}
-      onDrop={handleRootDrop}
+      // Two independent drags share this background: OS files (handleRoot*, unchanged) and
+      // a cross-surface entry drag (backgroundDrop, gated on its own MIME) — each ignores
+      // the other's kind, so calling both in sequence is safe.
+      onDragEnter={(e) => { handleRootDragEnter(e); backgroundDrop.handlers.onDragEnter(e); }}
+      onDragLeave={(e) => { handleRootDragLeave(e); backgroundDrop.handlers.onDragLeave(e); }}
+      onDragOver={(e) => { handleRootDragOver(e); backgroundDrop.handlers.onDragOver(e); }}
+      onDrop={(e) => { handleRootDrop(e); backgroundDrop.handlers.onDrop(e); }}
     >
       <SidebarHeader icon={FolderOpen} title="Explorer">
         <button onClick={() => handleAction("new-file", ROOT_NODE)} title="New File" className={toolbarBtnClass}>
@@ -481,6 +558,7 @@ export function FileTree({ onFileOpen }: FileTreeProps = {}) {
                         onAction={handleAction}
                         onFileDrop={uploadFiles}
                         onFileOpen={onFileOpen}
+                        transferRun={transferRun}
                       />
                     )}
                   </div>
@@ -514,9 +592,13 @@ export function FileTree({ onFileOpen }: FileTreeProps = {}) {
           node={actionState.node}
           projectName={activeProject.name}
           onClose={() => setActionState(null)}
-          onRefresh={reloadTree}
+          onRefresh={() => {
+            fsChanged(absoluteProjectPath(activeProject.path, parentDirOfRelative(actionState.node.path)));
+            reloadTree();
+          }}
         />
       )}
+      {transferPrompts}
     </div>
   );
 }