@@ -135,6 +135,10 @@ export function DashboardAgentPanel({
   );
   // Cursor feedback only; the drag itself is handled by `dragHandleProps`.
   const [draggingWindow, setDraggingWindow] = useState(false);
+  // Fullscreen passes no drag handlers at all (an empty object), so pan wiring is a no-op there.
+  const isDraggable = !!dragHandleProps?.onPan;
+  // Set when a gesture starts on a header button/link, so its onPan steps are dropped too.
+  const ignoringGesture = useRef(false);
 
   const currentPage = agentPageLabel(pageContext, location.pathname);
 
@@ -614,15 +618,45 @@ export function DashboardAgentPanel({
     >
       <motion.div
         {...dragHandleProps}
-        onPanStart={(event, info) => {
-          setDraggingWindow(true);
-          dragHandleProps?.onPanStart?.(event, info);
-        }}
-        onPanEnd={(event, info) => {
-          setDraggingWindow(false);
-          dragHandleProps?.onPanEnd?.(event, info);
-        }}
-        className={cn("select-none", draggingWindow ? "cursor-grabbing" : "cursor-grab")}
+        onPanStart={
+          isDraggable
+            ? (event, info) => {
+                // Buttons/links inside the header (history, new chat, expand, close) sit
+                // above the drag handle; a click there must not move the window.
+                if (
+                  (event.target as HTMLElement | null)?.closest("button, a, input, [role=button]")
+                ) {
+                  ignoringGesture.current = true;
+                  return;
+                }
+                ignoringGesture.current = false;
+                setDraggingWindow(true);
+                dragHandleProps?.onPanStart?.(event, info);
+              }
+            : undefined
+        }
+        onPan={
+          isDraggable
+            ? (event, info) => {
+                if (ignoringGesture.current) return;
+                dragHandleProps?.onPan?.(event, info);
+              }
+            : undefined
+        }
+        onPanEnd={
+          isDraggable
+            ? (event, info) => {
+                ignoringGesture.current = false;
+                setDraggingWindow(false);
+                dragHandleProps?.onPanEnd?.(event, info);
+              }
+            : undefined
+        }
+        className={cn(
+          "select-none",
+          isDraggable && "touch-none",
+          isDraggable && (draggingWindow ? "cursor-grabbing" : "cursor-grab")
+        )}
       >
         <DashboardAgentHeader
           title={headerTitle}
 
@@ -17,11 +17,7 @@ import { ChatSystemBlock } from "./chat-layout";
 import { TONE_ICON_COLOR } from "./agent-badges";
 import { cn } from "~/utils/cn";
 
-/**
- * Icon and label per outcome. `watching` is a live watch, still running — same
- * spinner the chat uses while the agent is responding, not a static glyph. The
- * one-shot outcomes are terminal (nothing left to watch), so they keep their icons.
- */
+/** `watching` is a live watch, so it gets the chat's spinner; the terminal outcomes keep static icons. */
 const OUTCOME = {
   watching: { label: "Watch", icon: <AgentSpinner size={14} /> },
   already_true: {
 
@@ -56,10 +56,14 @@ export function DashboardAgentLauncher() {
       tabbable
       disableHoverableContent
       content={
-        <span className="flex items-center">
-          {open ? "Close chat" : "Open chat"}
-          <ShortcutKey shortcut={TOGGLE_PANEL_SHORTCUT} variant="medium" />
-        </span>
+        open ? (
+          "Close chat"
+        ) : (
+          <span className="flex items-center">
+            Open chat
+            <ShortcutKey shortcut={TOGGLE_PANEL_SHORTCUT} variant="medium" />
+          </span>
+        )
       }
       button={
         <span className="relative inline-flex shrink-0">
 
@@ -0,0 +1,97 @@
+// @vitest-environment jsdom
+import { createElement } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { act } from "react-dom/test-utils";
+import { afterEach, describe, expect, it } from "vitest";
+import type { PanInfo } from "framer-motion";
+import { useDraggableResizable } from "~/components/primitives/DraggableResizable";
+import {
+  FLOATING_HEIGHT,
+  FLOATING_MARGIN,
+  FLOATING_MIN_SIZE,
+  FLOATING_WIDTH,
+  initialFloatingRect,
+} from "./panel-layout";
+
+let container: HTMLDivElement | undefined;
+let root: Root | undefined;
+
+afterEach(() => {
+  if (root) {
+    act(() => root!.unmount());
+  }
+  container?.remove();
+  container = undefined;
+  root = undefined;
+});
+
+function stubViewport(width: number, height: number) {
+  Object.defineProperty(window, "innerWidth", { value: width, configurable: true });
+  Object.defineProperty(window, "innerHeight", { value: height, configurable: true });
+}
+
+describe("initialFloatingRect", () => {
+  it("docks bottom-right, sized to FLOATING_WIDTH/HEIGHT, padded by FLOATING_MARGIN", () => {
+    stubViewport(1200, 900);
+    expect(initialFloatingRect()).toEqual({
+      x: 1200 - FLOATING_WIDTH - FLOATING_MARGIN,
+      y: 900 - FLOATING_HEIGHT - FLOATING_MARGIN,
+      w: FLOATING_WIDTH,
+      h: FLOATING_HEIGHT,
+    });
+  });
+});
+
+// Same render-hook pattern as DraggableResizable.dom.test.ts.
+function renderDraggableResizable() {
+  let latest!: ReturnType<typeof useDraggableResizable>;
+  function Harness() {
+    // oxlint-disable-next-line react/globals -- test harness capturing the hook's return value.
+    latest = useDraggableResizable({
+      initial: initialFloatingRect(),
+      minSize: FLOATING_MIN_SIZE,
+      viewportPadding: FLOATING_MARGIN,
+    });
+    return null;
+  }
+  container = document.createElement("div");
+  document.body.appendChild(container);
+  root = createRoot(container);
+  act(() => {
+    root!.render(createElement(Harness));
+  });
+  return {
+    get current() {
+      return latest;
+    },
+  };
+}
+
+const fakeEvent = {} as PointerEvent;
+function fakePanInfo(dx: number, dy: number): PanInfo {
+  return {
+    delta: { x: dx, y: dy },
+    offset: { x: dx, y: dy },
+    point: { x: 0, y: 0 },
+    velocity: { x: 0, y: 0 },
+  };
+}
+
+describe("the floating window's rect, wired with panel-layout's own constants", () => {
+  it("renders at initialFloatingRect's position and size", () => {
+    stubViewport(1200, 900);
+    const hook = renderDraggableResizable();
+    expect(hook.current.position).toEqual({
+      x: 1200 - FLOATING_WIDTH - FLOATING_MARGIN,
+      y: 900 - FLOATING_HEIGHT - FLOATING_MARGIN,
+    });
+    expect(hook.current.size).toEqual({ w: FLOATING_WIDTH, h: FLOATING_HEIGHT });
+  });
+
+  it("never shrinks below FLOATING_MIN_SIZE even against a viewport smaller than it", () => {
+    stubViewport(300, 300);
+    const hook = renderDraggableResizable();
+    act(() => hook.current.resizeHandleProps("e").onPan(fakeEvent, fakePanInfo(0, 0)));
+    expect(hook.current.size.w).toBe(FLOATING_MIN_SIZE.w);
+  });
+});
@@ -13,13 +13,13 @@ import { cn } from "~/utils/cn";
 const AGENT_FULLSCREEN_STORAGE_KEY = "tdev:dashboard-agent:fullscreen";
 
 // V1 floating window: 380x512, bottom-right, matching the gallery's own panel frame.
-const FLOATING_WIDTH = 380;
-const FLOATING_HEIGHT = 512;
-const FLOATING_MARGIN = 16;
-const FLOATING_MIN_SIZE = { w: 320, h: 360 };
+export const FLOATING_WIDTH = 380;
+export const FLOATING_HEIGHT = 512;
+export const FLOATING_MARGIN = 16;
+export const FLOATING_MIN_SIZE = { w: 320, h: 360 };
 const RESIZE_EDGES: ResizeEdge[] = ["n", "e", "s", "w", "ne", "nw", "se", "sw"];
 
-function initialFloatingRect() {
+export function initialFloatingRect() {
   if (typeof window === "undefined") {
     return { x: 0, y: 0, w: FLOATING_WIDTH, h: FLOATING_HEIGHT };
   }
@@ -59,12 +59,7 @@ export function agentHiddenContentClassName(fullscreen: boolean): string {
   return cn("h-full overflow-hidden", fullscreen && "invisible");
 }
 
-/**
- * The floating chat window: `useDraggableResizable`-positioned bottom-right, draggable
- * and resizable across the whole page. Fullscreen swaps it back to the same takeover the
- * old right-column mode used, which needs `children` positioned inside a `relative`
- * ancestor — the caller (`DashboardAgent`) supplies that.
- */
+/** Fullscreen needs a `relative` ancestor for `agentTakeoverClassName`; the caller (`DashboardAgent`) supplies it. */
 export function FloatingAgentWindow({
   fullscreen,
   children,
@@ -86,9 +81,13 @@ export function FloatingAgentWindow({
   return (
     <div
       style={style}
-      className="z-20 flex flex-col overflow-hidden rounded-lg border border-border-bright bg-background-bright shadow-2xl"
+      className="z-20 flex flex-col rounded-lg border border-border-bright bg-background-bright shadow-2xl"
     >
-      {children(dragHandleProps)}
+      {/* Clips content to the rounded corners without clipping the resize handles below,
+          which sit half outside this box's edges. */}
+      <div className="flex min-h-0 flex-1 flex-col overflow-hidden rounded-lg">
+        {children(dragHandleProps)}
+      </div>
       {RESIZE_EDGES.map((edge) => (
         <motion.div
           key={edge}
 
@@ -27,12 +27,7 @@ import { useThemeMode } from "~/hooks/useThemeMode";
 
 export const MATRIX = 5;
 
-/**
- * The grid geometry every dot in the library shares: a `MATRIX`x`MATRIX` grid, dot
- * centered per cell, radius 30% of the cell pitch (never below 0.75px). Static icon
- * variants (e.g. `dotMatrixIcon.tsx`) reuse this so they read as native shape-library
- * members instead of a different dot system.
- */
+/** Shared so anything else drawing on this grid stays visually identical to the shape library. */
 export function dotMatrixGeometry(size: number) {
   const pitch = size / MATRIX;
   const dotR = Math.max(0.75, pitch * 0.3);
 
@@ -1,14 +1,9 @@
 // @vitest-environment jsdom
 //
-// Drives the hook's own handlers in framer-motion's *real* callback order, not the
-// pure math functions: framer-motion defers onPanStart/onPanEnd by a frame (its internal
-// scheduler) while onPan fires synchronously, so a real gesture can deliver one or more
-// onPan events before the onPanStart for that same gesture lands. A startRectRef-based
-// implementation resets its baseline to the *already-moved* rect when the late onPanStart
-// finally fires, corrupting every subsequent onPan in the gesture. This file proves the
-// hook survives that ordering; draggableResizableMath.test.ts's pure-function tests can't,
-// since they call the (already-fixed) math directly and have no callback ordering to get
-// wrong.
+// Framer-motion can deliver onPan before onPanStart for the same gesture (its scheduler
+// defers onPanStart by a frame); a start-rect-ref implementation would corrupt its
+// baseline when the late onPanStart lands. This drives the hook's real handlers to prove
+// it survives that ordering, unlike the pure-math tests in draggableResizableMath.test.ts.
 import { createElement } from "react";
 import { createRoot, type Root } from "react-dom/client";
 import { act } from "react-dom/test-utils";
 
@@ -75,12 +75,10 @@ export function useDraggableResizable({
     return () => window.removeEventListener("resize", onResize);
   }, [viewportPadding]);
 
-  // Each onPan step folds `info.delta` (movement since the *last* event, not cumulative)
-  // onto the latest committed rect via the functional setState form. No gesture-start
-  // snapshot is kept: framer-motion defers onPanStart/onPanEnd by a frame but calls onPan
-  // synchronously, so a ref-based baseline captured in onPanStart can still be stale (or
-  // the mount-time initial rect) when the first onPan of a gesture lands. Delta + functional
-  // update has no baseline to go stale, so gestures compose correctly back-to-back.
+  // Each onPan step folds `info.delta` onto the latest committed rect via functional
+  // setState, with no gesture-start baseline kept: framer-motion can deliver onPan before
+  // onPanStart (its scheduler defers onPanStart by a frame), which would make a ref-based
+  // baseline stale.
   const dragHandleProps: PanHandlerProps = {
     onPanStart: () => {},
     onPan: (_event, info: PanInfo) => {
 
@@ -195,14 +195,38 @@ describe("resizeRect", () => {
   });
 });
 
-// These reproduce the live-testing symptoms: framer-motion defers onPanStart/onPanEnd by a
-// frame (via its internal scheduler) but calls onPan synchronously, so a gesture-start
-// snapshot captured in onPanStart can be stale — or still the mount-time initial rect — when
-// a gesture's first onPan lands. applyDragDelta/applyResizeDelta take framer's per-event
-// `delta` (not the cumulative `offset`) and fold it onto whatever rect is passed in, so the
-// hook can drive them with `setRect(current => apply...(current, ...))` and never needs a
-// separate baseline that could go stale. Simulating "gesture A steps, then gesture B steps,
-// no reset in between" is exactly what a stale-baseline bug would fail on.
+describe("resizeRect — minSize wins over a viewport-derived cap smaller than it", () => {
+  const minSize = { w: 320, h: 360 };
+
+  it("east: a narrow viewport still floors width at minSize.w", () => {
+    const start = { x: 100, y: 50, w: 300, h: 400 };
+    const viewport = { width: 350, height: 800 };
+    expect(resizeRect("e", start, 1000, 0, minSize, undefined, viewport, 16).w).toBe(320);
+  });
+
+  it("south: a short viewport still floors height at minSize.h", () => {
+    const start = { x: 50, y: 100, w: 400, h: 300 };
+    const viewport = { width: 800, height: 400 };
+    expect(resizeRect("s", start, 0, 1000, minSize, undefined, viewport, 16).h).toBe(360);
+  });
+
+  it("west: a small fixed right edge still floors width at minSize.w", () => {
+    const start = { x: 10, y: 50, w: 50, h: 400 };
+    const viewport = { width: 1000, height: 800 };
+    expect(resizeRect("w", start, -1000, 0, minSize, undefined, viewport, 16).w).toBe(320);
+  });
+
+  it("north: a small fixed bottom edge still floors height at minSize.h", () => {
+    const start = { x: 50, y: 10, w: 400, h: 50 };
+    const viewport = { width: 1000, height: 800 };
+    expect(resizeRect("n", start, 0, -1000, minSize, undefined, viewport, 16).h).toBe(360);
+  });
+});
+
+// These reproduce the live-testing symptoms: framer-motion can deliver a gesture's first
+// onPan before its onPanStart, so a baseline captured in onPanStart can be stale.
+// applyDragDelta/applyResizeDelta avoid that by folding framer's per-event `delta` onto
+// whatever rect is passed in, with no baseline to go stale.
 describe("applyResizeDelta / applyDragDelta — gesture sequencing", () => {
   const start: Rect = { x: 100, y: 100, w: 300, h: 200 };
   const minSize = { w: 100, h: 80 };
@@ -248,10 +272,8 @@ describe("applyResizeDelta / applyDragDelta — gesture sequencing", () => {
     let rect = applyDragDelta(start, { x: 200, y: 150 }, viewport, padding);
     expect(rect).toEqual({ x: 300, y: 250, w: 300, h: 200 });
 
-    // Resizing next must clamp against the *current* x/y (300, 250), not `start` (100, 100)
-    // or any other stale baseline — a stale baseline pinned near the right edge would show
-    // up here as the box jumping back toward x=690 (the viewport-clamped position for `start`
-    // near the right edge) instead of resizing in place.
+    // Resize must clamp against the current x/y (300, 250), not `start` — a stale baseline
+    // would show up as x jumping back toward 690, the viewport-clamped position near the edge.
     rect = applyResizeDelta("e", rect, { x: 10, y: 0 }, minSize, undefined, viewport, padding);
     expect(rect.x).toBe(300);
     expect(rect.w).toBe(310);