feat(workspaces): Win8 Start-style tile-grid home page

Rebuild the workspace home as a Windows 8 Start-screen-style tile grid,
replacing the max-w-3xl vertical card list.

Pure core (zero DOM/Svelte/fetch, fully unit-tested):
- logic/tile-layout.ts — geometryFor(width, height) resolves WIDE (4 fixed
  ~120px rows, column-wise flow, 4x2 span cap) or TALL (2 fixed columns,
  row-wise flow, 2x2 cap); pack() is the ONLY order->coordinates transform
  (greedy first-fit in fill order, hole-free, render-clamped per geometry);
  firstEmptySlot/insertAtFirstEmptySlot/mergeLayout/resizeTile/moveTile/
  sortByRecentActivity/sanitizeLayout. Persisted data is
  orientation-independent {version:1, tiles:[{id,colSpan,rowSpan,order}]} —
  order + spans only, never positions; the same data renders in either
  geometry (spans clamp for the render, persisted values untouched).
- logic/drag-controller.ts — pure pointer/press state machine: mouse
  threshold-drag + tap-open; touch long-press lifts + selects, pre-lift
  movement cancels so vertical scrolling never fights the gesture.

Shell:
- tile-layout-store.svelte.ts — thin reactive wrapper persisting through
  the injected createLocalStore adapter (dispatch.workspaces.tiles), ops:
  sync/resize/move/placeFirstEmpty/sortByRecentActivity.
- ui/HomeTileGrid.svelte — CSS-grid tile canvas (wide: horizontal scroll +
  snap + wheel pan + pan arrow + scroll indicator; tall: native vertical
  scroll), FLIP-animated reflow, drag ghost, transient resize preview.
- ui/HomeHeader.svelte — fixed chrome: Dispatch display title, New
  workspace popover (same slug validation; creates via create-on-miss and
  does NOT navigate — the new tile lands in the first empty slot in fill
  order and enters rename mode), global Plugins button, sort-by-recent
  overflow; compact icon buttons + bottom sheet on tall screens.
- ui/WorkspaceTile.svelte — tile face (title, /slug, conversation count,
  relative last-activity, live active dots, starred tint); inline rename
  with the old card's semantics.
- ui/TileActionBar.svelte — slides up on select (right-click / long-press):
  Open, Rename, Resize, Star/Unstar, Details, Plugins, Delete (old confirm
  + store call preserved).
- ui/ResizePicker.svelte — Word-style insert-table hover grid (wide 4x2 /
  tall 2x2) with arrow/Enter/Escape support and ghost preview on commit.
- ui/WorkspaceDetails.svelte — flyout holding the old card's default-cwd
  input + default-computer select (same store calls + error states).
- WorkspacesHome.svelte orchestrates; App.svelte untouched (same props).
- WorkspaceCard.svelte is removed (replaced by the tile system).

Manual tile order rules; starred workspaces get a tint (star is no longer
a sort key); workspaces unknown to the layout append at the end.

vitest: jsdom gains PointerEvent (MouseEvent-based) + Element.animate
stubs — the pointer logic is the outermost edge for the drag tests.

Verification: svelte-check 0/0, vitest 1655 passed (102 files, twice),
biome clean, vite build OK.

1 files changed, 159 insertions, 0 deletions

diff --git a/src/features/workspaces/logic/drag-controller.ts b/src/features/workspaces/logic/drag-controller.ts
new file mode 100644
index 0000000..03dcade
--- /dev/null
+++ b/src/features/workspaces/logic/drag-controller.ts
@@ -0,0 +1,159 @@
+/**
+ * Pure drag/press state machine for the home tile grid — zero DOM, zero
+ * timers (the component schedules the long-press timer and dispatches its
+ * firing as an event), zero Svelte.
+ *
+ * Pointer semantics:
+ * - **Mouse**: press → move past the threshold = DRAG; release without
+ *   moving = a TAP (open the workspace). Selection is right-click.
+ * - **Touch**: press → (no movement past the threshold) long-press = LIFT
+ *   (arm the drag + select the tile) → further moves drag. Moving past the
+ *   threshold BEFORE the lift cancels the press — vertical scrolling wins,
+ *   so the two gestures never fight. Release while lifted = DROP.
+ *
+ * Pure: `(phase, event, options) → { phase, emit }`. The component owns the
+ * reactive `$state` and performs the emits (navigate / select / reorder).
+ */
+
+/** Where the interaction currently stands. */
+export type DragPhase =
+  | { readonly kind: "idle" }
+  /** Pointer is down; not yet decided between tap / drag / long-press. */
+  | {
+      readonly kind: "pressing";
+      readonly id: string;
+      readonly x: number;
+      readonly y: number;
+      readonly touch: boolean;
+    }
+  /** The tile is lifted and following the pointer (touch: after the long-press). */
+  | {
+      readonly kind: "dragging";
+      readonly id: string;
+      readonly x: number;
+      readonly y: number;
+      readonly targetIndex: number;
+      readonly touch: boolean;
+    };
+
+/** An action the component should perform as a result of a transition. */
+export type DragEmit =
+  | { readonly kind: "tap"; readonly id: string }
+  | { readonly kind: "lift"; readonly id: string }
+  | { readonly kind: "drop"; readonly id: string; readonly targetIndex: number };
+
+/** Events the component dispatches (DOM events + the long-press timer firing). */
+export type DragEvent =
+  | {
+      readonly type: "pointer-down";
+      readonly id: string;
+      readonly x: number;
+      readonly y: number;
+      readonly touch: boolean;
+    }
+  | {
+      readonly type: "pointer-move";
+      readonly x: number;
+      readonly y: number;
+      readonly targetIndex: number;
+    }
+  | { readonly type: "pointer-up" }
+  | { readonly type: "long-press" }
+  /** pointercancel / blur / the tile unmounting / Escape. */
+  | { readonly type: "cancel" };
+
+export interface DragOptions {
+  /** Pointer travel (px) that turns a press into a drag (or cancels a touch press). */
+  readonly dragThresholdPx: number;
+}
+
+export interface DragTransition {
+  readonly phase: DragPhase;
+  readonly emit?: DragEmit;
+}
+
+const IDLE: DragPhase = { kind: "idle" };
+
+/** Advance the state machine. Pure: phase + event in, NEXT phase + emit out. */
+export function nextDragPhase(
+  phase: DragPhase,
+  event: DragEvent,
+  options: DragOptions,
+): DragTransition {
+  switch (event.type) {
+    case "pointer-down":
+      // A press always restarts (a pointerdown while dragging is a new gesture).
+      return {
+        phase: {
+          kind: "pressing",
+          id: event.id,
+          x: event.x,
+          y: event.y,
+          touch: event.touch,
+        },
+      };
+    case "pointer-move": {
+      if (phase.kind === "pressing") {
+        const travelled = Math.hypot(event.x - phase.x, event.y - phase.y);
+        if (travelled < options.dragThresholdPx) return { phase };
+        // Touch: a big movement before the long-press lift is a SCROLL, not a
+        // drag — abandon the press so the canvas scrolls natively.
+        if (phase.touch) return { phase: IDLE };
+        return {
+          phase: {
+            kind: "dragging",
+            id: phase.id,
+            x: event.x,
+            y: event.y,
+            targetIndex: event.targetIndex,
+            touch: phase.touch,
+          },
+        };
+      }
+      if (phase.kind === "dragging") {
+        return {
+          phase: {
+            ...phase,
+            x: event.x,
+            y: event.y,
+            targetIndex: event.targetIndex,
+          },
+        };
+      }
+      return { phase };
+    }
+    case "pointer-up": {
+      if (phase.kind === "pressing") {
+        // No drag, no lift → a tap.
+        return { phase: IDLE, emit: { kind: "tap", id: phase.id } };
+      }
+      if (phase.kind === "dragging") {
+        return {
+          phase: IDLE,
+          emit: { kind: "drop", id: phase.id, targetIndex: phase.targetIndex },
+        };
+      }
+      return { phase };
+    }
+    case "long-press": {
+      if (phase.kind === "pressing" && phase.touch) {
+        // Touch lift: arm the drag at the press point (the pointer will move
+        // from here) + tell the component to select the tile.
+        return {
+          phase: {
+            kind: "dragging",
+            id: phase.id,
+            x: phase.x,
+            y: phase.y,
+            targetIndex: -1,
+            touch: true,
+          },
+          emit: { kind: "lift", id: phase.id },
+        };
+      }
+      return { phase };
+    }
+    case "cancel":
+      return { phase: IDLE };
+  }
+}