fix(webapp): stop the agent's retry duplicating the failed message

Retry appended the last user message again, so the failed turn stayed in the
transcript and its text was sent twice. It now regenerates once the agent has
started answering, and otherwise re-sends the failed turn under its own id.

Author: kathiekiwi

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

@@ -16,6 +16,7 @@ import { createTranscriptOrder, orderTranscript } from "./message-order";
 import { appendRunFilters } from "./navigate-target";
 import { pendingNavigateIntents } from "./pending-intents";
 import type { AgentPageContext } from "./page-context-types";
+import { retryAction } from "./retry-action";
 import {
   fetchChatTranscript,
   hasOpenInvestigation,
@@ -149,6 +150,7 @@ export function DashboardAgentChat({
     messages: rawMessages,
     setMessages,
     sendMessage,
+    regenerate,
     status,
     stop: aiStop,
     error,
@@ -192,15 +194,15 @@ export function DashboardAgentChat({
   );
 
   const retry = useCallback(() => {
-    const lastUserMessage = [...messages].reverse().find((m) => m.role === "user");
-    const text = lastUserMessage?.parts
-      ?.filter((p): p is { type: "text"; text: string } => p.type === "text")
-      .map((p) => p.text)
-      .join("\n")
-      .trim();
+    const action = retryAction(messages);
+    if (!action) return;
     clearError();
-    if (text) void sendMessage({ text });
-  }, [messages, sendMessage, clearError]);
+    if (action.kind === "regenerate") {
+      void regenerate();
+      return;
+    }
+    void sendMessage({ text: action.text, messageId: action.messageId });
+  }, [messages, sendMessage, regenerate, clearError]);
 
   const resolveUri = useTriggerUriResolver(actionPath);
 

apps/webapp/app/components/dashboard-agent/retry-action.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { retryAction } from "./retry-action";
+
+function user(id: string, ...texts: string[]) {
+  return { id, role: "user", parts: texts.map((text) => ({ type: "text", text })) };
+}
+
+function assistant(id: string, text: string) {
+  return { id, role: "assistant", parts: [{ type: "text", text }] };
+}
+
+describe("retryAction", () => {
+  it("re-sends the failed turn under its own id, never as a new message", () => {
+    expect(retryAction([assistant("a1", "hi"), user("u2", "why is it slow?")])).toEqual({
+      kind: "resend",
+      messageId: "u2",
+      text: "why is it slow?",
+    });
+  });
+
+  it("joins the failed turn's text parts", () => {
+    expect(retryAction([user("u1", "one", "two")])).toMatchObject({ text: "one\ntwo" });
+  });
+
+  it("regenerates when the agent already started answering", () => {
+    expect(retryAction([user("u1", "why?"), assistant("a1", "partial")])).toEqual({
+      kind: "regenerate",
+    });
+  });
+
+  it("does nothing on an empty transcript, where there is no turn to retry", () => {
+    expect(retryAction([])).toBeNull();
+  });
+
+  it("does nothing when the failed turn carries no text to re-send", () => {
+    expect(retryAction([{ id: "u1", role: "user", parts: [] }])).toBeNull();
+  });
+});

apps/webapp/app/components/dashboard-agent/retry-action.ts

@@ -0,0 +1,35 @@
+/**
+ * What the retry button should do after a failed turn.
+ *
+ * `regenerate()` sends no message at all — the agent trims its trailing assistant and re-runs
+ * from its own history. That is only safe once the agent has answered, because a turn can also
+ * fail before the message reaches it (a rejected or dropped `.in` append), and on the
+ * head-started first turn the agent would then have no history to run on.
+ */
+
+export type RetryMessage = {
+  id: string;
+  role: string;
+  parts?: readonly { type: string; text?: string }[];
+};
+
+export type RetryAction =
+  /** Built-in retry: the agent owns the turn and drops its own partial answer. */
+  | { kind: "regenerate" }
+  /** Re-send under the same id, so the message lands even if it never did, and never twice. */
+  | { kind: "resend"; messageId: string; text: string }
+  | null;
+
+export function retryAction(messages: readonly RetryMessage[]): RetryAction {
+  const last = messages[messages.length - 1];
+  if (!last) return null;
+  if (last.role !== "user") return { kind: "regenerate" };
+
+  const text = (last.parts ?? [])
+    .filter((part) => part.type === "text")
+    .map((part) => part.text ?? "")
+    .join("\n")
+    .trim();
+
+  return text ? { kind: "resend", messageId: last.id, text } : null;
+}