diff --git a/packages/chat-ui/src/api.ts b/packages/chat-ui/src/api.ts
index 2e7c5b21a..6bbe2c074 100644
--- a/packages/chat-ui/src/api.ts
+++ b/packages/chat-ui/src/api.ts
@@ -1056,6 +1056,7 @@ const BlockResponsePayloadWire = type({
       kind: "'question'",
       answer: "string",
       "optionIndex?": "number",
+      notifiedAt: "string | null",
     }),
   );
 export type BlockResponsePayload = typeof BlockResponsePayloadWire.infer;
diff --git a/packages/chat-ui/src/blocks/block-responses.ts b/packages/chat-ui/src/blocks/block-responses.ts
index b8c015c0c..422ffe2c6 100644
--- a/packages/chat-ui/src/blocks/block-responses.ts
+++ b/packages/chat-ui/src/blocks/block-responses.ts
@@ -25,6 +25,13 @@ export type QuestionResponsePayload = {
   readonly kind: "question";
   readonly answer: string;
   readonly optionIndex?: number;
+  /**
+   * ISO timestamp once the asking agent was notified, or `null` when
+   * the answer is on file but notify never landed. Omitted only in
+   * tests that are not exercising the retry path — treat missing as
+   * already notified.
+   */
+  readonly notifiedAt?: string | null;
 };
 
 export type BlockResponsePayload =
diff --git a/packages/chat-ui/src/blocks/question-block.tsx b/packages/chat-ui/src/blocks/question-block.tsx
index 689520847..c39131b46 100644
--- a/packages/chat-ui/src/blocks/question-block.tsx
+++ b/packages/chat-ui/src/blocks/question-block.tsx
@@ -6,9 +6,12 @@
 // route additionally relays it into the workbench as this principal's own
 // message (see `packages/chat/src/routes.ts`) -- the card itself never
 // asserts a resolved answer; it always re-reads `own` from the server,
-// same anti-spoof rule every other block card follows.
+// same anti-spoof rule every other block card follows. A question `own`
+// carries `notifiedAt`: null means the answer is on file but notify never
+// landed, so the card keeps a retry (including after remount) rather than
+// collapsing as if the agent had already been reached.
 
-import { useEffect, useState, type FormEvent } from "react";
+import { useEffect, useRef, useState, type FormEvent } from "react";
 import type { QuestionBlockData } from "@corbits/chat/blocks";
 import { Check } from "@corbits/icons";
 
@@ -19,14 +22,60 @@ import type {
   BlockResponseQuery,
 } from "./block-responses";
 
-function ownAnswer(
-  query: BlockResponseQuery,
-): { readonly answer: string; readonly optionIndex?: number } | null {
+function ownAnswer(query: BlockResponseQuery): {
+  readonly answer: string;
+  readonly optionIndex?: number;
+  readonly notifiedAt?: string | null;
+} | null {
   if (query.kind !== "ready" || query.own === null) return null;
   if (query.own.kind !== "question") return null;
-  return query.own.optionIndex !== undefined
-    ? { answer: query.own.answer, optionIndex: query.own.optionIndex }
-    : { answer: query.own.answer };
+  return {
+    answer: query.own.answer,
+    ...(query.own.optionIndex !== undefined
+      ? { optionIndex: query.own.optionIndex }
+      : {}),
+    ...(query.own.notifiedAt !== undefined
+      ? { notifiedAt: query.own.notifiedAt }
+      : {}),
+  };
+}
+
+function notifyNeverLanded(answered: ReturnType<typeof ownAnswer>): boolean {
+  return answered !== null && answered.notifiedAt === null;
+}
+
+function answeredValue(
+  answered: NonNullable<ReturnType<typeof ownAnswer>>,
+): string {
+  return answered.optionIndex !== undefined
+    ? `${CHAT_STRINGS.optionLetter(answered.optionIndex)}. ${answered.answer}`
+    : answered.answer;
+}
+
+function AnsweredSummary({
+  answered,
+  notifyFailed,
+}: {
+  readonly answered: NonNullable<ReturnType<typeof ownAnswer>>;
+  readonly notifyFailed: boolean;
+}) {
+  return (
+    <div className="chat-block-question-answered" data-answered="true">
+      {!notifyFailed && (
+        <span className="chat-block-question-check" aria-hidden="true">
+          <Check />
+        </span>
+      )}
+      <div>
+        <p className="chat-block-question-answered-label">
+          {CHAT_STRINGS.blockQuestionAnsweredLabel}
+        </p>
+        <p className="chat-block-question-answered-value">
+          {answeredValue(answered)}
+        </p>
+      </div>
+    </div>
+  );
 }
 
 function StaticOptions({ data }: { readonly data: QuestionBlockData }) {
@@ -60,6 +109,7 @@ export function QuestionBlockView({
 }) {
   const [query, setQuery] = useState<BlockResponseQuery>({ kind: "loading" });
   const [submitting, setSubmitting] = useState(false);
+  const submittingRef = useRef(false);
   const [error, setError] = useState<string | null>(null);
   const [freeText, setFreeText] = useState("");
 
@@ -67,6 +117,7 @@ export function QuestionBlockView({
     if (actions === undefined || messageId === undefined) return;
     let cancelled = false;
     setQuery({ kind: "loading" });
+    setError(null);
     actions.getResponses(messageId, data.questionId).then((result) => {
       if (!cancelled) setQuery(result);
     });
@@ -90,17 +141,29 @@ export function QuestionBlockView({
 
   function submitAnswer(answer: string, optionIndex?: number) {
     if (actions === undefined || messageId === undefined) return;
+    if (submitting || submittingRef.current) return;
+    submittingRef.current = true;
     setSubmitting(true);
     setError(null);
     actions
       .submitQuestion(messageId, data.questionId, answer, optionIndex)
-      .then((result) => {
-        if (result.kind !== "submitted") {
-          setError(CHAT_STRINGS.blockQuestionAnswerError);
-        }
-        return actions.getResponses(messageId, data.questionId).then(setQuery);
+      .then(async (result) => {
+        const next = await actions.getResponses(messageId, data.questionId);
+        setQuery(next);
+        if (result.kind === "submitted") return;
+        // Persist failure leaves no `own`; notify_failed leaves `own` with
+        // `notifiedAt: null`. The card derives retry from that GET, not from
+        // this submit result — the result only picks the error copy.
+        setError(
+          ownAnswer(next) !== null
+            ? CHAT_STRINGS.blockQuestionNotifyFailed
+            : CHAT_STRINGS.blockQuestionAnswerError,
+        );
       })
-      .finally(() => setSubmitting(false));
+      .finally(() => {
+        submittingRef.current = false;
+        setSubmitting(false);
+      });
   }
 
   function onFreeTextSubmit(event: FormEvent<HTMLFormElement>) {
@@ -112,25 +175,36 @@ export function QuestionBlockView({
 
   const loading = query.kind === "loading";
   const answered = ownAnswer(query);
+  const notifyFailed = notifyNeverLanded(answered);
 
   if (answered !== null) {
     return (
       <BlockCard title={data.question}>
-        <div className="chat-block-question-answered" data-answered="true">
-          <span className="chat-block-question-check" aria-hidden="true">
-            <Check />
-          </span>
-          <div>
-            <p className="chat-block-question-answered-label">
-              {CHAT_STRINGS.blockQuestionAnsweredLabel}
+        <AnsweredSummary answered={answered} notifyFailed={notifyFailed} />
+        {notifyFailed && (
+          <>
+            <p className="chat-block-text" role="alert">
+              {error ?? CHAT_STRINGS.blockQuestionNotifyFailed}
             </p>
-            <p className="chat-block-question-answered-value">
-              {answered.optionIndex !== undefined
-                ? `${CHAT_STRINGS.optionLetter(answered.optionIndex)}. ${answered.answer}`
-                : answered.answer}
-            </p>
-          </div>
-        </div>
+            <div className="chat-block-actions">
+              <button
+                type="button"
+                className="chat-block-question-freetext-submit"
+                data-question-retry=""
+                disabled={submitting}
+                onClick={() =>
+                  answered.optionIndex !== undefined
+                    ? submitAnswer(answered.answer, answered.optionIndex)
+                    : submitAnswer(answered.answer)
+                }
+              >
+                {submitting
+                  ? CHAT_STRINGS.blockQuestionSubmitting
+                  : CHAT_STRINGS.blockQuestionRetry}
+              </button>
+            </div>
+          </>
+        )}
       </BlockCard>
     );
   }
diff --git a/packages/chat-ui/src/strings.ts b/packages/chat-ui/src/strings.ts
index 4a9790311..70237a9ff 100644
--- a/packages/chat-ui/src/strings.ts
+++ b/packages/chat-ui/src/strings.ts
@@ -216,6 +216,9 @@ export const CHAT_STRINGS = {
   blockQuestionSubmit: "Send",
   blockQuestionSubmitting: "Sending…",
   blockQuestionAnswerError: "Couldn't send your answer — try again.",
+  blockQuestionNotifyFailed:
+    "Your answer was saved, but the agent couldn't be notified — try again.",
+  blockQuestionRetry: "Try again",
   blockQuestionAnsweredLabel: "Your answer",
   blockConnectGithubPickHeadline: "Choose what gets reviewed",
   blockConnectGithubStepDone: "Done",
diff --git a/packages/chat-ui/test/question-block.test.tsx b/packages/chat-ui/test/question-block.test.tsx
index 04091ee50..e98e708fb 100644
--- a/packages/chat-ui/test/question-block.test.tsx
+++ b/packages/chat-ui/test/question-block.test.tsx
@@ -1,10 +1,13 @@
 // DOM tests for the interview-question card: open state (lettered options,
 // optional free-text field), answered state (collapsed with a checkmark,
-// controls disabled), and keyboard navigation over the option buttons
-// (native tab order — no custom key handling needed since each option is
-// a plain `<button>`). Mirrors `poll-block.test.tsx`'s stateful-fake
-// pattern: the render always reflects the last `getResponses` read, never
-// a click's own optimistic guess.
+// controls disabled), retry after a failed notify (the route persists the
+// answer before notify, so `own` is set with `notifiedAt: null` even when
+// submit returns an error — including after remount), persist failure (no
+// `own`, open form + generic error), and keyboard navigation over the
+// option buttons (native tab order — no custom key handling needed since
+// each option is a plain `<button>`).
+// Mirrors `poll-block.test.tsx`'s stateful-fake pattern: the render always
+// reflects the last `getResponses` read, never a click's own optimistic guess.
 import { afterEach, describe, expect, test } from "bun:test";
 import { act } from "react";
 import { createRoot } from "react-dom/client";
@@ -15,6 +18,7 @@ import type {
   BlockResponseQuery,
 } from "../src/blocks/block-responses";
 import type { MessageItem } from "../src/api";
+import { CHAT_STRINGS } from "../src/strings";
 import { WorkbenchTimeline } from "../src/timeline";
 
 function messageWithQuestionBlock(allowFreeText = false): MessageItem[] {
@@ -42,9 +46,17 @@ function messageWithQuestionBlock(allowFreeText = false): MessageItem[] {
   ];
 }
 
-function fakeBackend() {
-  let answer: { answer: string; optionIndex?: number } | null = null;
+function fakeBackend(opts?: {
+  readonly failSubmits?: number;
+  readonly persistFails?: boolean;
+}) {
+  let answer: {
+    answer: string;
+    optionIndex?: number;
+    notifiedAt: string | null;
+  } | null = null;
   const submitCalls: { answer: string; optionIndex: number | undefined }[] = [];
+  let remainingFails = opts?.failSubmits ?? 0;
 
   const actions: BlockResponseActions = {
     getResponses: async (): Promise<BlockResponseQuery> => ({
@@ -60,6 +72,7 @@ function fakeBackend() {
               ...(answer.optionIndex !== undefined
                 ? { optionIndex: answer.optionIndex }
                 : {}),
+              notifiedAt: answer.notifiedAt,
             },
     }),
     submitPoll: async () => ({ kind: "submitted" }),
@@ -71,10 +84,21 @@ function fakeBackend() {
       optionIndex,
     ) => {
       submitCalls.push({ answer: submittedAnswer, optionIndex });
+      if (opts?.persistFails === true) {
+        return { kind: "error", message: "persist_failed" };
+      }
+      // The route persists the answer before notify; a failed notify still
+      // leaves `own` with `notifiedAt: null` on the subsequent GET.
+      const failing = remainingFails > 0;
+      if (failing) remainingFails -= 1;
       answer = {
         answer: submittedAnswer,
         ...(optionIndex !== undefined ? { optionIndex } : {}),
+        notifiedAt: failing ? null : "2026-01-01T00:00:00.000Z",
       };
+      if (failing) {
+        return { kind: "error", message: "notify_failed" };
+      }
       return { kind: "submitted" };
     },
   };
@@ -116,6 +140,22 @@ async function mount(actions: BlockResponseActions, allowFreeText = false) {
   return container;
 }
 
+function choiceButton(el: HTMLElement, label: string): HTMLButtonElement {
+  const button = [...el.querySelectorAll(".chat-block-question-choice")].find(
+    (node) => node.textContent?.includes(label),
+  ) as HTMLButtonElement | undefined;
+  if (button === undefined) throw new Error(`expected ${label}`);
+  return button;
+}
+
+async function remount(actions: BlockResponseActions, allowFreeText = false) {
+  if (root !== null) act(() => root?.unmount());
+  container?.remove();
+  container = null;
+  root = null;
+  return mount(actions, allowFreeText);
+}
+
 describe("question card — open state", () => {
   test("with no port, options render disabled with no answer state", async () => {
     container = document.createElement("div");
@@ -183,20 +223,15 @@ describe("question card — answering", () => {
     const backend = fakeBackend();
     const el = await mount(backend.actions);
 
-    const production = [
-      ...el.querySelectorAll(".chat-block-question-choice"),
-    ].find((button) => button.textContent?.includes("Production")) as
-      HTMLButtonElement | undefined;
-    if (production === undefined) throw new Error("expected Production");
-
     await act(async () => {
-      production.click();
+      choiceButton(el, "Production").click();
     });
 
     expect(backend.submitCalls).toEqual([
       { answer: "Production", optionIndex: 1 },
     ]);
     expect(el.querySelector('[data-answered="true"]')).not.toBeNull();
+    expect(el.querySelector(".chat-block-question-check")).not.toBeNull();
     expect(el.textContent).toContain("Production");
     expect(el.querySelectorAll(".chat-block-question-choice")).toHaveLength(0);
   });
@@ -223,5 +258,132 @@ describe("question card — answering", () => {
       { answer: "Somewhere else entirely", optionIndex: undefined },
     ]);
     expect(el.textContent).toContain("Somewhere else entirely");
+    expect(el.querySelector(".chat-block-question-check")).not.toBeNull();
+  });
+
+  test("a failed notify keeps a retry so the saved answer can still reach the agent", async () => {
+    const backend = fakeBackend({ failSubmits: 1 });
+    const el = await mount(backend.actions);
+
+    await act(async () => {
+      choiceButton(el, "Production").click();
+    });
+
+    expect(backend.submitCalls).toEqual([
+      { answer: "Production", optionIndex: 1 },
+    ]);
+    expect(el.querySelector('[data-answered="true"]')).not.toBeNull();
+    expect(el.textContent).toContain("Production");
+    expect(el.querySelector(".chat-block-question-check")).toBeNull();
+    const alert = el.querySelector("[role='alert']");
+    expect(alert).not.toBeNull();
+    expect(alert?.textContent).toBe(CHAT_STRINGS.blockQuestionNotifyFailed);
+
+    const retry = el.querySelector(
+      "[data-question-retry]",
+    ) as HTMLButtonElement | null;
+    expect(retry).not.toBeNull();
+    expect(retry?.disabled).toBe(false);
+
+    await act(async () => {
+      retry?.click();
+    });
+
+    expect(backend.submitCalls).toEqual([
+      { answer: "Production", optionIndex: 1 },
+      { answer: "Production", optionIndex: 1 },
+    ]);
+    expect(el.querySelector("[role='alert']")).toBeNull();
+    expect(el.querySelector("[data-question-retry]")).toBeNull();
+    expect(el.querySelector('[data-answered="true"]')).not.toBeNull();
+    expect(el.querySelector(".chat-block-question-check")).not.toBeNull();
+    expect(el.querySelectorAll(".chat-block-question-choice")).toHaveLength(0);
+  });
+
+  test("remount after notify_failed still offers retry from GET own", async () => {
+    const backend = fakeBackend({ failSubmits: 1 });
+    const el = await mount(backend.actions);
+
+    await act(async () => {
+      choiceButton(el, "Production").click();
+    });
+    expect(el.querySelector("[data-question-retry]")).not.toBeNull();
+
+    const remounted = await remount(backend.actions);
+    expect(remounted.querySelector('[data-answered="true"]')).not.toBeNull();
+    expect(remounted.querySelector(".chat-block-question-check")).toBeNull();
+    const alert = remounted.querySelector("[role='alert']");
+    expect(alert?.textContent).toBe(CHAT_STRINGS.blockQuestionNotifyFailed);
+    const retry = remounted.querySelector(
+      "[data-question-retry]",
+    ) as HTMLButtonElement | null;
+    expect(retry).not.toBeNull();
+
+    await act(async () => {
+      retry?.click();
+    });
+    expect(backend.submitCalls).toEqual([
+      { answer: "Production", optionIndex: 1 },
+      { answer: "Production", optionIndex: 1 },
+    ]);
+    expect(remounted.querySelector("[data-question-retry]")).toBeNull();
+    expect(
+      remounted.querySelector(".chat-block-question-check"),
+    ).not.toBeNull();
+  });
+
+  test("free-text notify-failed retry resubmits the same string without optionIndex", async () => {
+    const backend = fakeBackend({ failSubmits: 1 });
+    const el = await mount(backend.actions, true);
+
+    const input = el.querySelector(
+      ".chat-block-question-freetext input",
+    ) as HTMLInputElement;
+    const form = el.querySelector(
+      ".chat-block-question-freetext",
+    ) as HTMLFormElement;
+
+    await act(async () => {
+      setInputValue(input, "Somewhere else entirely");
+    });
+    await act(async () => {
+      form.requestSubmit();
+    });
+
+    expect(backend.submitCalls).toEqual([
+      { answer: "Somewhere else entirely", optionIndex: undefined },
+    ]);
+    const retry = el.querySelector(
+      "[data-question-retry]",
+    ) as HTMLButtonElement | null;
+    expect(retry).not.toBeNull();
+
+    await act(async () => {
+      retry?.click();
+    });
+
+    expect(backend.submitCalls).toEqual([
+      { answer: "Somewhere else entirely", optionIndex: undefined },
+      { answer: "Somewhere else entirely", optionIndex: undefined },
+    ]);
+    expect(el.querySelector("[data-question-retry]")).toBeNull();
+  });
+
+  test("persist failure with no own still shows the open form and a generic error", async () => {
+    const backend = fakeBackend({ persistFails: true });
+    const el = await mount(backend.actions);
+
+    await act(async () => {
+      choiceButton(el, "Production").click();
+    });
+
+    expect(backend.submitCalls).toEqual([
+      { answer: "Production", optionIndex: 1 },
+    ]);
+    expect(el.querySelector('[data-answered="true"]')).toBeNull();
+    expect(el.querySelector("[data-question-retry]")).toBeNull();
+    expect(el.querySelectorAll(".chat-block-question-choice")).toHaveLength(3);
+    const alert = el.querySelector("[role='alert']");
+    expect(alert?.textContent).toBe(CHAT_STRINGS.blockQuestionAnswerError);
   });
 });
diff --git a/packages/chat/src/routes.ts b/packages/chat/src/routes.ts
index 206468214..bacc91edd 100644
--- a/packages/chat/src/routes.ts
+++ b/packages/chat/src/routes.ts
@@ -28,6 +28,7 @@ import { Part, type Part as PartType } from "./parts";
 import {
   aggregatePollResponses,
   type BlockResponsePayload,
+  type BlockResponseRow,
   type BlockResponseStore,
 } from "./block-responses";
 import {
@@ -499,6 +500,34 @@ const SubmitBlockResponseBody = SubmitPollResponseBody.or(
   SubmitFormResponseBody,
 ).or(SubmitQuestionResponseBody);
 
+/**
+ * The caller's own row on the GET wire. A question also carries
+ * `notifiedAt` (ISO timestamp, or null when notify never landed) so
+ * the card can keep a retry after remount instead of collapsing as
+ * if the agent had already been reached. Poll/form payloads are
+ * unchanged — `notifiedAt` is a question-only claim flag.
+ */
+function ownBlockResponseForClient(row: BlockResponseRow | undefined):
+  | BlockResponsePayload
+  | {
+      readonly kind: "question";
+      readonly answer: string;
+      readonly optionIndex?: number;
+      readonly notifiedAt: string | null;
+    }
+  | null {
+  if (row === undefined) return null;
+  if (row.payload.kind !== "question") return row.payload;
+  return {
+    kind: "question",
+    answer: row.payload.answer,
+    ...(row.payload.optionIndex !== undefined
+      ? { optionIndex: row.payload.optionIndex }
+      : {}),
+    notifiedAt: row.notifiedAt === null ? null : row.notifiedAt.toISOString(),
+  };
+}
+
 /**
  * Every `/workbenches/:id/*` handler must resolve the workbench inside the
  * request tenant before acting. A workbench is in-tenant when it has a
@@ -2552,7 +2581,9 @@ export function createChatRoutes(deps: CreateChatRoutesDeps): Hono<TenantEnv> {
       // before any of it reaches the wire: a poll's tally is a count over
       // every row regardless of whose it is, but `own` is this caller's row
       // and this caller's alone — no other principal's raw poll choice or
-      // form values is ever assembled into the response body.
+      // form values is ever assembled into the response body. A question's
+      // `own` also carries `notifiedAt` so the card can tell a completed
+      // notify from an answer that never reached the agent.
       const rows = await deps.blockResponses.listBlockResponses(
         access.ownerTenantId,
         workbenchId,
@@ -2560,8 +2591,9 @@ export function createChatRoutes(deps: CreateChatRoutesDeps): Hono<TenantEnv> {
         blockId,
       );
       const { tally, total } = aggregatePollResponses(rows);
-      const own =
-        rows.find((row) => row.principalId === principal.id)?.payload ?? null;
+      const own = ownBlockResponseForClient(
+        rows.find((row) => row.principalId === principal.id),
+      );
 
       return c.json({ tally, total, own });
     },
diff --git a/packages/chat/test/block-responses-routes.test.ts b/packages/chat/test/block-responses-routes.test.ts
index 0f70f9d20..81b8a9cec 100644
--- a/packages/chat/test/block-responses-routes.test.ts
+++ b/packages/chat/test/block-responses-routes.test.ts
@@ -322,11 +322,14 @@ describe("block response routes — question answers", () => {
 
     const get = await getResponses(app, workbenchId, "m1", "blk_question1");
     const body = (await get.json()) as { own: unknown };
-    expect(body.own).toEqual({
+    expect(body.own).toMatchObject({
       kind: "question",
       answer: "Production",
       optionIndex: 1,
     });
+    expect((body.own as { notifiedAt: unknown }).notifiedAt).toEqual(
+      expect.any(String),
+    );
   });
 
   test("changing an answer updates the stored response but never dispatches a second turn", async () => {
@@ -367,7 +370,13 @@ describe("block response routes — question answers", () => {
 
     const get = await getResponses(app, workbenchId, "m1", "blk_question1");
     const body = (await get.json()) as { own: unknown };
-    expect(body.own).toEqual({ kind: "question", answer: "Production" });
+    expect(body.own).toMatchObject({
+      kind: "question",
+      answer: "Production",
+    });
+    expect((body.own as { notifiedAt: unknown }).notifiedAt).toEqual(
+      expect.any(String),
+    );
   });
 
   test("a double-click resubmitting the identical answer never dispatches a second turn", async () => {
@@ -433,6 +442,7 @@ describe("block response routes — question answers", () => {
     expect(afterFailureBody.own).toEqual({
       kind: "question",
       answer: "Production",
+      notifiedAt: null,
     });
     expect(timelineTexts(await timelineOf(deps, workbenchId))).toEqual([]);