Fix HIGH and MEDIUM frontend defects

Files pane
- F16: a drag-out released back inside the app no longer re-imports its own
  staged copy over the container original. An in-flight flag (cleared from the
  drag plugin's `onEvent` channel, with a watchdog) suppresses the drop and the
  "Drop files into …" hint, and an exact staged-path filter is the second line
  of defence — the `path|size|modified` cache could otherwise write a
  minutes-old snapshot over a file an agent had since rewritten.
- F17: a slow upload/rename no longer yanks the user back to the directory the
  operation started in. Every operation captures its target path and re-lists
  only if the user is still there; failures go to the toast host either way.
- The grid keeps keyboard focus. Roving tabindex (one tab stop, not one per
  row) plus focus restore after navigation, rename commit/cancel and Escape.
- Transient failures now surface in `ToastHost` (z-[60], persistent aria-live)
  instead of a `role="alert"` 300 rows down a scroller or behind a modal
  overlay. The inline error is kept only for the listing failure.
- `navigate` is sequenced by generation; "Save to host…" sets `busy`.
- Grid a11y: column headers, a text affordance for folder vs file, a live
  region that is mounted empty and announces completion, Label-in-Name fixed.
- FileViewerModal: the blob URL is released only once its replacement exists;
  the preview is a focusable, named, scrollable region.

Native drop routing
- New `lib/dropTarget.ts`: the hit test now refuses a drop while any
  `[aria-modal="true"]` dialog or `[data-blocks-drop]` overlay is up, and
  checks z-order where the environment can answer it. Shared by FilesTab and
  TerminalView; App's shutdown overlay opts in.

Disk
- A partially failed reclaim says so in words ("… — 2 of 5 failed"), not by hue
  alone.
- The scan/reclaim race is closed: every mutation retires an in-flight scan, so
  a scan can no longer repaint a pre-reclaim report plus a clickable plan of
  objects that are gone. Scan is disabled while working; the status is a live
  region; a failed destructive action keeps its dialog open and reports there.
- The "unknown" layer count gets a screen-reader fallback; `--text-disabled`
  no longer carries live information.

Terminal / OAuth
- After the toast is dismissed, a truncated heuristic guess can no longer fill
  the slot that an exact OSC 8 or relay URL occupied — the detector remembers
  every exact URL and drops any candidate that is a strict prefix of one.
- The prompt is reachable by keyboard: Ctrl+Shift+O jumps to the default
  action, Escape dismisses, focus returns to the terminal, and auto-dismiss
  holds off while focus is inside. It deliberately does not steal focus.
- UrlToast renders through `ui/Button` and `--shadow-overlay`.

Elsewhere
- AuthBridgeRow: a pushed `auth-bridge-changed` status always outranks an older
  awaited toggle result.
- The last two ad-hoc byte formatters route through `lib/formatBytes`.

Contract for the backend agent: `upload_file_to_container` refusing to
overwrite must satisfy `isFileExistsError` in `src/lib/uploadErrors.ts` (marker
`FILE_EXISTS`) and accept an `overwrite` argument; the frontend turns that into
an `ui/Modal` Replace/Skip prompt rather than a raw error string.

Tests: 536 -> 627 passing. `npm run build` and `npx tsc --noEmit` green.

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

app/src/lib/uploadErrors.ts

@@ -0,0 +1,116 @@
+/**
+ * The one place the frontend agrees with Rust about "that name is taken".
+ *
+ * `upload_file_to_container` used to clobber whatever was already at the
+ * destination, which is the wrong default for a drop: a drag is aimed with a
+ * mouse, and the file it lands on is frequently not the file the user meant to
+ * replace. So the backend refuses by default and the frontend asks — but only
+ * if it can tell *this* refusal apart from "permission denied" or "no space
+ * left", because an overwrite prompt raised over an unrelated failure would
+ * offer a button that cannot possibly work.
+ *
+ * **This module is the contract point, and the Rust half has to hold up its
+ * end**: `upload_file_to_container` must put `FILE_EXISTS_MARKER` in the error
+ * it returns when the destination already exists, ideally in the agreed shape
+ *
+ *     FILE_EXISTS: /workspace/notes.txt already exists
+ *
+ * and must accept an `overwrite: bool` argument that skips the check. Nothing
+ * here parses a human sentence — the marker is the whole agreement, and the
+ * path is a bonus that is only used to name the file in the prompt.
+ *
+ * The predicate is deliberately tolerant about the *shape* of the error rather
+ * than its wording, because a Tauri command error crosses the IPC boundary as
+ * whatever `serde` made of it: a bare string from `Err(String)`, an object from
+ * a `#[derive(Serialize)]` error enum, or an `Error` if a JS layer wrapped it
+ * on the way through. All three are the same refusal, and the UI must not
+ * behave differently depending on which one a future refactor produces.
+ */
+
+/** Marker the backend puts in the error for "a file with this name is already there". */
+export const FILE_EXISTS_MARKER = "FILE_EXISTS";
+
+/**
+ * Structured error shapes carry the marker in a discriminant rather than in
+ * prose. These are the field names a serialised Rust error realistically uses;
+ * matching is case-insensitive and ignores `_`/`-` so `FileExists`,
+ * `file_exists` and `FILE-EXISTS` all read as the same variant.
+ */
+const KIND_FIELDS = ["kind", "code", "type", "error", "reason"] as const;
+const MESSAGE_FIELDS = ["message", "msg", "detail", "description"] as const;
+const PATH_FIELDS = ["path", "container_path", "containerPath", "target", "file"] as const;
+
+/** `FileExists` / `file-exists` / `FILE_EXISTS` all normalise to `fileexists`. */
+function normaliseKind(value: string): string {
+  return value.toLowerCase().replace(/[\s_-]/g, "");
+}
+
+const KIND_NEEDLE = normaliseKind(FILE_EXISTS_MARKER);
+
+function asRecord(e: unknown): Record<string, unknown> | null {
+  return typeof e === "object" && e !== null ? (e as Record<string, unknown>) : null;
+}
+
+/**
+ * Every string an error carries, flattened: the error itself if it is one, its
+ * message-ish fields, and its kind-ish fields. Nesting is followed one level
+ * because a wrapped error (`{ error: { kind: … } }`) is the same refusal.
+ */
+function stringsIn(e: unknown, depth = 0): string[] {
+  if (typeof e === "string") return [e];
+  if (e instanceof Error) return [e.message, e.name];
+  const record = asRecord(e);
+  if (!record || depth > 1) return [];
+  const out: string[] = [];
+  for (const field of [...KIND_FIELDS, ...MESSAGE_FIELDS]) {
+    const value = record[field];
+    if (typeof value === "string") out.push(value);
+    else if (value !== undefined) out.push(...stringsIn(value, depth + 1));
+  }
+  return out;
+}
+
+/**
+ * True when the backend refused an upload because the destination is taken.
+ *
+ * Accepts a bare string, an `Error`, or an object with a `kind`/`code`
+ * discriminant or a `message` — see the module comment for why all three have
+ * to work.
+ */
+export function isFileExistsError(e: unknown): boolean {
+  return stringsIn(e).some((s) => normaliseKind(s).includes(KIND_NEEDLE));
+}
+
+/**
+ * The container path the conflict is about, when the error carries one — used
+ * only to name the file in the prompt, so `null` is a perfectly good answer
+ * and the caller falls back to the host path it was uploading.
+ */
+export function fileExistsPath(e: unknown): string | null {
+  const record = asRecord(e);
+  if (record) {
+    for (const field of PATH_FIELDS) {
+      const value = record[field];
+      if (typeof value === "string" && value.length > 0) return value;
+    }
+    // One level down, for `{ error: { path } }`.
+    for (const field of KIND_FIELDS) {
+      const nested = fileExistsPath(record[field]);
+      if (nested) return nested;
+    }
+  }
+  for (const s of stringsIn(e)) {
+    // The agreed prose form: `FILE_EXISTS: <path>` — everything up to the
+    // first space after the marker.
+    const match = new RegExp(`${FILE_EXISTS_MARKER}\\s*[:=]\\s*(\\S+)`).exec(s);
+    if (match) return match[1];
+  }
+  return null;
+}
+
+/**
+ * What the user answered to one conflict. The blanket answers exist because a
+ * ten-file drop onto a populated directory is ten prompts otherwise, which is
+ * the kind of dialog people dismiss without reading.
+ */
+export type OverwriteChoice = "replace" | "skip" | "replace-all" | "skip-all";