fix(webapp): resume a chat's in-flight turn on reopen; final comment sweep

Closing the panel already keeps the server turn alive
(teardownCancelsTurn returns false for panel-closed and chat-switched).
The missing piece was resume-on-reopen: opening a chat never marked it
streaming, so the transport never resumed the live `.out` stream and a
mid-turn reopen showed a stalled transcript.

resolveOpenedChat now derives `streaming` from whether the fetched
transcript still looks mid-turn (the same transcriptLooksUnfinished
check already used to poll a just-settled turn), and DashboardAgentPanel
already spreads it into ActiveChat, so useTriggerChatTransport's
isStreaming resume engages on reopen.

Chat-switch design decision: unchanged, matches the packet's
preference — teardownCancelsTurn already keeps chat-switched turns
alive, same as panel-closed, so switching away and back also resumes.

A true SSE integration test is impractical in jsdom; resume-wiring.test.ts
source-checks the streaming/isStreaming/stopGeneration wiring instead,
alongside new resolveOpenedChat unit tests for the streaming derivation.

Final comment sweep over the branch diff: every comment capped at two
plain lines, non-critical/signpost ones removed.

Author: kathiekiwi

apps/webapp/app/components/dashboard-agent/floating-window-mode.test.ts

@@ -1,6 +1,4 @@
-// Source-level guard: the floating window is the default and only mode. A regression to
-// the old slide-in-from-the-right column would reintroduce `ResizablePanelGroup` here —
-// this fails red the moment it comes back, instead of waiting for a visual regression.
+// Guards against reintroducing the old right-column ResizablePanelGroup.
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { describe, expect, it } from "vitest";

apps/webapp/app/components/dashboard-agent/opened-chat.test.ts

@@ -10,18 +10,37 @@ const message: UIMessage = {
   parts: [{ type: "text", text: "why did this run fail?" }],
 };
 
+// A tool call the stream died on: still `input-available`, no result part.
+const unfinishedMessage: UIMessage = {
+  id: "msg_2",
+  role: "assistant",
+  parts: [{ type: "tool-run_query", state: "input-available" } as never],
+};
+
 describe("resolveOpenedChat", () => {
   it("opens a chat that has messages", () => {
     const opened = resolveOpenedChat(CHAT_ID, { messages: [message], session: null });
 
-    expect(opened).toEqual({ kind: "chat", chatId: CHAT_ID, messages: [message], session: null });
+    expect(opened).toEqual({
+      kind: "chat",
+      chatId: CHAT_ID,
+      messages: [message],
+      session: null,
+      streaming: false,
+    });
   });
 
   it("still opens a chat that exists but has no messages", () => {
     const opened = resolveOpenedChat(CHAT_ID, { messages: [], session: null });
 
     expect(opened.kind).toBe("chat");
-    expect(opened).toEqual({ kind: "chat", chatId: CHAT_ID, messages: [], session: null });
+    expect(opened).toEqual({
+      kind: "chat",
+      chatId: CHAT_ID,
+      messages: [],
+      session: null,
+      streaming: false,
+    });
   });
 
   it("treats a chat with no messages field the same way", () => {
@@ -54,4 +73,23 @@ describe("resolveOpenedChat", () => {
   it("has no session when the token is missing", () => {
     expect(resolveOpenedChat(CHAT_ID, { messages: [message] })).toMatchObject({ session: null });
   });
+
+  // The bug this guards: closing mid-turn and reopening must resume, not show a stalled turn.
+  it("marks streaming when the fetched transcript still looks mid-turn", () => {
+    const opened = resolveOpenedChat(CHAT_ID, {
+      messages: [message, unfinishedMessage],
+      session: { publicAccessToken: "pat_1", lastEventId: "evt_9" },
+    });
+
+    expect(opened).toMatchObject({ streaming: true });
+  });
+
+  it("is not streaming once the transcript settles", () => {
+    const opened = resolveOpenedChat(CHAT_ID, {
+      messages: [message],
+      session: { publicAccessToken: "pat_1", lastEventId: "evt_9" },
+    });
+
+    expect(opened).toMatchObject({ streaming: false });
+  });
 });

apps/webapp/app/components/dashboard-agent/opened-chat.ts

@@ -1,4 +1,5 @@
 import type { UIMessage } from "@ai-sdk/react";
+import { transcriptLooksUnfinished } from "./settled-transcript";
 
 export type OpenedChatResponse = {
   messages?: UIMessage[];
@@ -11,6 +12,8 @@ export type OpenedChat =
       chatId: string;
       messages: UIMessage[];
       session: { publicAccessToken: string; lastEventId?: string } | null;
+      // True if the transcript still reads as mid-turn, so the transport resumes it.
+      streaming: boolean;
     }
   // Deleted, or belonging to someone else: the read failed, so there is no chat to show.
   | { kind: "gone" };
@@ -23,15 +26,17 @@ export function resolveOpenedChat(
   if (!response) return { kind: "gone" };
 
   const session = response.session;
+  const messages = response.messages ?? [];
   return {
     kind: "chat",
     chatId,
-    messages: response.messages ?? [],
+    messages,
     session: session?.publicAccessToken
       ? {
           publicAccessToken: session.publicAccessToken,
           lastEventId: session.lastEventId ?? undefined,
         }
       : null,
+    streaming: transcriptLooksUnfinished(messages),
   };
 }

apps/webapp/app/components/dashboard-agent/panel-layout.dom.test.ts

@@ -44,7 +44,6 @@ describe("initialFloatingRect", () => {
   });
 });
 
-// Same render-hook pattern as DraggableResizable.dom.test.ts.
 function renderDraggableResizable() {
   let latest!: ReturnType<typeof useDraggableResizable>;
   function Harness() {

apps/webapp/app/components/dashboard-agent/panel-layout.tsx

@@ -69,12 +69,7 @@ export function agentHiddenContentClassName(fullscreen: boolean): string {
   return cn("h-full overflow-hidden", fullscreen && "invisible");
 }
 
-/**
- * Fullscreen needs a `relative` ancestor for `agentTakeoverClassName`; the caller
- * (`DashboardAgent`) supplies it. Owns the drag-vs-click filter so every consumer (the real
- * panel, the standalone story) gets identical behavior: a pan starting on a
- * `data-agent-no-drag` element (or a descendant of one) never moves the window.
- */
+/** Fullscreen needs a `relative` ancestor for `agentTakeoverClassName`, supplied by the caller. */
 export function FloatingAgentWindow({
   fullscreen,
   children,
@@ -89,9 +84,7 @@ export function FloatingAgentWindow({
     viewportPadding: FLOATING_MARGIN,
   });
   const [dragging, setDragging] = useState(false);
-  // Framer-motion can deliver onPan before onPanStart, so the no-drag check runs on
-  // whichever event lands first; `gestureClassified` makes sure it only runs once per
-  // gesture (a late onPanStart must not re-decide after onPan already classified it).
+  // onPan can arrive before onPanStart, so the no-drag check runs once, on whichever fires first.
   const gestureClassified = useRef(false);
   const ignoringGesture = useRef(false);
 
@@ -137,7 +130,7 @@ export function FloatingAgentWindow({
       {/* 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">
-        {/* oxlint-disable-next-line react/refs -- filteredDragHandleProps' closures only touch the ref inside their own event handlers, not during this render. */}
+        {/* oxlint-disable-next-line react/refs -- the ref is only read inside event handlers, not during render. */}
         {children({
           dragHandleProps: filteredDragHandleProps,
           dragHandleClassName: cn(

apps/webapp/app/components/dashboard-agent/resume-wiring.test.ts

@@ -0,0 +1,24 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+
+// Structural guard: a live SSE resume is impractical in jsdom, so this pins the wiring
+// instead. `opened-chat.test.ts` covers the `streaming` value; this covers it reaching the transport.
+describe("the panel's resume wiring, source-checked", () => {
+  const chat = readFileSync(new URL("./DashboardAgentChat.tsx", import.meta.url), "utf8");
+  const panel = readFileSync(new URL("./DashboardAgentPanel.tsx", import.meta.url), "utf8");
+
+  it("marks a reopened chat's session isStreaming from the `streaming` prop", () => {
+    expect(chat).toContain("isStreaming: streaming ?? false");
+  });
+
+  it("only stopGeneration is called from the explicit Stop button and the gated teardown", () => {
+    const calls = [...chat.matchAll(/transport\.stopGeneration\(/g)];
+    expect(calls).toHaveLength(1);
+    expect(chat).toContain("if (!teardownCancelsTurn(reason)) return;");
+  });
+
+  it("passes the opened chat's streaming flag through to the mounted chat", () => {
+    expect(panel).toContain("setActive({ ...opened, organizationId: organization.id });");
+    expect(panel).toContain("streaming={active.streaming}");
+  });
+});

apps/webapp/app/components/primitives/DraggableResizable.dom.test.ts

@@ -1,9 +1,6 @@
 // @vitest-environment jsdom
-//
-// 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.
+// Framer-motion can deliver onPan before onPanStart; drives the real handlers to prove
+// the hook survives that ordering (draggableResizableMath.test.ts only covers the math).
 import { createElement } from "react";
 import { createRoot, type Root } from "react-dom/client";
 import { act } from "react-dom/test-utils";
@@ -47,9 +44,8 @@ function renderHook(options: UseDraggableResizableOptions) {
   };
 }
 
-// `offset` is populated alongside `delta` (framer-motion always sends both) so a reverted
-// offset+baseline implementation runs its real math instead of crashing on `undefined` —
-// it must fail on the *value*, not on a missing field.
+// `offset` is set too (framer always sends both), so a reverted implementation fails on
+// the value, not on a missing field.
 function fakePanInfo(deltaX: number, offsetX: number): PanInfo {
   return {
     delta: { x: deltaX, y: 0 },

apps/webapp/app/components/primitives/DraggableResizable.tsx

@@ -32,11 +32,7 @@ export type PanHandlerProps = {
 };
 
 export type UseDraggableResizableResult = {
-  /**
-   * position:fixed with left/top/width/height set from state. `x`/`y` are the
-   * top-left corner in viewport coordinates — if the window docks bottom-right,
-   * derive the initial x/y from `window.innerWidth/innerHeight - w/h - padding`.
-   */
+  /** position:fixed from state; `x`/`y` are the top-left corner in viewport coordinates. */
   style: CSSProperties;
   dragHandleProps: PanHandlerProps;
   resizeHandleProps: (edge: ResizeEdge) => PanHandlerProps;
@@ -75,10 +71,8 @@ export function useDraggableResizable({
     return () => window.removeEventListener("resize", onResize);
   }, [viewportPadding]);
 
-  // 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.
+  // Folds `info.delta` via functional setState, no gesture-start baseline: onPan can
+  // arrive before onPanStart, which would make a ref-based baseline stale.
   const dragHandleProps: PanHandlerProps = {
     onPanStart: () => {},
     onPan: (_event, info: PanInfo) => {

apps/webapp/app/components/primitives/Popover.tsx

@@ -223,9 +223,8 @@ function PopoverArrowTrigger({
       >
         {children}
       </Paragraph>
-      {/* Wrapper only: `data-agent-no-drag` is an opt-out marker some draggable-window hosts
-          check via `closest()`, so the icon (not the title text beside it) can decline a drag
-          without changing this primitive's layout (`contents` keeps the icon as the flex item). */}
+      {/* `data-agent-no-drag`: an opt-out marker draggable-window hosts check via closest().
+          `contents` keeps this wrapper invisible to layout. */}
       <span data-agent-no-drag className="contents">
         <DropdownIcon className={cn("size-4 min-w-4 transition", variantStyles.icon)} />
       </span>

apps/webapp/app/components/primitives/draggableResizableMath.test.ts

@@ -223,10 +223,8 @@ describe("resizeRect — minSize wins over a viewport-derived cap smaller than i
   });
 });
 
-// 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.
+// onPan can arrive before onPanStart, so these prove the delta-folding approach has no
+// baseline to go stale across back-to-back gestures.
 describe("applyResizeDelta / applyDragDelta — gesture sequencing", () => {
   const start: Rect = { x: 100, y: 100, w: 300, h: 200 };
   const minSize = { w: 100, h: 80 };