fix(webapp): send a deep-linked question once

setSearchParams only starts the navigation that drops the param, so a render
before it commits saw the question again and asked it a second time. The reader
now records what it sent and forgets it once the URL no longer carries it, so a
later visit with the same question still works.

Author: kathiekiwi

apps/webapp/app/components/dashboard-agent/dashboardAgentOpenRequest.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest";
+import { consumeDeepLinkQuestion } from "./dashboardAgentOpenRequest";
+
+const NAMES = ["aiHelp"];
+
+/**
+ * The reader is an effect over `useSearchParams`. Dropping the param is a navigation, so the
+ * effect can run again on the original params before it commits; without a record of what was
+ * already sent, the deep-linked question is asked twice.
+ */
+describe("consumeDeepLinkQuestion", () => {
+  const params = (search: string) => new URLSearchParams(search);
+
+  it("hands over the question the first time it sees it", () => {
+    expect(consumeDeepLinkQuestion(params("?aiHelp=why+is+it+slow"), NAMES, null)).toEqual({
+      question: "why is it slow",
+      sent: "why is it slow",
+    });
+  });
+
+  it("does not hand it over again while the param is still in the URL", () => {
+    const first = consumeDeepLinkQuestion(params("?aiHelp=why"), NAMES, null);
+    expect(first.question).toBe("why");
+    expect(consumeDeepLinkQuestion(params("?aiHelp=why"), NAMES, first.sent).question).toBeNull();
+  });
+
+  it("keeps the record until the param is gone, however many renders that takes", () => {
+    let sent: string | null = null;
+    let asked = 0;
+    for (let render = 0; render < 5; render++) {
+      const result = consumeDeepLinkQuestion(params("?aiHelp=why"), NAMES, sent);
+      sent = result.sent;
+      if (result.question !== null) asked++;
+    }
+    expect(asked).toBe(1);
+  });
+
+  it("forgets the question once the URL no longer carries it, so a later visit works", () => {
+    const first = consumeDeepLinkQuestion(params("?aiHelp=why"), NAMES, null);
+    const cleared = consumeDeepLinkQuestion(params(""), NAMES, first.sent);
+    expect(cleared).toEqual({ question: null, sent: null });
+    expect(consumeDeepLinkQuestion(params("?aiHelp=why"), NAMES, cleared.sent).question).toBe(
+      "why"
+    );
+  });
+
+  it("asks a different question that arrives before the first is dropped", () => {
+    const first = consumeDeepLinkQuestion(params("?aiHelp=why"), NAMES, null);
+    expect(consumeDeepLinkQuestion(params("?aiHelp=how"), NAMES, first.sent).question).toBe("how");
+  });
+
+  it("has nothing to ask when no watched param is present", () => {
+    expect(consumeDeepLinkQuestion(params("?other=x"), NAMES, null)).toEqual({
+      question: null,
+      sent: null,
+    });
+    expect(consumeDeepLinkQuestion(params("?aiHelp=why"), [], null).question).toBeNull();
+  });
+
+  it("ignores an empty question", () => {
+    expect(consumeDeepLinkQuestion(params("?aiHelp="), NAMES, null).question).toBeNull();
+  });
+});

apps/webapp/app/components/dashboard-agent/dashboardAgentOpenRequest.ts

@@ -1,4 +1,4 @@
-import { useEffect, useSyncExternalStore } from "react";
+import { useEffect, useRef, useSyncExternalStore } from "react";
 import { useSearchParams } from "@remix-run/react";
 
 // Module-level bridge: `DashboardAgentProvider` is mounted by the environment layout, so
@@ -49,6 +49,24 @@ export function useDashboardAgentAvailable(): boolean {
   );
 }
 
+/**
+ * The deep-link question still in the URL, or null when there is none left to ask. `sent` is the
+ * question already handed to the agent: `setSearchParams` only starts the navigation that drops
+ * the param, so every render until it commits sees the question again. Clearing `sent` once the
+ * param is gone lets the same question arrive a second time on a later visit.
+ */
+export function consumeDeepLinkQuestion(
+  params: URLSearchParams,
+  names: readonly string[],
+  sent: string | null
+): { question: string | null; sent: string | null } {
+  const name = names.find((candidate) => params.get(candidate));
+  if (!name) return { question: null, sent: null };
+  const question = params.get(name)!;
+  if (question === sent) return { question: null, sent };
+  return { question, sent: question };
+}
+
 /** While `enabled` is false nothing is registered, so every entry point stays hidden. */
 export function useDashboardAgentOpenRequests({
   enabled,
@@ -68,12 +86,16 @@ export function useDashboardAgentOpenRequests({
   }, [enabled, openWith, setOpen]);
 
   const [searchParams, setSearchParams] = useSearchParams();
+  const sent = useRef<string | null>(null);
   useEffect(() => {
     if (!enabled) return;
-    const param = deepLinkParams.find((name) => searchParams.get(name));
-    if (!param) return;
-    const question = searchParams.get(param)!;
-    // Consume it before opening, or a re-render asks the same question twice.
+    const { question, sent: nextSent } = consumeDeepLinkQuestion(
+      searchParams,
+      deepLinkParams,
+      sent.current
+    );
+    sent.current = nextSent;
+    if (question === null) return;
     const next = new URLSearchParams(searchParams);
     for (const name of deepLinkParams) next.delete(name);
     setSearchParams(next, { replace: true, preventScrollReset: true });