fix(webapp): scope a turn's navigation to the page it was asked on

A turn that outlives its page no longer moves a user who has since walked to another screen. The answer's own button still takes them there.

Author: kathiekiwi

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

@@ -27,6 +27,7 @@ import {
   hasOpenInvestigation,
   pollSettledTranscript,
 } from "./settled-transcript";
+import { navigateIntentApplies } from "./turn-navigation";
 import { teardownCancelsTurn, unmountTeardown } from "./turn-teardown";
 import { useAgentMessageQuota } from "./useAgentMessageQuota";
 import { useTriggerUriResolver } from "./useTriggerUriResolver";
@@ -103,6 +104,11 @@ export function DashboardAgentChat({
   const location = useLocation();
   const toast = useToast();
 
+  // The path this chat last rendered on. React never unmounts on a page teardown, so an
+  // unmount whose live URL has moved is the router having navigated out from under it.
+  const renderedPathRef = useRef(location.pathname);
+  renderedPathRef.current = location.pathname;
+
   const prefilledSeq = useRef<number | undefined>(undefined);
   useEffect(() => {
     if (!prefill || prefilledSeq.current === prefill.seq) return;
@@ -287,10 +293,27 @@ 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 pending = pendingNavigateIntents(messages, navigatedRef.current!);
     const target = pending.at(-1);
-    if (target) void goTo(target);
+    if (!target) return;
+    // Marked handled above either way, so a dropped navigation stays dropped and the answer's
+    // own button remains the way to take it.
+    const applies = navigateIntentApplies({
+      startedPath: turnStartedPathRef.current,
+      currentPath: renderedPathRef.current,
+    });
+    if (applies) void goTo(target);
   }, [messages, goTo]);
 
   const watchProposedRef = useRef<Set<string> | null>(null);
@@ -309,11 +332,6 @@ export function DashboardAgentChat({
     aiStop();
   }, [transport, chatId, aiStop]);
 
-  // The path this chat last rendered on. React never unmounts on a page teardown, so an
-  // unmount whose live URL has moved is the router having navigated out from under it.
-  const renderedPathRef = useRef(location.pathname);
-  renderedPathRef.current = location.pathname;
-
   const teardownRef = useRef<() => void>(() => {});
   teardownRef.current = () => {
     if (status !== "streaming" && status !== "submitted") return;

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

@@ -0,0 +1,60 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { navigateIntentApplies } from "./turn-navigation";
+
+const runs = "/orgs/acme/projects/api/env/prod/runs";
+const queues = "/orgs/acme/projects/api/env/prod/queues";
+
+describe("navigateIntentApplies", () => {
+  it("navigates when the user is still where the turn was asked for", () => {
+    expect(navigateIntentApplies({ startedPath: runs, currentPath: runs })).toBe(true);
+  });
+
+  it("drops the navigation once the user has walked to another screen", () => {
+    expect(navigateIntentApplies({ startedPath: runs, currentPath: queues })).toBe(false);
+  });
+
+  it("drops it when this tab never saw the turn start", () => {
+    // A resumed turn: nothing here knows the page it was asked on.
+    expect(navigateIntentApplies({ startedPath: null, currentPath: runs })).toBe(false);
+  });
+});
+
+/**
+ * Structural guards, not behavioural proof: whether the started-at path is still right when the
+ * intent lands depends on effect order and on nothing clearing it, which these assertions pin
+ * down without rendering anything.
+ */
+describe("the chat scopes a turn's navigation to the page it started on", () => {
+  const chat = readFileSync(new URL("./DashboardAgentChat.tsx", import.meta.url), "utf8");
+
+  it("gates the navigate intent on the shared rule", () => {
+    expect(chat).toContain("navigateIntentApplies({");
+    expect(chat).toContain("startedPath: turnStartedPathRef.current");
+    expect(chat).not.toContain("if (target) void goTo(target);");
+  });
+
+  it("records the path only as a turn goes in flight", () => {
+    expect(chat).toContain(
+      "if (inFlight && !turnWasInFlight.current) turnStartedPathRef.current = renderedPathRef.current;"
+    );
+  });
+
+  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);
+  });
+
+  it("records the path before the intent effect reads it", () => {
+    expect(chat.indexOf("turnStartedPathRef.current = renderedPathRef.current")).toBeLessThan(
+      chat.indexOf("navigateIntentApplies({")
+    );
+  });
+
+  it("marks a dropped navigation handled, so it cannot fire on a later commit", () => {
+    const effect = chat.slice(chat.indexOf("const pending = pendingNavigateIntents(messages"));
+    expect(effect.indexOf("pendingNavigateIntents(messages")).toBeLessThan(
+      effect.indexOf("navigateIntentApplies({")
+    );
+  });
+});

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

@@ -0,0 +1,12 @@
+/**
+ * The panel follows the user around the dashboard, so a turn can outlive the page it was asked
+ * on. Its navigation applies only there: someone who has since walked to another screen keeps
+ * the screen they chose, and the answer's own button is still theirs to click.
+ */
+export function navigateIntentApplies(paths: {
+  /** Null when this tab never saw the turn start, so it cannot claim the user is still there. */
+  startedPath: string | null;
+  currentPath: string;
+}): boolean {
+  return paths.startedPath === paths.currentPath;
+}