test(webapp): prove a dropped navigation stays dropped

The guard compared a slice against its own start, so it could not fail. Move
the decision into takeNavigateIntent and drive it across two commits instead.

Author: kathiekiwi

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

@@ -27,7 +27,7 @@ import {
   hasOpenInvestigation,
   pollSettledTranscript,
 } from "./settled-transcript";
-import { navigateIntentApplies } from "./turn-navigation";
+import { takeNavigateIntent } from "./turn-navigation";
 import { teardownCancelsTurn, unmountTeardown } from "./turn-teardown";
 import { useAgentMessageQuota } from "./useAgentMessageQuota";
 import { useTriggerUriResolver } from "./useTriggerUriResolver";
@@ -306,16 +306,13 @@ export function DashboardAgentChat({
   }, [status]);
 
   useEffect(() => {
-    const pending = pendingNavigateIntents(messages, navigatedRef.current!);
-    const target = pending.at(-1);
-    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({
+    const target = takeNavigateIntent({
+      messages,
+      handled: navigatedRef.current!,
       startedPath: turnStartedPathRef.current,
       currentPath: renderedPathRef.current,
     });
-    if (applies) void goTo(target);
+    if (target) void goTo(target);
   }, [messages, goTo]);
 
   const watchProposedRef = useRef<Set<string> | null>(null);

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

@@ -1,6 +1,6 @@
 import { readFileSync } from "node:fs";
 import { describe, expect, it } from "vitest";
-import { navigateIntentApplies } from "./turn-navigation";
+import { navigateIntentApplies, takeNavigateIntent } from "./turn-navigation";
 
 const runs = "/orgs/acme/projects/api/env/prod/runs";
 const queues = "/orgs/acme/projects/api/env/prod/queues";
@@ -20,6 +20,62 @@ describe("navigateIntentApplies", () => {
   });
 });
 
+describe("takeNavigateIntent", () => {
+  const target = "trigger://proj_abc/env_123/run/run_abc";
+
+  function messages() {
+    return [
+      {
+        id: "msg_1",
+        parts: [
+          {
+            type: "tool-navigate_to",
+            state: "output-available",
+            toolCallId: "call_1",
+            output: { intent: { kind: "navigate", target } },
+          },
+        ],
+      },
+    ];
+  }
+
+  it("takes the navigation on the page the turn was asked for", () => {
+    const taken = takeNavigateIntent({
+      messages: messages(),
+      handled: new Set(),
+      startedPath: runs,
+      currentPath: runs,
+    });
+    expect(taken).toMatchObject({ kind: "navigate", target });
+  });
+
+  it("takes nothing once the user has walked to another screen", () => {
+    expect(
+      takeNavigateIntent({
+        messages: messages(),
+        handled: new Set(),
+        startedPath: runs,
+        currentPath: queues,
+      })
+    ).toBeUndefined();
+  });
+
+  // The property the panel depends on: a commit that drops a navigation still consumes it, so
+  // walking back to the page it was asked on does not make it fire late.
+  it("marks a dropped navigation handled, so a later commit cannot fire it", () => {
+    const handled = new Set<string>();
+    const parts = messages();
+
+    expect(
+      takeNavigateIntent({ messages: parts, handled, startedPath: runs, currentPath: queues })
+    ).toBeUndefined();
+
+    expect(
+      takeNavigateIntent({ messages: parts, handled, startedPath: runs, currentPath: runs })
+    ).toBeUndefined();
+  });
+});
+
 /**
  * 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
@@ -29,9 +85,9 @@ 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("takeNavigateIntent({");
     expect(chat).toContain("startedPath: turnStartedPathRef.current");
-    expect(chat).not.toContain("if (target) void goTo(target);");
+    expect(chat).not.toContain("pendingNavigateIntents(messages");
   });
 
   it("records the path only as a turn goes in flight", () => {
@@ -47,14 +103,11 @@ describe("the chat scopes a turn's navigation to the page it started on", () =>
 
   it("records the path before the intent effect reads it", () => {
     expect(chat.indexOf("turnStartedPathRef.current = renderedPathRef.current")).toBeLessThan(
-      chat.indexOf("navigateIntentApplies({")
+      chat.indexOf("takeNavigateIntent({")
     );
   });
 
-  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({")
-    );
+  it("hands the persistent handled-set in, so drops are recorded across commits", () => {
+    expect(chat).toContain("handled: navigatedRef.current!");
   });
 });

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

@@ -1,3 +1,5 @@
+import { pendingNavigateIntents } from "./pending-intents";
+
 /**
  * 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
@@ -10,3 +12,22 @@ export function navigateIntentApplies(paths: {
 }): boolean {
   return paths.startedPath === paths.currentPath;
 }
+
+type NavigateIntent = ReturnType<typeof pendingNavigateIntents>[number];
+
+/**
+ * The navigation to take on this commit, if any. Every intent is marked handled whether or not
+ * it applies, so one dropped here cannot fire on a later commit.
+ */
+export function takeNavigateIntent(args: {
+  messages: Parameters<typeof pendingNavigateIntents>[0];
+  handled: Set<string>;
+  startedPath: string | null;
+  currentPath: string;
+}): NavigateIntent | undefined {
+  const target = pendingNavigateIntents(args.messages, args.handled).at(-1);
+  if (!target) return undefined;
+  return navigateIntentApplies({ startedPath: args.startedPath, currentPath: args.currentPath })
+    ? target
+    : undefined;
+}