fix(webapp): send every prompt the user clicks, never just fill the composer

Investigate and the prompt chips now always send. With a chat open the message goes there; mid-turn or mid-open it waits for the chat rather than barging in.

Author: kathiekiwi

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

@@ -62,7 +62,7 @@ export function DashboardAgentChat({
   currentPage,
   pendingFirstMessage,
   streaming,
-  prefill,
+  sendRequest,
   promotedPrompt,
   watches,
   pagePaths,
@@ -86,8 +86,9 @@ export function DashboardAgentChat({
   // Undefined for head-started and resumed chats.
   pendingFirstMessage?: string;
   streaming?: boolean;
-  // `seq` makes each request distinct so the same text can be sent twice.
-  prefill?: { text: string; seq: number };
+  // A prompt the user asked for by clicking. `seq` makes each request distinct so the same
+  // text can be sent twice.
+  sendRequest?: { text: string; seq: number };
   promotedPrompt?: SuggestedPrompt;
   watches: WatchChip[];
   pagePaths?: Record<string, string>;
@@ -109,13 +110,6 @@ export function DashboardAgentChat({
   const renderedPathRef = useRef(location.pathname);
   renderedPathRef.current = location.pathname;
 
-  const prefilledSeq = useRef<number | undefined>(undefined);
-  useEffect(() => {
-    if (!prefill || prefilledSeq.current === prefill.seq) return;
-    prefilledSeq.current = prefill.seq;
-    setInput(prefill.text);
-  }, [prefill]);
-
   const transport = useTriggerChatTransport<typeof dashboardAgent>({
     task: "dashboard-agent",
     baseURL: apiOrigin,
@@ -232,6 +226,14 @@ export function DashboardAgentChat({
     [isStreaming, atMessageCap, sendMessage]
   );
 
+  // The panel only sends when the chat can take it, so this never lands mid-turn.
+  const sentRequestSeq = useRef<number | undefined>(undefined);
+  useEffect(() => {
+    if (!sendRequest || sentRequestSeq.current === sendRequest.seq) return;
+    sentRequestSeq.current = sendRequest.seq;
+    submit(sendRequest.text);
+  }, [sendRequest, submit]);
+
   const retry = useCallback(() => {
     // A watch's consent record is a user message nobody typed, so retry never treats it as one.
     const action = retryAction(
@@ -416,7 +418,7 @@ export function DashboardAgentChat({
             onSubmit={() => submit(input)}
             onStop={stop}
             isStreaming={isStreaming}
-            focusKey={prefill?.seq}
+            focusKey={sendRequest?.seq}
             context={
               <DashboardAgentContextBanner
                 projectSlug={projectSlug}

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

@@ -27,6 +27,7 @@ import type { SuggestedPrompt, WatchSpec } from "@internal/dashboard-agent-contr
 import { resolveOpenedChat, type OpenedChatResponse } from "./opened-chat";
 import type { AgentPageContext } from "./page-context-types";
 import { agentPageLabel } from "./page-label";
+import { explicitPromptTarget } from "./explicit-prompt";
 import { escapeClosesPanel } from "./panel-escape";
 import { markChatListRead, unreadWorkCount } from "./unread-counts";
 import { AgentPanelColumn } from "./panel-layout";
@@ -341,20 +342,25 @@ export function DashboardAgentPanel({
   }, [chats, chatsLoaded, onUnreadWorkChange]);
 
   // Bound to its chat, which remounts with a fresh guard ref on every switch.
-  const [prefill, setPrefill] = useState<{ text: string; seq: number; chatId: string } | undefined>(
-    undefined
-  );
+  const [sendRequest, setSendRequest] = useState<
+    { text: string; seq: number; chatId: string } | undefined
+  >(undefined);
   const handledRequestSeq = useRef<number | undefined>(undefined);
   useEffect(() => {
-    if (!requestedMessage || loading) return;
-    if (handledRequestSeq.current === requestedMessage.seq) return;
+    if (!requestedMessage || handledRequestSeq.current === requestedMessage.seq) return;
+    const target = explicitPromptTarget({
+      chat: loading ? "opening" : active ? "open" : "none",
+      turnInFlight: thinkingChatId !== null && thinkingChatId === active?.chatId,
+    });
+    // Held requests are re-asked by this same effect once the panel settles.
+    if (target === "hold") return;
     handledRequestSeq.current = requestedMessage.seq;
-    if (active) {
-      setPrefill({ ...requestedMessage, chatId: active.chatId });
-    } else {
+    if (target === "new-chat") {
       void createChat(requestedMessage.text);
+      return;
     }
-  }, [requestedMessage, loading, active, createChat]);
+    setSendRequest({ ...requestedMessage, chatId: active!.chatId });
+  }, [requestedMessage, loading, active, thinkingChatId, createChat]);
 
   // Carries its chat id so a later-mounted chat cannot adopt another chat's block.
   const [appendedMessages, setAppendedMessages] = useState<
@@ -574,7 +580,9 @@ export function DashboardAgentPanel({
             session={active.session}
             pendingFirstMessage={active.pendingFirstMessage}
             streaming={active.streaming}
-            prefill={prefill && prefill.chatId === active.chatId ? prefill : undefined}
+            sendRequest={
+              sendRequest && sendRequest.chatId === active.chatId ? sendRequest : undefined
+            }
             clientData={clientData}
             apiOrigin={apiOrigin}
             actionPath={actionPath}

apps/webapp/app/components/dashboard-agent/explicit-prompt.test.ts

@@ -0,0 +1,62 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { explicitPromptTarget } from "./explicit-prompt";
+
+describe("explicitPromptTarget", () => {
+  it("starts a chat when the panel has none", () => {
+    expect(explicitPromptTarget({ chat: "none", turnInFlight: false })).toBe("new-chat");
+  });
+
+  it("sends into the chat the user is already in", () => {
+    expect(explicitPromptTarget({ chat: "open", turnInFlight: false })).toBe("send-to-open-chat");
+  });
+
+  it("holds while a chat is still opening, rather than racing it into a new one", () => {
+    expect(explicitPromptTarget({ chat: "opening", turnInFlight: false })).toBe("hold");
+  });
+
+  it("holds while the open chat is mid-turn instead of barging in", () => {
+    expect(explicitPromptTarget({ chat: "open", turnInFlight: true })).toBe("hold");
+  });
+
+  it("never fills the composer and leaves the sending to the user", () => {
+    const targets = (["none", "opening", "open"] as const).flatMap((chat) =>
+      [true, false].map((turnInFlight) => explicitPromptTarget({ chat, turnInFlight }))
+    );
+    expect(targets).not.toContain("prefill");
+  });
+});
+
+/**
+ * Structural guards, not behavioural proof: whether a held request is asked again, and whether
+ * the old prefill path is really gone, live in the wiring rather than in the rule.
+ */
+describe("the panel sends every explicit prompt", () => {
+  const panel = readFileSync(new URL("./DashboardAgentPanel.tsx", import.meta.url), "utf8");
+  const chat = readFileSync(new URL("./DashboardAgentChat.tsx", import.meta.url), "utf8");
+
+  it("routes through the shared rule", () => {
+    expect(panel).toContain("explicitPromptTarget({");
+  });
+
+  it("keeps a held request pending instead of marking it handled", () => {
+    const effect = panel.slice(panel.indexOf("const target = explicitPromptTarget({"));
+    expect(effect.indexOf('if (target === "hold") return;')).toBeLessThan(
+      effect.indexOf("handledRequestSeq.current = requestedMessage.seq;")
+    );
+  });
+
+  it("re-asks once the panel settles, so a hold cannot strand the prompt", () => {
+    expect(panel).toContain("}, [requestedMessage, loading, active, thinkingChatId, createChat]);");
+  });
+
+  it("leaves no prefill path behind", () => {
+    expect(panel).not.toMatch(/prefill/i);
+    expect(chat).not.toMatch(/prefill/i);
+  });
+
+  it("submits the request in the chat rather than typing it into the composer", () => {
+    expect(chat).toContain("submit(sendRequest.text);");
+    expect(chat).not.toContain("setInput(sendRequest.text)");
+  });
+});

apps/webapp/app/components/dashboard-agent/explicit-prompt.ts

@@ -0,0 +1,16 @@
+/** What to do with a prompt the user asked for by clicking, rather than by typing. */
+export type ExplicitPromptTarget = "new-chat" | "send-to-open-chat" | "hold";
+
+/**
+ * A click on Investigate or a prompt chip always ends in a sent message; only where it lands
+ * depends on the panel. `hold` is not a refusal — the request stays pending and is asked again
+ * once the chat has opened or its turn has finished.
+ */
+export function explicitPromptTarget(panel: {
+  chat: "none" | "opening" | "open";
+  turnInFlight: boolean;
+}): ExplicitPromptTarget {
+  if (panel.chat === "opening") return "hold";
+  if (panel.chat === "none") return "new-chat";
+  return panel.turnInFlight ? "hold" : "send-to-open-chat";
+}

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

@@ -10,9 +10,8 @@ export function teardownCancelsTurn(reason: TurnTeardown): boolean {
 }
 
 /**
- * The three unmounts look identical from inside React. A navigation has already moved the URL
- * by the time the cleanup runs; closing the panel and switching chat leave it alone, and since
- * both keep the turn they share one branch.
+ * The three unmounts look identical from inside React. Only a navigation has already moved the
+ * URL by the time the cleanup runs; the other two keep the turn, so they share one branch.
  */
 export function unmountTeardown(paths: { renderedPath: string; livePath: string }): TurnTeardown {
   return paths.renderedPath === paths.livePath ? "panel-closed" : "navigated-away";