fix(webapp): stop a resumed turn navigating the tab that only picked it up

navigateIntentApplies documents startedPath: null as 'this tab never saw the turn start', but
the path was inferred from the turn going in flight - and a resumed turn goes in flight too, so
the tab stamped wherever it happened to be and the rule always matched. Stamp the path where a
turn is actually started instead, which leaves it null for a turn this tab only resumed.

Author: kathiekiwi

apps/webapp/app/components/dashboard-agent/DashboardAgentChat.tsx

@@ -208,10 +208,17 @@ export function DashboardAgentChat({
     });
   }, [appendedMessages, setMessages]);
 
+  // Where this tab asked for the running turn, stamped only where a turn is actually started
+  // here. A turn this tab resumed leaves it null, which is what tells `takeNavigateIntent` the
+  // tab cannot claim the user is still on the page that asked. Never cleared on settle: the
+  // navigate intent can be committed alongside the status going ready.
+  const turnStartedPathRef = useRef<string | null>(null);
+
   const sentFirst = useRef(false);
   useEffect(() => {
     if (pendingFirstMessage && !sentFirst.current) {
       sentFirst.current = true;
+      turnStartedPathRef.current = renderedPathRef.current;
       void sendMessage({ text: pendingFirstMessage });
     }
   }, [pendingFirstMessage, sendMessage]);
@@ -222,6 +229,7 @@ export function DashboardAgentChat({
       // Suggested prompts and card actions bypass the composer, so the cap is enforced here too.
       if (!trimmed || isStreaming || atMessageCap) return;
       setInput("");
+      turnStartedPathRef.current = renderedPathRef.current;
       void sendMessage({ text: trimmed });
     },
     [isStreaming, atMessageCap, sendMessage]
@@ -250,6 +258,7 @@ export function DashboardAgentChat({
     );
     if (!action) return;
     clearError();
+    turnStartedPathRef.current = renderedPathRef.current;
     if (action.kind === "regenerate") {
       void regenerate();
       return;
@@ -313,16 +322,6 @@ export function DashboardAgentChat({
     navigatedRef.current = new Set();
     pendingNavigateIntents(initialMessages, navigatedRef.current);
   }
-  // Where the running turn was asked for. Never cleared on settle: the navigate intent can be
-  // committed alongside the status going ready, and it is the started-at path it belongs to.
-  const turnStartedPathRef = useRef<string | null>(null);
-  const turnWasInFlight = useRef(false);
-  useEffect(() => {
-    const inFlight = status === "submitted" || status === "streaming";
-    if (inFlight && !turnWasInFlight.current) turnStartedPathRef.current = renderedPathRef.current;
-    turnWasInFlight.current = inFlight;
-  }, [status]);
-
   useEffect(() => {
     const target = takeNavigateIntent({
       messages,

apps/webapp/app/components/dashboard-agent/turn-navigation.test.ts

@@ -90,15 +90,34 @@ describe("the chat scopes a turn's navigation to the page it started on", () =>
     expect(chat).not.toContain("pendingNavigateIntents(messages");
   });
 
-  it("records the path only as a turn goes in flight", () => {
-    expect(chat).toContain(
-      "if (inFlight && !turnWasInFlight.current) turnStartedPathRef.current = renderedPathRef.current;"
+  // Structural: the webapp has no DOM test environment, so the wiring is read off the source.
+  // Going in flight cannot mean "started here" — a resumed turn goes in flight too, and stamping
+  // on status handed it the current path and let it navigate.
+  it("does not infer the path from the turn going in flight", () => {
+    expect(chat).not.toContain("turnWasInFlight");
+    expect(chat).not.toMatch(
+      /status === "submitted"[\s\S]{0,160}turnStartedPathRef\.current = renderedPathRef/
     );
   });
 
+  it("stamps the path at every send, so a turn this tab only resumed leaves it null", () => {
+    const lines = chat.split("\n");
+    const sends = lines
+      .map((line, index) => ({ line, index }))
+      .filter(({ line }) => /void (sendMessage|regenerate)\(/.test(line));
+
+    expect(sends.length).toBeGreaterThan(0);
+    for (const { line, index } of sends) {
+      const preceding = lines.slice(Math.max(0, index - 5), index).join("\n");
+      expect(
+        preceding.includes("turnStartedPathRef.current = renderedPathRef.current"),
+        `no path stamped before: ${line.trim()}`
+      ).toBe(true);
+    }
+  });
+
   it("never clears the path on settle, which can share a commit with the intent", () => {
-    const assignments = [...chat.matchAll(/turnStartedPathRef\.current = /g)];
-    expect(assignments).toHaveLength(1);
+    expect(chat).not.toMatch(/turnStartedPathRef\.current = null/);
   });
 
   it("records the path before the intent effect reads it", () => {