Drag a file out of the Files tab onto the host desktop

The Files tab could accept a drop but never produce one: getting a file
out meant "Save to host…" and a file picker. This adds the other
direction.

Two constraints shape it. `dragDropEnabled` is on — TerminalView needs
it, since the native drag-drop event is the only one carrying dropped
file paths — and it blocks HTML5 drag inside the webview, so `draggable`
plus `DataTransfer.setData("DownloadURL", …)` was never available. The
gesture is therefore pointer events into `tauri-plugin-drag`, the same
shape and the same reason as the tab strip's drag. And the file being
dragged does not exist on the host at all: it lives in a container, and
the OS can only drag a real host path.

So a drag-out is a copy first and a drag second.
`stage_container_file_for_drag` materialises the file into
`<os-temp>/triple-c-drag-out/<session>/<slot>/<name>` through the same
`fetch_container_file` the download and the viewer use, keeps the
original filename (a dropped `tmp1234` is not a file anyone wants), and
caps at the 256 MiB an upload already caps at, naming "Save to host…" in
the refusal. The path comes from Tauri's path API rather than `/tmp`,
because on Windows it is neither.

The staging directory has a lifecycle, because whole files accumulating
in the host temp dir would be the disk problem this project just fixed,
in a new place: cleared on exit inside the existing teardown (still
guarded on the main window), and reaped at startup for whatever a crash
left behind.

The copy is also an async gap in the middle of a gesture that feels
instantaneous, and the OS only adopts a drag while the button is still
down. Small files beat the pointer; large ones do not — so the staged
path is cached per entry (keyed on size and mtime, so an edited file
re-stages) and the pane says the copy is ready and to drag again, which
is an instruction rather than an apology because the retry is immediate.
A per-file slot keeps `a/notes.txt` and `b/notes.txt` from becoming the
same host path.

"Save to host…" stays exactly as it was. Drag-out is the enhancement;
a platform that refuses `startDrag` says so and points back at it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GBq2rGum6GX7xXgsas1fDc

app/src/hooks/useFileManager.ts

@@ -1,4 +1,4 @@
-import { useState, useCallback } from "react";
+import { useState, useCallback, useRef } from "react";
 import { save, open as openDialog } from "@tauri-apps/plugin-dialog";
 import type { FileEntry } from "../lib/types";
 import * as commands from "../lib/tauri-commands";
@@ -83,6 +83,44 @@ export function useFileManager(projectId: string) {
     [projectId, currentPath, navigate],
   );
 
+  /**
+   * Host paths already copied out this session, keyed by the entry they came
+   * from. Size and mtime are in the key, so an entry that changed since the
+   * last listing re-stages rather than dragging a stale copy.
+   */
+  const stagedRef = useRef(new Map<string, string>());
+
+  /**
+   * Copy an entry onto the host so the OS can drag it, and return the absolute
+   * host path — or `null`, having set `error`, if it could not be staged.
+   *
+   * `cached` is what the caller needs to tell a gesture that will feel
+   * instantaneous from one that has a whole-file copy in front of it: the copy
+   * is the slow half of a drag-out, and the OS only picks a drag up while the
+   * button is still down.
+   */
+  const stageForDrag = useCallback(
+    async (entry: FileEntry): Promise<{ hostPath: string; cached: boolean } | null> => {
+      const key = `${entry.path}|${entry.size}|${entry.modified}`;
+      const cached = stagedRef.current.get(key);
+      if (cached) return { hostPath: cached, cached: true };
+
+      setError(null);
+      setBusy(`Preparing "${entry.name}"…`);
+      try {
+        const hostPath = await commands.stageContainerFileForDrag(projectId, entry.path);
+        stagedRef.current.set(key, hostPath);
+        return { hostPath, cached: false };
+      } catch (e) {
+        setError(String(e));
+        return null;
+      } finally {
+        setBusy(null);
+      }
+    },
+    [projectId],
+  );
+
   const uploadFile = useCallback(async () => {
     try {
       const selected = await openDialog({ multiple: true, directory: false });
@@ -145,6 +183,7 @@ export function useFileManager(projectId: string) {
     downloadFile,
     uploadFile,
     uploadPaths,
+    stageForDrag,
     renameEntry,
     createFolder,
   };