From 6ea71700169094f5b9704f6ed7c044735566def2 Mon Sep 17 00:00:00 2001
From: Daniil Perkin <danetschka4pertschik@gmail.com>
Date: Sun, 27 Sep 2026 22:51:11 +0200
Subject: [PATCH 1/4] fix(buddy): edit the flag-to-PM question before
 confirming (#235)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A flag to the PM leaves the product in the hire's name, and the buddy composes the
question — but the confirm showed only the button's label plus a read-only line under
it, so the words that actually land in somebody's inbox could not be checked, let
alone corrected, before they went out.

The card now shows the composed question in an editable field above the confirm, and
sends exactly what that field holds: handleConfirm is the single send path (the
offer's button and a refusal's retry both come through it), it trims the text, and it
refuses to send nothing — a blank flag is not a question, and the backend's
blank-question refusal is a card with no field left to fix it in.

Every action is now its own BuddyProposalCard rather than an inline branch of the
map, because the draft is per-action state and it has to survive the switch from the
offer to its refusal: the retry is precisely where the hire's own wording matters
again. The field is frozen while the confirm is in flight, so what was sent is what
is still on screen when the outcome lands.

Field and control are ui/Field + ui/Textarea, not the legacy AutoResizeTextarea: the
primitives already carry the label binding, the hint's aria-describedby and the
disabled treatment, and ui/Textarea is what the standards ask for at every text field
(the buddy composer is the documented composite exception; this is not one).

The skip request's reason stays a static line under the buttons — it is a sentence to
acknowledge, not one to compose — and the question field's doc in types.ts now says
where it is shown.

Tests: the static-preview assertion became a nine-test suite over the flag card
(editable prefill, edited text sent, untouched text sent, trimming, empty and
whitespace guards, freeze while confirming, decline, retry carrying the edited text).
Red-checked: with the component reverted to the previous commit, seven of them fail.
---
 .../buddy/components/BuddyActionProposals.tsx | 434 ++++++++++--------
 src/features/buddy/types.ts                   |   5 +-
 .../a11y/BuddyActionProposals.a11y.test.tsx   |  32 ++
 .../buddy/BuddyActionProposals.test.tsx       | 233 +++++++++-
 4 files changed, 494 insertions(+), 210 deletions(-)
 create mode 100644 tests/unit/a11y/BuddyActionProposals.a11y.test.tsx

diff --git a/src/features/buddy/components/BuddyActionProposals.tsx b/src/features/buddy/components/BuddyActionProposals.tsx
index 84e6d8ce..ff332a05 100644
--- a/src/features/buddy/components/BuddyActionProposals.tsx
+++ b/src/features/buddy/components/BuddyActionProposals.tsx
@@ -1,4 +1,7 @@
+import { useState } from "react";
 import { Check, Info, Loader2, RotateCcw, TriangleAlert, Users, X } from "lucide-react";
+import { Field } from "../../../components/ui/Field";
+import { Textarea } from "../../../components/ui/Textarea";
 import type { ProposedAction, ProposalRisk } from "../types";
 import {
   BUDDY_ACTION_AMEND_CHECKLIST,
@@ -17,6 +20,13 @@ type BuddyActionProposalsProps = {
   onDismiss: (messageId: string, actionId: string) => void;
 };
 
+type BuddyProposalCardProps = {
+  messageId: string;
+  action: ProposedAction;
+  onConfirm: (messageId: string, action: ProposedAction) => void;
+  onDismiss: (messageId: string, actionId: string) => void;
+};
+
 /**
  * The confirm affordance for actions the buddy proposed. Nothing here has changed anything yet —
  * the buddy offered, and only a click on "Confirm" mutates. Each action shows its own state: the
@@ -33,6 +43,12 @@ type BuddyActionProposalsProps = {
  * the only control for it taken away, and the mentor, which is never told what became of a
  * proposal, went on asking them to click a button that was no longer on screen. So the outcome
  * stays, and the offer comes back under it.
+ *
+ * Each one is its own {@link BuddyProposalCard} rather than an inline branch of the map below,
+ * because a flag to the PM carries the hire's own words and those are edited **before** confirming:
+ * the offer's draft is per-action state, and state cannot live inside a `map` callback — nor
+ * survive the switch from the offer to its refusal, which is precisely where a retry has to send
+ * the text the hire last saw.
  */
 export function BuddyActionProposals({
   messageId,
@@ -44,111 +60,146 @@ export function BuddyActionProposals({
 
   return (
     <div className="mt-2 flex flex-col gap-2">
-      {actions.map((action) => {
-        if (action.status === "dismissed") {
-          return (
-            <p key={action.id} className="text-xs text-app-text-disabled">
-              Dismissed — nothing changed.
-            </p>
-          );
-        }
+      {actions.map((action) => (
+        <BuddyProposalCard
+          key={action.id}
+          messageId={messageId}
+          action={action}
+          onConfirm={onConfirm}
+          onDismiss={onDismiss}
+        />
+      ))}
+    </div>
+  );
+}
 
-        if (action.status === "resolved") {
-          return (
-            <div key={action.id} className="flex flex-col items-start">
-              <p
-                className={`flex min-w-0 items-start gap-1.5 text-sm break-words ${
-                  action.ok ? "text-app-text" : "text-app-text-muted"
-                }`}
-              >
-                <Check
-                  className={`mt-0.5 h-4 w-4 shrink-0 ${
-                    action.ok ? "text-app-success-solid" : "text-app-text-disabled"
-                  }`}
-                  aria-hidden="true"
-                />
-                {action.outcome}
-              </p>
-              {/* Under the refusal, not instead of it. The outcome is why it did not work and is
+/**
+ * One proposed action, from offer to settled — and the only place the hire's own words can be
+ * edited before they leave the product.
+ *
+ * A `flag_to_pm` is the one proposal whose payload is a message a person reads: the buddy composes
+ * the question, but it arrives in a PM's inbox in the hire's name, so the whole question is shown
+ * in a field above the button and is theirs to correct. What is confirmed is therefore exactly what
+ * the field held (see `handleConfirm`), never the original proposal. Every other action echoes a
+ * target back verbatim and a stored team proposal confirms by id — nothing there is editable, so
+ * nothing there grows a field.
+ */
+function BuddyProposalCard({ messageId, action, onConfirm, onDismiss }: BuddyProposalCardProps) {
+  const isStored = "proposalId" in action;
+  const isFlagToPm = !isStored && action.action === BUDDY_ACTION_FLAG_TO_PM;
+  const isConfirming = action.status === "confirming";
+  // Seeded once, on mount, and never re-seeded from the prop: a retry after a refusal has to send
+  // the text the hire last read, and an edit that silently reverted would be worse than no field.
+  const [editedQuestion, setEditedQuestion] = useState(() =>
+    !isStored && action.action === BUDDY_ACTION_FLAG_TO_PM ? (action.question ?? "") : "",
+  );
+  /** A flag with nothing in it is not a question — the confirm stays out of reach rather than
+   *  letting the backend answer with a refusal the hire cannot act on. */
+  const canConfirm = !isConfirming && (!isFlagToPm || editedQuestion.trim().length > 0);
+
+  /** The offer's own button and a refusal's retry both come through here, so neither can send a
+   *  question other than the one on screen — or an empty one. */
+  const handleConfirm = () => {
+    if (!isStored && action.action === BUDDY_ACTION_FLAG_TO_PM) {
+      const question = editedQuestion.trim();
+      if (!question) return;
+      onConfirm(messageId, { ...action, question });
+      return;
+    }
+
+    onConfirm(messageId, action);
+  };
+
+  if (action.status === "dismissed") {
+    return <p className="text-xs text-app-text-disabled">Dismissed — nothing changed.</p>;
+  }
+
+  if (action.status === "resolved") {
+    return (
+      <div className="flex flex-col items-start">
+        <p
+          className={`flex min-w-0 items-start gap-1.5 text-sm break-words ${
+            action.ok ? "text-app-text" : "text-app-text-muted"
+          }`}
+        >
+          <Check
+            className={`mt-0.5 h-4 w-4 shrink-0 ${
+              action.ok ? "text-app-success-solid" : "text-app-text-disabled"
+            }`}
+            aria-hidden="true"
+          />
+          {action.outcome}
+        </p>
+        {/* Under the refusal, not instead of it. The outcome is why it did not work and is
                   the thing worth reading; this is only the way to try it once the reason has been
                   dealt with. Never offered on success — running a confirmed action twice is how
                   somebody claims the same task twice. Hire actions only: a stored team
                   proposal is settled server-side once decided, so confirming it again
                   could only be refused. */}
-              {!action.ok && "action" in action && (
-                <button
-                  type="button"
-                  onClick={() => onConfirm(messageId, action)}
-                  className="mt-1.5 ml-5.5 flex items-center gap-1.5 rounded-lg px-2.5 py-1.5 text-sm text-app-text-muted transition-colors hover:bg-app-surface-hover hover:text-app-text"
-                >
-                  <RotateCcw className="h-3.5 w-3.5" aria-hidden="true" />
-                  Try again: {action.label}
-                </button>
-              )}
-              {/* Opening orientation is the one hire action whose result is content, not
+        {!action.ok && "action" in action && (
+          <button
+            type="button"
+            onClick={handleConfirm}
+            className="mt-1.5 ml-5.5 flex items-center gap-1.5 rounded-lg px-2.5 py-1.5 text-sm text-app-text-muted transition-colors hover:bg-app-surface-hover hover:text-app-text"
+          >
+            <RotateCcw className="h-3.5 w-3.5" aria-hidden="true" />
+            Try again: {action.label}
+          </button>
+        )}
+        {/* Opening orientation is the one hire action whose result is content, not
                                 just an outcome line: the packet renders right here in the thread
                                 instead of navigating to a page. Stored proposals have no `action`
                                 name to match — their payoff is always the outcome line. */}
-              {"action" in action &&
-                action.action === BUDDY_ACTION_OPEN_ORIENTATION &&
-                action.ok && <BuddyOrientationCard />}
-            </div>
-          );
-        }
+        {"action" in action && action.action === BUDDY_ACTION_OPEN_ORIENTATION && action.ok && (
+          <BuddyOrientationCard />
+        )}
+      </div>
+    );
+  }
 
-        const isConfirming = action.status === "confirming";
-        const isStored = "proposalId" in action;
-        // Fail closed: a proposal whose risk did not survive the stream (or that arrived
-        // without its description) is not confirmable — an approval card for a project
-        // mutation must never guess how loudly to warn, nor confirm what it cannot show.
-        const isUnsupported = isStored && (action.risk === null || !action.preview);
-        const previewId = `buddy-proposal-preview-${action.id}`;
+  // Fail closed: a proposal whose risk did not survive the stream (or that arrived
+  // without its description) is not confirmable — an approval card for a project
+  // mutation must never guess how loudly to warn, nor confirm what it cannot show.
+  const isUnsupported = isStored && (action.risk === null || !action.preview);
+  const previewId = `buddy-proposal-preview-${action.id}`;
 
-        return (
-          <div
-            key={action.id}
-            className="flex max-w-full min-w-0 flex-col gap-1.5 rounded-xl border border-app-border bg-app-bg p-2.5"
-          >
-            {/* Shown before the press, not after it, and only where the payload is *content*.
+  return (
+    <div className="flex max-w-full min-w-0 flex-col gap-1.5 rounded-xl border border-app-border bg-app-bg p-2.5">
+      {/* Shown before the press, not after it, and only where the payload is *content*.
                 `place_checklist` is the one action whose confirm writes the mentor's own sentences
                 onto a surface the hire owns — the same reason the assessment proposal names the
                 skill and the level rather than saying "Save this". The lines are in the reply
                 above as well; having them here is what makes the two comparable, so a list that
                 does not match what was written is visible before it is kept, not after. */}
-            {!isStored && action.checklistItems && action.checklistItems.length > 0 && (
-              <div className="min-w-0">
-                {action.checklistTitle && (
-                  <p className="text-sm font-medium break-words text-app-text">
-                    {action.checklistTitle}
-                  </p>
-                )}
-                {/* Named as an addition when it is one. The card keeps everything it already has,
+      {!isStored && action.checklistItems && action.checklistItems.length > 0 && (
+        <div className="min-w-0">
+          {action.checklistTitle && (
+            <p className="text-sm font-medium break-words text-app-text">{action.checklistTitle}</p>
+          )}
+          {/* Named as an addition when it is one. The card keeps everything it already has,
                     and these lines go after it — saying so is the difference between agreeing to
                     three new steps and agreeing to whatever the list becomes. */}
-                {action.action === BUDDY_ACTION_AMEND_CHECKLIST && (
-                  <p className="text-xs text-app-text-muted">
-                    Added to the end of that list — nothing on it changes:
-                  </p>
-                )}
-                {action.action === BUDDY_ACTION_TICK_CHECKLIST && (
-                  <p className="text-xs text-app-text-muted">
-                    Ticked off on that list — nothing else on it changes:
-                  </p>
-                )}
-                <ul className="mt-1 space-y-0.5">
-                  {action.checklistItems.map((item, index) => (
-                    <li
-                      key={`${action.id}-${index}`}
-                      className="text-xs break-words text-app-text-muted"
-                    >
-                      · {item}
-                    </li>
-                  ))}
-                </ul>
-              </div>
-            )}
+          {action.action === BUDDY_ACTION_AMEND_CHECKLIST && (
+            <p className="text-xs text-app-text-muted">
+              Added to the end of that list — nothing on it changes:
+            </p>
+          )}
+          {action.action === BUDDY_ACTION_TICK_CHECKLIST && (
+            <p className="text-xs text-app-text-muted">
+              Ticked off on that list — nothing else on it changes:
+            </p>
+          )}
+          <ul className="mt-1 space-y-0.5">
+            {action.checklistItems.map((item, index) => (
+              <li key={`${action.id}-${index}`} className="text-xs break-words text-app-text-muted">
+                · {item}
+              </li>
+            ))}
+          </ul>
+        </div>
+      )}
 
-            {/* The one offer that *replaces* something already on a card, so it shows both: the
+      {/* The one offer that *replaces* something already on a card, so it shows both: the
                 line as it reads now and as it would read. Only the new wording would be asking
                 them to agree to a change they would have to go and diff for themselves.
 
@@ -159,118 +210,129 @@ export function BuddyActionProposals({
 
                 Keyed off the action, like the amend and tick branches above, so a future action
                 that happens to carry both fields does not render as a rewording. */}
-            {!isStored &&
-              action.action === BUDDY_ACTION_REWORD_CHECKLIST &&
-              action.lineBefore &&
-              action.lineAfter && (
-                <div className="min-w-0 text-xs">
-                  <del className="block break-words text-app-text-muted line-through">
-                    <span className="sr-only">Currently: </span>
-                    {action.lineBefore}
-                  </del>
-                  <ins className="block break-words text-app-text no-underline">
-                    <span className="sr-only">Would become: </span>
-                    {action.lineAfter}
-                  </ins>
-                </div>
-              )}
+      {!isStored &&
+        action.action === BUDDY_ACTION_REWORD_CHECKLIST &&
+        action.lineBefore &&
+        action.lineAfter && (
+          <div className="min-w-0 text-xs">
+            <del className="block break-words text-app-text-muted line-through">
+              <span className="sr-only">Currently: </span>
+              {action.lineBefore}
+            </del>
+            <ins className="block break-words text-app-text no-underline">
+              <span className="sr-only">Would become: </span>
+              {action.lineAfter}
+            </ins>
+          </div>
+        )}
 
-            {/* Whitespace kept: the note's first line becomes the card's heading, so a preview that
+      {/* Whitespace kept: the note's first line becomes the card's heading, so a preview that
                 reflowed it would not be showing what would be kept. */}
-            {!isStored && action.noteText && (
-              <p className="min-w-0 text-xs break-words whitespace-pre-wrap text-app-text-muted">
-                {action.noteText}
-              </p>
-            )}
-            {/* What the manager is agreeing to comes FIRST, in the buddy's own words, and the
+      {!isStored && action.noteText && (
+        <p className="min-w-0 text-xs break-words whitespace-pre-wrap text-app-text-muted">
+          {action.noteText}
+        </p>
+      )}
+      {/* What the manager is agreeing to comes FIRST, in the buddy's own words, and the
                 confirm button describes it (aria-describedby): the target is the stored id, so
                 this text is the offer's full description — never a summary the client
                 recomposed, and never read after the button that acts on it. */}
-            {isStored && action.preview && (
-              <p id={previewId} className="text-xs leading-relaxed break-words text-app-text-muted">
-                {action.preview}
-              </p>
-            )}
+      {isStored && action.preview && (
+        <p id={previewId} className="text-xs leading-relaxed break-words text-app-text-muted">
+          {action.preview}
+        </p>
+      )}
 
-            {/* A stored proposal warns about itself before it is even clicked: how much it would
+      {/* A stored proposal warns about itself before it is even clicked: how much it would
                 change decides how loudly the card speaks, before any confirm happens. */}
-            {isStored && action.risk !== null && <ProposalRiskBadge risk={action.risk} />}
+      {isStored && action.risk !== null && <ProposalRiskBadge risk={action.risk} />}
 
-            {isUnsupported && (
-              <>
-                <p
-                  data-testid="buddy-proposal-unsupported"
-                  className="text-xs leading-relaxed text-app-warning-text"
-                >
-                  This proposal arrived without its details, so it cannot be confirmed here. Ask the
-                  buddy to propose it again.
-                </p>
-                <div className="flex flex-wrap items-center gap-2">
-                  <button
-                    type="button"
-                    onClick={() => onDismiss(messageId, action.id)}
-                    disabled={isConfirming}
-                    className="flex items-center gap-1 rounded-lg px-2.5 py-1.5 text-sm text-app-text-muted transition-colors hover:bg-app-surface-hover hover:text-app-text disabled:opacity-60"
-                  >
-                    <X className="h-3.5 w-3.5" aria-hidden="true" />
-                    Not now
-                  </button>
-                </div>
-              </>
-            )}
-            {!isUnsupported && (
-              <div className="flex flex-wrap items-center gap-2">
-                {/* `action.label` is written by the model, so its length is not ours to
+      {isUnsupported && (
+        <>
+          <p
+            data-testid="buddy-proposal-unsupported"
+            className="text-xs leading-relaxed text-app-warning-text"
+          >
+            This proposal arrived without its details, so it cannot be confirmed here. Ask the buddy
+            to propose it again.
+          </p>
+          <div className="flex flex-wrap items-center gap-2">
+            <button
+              type="button"
+              onClick={() => onDismiss(messageId, action.id)}
+              disabled={isConfirming}
+              className="flex items-center gap-1 rounded-lg px-2.5 py-1.5 text-sm text-app-text-muted transition-colors hover:bg-app-surface-hover hover:text-app-text disabled:opacity-60"
+            >
+              <X className="h-3.5 w-3.5" aria-hidden="true" />
+              Not now
+            </button>
+          </div>
+        </>
+      )}
+      {/* The one proposal whose payload is a *message*: the buddy composes the question,
+                the hire sends it under their own name, and a person reads it — so it is shown in
+                full, editable, above the button that sends it. Two things follow from that, and
+                both are enforced: what goes out is the field's own text (`handleConfirm`), and an
+                empty field cannot be confirmed at all. */}
+      {isFlagToPm && (
+        <Field
+          label="Sends to your PM"
+          hint="Edit it if it is not quite right — this exact text is what they will read."
+          disabled={isConfirming}
+        >
+          <Textarea
+            value={editedQuestion}
+            onChange={(event) => setEditedQuestion(event.target.value)}
+            placeholder="What do you need answered?"
+            minRows={2}
+            maxRows={5}
+          />
+        </Field>
+      )}
+
+      {!isUnsupported && (
+        <div className="flex flex-wrap items-center gap-2">
+          {/* `action.label` is written by the model, so its length is not ours to
                                 assume. In a 384 px panel an unbreakable one would push the button
                                 past the edge -- hence the wrap and the left alignment that follows
                                 from a label running to two lines. */}
-                <button
-                  type="button"
-                  onClick={() => onConfirm(messageId, action)}
-                  disabled={isConfirming}
-                  aria-describedby={isStored && action.preview ? previewId : undefined}
-                  className="flex max-w-full min-w-0 items-center gap-1.5 rounded-lg bg-app-brand px-3 py-1.5 text-left text-sm font-medium break-words text-white transition-colors hover:bg-app-brand-hover disabled:cursor-not-allowed disabled:opacity-60"
-                >
-                  {isConfirming ? (
-                    <Loader2 className="h-3.5 w-3.5 animate-spin" aria-hidden="true" />
-                  ) : (
-                    <Check className="h-3.5 w-3.5" aria-hidden="true" />
-                  )}
-                  {action.label}
-                </button>
-                <button
-                  type="button"
-                  onClick={() => onDismiss(messageId, action.id)}
-                  disabled={isConfirming}
-                  className="flex items-center gap-1 rounded-lg px-2.5 py-1.5 text-sm text-app-text-muted transition-colors hover:bg-app-surface-hover hover:text-app-text disabled:opacity-60"
-                >
-                  <X className="h-3.5 w-3.5" aria-hidden="true" />
-                  Not now
-                </button>
-              </div>
-            )}
-            {/* Anything that leaves the product in the hire's name shows its words before the
-                click -- the label only names the kind of thing it is. A skip request carries the
-                reason; a flag to the PM carries the question the buddy composed, which is the whole
-                of what that person will read. */}
-            {!isStored && action.reason && (
-              <p className="px-1 text-xs break-words text-app-text-muted">
-                Your reason: &ldquo;{action.reason}&rdquo;
-              </p>
-            )}
-            {!isStored && action.action === BUDDY_ACTION_FLAG_TO_PM && action.question && (
-              <p className="px-1 text-xs break-words text-app-text-muted">
-                Sends to your PM: &ldquo;{action.question}&rdquo;
-              </p>
-            )}
-            {action.status === "error" && (
-              <p className="text-xs text-app-danger-text">
-                Couldn&apos;t reach the server — try again.
-              </p>
+          <button
+            type="button"
+            onClick={handleConfirm}
+            disabled={!canConfirm}
+            aria-describedby={isStored && action.preview ? previewId : undefined}
+            className="flex max-w-full min-w-0 items-center gap-1.5 rounded-lg bg-app-brand px-3 py-1.5 text-left text-sm font-medium break-words text-white transition-colors hover:bg-app-brand-hover disabled:cursor-not-allowed disabled:opacity-60"
+          >
+            {isConfirming ? (
+              <Loader2 className="h-3.5 w-3.5 animate-spin" aria-hidden="true" />
+            ) : (
+              <Check className="h-3.5 w-3.5" aria-hidden="true" />
             )}
-          </div>
-        );
-      })}
+            {action.label}
+          </button>
+          <button
+            type="button"
+            onClick={() => onDismiss(messageId, action.id)}
+            disabled={isConfirming}
+            className="flex items-center gap-1 rounded-lg px-2.5 py-1.5 text-sm text-app-text-muted transition-colors hover:bg-app-surface-hover hover:text-app-text disabled:opacity-60"
+          >
+            <X className="h-3.5 w-3.5" aria-hidden="true" />
+            Not now
+          </button>
+        </div>
+      )}
+      {/* The other thing that leaves the product in the hire's name: a skip request's
+                reason, which is the whole of what that PM reads. A static line rather than a
+                field, and deliberately left where it was — a sentence to acknowledge, not one to
+                compose. A flag's question is the field above, because that one is rewordable. */}
+      {!isStored && action.reason && (
+        <p className="px-1 text-xs break-words text-app-text-muted">
+          Your reason: &ldquo;{action.reason}&rdquo;
+        </p>
+      )}
+      {action.status === "error" && (
+        <p className="text-xs text-app-danger-text">Couldn&apos;t reach the server — try again.</p>
+      )}
     </div>
   );
 }
diff --git a/src/features/buddy/types.ts b/src/features/buddy/types.ts
index 18d4a724..f083921f 100644
--- a/src/features/buddy/types.ts
+++ b/src/features/buddy/types.ts
@@ -88,8 +88,9 @@ export type HireActionProposal = {
   /** The button text ("Work toward this task"). */
   label: string;
   /**
-   * Carried through only for flag-to-PM: the question the buddy composed, and the one that is
-   * actually sent. Shown under the button — see `BuddyActionProposals`.
+   * Carried through only for flag-to-PM: the question the buddy composed. Shown in an editable
+   * field *above* the confirm — this one is a message, so the hire may reword it, and what reaches
+   * the PM is whatever that field held. See `BuddyActionProposals`.
    */
   question?: string;
   /**
diff --git a/tests/unit/a11y/BuddyActionProposals.a11y.test.tsx b/tests/unit/a11y/BuddyActionProposals.a11y.test.tsx
new file mode 100644
index 00000000..6c599142
--- /dev/null
+++ b/tests/unit/a11y/BuddyActionProposals.a11y.test.tsx
@@ -0,0 +1,32 @@
+import { render } from "@testing-library/react";
+import { describe, it, expect, vi } from "vitest";
+import { axe } from "vitest-axe";
+import { BuddyActionProposals } from "../../../src/features/buddy/components/BuddyActionProposals";
+import type { ProposedAction } from "../../../src/features/buddy/types";
+
+describe("BuddyActionProposals Accessibility", () => {
+  it("has no violations on a flag whose question is edited before it is sent", async () => {
+    // The one proposal that carries an editable message: the field has to be a labelled control
+    // with its hint announced, exactly like every other text field in the app.
+    const flag: ProposedAction = {
+      id: "a1",
+      action: "flag_to_pm",
+      label: "Flag this to your PM",
+      question: "How do we request staging database credentials?",
+      status: "idle",
+    };
+
+    const { baseElement } = render(
+      <main>
+        <BuddyActionProposals
+          messageId="m1"
+          actions={[flag]}
+          onConfirm={vi.fn()}
+          onDismiss={vi.fn()}
+        />
+      </main>,
+    );
+
+    expect(await axe(baseElement)).toHaveNoViolations();
+  });
+});
diff --git a/tests/unit/features/buddy/BuddyActionProposals.test.tsx b/tests/unit/features/buddy/BuddyActionProposals.test.tsx
index 38f8c019..08032b83 100644
--- a/tests/unit/features/buddy/BuddyActionProposals.test.tsx
+++ b/tests/unit/features/buddy/BuddyActionProposals.test.tsx
@@ -144,30 +144,219 @@ describe("BuddyActionProposals", () => {
     expect(screen.queryByTestId("buddy-orientation-card")).not.toBeInTheDocument();
   });
 
-  it("shows the question a flag will send, not just the button", () => {
-    // The button only says that something will be flagged. What lands in the PM's inbox is
-    // the question the buddy composed, and the hire sends it in their name.
-    render(
-      <BuddyActionProposals
-        messageId="m1"
-        actions={[
-          action({
-            action: "flag_to_pm",
-            label: "Flag this to your PM",
-            question: "Who owns the staging database credentials?",
-          }),
-        ]}
-        onConfirm={vi.fn()}
-        onDismiss={vi.fn()}
-      />,
-    );
+  /**
+   * The one proposal whose payload is a message a person reads: the buddy composes the question,
+   * the hire sends it in their own name. So the whole question is on screen — and editable, because
+   * what leaves the product in somebody's name is theirs to word.
+   */
+  describe("a proposed flag to the PM", () => {
+    const flag = (overrides: Partial<ProposedAction> = {}) =>
+      action({
+        action: "flag_to_pm",
+        label: "Flag this to your PM",
+        question: "How do we request staging database credentials?",
+        ...overrides,
+      });
 
-    expect(
-      screen.getByText("Sends to your PM: “Who owns the staging database credentials?”"),
-    ).toBeInTheDocument();
+    it("shows the composed question in an editable field, not just a button", () => {
+      // The button only says that something will be flagged. What lands in the PM's inbox is
+      // the question the buddy composed — shown in full, and in a field, not a caption.
+      render(
+        <BuddyActionProposals
+          messageId="m1"
+          actions={[flag()]}
+          onConfirm={vi.fn()}
+          onDismiss={vi.fn()}
+        />,
+      );
+
+      expect(screen.getByLabelText(/sends to your PM/i)).toHaveValue(
+        "How do we request staging database credentials?",
+      );
+    });
+
+    it("sends the text the hire edited, not the one the buddy composed", async () => {
+      const onConfirm = vi.fn();
+      render(
+        <BuddyActionProposals
+          messageId="m1"
+          actions={[flag()]}
+          onConfirm={onConfirm}
+          onDismiss={vi.fn()}
+        />,
+      );
+
+      const field = screen.getByLabelText(/sends to your PM/i);
+      await userEvent.clear(field);
+      await userEvent.type(field, "Who manages the staging DB secrets?");
+
+      await userEvent.click(screen.getByRole("button", { name: /Flag this to your PM/i }));
+
+      expect(onConfirm).toHaveBeenCalledWith(
+        "m1",
+        expect.objectContaining({
+          action: "flag_to_pm",
+          question: "Who manages the staging DB secrets?",
+        }),
+      );
+    });
+
+    it("sends the composed question untouched when the hire does not edit it", async () => {
+      const onConfirm = vi.fn();
+      render(
+        <BuddyActionProposals
+          messageId="m1"
+          actions={[flag()]}
+          onConfirm={onConfirm}
+          onDismiss={vi.fn()}
+        />,
+      );
+
+      await userEvent.click(screen.getByRole("button", { name: /Flag this to your PM/i }));
+
+      expect(onConfirm).toHaveBeenCalledWith(
+        "m1",
+        expect.objectContaining({
+          action: "flag_to_pm",
+          question: "How do we request staging database credentials?",
+        }),
+      );
+    });
+
+    it("sends the question trimmed — what goes out is a message, not a field value", async () => {
+      const onConfirm = vi.fn();
+      render(
+        <BuddyActionProposals
+          messageId="m1"
+          actions={[flag()]}
+          onConfirm={onConfirm}
+          onDismiss={vi.fn()}
+        />,
+      );
+
+      const field = screen.getByLabelText(/sends to your PM/i);
+      await userEvent.clear(field);
+      await userEvent.type(field, "  Who owns the staging box?  ");
+
+      await userEvent.click(screen.getByRole("button", { name: /Flag this to your PM/i }));
+
+      expect(onConfirm.mock.calls[0][1]).toMatchObject({ question: "Who owns the staging box?" });
+    });
+
+    it("cannot be confirmed while the field is empty", async () => {
+      const onConfirm = vi.fn();
+      render(
+        <BuddyActionProposals
+          messageId="m1"
+          actions={[flag()]}
+          onConfirm={onConfirm}
+          onDismiss={vi.fn()}
+        />,
+      );
+
+      await userEvent.clear(screen.getByLabelText(/sends to your PM/i));
+
+      const confirm = screen.getByRole("button", { name: /Flag this to your PM/i });
+      expect(confirm).toBeDisabled();
+      await userEvent.click(confirm);
+      expect(onConfirm).not.toHaveBeenCalled();
+    });
+
+    it("cannot be confirmed on whitespace alone — a blank flag is not a question", async () => {
+      render(
+        <BuddyActionProposals
+          messageId="m1"
+          actions={[flag()]}
+          onConfirm={vi.fn()}
+          onDismiss={vi.fn()}
+        />,
+      );
+
+      const field = screen.getByLabelText(/sends to your PM/i);
+      await userEvent.clear(field);
+      await userEvent.type(field, "   ");
+
+      expect(screen.getByRole("button", { name: /Flag this to your PM/i })).toBeDisabled();
+    });
+
+    it("freezes the field while the flag is on its way", () => {
+      // What is sent is what is on screen. Editing mid-flight is the one way to break that.
+      render(
+        <BuddyActionProposals
+          messageId="m1"
+          actions={[flag({ status: "confirming" })]}
+          onConfirm={vi.fn()}
+          onDismiss={vi.fn()}
+        />,
+      );
+
+      expect(screen.getByLabelText(/sends to your PM/i)).toBeDisabled();
+      expect(screen.getByRole("button", { name: /Flag this to your PM/i })).toBeDisabled();
+    });
+
+    it("declines without flagging anything at all", async () => {
+      const onConfirm = vi.fn();
+      const onDismiss = vi.fn();
+      render(
+        <BuddyActionProposals
+          messageId="m1"
+          actions={[flag()]}
+          onConfirm={onConfirm}
+          onDismiss={onDismiss}
+        />,
+      );
+
+      await userEvent.click(screen.getByRole("button", { name: /Not now/i }));
+
+      // Declining a hire offer is purely local: no knowledge request, and no confirm.
+      expect(onDismiss).toHaveBeenCalledWith("m1", "a1");
+      expect(onConfirm).not.toHaveBeenCalled();
+    });
+
+    it("retries a refusal with the text the hire last edited", async () => {
+      const onConfirm = vi.fn();
+      const { rerender } = render(
+        <BuddyActionProposals
+          messageId="m1"
+          actions={[flag()]}
+          onConfirm={onConfirm}
+          onDismiss={vi.fn()}
+        />,
+      );
+
+      const field = screen.getByLabelText(/sends to your PM/i);
+      await userEvent.clear(field);
+      await userEvent.type(field, "Updated question?");
+
+      // The backend answered "couldn't": the outcome stays, the offer comes back under it — and
+      // the text it would send is still the text the hire last read, not the original proposal.
+      rerender(
+        <BuddyActionProposals
+          messageId="m1"
+          actions={[
+            flag({
+              status: "resolved",
+              ok: false,
+              outcome: "I need the question to flag — tell me what to ask.",
+            }),
+          ]}
+          onConfirm={onConfirm}
+          onDismiss={vi.fn()}
+        />,
+      );
+
+      await userEvent.click(
+        screen.getByRole("button", { name: /Try again: Flag this to your PM/i }),
+      );
+
+      expect(onConfirm).toHaveBeenCalledWith(
+        "m1",
+        expect.objectContaining({ question: "Updated question?" }),
+      );
+    });
   });
 
-  it("shows no message line for an action that sends nobody anything", () => {
+  it("grows no field for an action that sends nobody anything", () => {
     render(
       <BuddyActionProposals
         messageId="m1"
@@ -177,7 +366,7 @@ describe("BuddyActionProposals", () => {
       />,
     );
 
-    expect(screen.queryByText(/Sends to your PM/)).not.toBeInTheDocument();
+    expect(screen.queryByLabelText(/sends to your PM/i)).not.toBeInTheDocument();
   });
 
   it("shows the whole skip reason before the hire sends it in their name", () => {

From afa953e005459fd0ac6d67df65af275f65e4e74d Mon Sep 17 00:00:00 2001
From: Daniil Perkin <danetschka4pertschik@gmail.com>
Date: Mon, 28 Sep 2026 11:11:10 +0200
Subject: [PATCH 2/4] upgrade(buddy): keep the offer under a refusal, and the
 wording in the session (#235)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A refused flag used to collapse to an outcome line with a "Try again" underneath: the field
was unmounted, so the hire could not read — let alone correct — the text that would go out a
second time, and re-pressing swapped the whole card back in. The refusal now keeps the offer:
reason above, field and buttons exactly as they were, so the only thing a retry can send is
the wording on screen.

The card's own button is that retry. The separate "Try again" went with the branch that needed
it — the hook already let a refused hire offer be confirmed again — and it cannot be pressed
into a no-op: with the field empty the confirm is disabled, which is what the old button had
no way of saying. The reason stays put while the retry is in flight; the line above the card
is replaced only by the next outcome.

The wording moves out of the card into the session (`actionDrafts`, keyed by message and
action). A card's own state dies with it, and the card is unmounted by things that have
nothing to do with the text: the dock closes, the conversation is handed over to /buddy, a
route changes. The composer's draft already lives in the session for exactly that reason
(useBuddyConversation), so the field follows the same rule now. The session lets go of a draft
once the flag actually went out, or once the hire declined it — a card re-rendered later must
not offer wording that already left the product. A refusal keeps it: that card is about to be
handed the hire's own text back.

Corrected from the review: the unmount, the layout swap on retry, the draft lost across
surfaces, the docstring that promised an offer coming back, the a11y test whose title promised
an edit it never made, and the retry button with no disabled state. Overstated there: the
"inert Try again" was unreachable (an empty field could not be confirmed, so no refusal could
carry an empty draft), and the PR body's ticked "Manually verified" box was unchecked when the
PR was created — the claim is right about the body as it stood when the review ran, and it is
unchecked again. Their fix for the fourth finding (patch the question into the action) was not
taken: `ActionPatch` is documented as the round-trip, never the offer itself, and the session
draft answers the same need inside that invariant.

Tests: the flag card keeps its field, its text and a usable confirm under a refusal; the
reason survives a retry in flight; a refusal whose field was emptied cannot be confirmed; the
session carries the wording under `message:action`; the hook keeps a refusal's draft and drops
a sent one. Red-checked: reverting the two behaviours fails four of them.
---
 src/features/buddy/actionDrafts.ts            |  20 +
 .../buddy/components/BuddyActionProposals.tsx | 395 +++++++++--------
 .../buddy/components/BuddyConversation.tsx    |   9 +
 src/features/buddy/components/BuddyDock.tsx   |   6 +
 src/features/buddy/components/BuddyThread.tsx |   9 +
 src/features/buddy/components/BuddyWidget.tsx |   4 +
 .../buddy/hooks/useBuddyConversation.ts       |  48 ++-
 src/pages/BuddyPage.tsx                       |   4 +
 .../a11y/BuddyActionProposals.a11y.test.tsx   |  52 ++-
 .../buddy/BuddyActionProposals.test.tsx       | 396 ++++++++----------
 .../features/buddy/BuddyConversation.test.tsx |   2 +
 tests/unit/features/buddy/BuddyDock.test.tsx  |   2 +
 tests/unit/features/buddy/useBuddy.test.tsx   |  47 ++-
 .../features/buddy/useHandedOffDraft.test.tsx |   4 +
 14 files changed, 573 insertions(+), 425 deletions(-)
 create mode 100644 src/features/buddy/actionDrafts.ts

diff --git a/src/features/buddy/actionDrafts.ts b/src/features/buddy/actionDrafts.ts
new file mode 100644
index 00000000..2339f5ed
--- /dev/null
+++ b/src/features/buddy/actionDrafts.ts
@@ -0,0 +1,20 @@
+/**
+ * The hire's own wording for a proposal that carries an editable message, held per action.
+ *
+ * Deliberately *not* inside the card that renders the field. The dock unmounts every time it is
+ * closed, and the hand-off to `/buddy` mounts a second card for the same action — so a draft kept
+ * as component state is thrown away by gestures that were never about the text. Held by the
+ * session instead, the way the composer's own draft already is, the wording outlives whichever
+ * surface happens to be on screen.
+ */
+export type ActionDrafts = Record<string, string>;
+
+/**
+ * How one draft is keyed: an action inside the message it was proposed in.
+ *
+ * Both halves are needed. A hire offer's id is local to its message (the backend assigns none), so
+ * keying by id alone would let one message's wording surface in another's card.
+ */
+export function actionDraftKey(messageId: string, actionId: string): string {
+  return `${messageId}:${actionId}`;
+}
diff --git a/src/features/buddy/components/BuddyActionProposals.tsx b/src/features/buddy/components/BuddyActionProposals.tsx
index ff332a05..dc670a9f 100644
--- a/src/features/buddy/components/BuddyActionProposals.tsx
+++ b/src/features/buddy/components/BuddyActionProposals.tsx
@@ -1,7 +1,8 @@
-import { useState } from "react";
-import { Check, Info, Loader2, RotateCcw, TriangleAlert, Users, X } from "lucide-react";
+import { Check, Info, Loader2, TriangleAlert, Users, X } from "lucide-react";
 import { Field } from "../../../components/ui/Field";
 import { Textarea } from "../../../components/ui/Textarea";
+import { actionDraftKey } from "../actionDrafts";
+import type { ActionDrafts } from "../actionDrafts";
 import type { ProposedAction, ProposalRisk } from "../types";
 import {
   BUDDY_ACTION_AMEND_CHECKLIST,
@@ -16,6 +17,10 @@ type BuddyActionProposalsProps = {
   /** The message these actions were proposed in — needed to target the confirm. */
   messageId: string;
   actions: ProposedAction[];
+  /** The session's wording for the offers that carry an editable message — see `actionDrafts`. */
+  actionDrafts: ActionDrafts;
+  /** Records one, so it outlives whichever surface is on screen. */
+  setActionDraft: (key: string, text: string) => void;
   onConfirm: (messageId: string, action: ProposedAction) => void;
   onDismiss: (messageId: string, actionId: string) => void;
 };
@@ -23,6 +28,8 @@ type BuddyActionProposalsProps = {
 type BuddyProposalCardProps = {
   messageId: string;
   action: ProposedAction;
+  actionDrafts: ActionDrafts;
+  setActionDraft: (key: string, text: string) => void;
   onConfirm: (messageId: string, action: ProposedAction) => void;
   onDismiss: (messageId: string, actionId: string) => void;
 };
@@ -42,17 +49,20 @@ type BuddyProposalCardProps = {
  * permanent, and it was badly wrong when it was not — a hire whose packet failed to assemble had
  * the only control for it taken away, and the mentor, which is never told what became of a
  * proposal, went on asking them to click a button that was no longer on screen. So the outcome
- * stays, and the offer comes back under it.
+ * stays, and the offer comes back under it — whole, field and all, because a flag the backend
+ * could not send is precisely the one whose wording is worth another look.
  *
- * Each one is its own {@link BuddyProposalCard} rather than an inline branch of the map below,
- * because a flag to the PM carries the hire's own words and those are edited **before** confirming:
- * the offer's draft is per-action state, and state cannot live inside a `map` callback — nor
- * survive the switch from the offer to its refusal, which is precisely where a retry has to send
- * the text the hire last saw.
+ * Each one is its own {@link BuddyProposalCard} rather than an inline branch of the map below: a
+ * flag to the PM carries the hire's own words, and those are edited **before** confirming, so the
+ * offer is a component with an identity of its own rather than a row inside the callback — and what
+ * the hire typed is held by the **session** (`actionDrafts`), not by the card, so closing the dock
+ * or handing the conversation over to `/buddy` cannot throw away a half-worded question.
  */
 export function BuddyActionProposals({
   messageId,
   actions,
+  actionDrafts,
+  setActionDraft,
   onConfirm,
   onDismiss,
 }: BuddyActionProposalsProps) {
@@ -65,6 +75,8 @@ export function BuddyActionProposals({
           key={action.id}
           messageId={messageId}
           action={action}
+          actionDrafts={actionDrafts}
+          setActionDraft={setActionDraft}
           onConfirm={onConfirm}
           onDismiss={onDismiss}
         />
@@ -84,23 +96,32 @@ export function BuddyActionProposals({
  * target back verbatim and a stored team proposal confirms by id — nothing there is editable, so
  * nothing there grows a field.
  */
-function BuddyProposalCard({ messageId, action, onConfirm, onDismiss }: BuddyProposalCardProps) {
+function BuddyProposalCard({
+  messageId,
+  action,
+  actionDrafts,
+  setActionDraft,
+  onConfirm,
+  onDismiss,
+}: BuddyProposalCardProps) {
   const isStored = "proposalId" in action;
   const isFlagToPm = !isStored && action.action === BUDDY_ACTION_FLAG_TO_PM;
   const isConfirming = action.status === "confirming";
-  // Seeded once, on mount, and never re-seeded from the prop: a retry after a refusal has to send
-  // the text the hire last read, and an edit that silently reverted would be worse than no field.
-  const [editedQuestion, setEditedQuestion] = useState(() =>
-    !isStored && action.action === BUDDY_ACTION_FLAG_TO_PM ? (action.question ?? "") : "",
-  );
+  const draftKey = actionDraftKey(messageId, action.id);
+  // The hire's own words for this offer, if they have touched it — read from the session, never
+  // from state of this card's own: the dock unmounts when it is closed and `/buddy` mounts a
+  // second card for the same action, so wording kept here would be thrown away by either gesture.
+  // Until they edit, the field holds the question the buddy composed.
+  const editedQuestion = actionDrafts[draftKey] ?? (isFlagToPm ? (action.question ?? "") : "");
   /** A flag with nothing in it is not a question — the confirm stays out of reach rather than
    *  letting the backend answer with a refusal the hire cannot act on. */
   const canConfirm = !isConfirming && (!isFlagToPm || editedQuestion.trim().length > 0);
 
-  /** The offer's own button and a refusal's retry both come through here, so neither can send a
-   *  question other than the one on screen — or an empty one. */
+  /** The card's only way out: the offer's button before it has run, and the very same button after
+   *  a refusal. Both come through here, so neither can send a question other than the one on
+   *  screen — and never an empty one. */
   const handleConfirm = () => {
-    if (!isStored && action.action === BUDDY_ACTION_FLAG_TO_PM) {
+    if (isFlagToPm) {
       const question = editedQuestion.trim();
       if (!question) return;
       onConfirm(messageId, { ...action, question });
@@ -114,42 +135,41 @@ function BuddyProposalCard({ messageId, action, onConfirm, onDismiss }: BuddyPro
     return <p className="text-xs text-app-text-disabled">Dismissed — nothing changed.</p>;
   }
 
-  if (action.status === "resolved") {
+  // A hire offer the backend could not run is **not** spent: it keeps its card — reason above it,
+  // field and buttons as they were — so the hire can act on what the refusal said. That matters
+  // most for a flag, whose wording is the one thing on the card they can correct. A success *is*
+  // spent (running a confirmed action twice is how somebody claims the same task twice), and a
+  // stored team proposal is settled server-side once decided.
+  const wasRefused = action.ok === false && action.outcome !== undefined;
+  const isSettled = action.status === "resolved" && (action.ok === true || isStored);
+
+  // Kept above the card while a retry is on its way, not just when the refusal arrives: pressing
+  // the button again must not blank out the sentence explaining why it did not work.
+  const outcomeLine =
+    action.status === "resolved" || wasRefused ? (
+      <p
+        className={`flex min-w-0 items-start gap-1.5 text-sm break-words ${
+          action.ok ? "text-app-text" : "text-app-text-muted"
+        }`}
+      >
+        <Check
+          className={`mt-0.5 h-4 w-4 shrink-0 ${
+            action.ok ? "text-app-success-solid" : "text-app-text-disabled"
+          }`}
+          aria-hidden="true"
+        />
+        {action.outcome}
+      </p>
+    ) : null;
+
+  if (isSettled) {
     return (
       <div className="flex flex-col items-start">
-        <p
-          className={`flex min-w-0 items-start gap-1.5 text-sm break-words ${
-            action.ok ? "text-app-text" : "text-app-text-muted"
-          }`}
-        >
-          <Check
-            className={`mt-0.5 h-4 w-4 shrink-0 ${
-              action.ok ? "text-app-success-solid" : "text-app-text-disabled"
-            }`}
-            aria-hidden="true"
-          />
-          {action.outcome}
-        </p>
-        {/* Under the refusal, not instead of it. The outcome is why it did not work and is
-                  the thing worth reading; this is only the way to try it once the reason has been
-                  dealt with. Never offered on success — running a confirmed action twice is how
-                  somebody claims the same task twice. Hire actions only: a stored team
-                  proposal is settled server-side once decided, so confirming it again
-                  could only be refused. */}
-        {!action.ok && "action" in action && (
-          <button
-            type="button"
-            onClick={handleConfirm}
-            className="mt-1.5 ml-5.5 flex items-center gap-1.5 rounded-lg px-2.5 py-1.5 text-sm text-app-text-muted transition-colors hover:bg-app-surface-hover hover:text-app-text"
-          >
-            <RotateCcw className="h-3.5 w-3.5" aria-hidden="true" />
-            Try again: {action.label}
-          </button>
-        )}
-        {/* Opening orientation is the one hire action whose result is content, not
-                                just an outcome line: the packet renders right here in the thread
-                                instead of navigating to a page. Stored proposals have no `action`
-                                name to match — their payoff is always the outcome line. */}
+        {outcomeLine}
+        {/* Opening orientation is the one hire action whose result is content, not just an
+            outcome line: the packet renders right here in the thread instead of navigating to a
+            page. Stored proposals have no `action` name to match — their payoff is always the
+            outcome line. */}
         {"action" in action && action.action === BUDDY_ACTION_OPEN_ORIENTATION && action.ok && (
           <BuddyOrientationCard />
         )}
@@ -164,42 +184,52 @@ function BuddyProposalCard({ messageId, action, onConfirm, onDismiss }: BuddyPro
   const previewId = `buddy-proposal-preview-${action.id}`;
 
   return (
-    <div className="flex max-w-full min-w-0 flex-col gap-1.5 rounded-xl border border-app-border bg-app-bg p-2.5">
-      {/* Shown before the press, not after it, and only where the payload is *content*.
+    <>
+      {/* Under the refusal, never instead of it: the outcome says why it did not work, and the
+          card below is how it is tried again — whole, because a flag that came back unsent is
+          exactly the one whose wording is worth another look. */}
+      {outcomeLine}
+      <div className="flex max-w-full min-w-0 flex-col gap-1.5 rounded-xl border border-app-border bg-app-bg p-2.5">
+        {/* Shown before the press, not after it, and only where the payload is *content*.
                 `place_checklist` is the one action whose confirm writes the mentor's own sentences
                 onto a surface the hire owns — the same reason the assessment proposal names the
                 skill and the level rather than saying "Save this". The lines are in the reply
                 above as well; having them here is what makes the two comparable, so a list that
                 does not match what was written is visible before it is kept, not after. */}
-      {!isStored && action.checklistItems && action.checklistItems.length > 0 && (
-        <div className="min-w-0">
-          {action.checklistTitle && (
-            <p className="text-sm font-medium break-words text-app-text">{action.checklistTitle}</p>
-          )}
-          {/* Named as an addition when it is one. The card keeps everything it already has,
+        {!isStored && action.checklistItems && action.checklistItems.length > 0 && (
+          <div className="min-w-0">
+            {action.checklistTitle && (
+              <p className="text-sm font-medium break-words text-app-text">
+                {action.checklistTitle}
+              </p>
+            )}
+            {/* Named as an addition when it is one. The card keeps everything it already has,
                     and these lines go after it — saying so is the difference between agreeing to
                     three new steps and agreeing to whatever the list becomes. */}
-          {action.action === BUDDY_ACTION_AMEND_CHECKLIST && (
-            <p className="text-xs text-app-text-muted">
-              Added to the end of that list — nothing on it changes:
-            </p>
-          )}
-          {action.action === BUDDY_ACTION_TICK_CHECKLIST && (
-            <p className="text-xs text-app-text-muted">
-              Ticked off on that list — nothing else on it changes:
-            </p>
-          )}
-          <ul className="mt-1 space-y-0.5">
-            {action.checklistItems.map((item, index) => (
-              <li key={`${action.id}-${index}`} className="text-xs break-words text-app-text-muted">
-                · {item}
-              </li>
-            ))}
-          </ul>
-        </div>
-      )}
+            {action.action === BUDDY_ACTION_AMEND_CHECKLIST && (
+              <p className="text-xs text-app-text-muted">
+                Added to the end of that list — nothing on it changes:
+              </p>
+            )}
+            {action.action === BUDDY_ACTION_TICK_CHECKLIST && (
+              <p className="text-xs text-app-text-muted">
+                Ticked off on that list — nothing else on it changes:
+              </p>
+            )}
+            <ul className="mt-1 space-y-0.5">
+              {action.checklistItems.map((item, index) => (
+                <li
+                  key={`${action.id}-${index}`}
+                  className="text-xs break-words text-app-text-muted"
+                >
+                  · {item}
+                </li>
+              ))}
+            </ul>
+          </div>
+        )}
 
-      {/* The one offer that *replaces* something already on a card, so it shows both: the
+        {/* The one offer that *replaces* something already on a card, so it shows both: the
                 line as it reads now and as it would read. Only the new wording would be asking
                 them to agree to a change they would have to go and diff for themselves.
 
@@ -210,53 +240,108 @@ function BuddyProposalCard({ messageId, action, onConfirm, onDismiss }: BuddyPro
 
                 Keyed off the action, like the amend and tick branches above, so a future action
                 that happens to carry both fields does not render as a rewording. */}
-      {!isStored &&
-        action.action === BUDDY_ACTION_REWORD_CHECKLIST &&
-        action.lineBefore &&
-        action.lineAfter && (
-          <div className="min-w-0 text-xs">
-            <del className="block break-words text-app-text-muted line-through">
-              <span className="sr-only">Currently: </span>
-              {action.lineBefore}
-            </del>
-            <ins className="block break-words text-app-text no-underline">
-              <span className="sr-only">Would become: </span>
-              {action.lineAfter}
-            </ins>
-          </div>
-        )}
+        {!isStored &&
+          action.action === BUDDY_ACTION_REWORD_CHECKLIST &&
+          action.lineBefore &&
+          action.lineAfter && (
+            <div className="min-w-0 text-xs">
+              <del className="block break-words text-app-text-muted line-through">
+                <span className="sr-only">Currently: </span>
+                {action.lineBefore}
+              </del>
+              <ins className="block break-words text-app-text no-underline">
+                <span className="sr-only">Would become: </span>
+                {action.lineAfter}
+              </ins>
+            </div>
+          )}
 
-      {/* Whitespace kept: the note's first line becomes the card's heading, so a preview that
+        {/* Whitespace kept: the note's first line becomes the card's heading, so a preview that
                 reflowed it would not be showing what would be kept. */}
-      {!isStored && action.noteText && (
-        <p className="min-w-0 text-xs break-words whitespace-pre-wrap text-app-text-muted">
-          {action.noteText}
-        </p>
-      )}
-      {/* What the manager is agreeing to comes FIRST, in the buddy's own words, and the
+        {!isStored && action.noteText && (
+          <p className="min-w-0 text-xs break-words whitespace-pre-wrap text-app-text-muted">
+            {action.noteText}
+          </p>
+        )}
+        {/* What the manager is agreeing to comes FIRST, in the buddy's own words, and the
                 confirm button describes it (aria-describedby): the target is the stored id, so
                 this text is the offer's full description — never a summary the client
                 recomposed, and never read after the button that acts on it. */}
-      {isStored && action.preview && (
-        <p id={previewId} className="text-xs leading-relaxed break-words text-app-text-muted">
-          {action.preview}
-        </p>
-      )}
+        {isStored && action.preview && (
+          <p id={previewId} className="text-xs leading-relaxed break-words text-app-text-muted">
+            {action.preview}
+          </p>
+        )}
 
-      {/* A stored proposal warns about itself before it is even clicked: how much it would
+        {/* A stored proposal warns about itself before it is even clicked: how much it would
                 change decides how loudly the card speaks, before any confirm happens. */}
-      {isStored && action.risk !== null && <ProposalRiskBadge risk={action.risk} />}
+        {isStored && action.risk !== null && <ProposalRiskBadge risk={action.risk} />}
 
-      {isUnsupported && (
-        <>
-          <p
-            data-testid="buddy-proposal-unsupported"
-            className="text-xs leading-relaxed text-app-warning-text"
+        {isUnsupported && (
+          <>
+            <p
+              data-testid="buddy-proposal-unsupported"
+              className="text-xs leading-relaxed text-app-warning-text"
+            >
+              This proposal arrived without its details, so it cannot be confirmed here. Ask the
+              buddy to propose it again.
+            </p>
+            <div className="flex flex-wrap items-center gap-2">
+              <button
+                type="button"
+                onClick={() => onDismiss(messageId, action.id)}
+                disabled={isConfirming}
+                className="flex items-center gap-1 rounded-lg px-2.5 py-1.5 text-sm text-app-text-muted transition-colors hover:bg-app-surface-hover hover:text-app-text disabled:opacity-60"
+              >
+                <X className="h-3.5 w-3.5" aria-hidden="true" />
+                Not now
+              </button>
+            </div>
+          </>
+        )}
+        {/* The one proposal whose payload is a *message*: the buddy composes the question,
+                the hire sends it under their own name, and a person reads it — so it is shown in
+                full, editable, above the button that sends it. Three things follow from that, and
+                all are enforced: what goes out is the field's own text (`handleConfirm`), an empty
+                field cannot be confirmed at all, and the wording is held by the session rather
+                than by this card (`actionDrafts`) — neither a dock the hire closes nor the
+                hand-off to `/buddy` may throw away a half-worded question. */}
+        {isFlagToPm && (
+          <Field
+            label="Sends to your PM"
+            hint="Edit it if it is not quite right — this exact text is what they will read."
+            disabled={isConfirming}
           >
-            This proposal arrived without its details, so it cannot be confirmed here. Ask the buddy
-            to propose it again.
-          </p>
+            <Textarea
+              value={editedQuestion}
+              onChange={(event) => setActionDraft(draftKey, event.target.value)}
+              placeholder="What do you need answered?"
+              minRows={2}
+              maxRows={5}
+            />
+          </Field>
+        )}
+
+        {!isUnsupported && (
           <div className="flex flex-wrap items-center gap-2">
+            {/* `action.label` is written by the model, so its length is not ours to
+                                assume. In a 384 px panel an unbreakable one would push the button
+                                past the edge -- hence the wrap and the left alignment that follows
+                                from a label running to two lines. */}
+            <button
+              type="button"
+              onClick={handleConfirm}
+              disabled={!canConfirm}
+              aria-describedby={isStored && action.preview ? previewId : undefined}
+              className="flex max-w-full min-w-0 items-center gap-1.5 rounded-lg bg-app-brand px-3 py-1.5 text-left text-sm font-medium break-words text-white transition-colors hover:bg-app-brand-hover disabled:cursor-not-allowed disabled:opacity-60"
+            >
+              {isConfirming ? (
+                <Loader2 className="h-3.5 w-3.5 animate-spin" aria-hidden="true" />
+              ) : (
+                <Check className="h-3.5 w-3.5" aria-hidden="true" />
+              )}
+              {action.label}
+            </button>
             <button
               type="button"
               onClick={() => onDismiss(messageId, action.id)}
@@ -267,73 +352,23 @@ function BuddyProposalCard({ messageId, action, onConfirm, onDismiss }: BuddyPro
               Not now
             </button>
           </div>
-        </>
-      )}
-      {/* The one proposal whose payload is a *message*: the buddy composes the question,
-                the hire sends it under their own name, and a person reads it — so it is shown in
-                full, editable, above the button that sends it. Two things follow from that, and
-                both are enforced: what goes out is the field's own text (`handleConfirm`), and an
-                empty field cannot be confirmed at all. */}
-      {isFlagToPm && (
-        <Field
-          label="Sends to your PM"
-          hint="Edit it if it is not quite right — this exact text is what they will read."
-          disabled={isConfirming}
-        >
-          <Textarea
-            value={editedQuestion}
-            onChange={(event) => setEditedQuestion(event.target.value)}
-            placeholder="What do you need answered?"
-            minRows={2}
-            maxRows={5}
-          />
-        </Field>
-      )}
-
-      {!isUnsupported && (
-        <div className="flex flex-wrap items-center gap-2">
-          {/* `action.label` is written by the model, so its length is not ours to
-                                assume. In a 384 px panel an unbreakable one would push the button
-                                past the edge -- hence the wrap and the left alignment that follows
-                                from a label running to two lines. */}
-          <button
-            type="button"
-            onClick={handleConfirm}
-            disabled={!canConfirm}
-            aria-describedby={isStored && action.preview ? previewId : undefined}
-            className="flex max-w-full min-w-0 items-center gap-1.5 rounded-lg bg-app-brand px-3 py-1.5 text-left text-sm font-medium break-words text-white transition-colors hover:bg-app-brand-hover disabled:cursor-not-allowed disabled:opacity-60"
-          >
-            {isConfirming ? (
-              <Loader2 className="h-3.5 w-3.5 animate-spin" aria-hidden="true" />
-            ) : (
-              <Check className="h-3.5 w-3.5" aria-hidden="true" />
-            )}
-            {action.label}
-          </button>
-          <button
-            type="button"
-            onClick={() => onDismiss(messageId, action.id)}
-            disabled={isConfirming}
-            className="flex items-center gap-1 rounded-lg px-2.5 py-1.5 text-sm text-app-text-muted transition-colors hover:bg-app-surface-hover hover:text-app-text disabled:opacity-60"
-          >
-            <X className="h-3.5 w-3.5" aria-hidden="true" />
-            Not now
-          </button>
-        </div>
-      )}
-      {/* The other thing that leaves the product in the hire's name: a skip request's
+        )}
+        {/* The other thing that leaves the product in the hire's name: a skip request's
                 reason, which is the whole of what that PM reads. A static line rather than a
                 field, and deliberately left where it was — a sentence to acknowledge, not one to
                 compose. A flag's question is the field above, because that one is rewordable. */}
-      {!isStored && action.reason && (
-        <p className="px-1 text-xs break-words text-app-text-muted">
-          Your reason: &ldquo;{action.reason}&rdquo;
-        </p>
-      )}
-      {action.status === "error" && (
-        <p className="text-xs text-app-danger-text">Couldn&apos;t reach the server — try again.</p>
-      )}
-    </div>
+        {!isStored && action.reason && (
+          <p className="px-1 text-xs break-words text-app-text-muted">
+            Your reason: &ldquo;{action.reason}&rdquo;
+          </p>
+        )}
+        {action.status === "error" && (
+          <p className="text-xs text-app-danger-text">
+            Couldn&apos;t reach the server — try again.
+          </p>
+        )}
+      </div>
+    </>
   );
 }
 
diff --git a/src/features/buddy/components/BuddyConversation.tsx b/src/features/buddy/components/BuddyConversation.tsx
index 89b96e67..a2987956 100644
--- a/src/features/buddy/components/BuddyConversation.tsx
+++ b/src/features/buddy/components/BuddyConversation.tsx
@@ -1,5 +1,6 @@
 import type { ReactNode } from "react";
 import type { BuddyMessageView, ProposedAction } from "../types";
+import type { ActionDrafts } from "../actionDrafts";
 import { BuddyComposer } from "./BuddyComposer";
 import { BuddyThread } from "./BuddyThread";
 import { BuddyReplyActions } from "./BuddyReplyActions";
@@ -21,6 +22,10 @@ type BuddyConversationProps = {
   confirmAction: (messageId: string, action: ProposedAction) => void;
   /** Declines a proposed action; nothing changes. */
   dismissAction: (messageId: string, actionId: string) => void;
+  /** The session's wording for offers that carry an editable message — see `actionDrafts`. */
+  actionDrafts: ActionDrafts;
+  /** Records one, so it outlives whichever surface is on screen. */
+  setActionDraft: (key: string, text: string) => void;
   /** Composer placeholder — "Type your answer…" while the buddy is intaking. */
   placeholder?: string;
   /** Rendered above the first message: what came back from the hire's PM. */
@@ -81,6 +86,8 @@ export function BuddyConversation({
   handleSubmit,
   confirmAction,
   dismissAction,
+  actionDrafts,
+  setActionDraft,
   placeholder,
   before,
   lastMessageFooter,
@@ -147,6 +154,8 @@ export function BuddyConversation({
             activeTool={activeTool}
             confirmAction={confirmAction}
             dismissAction={dismissAction}
+            actionDrafts={actionDrafts}
+            setActionDraft={setActionDraft}
             showNames
             before={before}
             lastMessageFooter={lastMessageFooter}
diff --git a/src/features/buddy/components/BuddyDock.tsx b/src/features/buddy/components/BuddyDock.tsx
index d47230ba..448a8f08 100644
--- a/src/features/buddy/components/BuddyDock.tsx
+++ b/src/features/buddy/components/BuddyDock.tsx
@@ -46,6 +46,8 @@ type BuddyDockProps = Pick<
   | "handleSubmit"
   | "confirmAction"
   | "dismissAction"
+  | "actionDrafts"
+  | "setActionDraft"
   | "suggestions"
   | "startFreshVisit"
   | "isGreeting"
@@ -130,6 +132,8 @@ export function BuddyDock({
   handleSubmit,
   confirmAction,
   dismissAction,
+  actionDrafts,
+  setActionDraft,
   suggestions,
   startFreshVisit,
   isGreeting,
@@ -327,6 +331,8 @@ export function BuddyDock({
             lastMessageFooter={lastMessageFooter}
             confirmAction={confirmAction}
             dismissAction={dismissAction}
+            actionDrafts={actionDrafts}
+            setActionDraft={setActionDraft}
             // Hire-flow only: "Send this to your PM" escalates the hire's own question, and a
             // team-mode conversation is not one — the offer must not even render there.
             renderQuestionAction={(question) =>
diff --git a/src/features/buddy/components/BuddyThread.tsx b/src/features/buddy/components/BuddyThread.tsx
index 7a454b46..55f3030b 100644
--- a/src/features/buddy/components/BuddyThread.tsx
+++ b/src/features/buddy/components/BuddyThread.tsx
@@ -3,6 +3,7 @@ import type { ReactNode } from "react";
 import { AlertCircle, RotateCcw } from "lucide-react";
 import { Button } from "../../../components/ui/Button";
 import type { BuddyMessageView, ProposedAction } from "../types";
+import type { ActionDrafts } from "../actionDrafts";
 import { toolLabel } from "../toolLabel";
 import { BuddyActionProposals } from "./BuddyActionProposals";
 import { BuddyMarkdown } from "./BuddyMarkdown";
@@ -17,6 +18,10 @@ type BuddyThreadProps = {
   confirmAction: (messageId: string, action: ProposedAction) => void;
   /** Declines a proposed action; nothing changes. */
   dismissAction: (messageId: string, actionId: string) => void;
+  /** The session's wording for offers that carry an editable message — see `actionDrafts`. */
+  actionDrafts: ActionDrafts;
+  /** Records one, so it outlives whichever surface is on screen. */
+  setActionDraft: (key: string, text: string) => void;
   /** Names above the bubbles — on for the page, off in the dock. */
   showNames?: boolean;
   /** The dock's narrow layout — see `BuddyMessage`'s `compact`. */
@@ -93,6 +98,8 @@ export function BuddyThread({
   activeTool,
   confirmAction,
   dismissAction,
+  actionDrafts,
+  setActionDraft,
   showNames = false,
   compact = false,
   before,
@@ -197,6 +204,8 @@ export function BuddyThread({
                     <BuddyActionProposals
                       messageId={message.id}
                       actions={message.actions ?? []}
+                      actionDrafts={actionDrafts}
+                      setActionDraft={setActionDraft}
                       onConfirm={confirmAction}
                       onDismiss={dismissAction}
                     />
diff --git a/src/features/buddy/components/BuddyWidget.tsx b/src/features/buddy/components/BuddyWidget.tsx
index 9dce202e..670642b2 100644
--- a/src/features/buddy/components/BuddyWidget.tsx
+++ b/src/features/buddy/components/BuddyWidget.tsx
@@ -71,6 +71,8 @@ export function BuddyWidget() {
     handleSubmit,
     confirmAction,
     dismissAction,
+    actionDrafts,
+    setActionDraft,
     suggestions,
     openError,
     retryOpen,
@@ -304,6 +306,8 @@ export function BuddyWidget() {
             handleSubmit={handleSubmit}
             confirmAction={confirmAction}
             dismissAction={dismissAction}
+            actionDrafts={actionDrafts}
+            setActionDraft={setActionDraft}
             suggestions={suggestions}
             startFreshVisit={startFreshVisit}
             isGreeting={isGreeting}
diff --git a/src/features/buddy/hooks/useBuddyConversation.ts b/src/features/buddy/hooks/useBuddyConversation.ts
index f27f5a1b..779fdbb9 100644
--- a/src/features/buddy/hooks/useBuddyConversation.ts
+++ b/src/features/buddy/hooks/useBuddyConversation.ts
@@ -9,6 +9,8 @@ import {
   type BuddyOpeningAction,
 } from "../../../services/buddyService";
 import { announceBuddyPathChanged } from "../aiBuddyBus";
+import { actionDraftKey } from "../actionDrafts";
+import type { ActionDrafts } from "../actionDrafts";
 import { BUDDY_PATH_ACTIONS } from "../types";
 import { useAuth } from "../../../context/useAuth";
 import type { ActionPatch, BuddyMessageView, ProposedAction } from "../types";
@@ -105,6 +107,15 @@ export function useBuddyConversation(
   // failed, which carries its own reason. Nothing is on screen to hang that on, so it is state.
   const [openError, setOpenError] = useState<string | null>(null);
   const [draft, setDraft] = useState("");
+  /**
+   * The hire's wording for the proposals that carry an editable message — a flag's question, the
+   * only payload a person reads and the hire therefore rewords (see `actionDrafts` for the key).
+   *
+   * Session state rather than card state, for the same reason the composer's draft is: the dock
+   * unmounts when it closes, the full page mounts a second card for the same action, and either
+   * one would otherwise throw away words the hire was halfway through.
+   */
+  const [actionDrafts, setActionDrafts] = useState<ActionDrafts>({});
   /**
    * The last greeting a surface has actually put in front of the hire — either watched while it
    * streamed, or revealed by `useGreetingReveal`. Held here, not per surface, so a greeting the
@@ -638,6 +649,29 @@ export function useBuddyConversation(
   // the honest guard is here, where the second click is refused rather than re-sent.
   const inFlightRef = useRef<Set<string>>(new Set());
 
+  /**
+   * Records what the hire typed into a proposal's field, so it survives a closed dock, a handed-
+   * over conversation and the retry a refusal offers — see `actionDrafts` for why it is session
+   * state and not the card's own.
+   */
+  const setActionDraft = useCallback((key: string, text: string) => {
+    setActionDrafts((current) => ({ ...current, [key]: text }));
+  }, []);
+
+  /**
+   * Forgets a draft whose proposal is done with — it was sent, or the hire declined it. Nothing
+   * is left to edit, and a card re-rendered later must not offer wording that has already left
+   * the product.
+   */
+  const clearActionDraft = useCallback((key: string) => {
+    setActionDrafts((current) => {
+      if (!(key in current)) return current;
+      const next = { ...current };
+      delete next[key];
+      return next;
+    });
+  }, []);
+
   /**
    * Confirms a proposed action: the one call that mutates. Reflects the outcome inline — a
    * legible line whether it changed something (`ok`) or legibly couldn't, or a retryable error
@@ -716,6 +750,9 @@ export function useBuddyConversation(
             ok: result.ok,
             outcome: result.message,
           });
+          // It went out: the wording has left the product, so the session keeps none of it. A
+          // refusal keeps it — that card is about to be handed the hire's text back to correct.
+          if (result.ok) clearActionDraft(actionDraftKey(messageId, action.id));
           // A path action just moved something on a page that may be open behind this dock. Told
           // rather than polled, and only on success: a refused confirm changed nothing to refresh.
           if (result.ok && "action" in action && BUDDY_PATH_ACTIONS.includes(action.action)) {
@@ -744,7 +781,7 @@ export function useBuddyConversation(
         }
       })();
     },
-    [beginDecision, endDecision, patchAction],
+    [beginDecision, endDecision, patchAction, clearActionDraft],
   );
 
   /**
@@ -764,6 +801,9 @@ export function useBuddyConversation(
       // Unknown action: nothing to decline at the backend, but still worth putting away here.
       if (!action || !("proposalId" in action)) {
         patchAction(messageId, actionId, { status: "dismissed" });
+        // A hire offer is the only kind that carries a draft, and this is the only place one is
+        // declined — the wording goes with the offer it belonged to.
+        clearActionDraft(actionDraftKey(messageId, actionId));
         return;
       }
 
@@ -809,7 +849,7 @@ export function useBuddyConversation(
         }
       })();
     },
-    [beginDecision, endDecision, messages, patchAction],
+    [beginDecision, endDecision, messages, patchAction, clearActionDraft],
   );
 
   /**
@@ -926,6 +966,10 @@ export function useBuddyConversation(
 
     draft,
     setDraft,
+    // The same idea for the fields a proposal carries: a flag's question is the hire's to word,
+    // and the session is what keeps that wording across a closed dock and a handed-over page.
+    actionDrafts,
+    setActionDraft,
     sendMessage,
     handleSubmit,
     confirmAction,
diff --git a/src/pages/BuddyPage.tsx b/src/pages/BuddyPage.tsx
index 9a275ba0..abf73886 100644
--- a/src/pages/BuddyPage.tsx
+++ b/src/pages/BuddyPage.tsx
@@ -174,6 +174,8 @@ function BuddyMentorHome() {
     handleSubmit,
     confirmAction,
     dismissAction,
+    actionDrafts,
+    setActionDraft,
     openError,
     ensureOpened,
     retryOpen,
@@ -371,6 +373,8 @@ function BuddyMentorHome() {
         handleSubmit={handleSubmit}
         confirmAction={confirmAction}
         dismissAction={dismissAction}
+        actionDrafts={actionDrafts}
+        setActionDraft={setActionDraft}
         // Escalating hangs off the hire's own question now, not off the buddy's answer — see
         // `BuddyQuestionActions`. What is left here is the greeting's own next step, offered
         // where a messenger offers a quick reply: right under the message that suggested it. It
diff --git a/tests/unit/a11y/BuddyActionProposals.a11y.test.tsx b/tests/unit/a11y/BuddyActionProposals.a11y.test.tsx
index 6c599142..b467cbe3 100644
--- a/tests/unit/a11y/BuddyActionProposals.a11y.test.tsx
+++ b/tests/unit/a11y/BuddyActionProposals.a11y.test.tsx
@@ -4,27 +4,45 @@ import { axe } from "vitest-axe";
 import { BuddyActionProposals } from "../../../src/features/buddy/components/BuddyActionProposals";
 import type { ProposedAction } from "../../../src/features/buddy/types";
 
+function flag(overrides: Partial<ProposedAction> = {}): ProposedAction {
+  return {
+    id: "a1",
+    action: "flag_to_pm",
+    label: "Flag this to your PM",
+    question: "How do we request staging database credentials?",
+    status: "idle",
+    ...overrides,
+  };
+}
+
+/** Rendered the way the thread does: with a session-held store for the one field that is editable. */
+function renderFlag(action: ProposedAction) {
+  return render(
+    <main>
+      <BuddyActionProposals
+        messageId="m1"
+        actions={[action]}
+        actionDrafts={{}}
+        setActionDraft={vi.fn()}
+        onConfirm={vi.fn()}
+        onDismiss={vi.fn()}
+      />
+    </main>,
+  );
+}
+
 describe("BuddyActionProposals Accessibility", () => {
-  it("has no violations on a flag whose question is edited before it is sent", async () => {
+  it("has no violations on the flag's own question field", async () => {
     // The one proposal that carries an editable message: the field has to be a labelled control
     // with its hint announced, exactly like every other text field in the app.
-    const flag: ProposedAction = {
-      id: "a1",
-      action: "flag_to_pm",
-      label: "Flag this to your PM",
-      question: "How do we request staging database credentials?",
-      status: "idle",
-    };
+    const { baseElement } = renderFlag(flag());
+
+    expect(await axe(baseElement)).toHaveNoViolations();
+  });
 
-    const { baseElement } = render(
-      <main>
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[flag]}
-          onConfirm={vi.fn()}
-          onDismiss={vi.fn()}
-        />
-      </main>,
+  it("has no violations on a flag that came back unsent, its card still under the reason", async () => {
+    const { baseElement } = renderFlag(
+      flag({ status: "resolved", ok: false, outcome: "I could not send that just now." }),
     );
 
     expect(await axe(baseElement)).toHaveNoViolations();
diff --git a/tests/unit/features/buddy/BuddyActionProposals.test.tsx b/tests/unit/features/buddy/BuddyActionProposals.test.tsx
index 08032b83..fb652c26 100644
--- a/tests/unit/features/buddy/BuddyActionProposals.test.tsx
+++ b/tests/unit/features/buddy/BuddyActionProposals.test.tsx
@@ -1,7 +1,8 @@
 import { render, screen } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
+import { useState } from "react";
 import { describe, it, expect, vi } from "vitest";
-import { BuddyActionProposals } from "../../../../src/features/buddy/components/BuddyActionProposals";
+import { BuddyActionProposals as BuddyActionList } from "../../../../src/features/buddy/components/BuddyActionProposals";
 import type { ProposedAction } from "../../../../src/features/buddy/types";
 
 // The card has its own test file; here we only assert *whether* it renders.
@@ -19,17 +20,49 @@ function action(overrides: Partial<ProposedAction> = {}): ProposedAction {
   };
 }
 
+/**
+ * The list as the thread renders it: the draft store comes from the session (`actionDrafts`), not
+ * from the card — which is what keeps the hire's wording across a closed dock and the hand-off to
+ * `/buddy`. These tests hold a store of their own, so one test can seed what another surface would
+ * have left behind, and another can watch where a keystroke goes.
+ */
+function Proposals({
+  actions,
+  onConfirm = vi.fn(),
+  onDismiss = vi.fn(),
+  initialDrafts,
+  onDraftChange,
+}: {
+  actions: ProposedAction[];
+  onConfirm?: (messageId: string, action: ProposedAction) => void;
+  onDismiss?: (messageId: string, actionId: string) => void;
+  /** Wording another surface already put in — as if the hire had typed it there. */
+  initialDrafts?: Record<string, string>;
+  /** Watches the store, for the tests that assert *where* a draft is kept. */
+  onDraftChange?: (key: string, text: string) => void;
+}) {
+  const [drafts, setDrafts] = useState<Record<string, string>>(initialDrafts ?? {});
+  const setActionDraft = (key: string, text: string) => {
+    onDraftChange?.(key, text);
+    setDrafts((current) => ({ ...current, [key]: text }));
+  };
+
+  return (
+    <BuddyActionList
+      messageId="m1"
+      actions={actions}
+      actionDrafts={drafts}
+      setActionDraft={setActionDraft}
+      onConfirm={onConfirm}
+      onDismiss={onDismiss}
+    />
+  );
+}
+
 describe("BuddyActionProposals", () => {
   it("confirms only when the hire clicks — the proposal itself mutates nothing", async () => {
     const onConfirm = vi.fn();
-    render(
-      <BuddyActionProposals
-        messageId="m1"
-        actions={[action()]}
-        onConfirm={onConfirm}
-        onDismiss={vi.fn()}
-      />,
-    );
+    render(<Proposals actions={[action()]} onConfirm={onConfirm} onDismiss={vi.fn()} />);
 
     // Rendering the offer must not fire the action.
     expect(onConfirm).not.toHaveBeenCalled();
@@ -42,14 +75,7 @@ describe("BuddyActionProposals", () => {
   it("declines without mutating", async () => {
     const onDismiss = vi.fn();
     const onConfirm = vi.fn();
-    render(
-      <BuddyActionProposals
-        messageId="m1"
-        actions={[action()]}
-        onConfirm={onConfirm}
-        onDismiss={onDismiss}
-      />,
-    );
+    render(<Proposals actions={[action()]} onConfirm={onConfirm} onDismiss={onDismiss} />);
 
     await userEvent.click(screen.getByRole("button", { name: /Not now/ }));
 
@@ -59,8 +85,7 @@ describe("BuddyActionProposals", () => {
 
   it("shows the outcome line once resolved instead of the buttons", () => {
     render(
-      <BuddyActionProposals
-        messageId="m1"
+      <Proposals
         actions={[
           action({ status: "resolved", ok: true, outcome: "You are now working toward it." }),
         ]}
@@ -75,12 +100,7 @@ describe("BuddyActionProposals", () => {
 
   it("offers a retry on a transport error", () => {
     render(
-      <BuddyActionProposals
-        messageId="m1"
-        actions={[action({ status: "error" })]}
-        onConfirm={vi.fn()}
-        onDismiss={vi.fn()}
-      />,
+      <Proposals actions={[action({ status: "error" })]} onConfirm={vi.fn()} onDismiss={vi.fn()} />,
     );
 
     expect(screen.getByText(/try again/i)).toBeInTheDocument();
@@ -91,8 +111,7 @@ describe("BuddyActionProposals", () => {
   it("renders the orientation packet in the thread once open_orientation resolves", () => {
     // The conversation is the surface now: confirming must not navigate anywhere.
     render(
-      <BuddyActionProposals
-        messageId="m1"
+      <Proposals
         actions={[
           action({
             action: "open_orientation",
@@ -112,8 +131,7 @@ describe("BuddyActionProposals", () => {
 
   it("renders no orientation card for other actions, or when open_orientation could not", () => {
     const { rerender } = render(
-      <BuddyActionProposals
-        messageId="m1"
+      <Proposals
         actions={[
           action({ status: "resolved", ok: true, outcome: "You are now working toward it." }),
         ]}
@@ -125,8 +143,7 @@ describe("BuddyActionProposals", () => {
     expect(screen.queryByTestId("buddy-orientation-card")).not.toBeInTheDocument();
 
     rerender(
-      <BuddyActionProposals
-        messageId="m1"
+      <Proposals
         actions={[
           action({
             action: "open_orientation",
@@ -161,14 +178,7 @@ describe("BuddyActionProposals", () => {
     it("shows the composed question in an editable field, not just a button", () => {
       // The button only says that something will be flagged. What lands in the PM's inbox is
       // the question the buddy composed — shown in full, and in a field, not a caption.
-      render(
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[flag()]}
-          onConfirm={vi.fn()}
-          onDismiss={vi.fn()}
-        />,
-      );
+      render(<Proposals actions={[flag()]} onConfirm={vi.fn()} onDismiss={vi.fn()} />);
 
       expect(screen.getByLabelText(/sends to your PM/i)).toHaveValue(
         "How do we request staging database credentials?",
@@ -177,14 +187,7 @@ describe("BuddyActionProposals", () => {
 
     it("sends the text the hire edited, not the one the buddy composed", async () => {
       const onConfirm = vi.fn();
-      render(
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[flag()]}
-          onConfirm={onConfirm}
-          onDismiss={vi.fn()}
-        />,
-      );
+      render(<Proposals actions={[flag()]} onConfirm={onConfirm} onDismiss={vi.fn()} />);
 
       const field = screen.getByLabelText(/sends to your PM/i);
       await userEvent.clear(field);
@@ -203,14 +206,7 @@ describe("BuddyActionProposals", () => {
 
     it("sends the composed question untouched when the hire does not edit it", async () => {
       const onConfirm = vi.fn();
-      render(
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[flag()]}
-          onConfirm={onConfirm}
-          onDismiss={vi.fn()}
-        />,
-      );
+      render(<Proposals actions={[flag()]} onConfirm={onConfirm} onDismiss={vi.fn()} />);
 
       await userEvent.click(screen.getByRole("button", { name: /Flag this to your PM/i }));
 
@@ -225,14 +221,7 @@ describe("BuddyActionProposals", () => {
 
     it("sends the question trimmed — what goes out is a message, not a field value", async () => {
       const onConfirm = vi.fn();
-      render(
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[flag()]}
-          onConfirm={onConfirm}
-          onDismiss={vi.fn()}
-        />,
-      );
+      render(<Proposals actions={[flag()]} onConfirm={onConfirm} onDismiss={vi.fn()} />);
 
       const field = screen.getByLabelText(/sends to your PM/i);
       await userEvent.clear(field);
@@ -245,14 +234,7 @@ describe("BuddyActionProposals", () => {
 
     it("cannot be confirmed while the field is empty", async () => {
       const onConfirm = vi.fn();
-      render(
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[flag()]}
-          onConfirm={onConfirm}
-          onDismiss={vi.fn()}
-        />,
-      );
+      render(<Proposals actions={[flag()]} onConfirm={onConfirm} onDismiss={vi.fn()} />);
 
       await userEvent.clear(screen.getByLabelText(/sends to your PM/i));
 
@@ -263,14 +245,7 @@ describe("BuddyActionProposals", () => {
     });
 
     it("cannot be confirmed on whitespace alone — a blank flag is not a question", async () => {
-      render(
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[flag()]}
-          onConfirm={vi.fn()}
-          onDismiss={vi.fn()}
-        />,
-      );
+      render(<Proposals actions={[flag()]} onConfirm={vi.fn()} onDismiss={vi.fn()} />);
 
       const field = screen.getByLabelText(/sends to your PM/i);
       await userEvent.clear(field);
@@ -282,8 +257,7 @@ describe("BuddyActionProposals", () => {
     it("freezes the field while the flag is on its way", () => {
       // What is sent is what is on screen. Editing mid-flight is the one way to break that.
       render(
-        <BuddyActionProposals
-          messageId="m1"
+        <Proposals
           actions={[flag({ status: "confirming" })]}
           onConfirm={vi.fn()}
           onDismiss={vi.fn()}
@@ -297,14 +271,7 @@ describe("BuddyActionProposals", () => {
     it("declines without flagging anything at all", async () => {
       const onConfirm = vi.fn();
       const onDismiss = vi.fn();
-      render(
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[flag()]}
-          onConfirm={onConfirm}
-          onDismiss={onDismiss}
-        />,
-      );
+      render(<Proposals actions={[flag()]} onConfirm={onConfirm} onDismiss={onDismiss} />);
 
       await userEvent.click(screen.getByRole("button", { name: /Not now/i }));
 
@@ -316,23 +283,18 @@ describe("BuddyActionProposals", () => {
     it("retries a refusal with the text the hire last edited", async () => {
       const onConfirm = vi.fn();
       const { rerender } = render(
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[flag()]}
-          onConfirm={onConfirm}
-          onDismiss={vi.fn()}
-        />,
+        <Proposals actions={[flag()]} onConfirm={onConfirm} onDismiss={vi.fn()} />,
       );
 
       const field = screen.getByLabelText(/sends to your PM/i);
       await userEvent.clear(field);
       await userEvent.type(field, "Updated question?");
 
-      // The backend answered "couldn't": the outcome stays, the offer comes back under it — and
-      // the text it would send is still the text the hire last read, not the original proposal.
+      // The backend answered "couldn't": the reason stays, and the card stays under it — field and
+      // all, because a flag that came back unsent is exactly the one whose wording needs another
+      // look. What it would send is still the text the hire last read, never the original proposal.
       rerender(
-        <BuddyActionProposals
-          messageId="m1"
+        <Proposals
           actions={[
             flag({
               status: "resolved",
@@ -345,21 +307,106 @@ describe("BuddyActionProposals", () => {
         />,
       );
 
-      await userEvent.click(
-        screen.getByRole("button", { name: /Try again: Flag this to your PM/i }),
-      );
+      expect(screen.getByText(/I need the question to flag/)).toBeInTheDocument();
+      expect(screen.getByLabelText(/sends to your PM/i)).toHaveValue("Updated question?");
+
+      await userEvent.click(screen.getByRole("button", { name: /Flag this to your PM/i }));
 
       expect(onConfirm).toHaveBeenCalledWith(
         "m1",
         expect.objectContaining({ question: "Updated question?" }),
       );
     });
+
+    it("keeps the reason on screen while the retry is on its way", () => {
+      // The retry re-runs the confirm. Without this the card would blank the sentence the hire is
+      // acting on the instant they press the button.
+      const { rerender } = render(
+        <Proposals
+          actions={[
+            flag({ status: "resolved", ok: false, outcome: "Could not send that just now." }),
+          ]}
+          onConfirm={vi.fn()}
+          onDismiss={vi.fn()}
+        />,
+      );
+
+      // The card the hire would retry from is still there, with their words in it...
+      expect(screen.getByLabelText(/sends to your PM/i)).toHaveValue(
+        "How do we request staging database credentials?",
+      );
+
+      rerender(
+        <Proposals
+          actions={[
+            flag({ status: "confirming", ok: false, outcome: "Could not send that just now." }),
+          ]}
+          onConfirm={vi.fn()}
+          onDismiss={vi.fn()}
+        />,
+      );
+
+      expect(screen.getByText("Could not send that just now.")).toBeInTheDocument();
+      // ...frozen on its way out, the way it is on the way in.
+      expect(screen.getByLabelText(/sends to your PM/i)).toBeDisabled();
+    });
+
+    it("cannot retry a refusal with an empty field — a blank flag is not a question", async () => {
+      render(
+        <Proposals
+          actions={[
+            flag({ status: "resolved", ok: false, outcome: "I need the question to flag." }),
+          ]}
+          onConfirm={vi.fn()}
+          onDismiss={vi.fn()}
+        />,
+      );
+
+      await userEvent.clear(screen.getByLabelText(/sends to your PM/i));
+
+      // The button cannot be pressed into a no-op: it says so instead.
+      expect(screen.getByRole("button", { name: /Flag this to your PM/i })).toBeDisabled();
+    });
+
+    it("keeps the hire's wording when the surface they typed it on goes away", () => {
+      // Closing the dock, handing the conversation over to `/buddy`, a route change: the card
+      // unmounts and re-mounts, and the session's store is what carries the words to the next one.
+      render(
+        <Proposals
+          actions={[flag()]}
+          initialDrafts={{ "m1:a1": "Written in the dock" }}
+          onConfirm={vi.fn()}
+          onDismiss={vi.fn()}
+        />,
+      );
+
+      expect(screen.getByLabelText(/sends to your PM/i)).toHaveValue("Written in the dock");
+    });
+
+    it("records a keystroke against its message and action, not against the card", async () => {
+      const onDraftChange = vi.fn();
+      render(
+        <Proposals
+          actions={[flag()]}
+          onDraftChange={onDraftChange}
+          onConfirm={vi.fn()}
+          onDismiss={vi.fn()}
+        />,
+      );
+
+      await userEvent.type(screen.getByLabelText(/sends to your PM/i), "!");
+
+      // Keyed by both halves, so one message's wording can never surface in another's card.
+      expect(onDraftChange).toHaveBeenLastCalledWith(
+        "m1:a1",
+        "How do we request staging database credentials?!",
+      );
+    });
   });
 
   it("grows no field for an action that sends nobody anything", () => {
     render(
-      <BuddyActionProposals
-        messageId="m1"
+      <Proposals
         actions={[action({ action: "claim_goal", label: "Work toward this task", taskId: "t1" })]}
         onConfirm={vi.fn()}
         onDismiss={vi.fn()}
@@ -371,8 +418,7 @@ describe("BuddyActionProposals", () => {
 
   it("shows the whole skip reason before the hire sends it in their name", () => {
     render(
-      <BuddyActionProposals
-        messageId="m1"
+      <Proposals
         actions={[
           action({
             action: "request_skip",
@@ -406,14 +452,7 @@ describe("BuddyActionProposals", () => {
       });
 
     it("shows what would be kept, before it is kept", () => {
-      render(
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[proposal()]}
-          onConfirm={vi.fn()}
-          onDismiss={vi.fn()}
-        />,
-      );
+      render(<Proposals actions={[proposal()]} onConfirm={vi.fn()} onDismiss={vi.fn()} />);
 
       expect(screen.getByText("Getting started on the skill-gap view")).toBeInTheDocument();
       expect(screen.getByText(/Find the component/)).toBeInTheDocument();
@@ -423,14 +462,7 @@ describe("BuddyActionProposals", () => {
     /** The lines ride back verbatim, so what is kept is what they read. */
     it("hands the lines back on confirm rather than re-deriving them", async () => {
       const onConfirm = vi.fn();
-      render(
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[proposal()]}
-          onConfirm={onConfirm}
-          onDismiss={vi.fn()}
-        />,
-      );
+      render(<Proposals actions={[proposal()]} onConfirm={onConfirm} onDismiss={vi.fn()} />);
 
       await userEvent.click(screen.getByRole("button", { name: /keep this as a checklist/i }));
 
@@ -442,14 +474,7 @@ describe("BuddyActionProposals", () => {
 
     /** Every other action carries a target, not content — nothing to preview there. */
     it("previews nothing for an action that carries no list", () => {
-      render(
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[action({})]}
-          onConfirm={vi.fn()}
-          onDismiss={vi.fn()}
-        />,
-      );
+      render(<Proposals actions={[action({})]} onConfirm={vi.fn()} onDismiss={vi.fn()} />);
 
       expect(screen.queryByRole("list")).not.toBeInTheDocument();
     });
@@ -459,8 +484,7 @@ describe("BuddyActionProposals", () => {
   describe("a proposed amendment", () => {
     it("names it as an addition and shows only the new lines", () => {
       render(
-        <BuddyActionProposals
-          messageId="m1"
+        <Proposals
           actions={[
             action({
               action: "amend_checklist",
@@ -481,8 +505,7 @@ describe("BuddyActionProposals", () => {
     it("carries the card it would be added to back on confirm", async () => {
       const onConfirm = vi.fn();
       render(
-        <BuddyActionProposals
-          messageId="m1"
+        <Proposals
           actions={[
             action({
               action: "amend_checklist",
@@ -520,14 +543,7 @@ describe("BuddyActionProposals", () => {
       });
 
     it("says it ticks, and never that it adds", () => {
-      render(
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[ticks()]}
-          onConfirm={vi.fn()}
-          onDismiss={vi.fn()}
-        />,
-      );
+      render(<Proposals actions={[ticks()]} onConfirm={vi.fn()} onDismiss={vi.fn()} />);
 
       expect(screen.getByText(/ticked off on that list/i)).toBeInTheDocument();
       expect(screen.queryByText(/added to the end/i)).not.toBeInTheDocument();
@@ -536,14 +552,7 @@ describe("BuddyActionProposals", () => {
 
     it("carries the card and the lines back on confirm", async () => {
       const onConfirm = vi.fn();
-      render(
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[ticks()]}
-          onConfirm={onConfirm}
-          onDismiss={vi.fn()}
-        />,
-      );
+      render(<Proposals actions={[ticks()]} onConfirm={onConfirm} onDismiss={vi.fn()} />);
 
       await userEvent.click(screen.getByRole("button", { name: /tick these off/i }));
 
@@ -568,12 +577,7 @@ describe("BuddyActionProposals", () => {
 
     it("marks the old wording as removed and the new one as added", () => {
       const { container } = render(
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[reword()]}
-          onConfirm={vi.fn()}
-          onDismiss={vi.fn()}
-        />,
+        <Proposals actions={[reword()]} onConfirm={vi.fn()} onDismiss={vi.fn()} />,
       );
 
       // The elements carry the meaning; the spoken labels carry it where they are not announced.
@@ -585,14 +589,7 @@ describe("BuddyActionProposals", () => {
 
     it("carries both wordings back on confirm", async () => {
       const onConfirm = vi.fn();
-      render(
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[reword()]}
-          onConfirm={onConfirm}
-          onDismiss={vi.fn()}
-        />,
-      );
+      render(<Proposals actions={[reword()]} onConfirm={onConfirm} onDismiss={vi.fn()} />);
 
       await userEvent.click(screen.getByRole("button", { name: /reword this line/i }));
 
@@ -605,8 +602,7 @@ describe("BuddyActionProposals", () => {
 
     it("renders no rewording for another action that happens to carry both fields", () => {
       render(
-        <BuddyActionProposals
-          messageId="m1"
+        <Proposals
           actions={[reword({ action: "amend_checklist", label: "Add these to the list" })]}
           onConfirm={vi.fn()}
           onDismiss={vi.fn()}
@@ -623,8 +619,7 @@ describe("BuddyActionProposals", () => {
   describe("a proposed note", () => {
     it("shows the words that would be kept", () => {
       render(
-        <BuddyActionProposals
-          messageId="m1"
+        <Proposals
           actions={[
             action({
               action: "place_note",
@@ -657,19 +652,11 @@ describe("BuddyActionProposals", () => {
 
     it("keeps the reason and offers it again under it", async () => {
       const onConfirm = vi.fn();
-      render(
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[refused()]}
-          onConfirm={onConfirm}
-          onDismiss={vi.fn()}
-        />,
-      );
+      render(<Proposals actions={[refused()]} onConfirm={onConfirm} onDismiss={vi.fn()} />);
 
       expect(screen.getByText(/couldn't put a packet together/i)).toBeInTheDocument();
-      await userEvent.click(
-        screen.getByRole("button", { name: /try again: open the task packet/i }),
-      );
+      // The offer is back under the reason, whole: the same button the hire pressed the first time.
+      await userEvent.click(screen.getByRole("button", { name: /open the task packet/i }));
 
       expect(onConfirm).toHaveBeenCalledTimes(1);
       expect(onConfirm.mock.calls[0][0]).toBe("m1");
@@ -678,8 +665,7 @@ describe("BuddyActionProposals", () => {
     /** Running a confirmed action twice is how somebody claims the same task twice. */
     it("offers nothing again once it worked", () => {
       render(
-        <BuddyActionProposals
-          messageId="m1"
+        <Proposals
           actions={[action({ status: "resolved", ok: true, outcome: "Task 0 is yours." })]}
           onConfirm={vi.fn()}
           onDismiss={vi.fn()}
@@ -703,14 +689,7 @@ describe("BuddyActionProposals", () => {
     }
 
     it("shows what the manager is agreeing to, and how loud the warning is", () => {
-      render(
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[storedAction()]}
-          onConfirm={vi.fn()}
-          onDismiss={vi.fn()}
-        />,
-      );
+      render(<Proposals actions={[storedAction()]} onConfirm={vi.fn()} onDismiss={vi.fn()} />);
 
       expect(screen.getByText("Jonas takes Task 0 instead.")).toBeInTheDocument();
       // Colour-blind rule: the risk badge is words next to an icon, never colour alone.
@@ -723,8 +702,7 @@ describe("BuddyActionProposals", () => {
       const onConfirm = vi.fn();
       const onDismiss = vi.fn();
       render(
-        <BuddyActionProposals
-          messageId="m1"
+        <Proposals
           actions={[storedAction({ risk: null, preview: null })]}
           onConfirm={onConfirm}
           onDismiss={onDismiss}
@@ -745,14 +723,7 @@ describe("BuddyActionProposals", () => {
     });
 
     it("puts the details before the controls and describes the confirm by them", () => {
-      render(
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[storedAction()]}
-          onConfirm={vi.fn()}
-          onDismiss={vi.fn()}
-        />,
-      );
+      render(<Proposals actions={[storedAction()]} onConfirm={vi.fn()} onDismiss={vi.fn()} />);
 
       const preview = screen.getByText("Jonas takes Task 0 instead.");
       const confirm = screen.getByRole("button", { name: /Shift Task 0/ });
@@ -766,8 +737,7 @@ describe("BuddyActionProposals", () => {
 
     it("tones the badge down for a standard change", () => {
       render(
-        <BuddyActionProposals
-          messageId="m1"
+        <Proposals
           actions={[storedAction({ risk: "STANDARD" })]}
           onConfirm={vi.fn()}
           onDismiss={vi.fn()}
@@ -779,8 +749,7 @@ describe("BuddyActionProposals", () => {
 
     it("scales to bulk changes", () => {
       render(
-        <BuddyActionProposals
-          messageId="m1"
+        <Proposals
           actions={[storedAction({ risk: "BULK" })]}
           onConfirm={vi.fn()}
           onDismiss={vi.fn()}
@@ -792,14 +761,7 @@ describe("BuddyActionProposals", () => {
 
     it("confirms by id — the click passes the whole stored proposal through", async () => {
       const onConfirm = vi.fn();
-      render(
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[storedAction()]}
-          onConfirm={onConfirm}
-          onDismiss={vi.fn()}
-        />,
-      );
+      render(<Proposals actions={[storedAction()]} onConfirm={onConfirm} onDismiss={vi.fn()} />);
 
       await userEvent.click(screen.getByRole("button", { name: /Shift Task 0/ }));
 
@@ -811,14 +773,7 @@ describe("BuddyActionProposals", () => {
 
     it("dismisses without mutating", async () => {
       const onDismiss = vi.fn();
-      render(
-        <BuddyActionProposals
-          messageId="m1"
-          actions={[storedAction()]}
-          onConfirm={vi.fn()}
-          onDismiss={onDismiss}
-        />,
-      );
+      render(<Proposals actions={[storedAction()]} onConfirm={vi.fn()} onDismiss={onDismiss} />);
 
       await userEvent.click(screen.getByRole("button", { name: /Not now/ }));
 
@@ -828,8 +783,7 @@ describe("BuddyActionProposals", () => {
 
     it("hides the buttons once the outcome is known, whatever it was", () => {
       render(
-        <BuddyActionProposals
-          messageId="m1"
+        <Proposals
           actions={[storedAction({ status: "resolved", ok: false, outcome: "Nothing changed." })]}
           onConfirm={vi.fn()}
           onDismiss={vi.fn()}
diff --git a/tests/unit/features/buddy/BuddyConversation.test.tsx b/tests/unit/features/buddy/BuddyConversation.test.tsx
index dae0d0b8..b45d2d8a 100644
--- a/tests/unit/features/buddy/BuddyConversation.test.tsx
+++ b/tests/unit/features/buddy/BuddyConversation.test.tsx
@@ -45,6 +45,8 @@ function renderConversation(overrides: {
       handleSubmit={vi.fn()}
       confirmAction={vi.fn()}
       dismissAction={vi.fn()}
+      actionDrafts={{}}
+      setActionDraft={vi.fn()}
       openError={overrides.openError ?? null}
       onRetryOpen={overrides.onRetryOpen}
     />,
diff --git a/tests/unit/features/buddy/BuddyDock.test.tsx b/tests/unit/features/buddy/BuddyDock.test.tsx
index 6f60a11c..0e639e5d 100644
--- a/tests/unit/features/buddy/BuddyDock.test.tsx
+++ b/tests/unit/features/buddy/BuddyDock.test.tsx
@@ -52,6 +52,8 @@ function renderDock(
       handleSubmit={vi.fn()}
       confirmAction={vi.fn()}
       dismissAction={vi.fn()}
+      actionDrafts={{}}
+      setActionDraft={vi.fn()}
       suggestions={suggestions}
       startFreshVisit={startFreshVisit}
       isGreeting={false}
diff --git a/tests/unit/features/buddy/useBuddy.test.tsx b/tests/unit/features/buddy/useBuddy.test.tsx
index e3664c65..f3faf0de 100644
--- a/tests/unit/features/buddy/useBuddy.test.tsx
+++ b/tests/unit/features/buddy/useBuddy.test.tsx
@@ -356,8 +356,8 @@ describe("useBuddy", () => {
     });
   });
   /**
-   * The seam between the card and the hook. The card offers "Try again" on a hire action that
-   * came back "couldn't"; the hook has to let that second confirm through. Rendered-component
+   * The seam between the card and the hook. The card keeps a refused hire offer on screen — same
+   * button, same field — so the hook has to let that second confirm through. Rendered-component
    * tests mock `onConfirm`, so only a test at this level sees the two meet.
    */
   describe("confirming a resolved hire offer again", () => {
@@ -379,7 +379,14 @@ describe("useBuddy", () => {
       );
     }
 
-    async function confirmOnce(ok: boolean) {
+    async function confirmOnce(
+      ok: boolean,
+      /** Runs once the offer is on screen and before it is confirmed — for the draft tests below. */
+      beforeConfirm?: (
+        session: { setActionDraft: (key: string, text: string) => void },
+        key: string,
+      ) => void,
+    ) {
       let calls = 0;
       server.use(
         http.get("/api/v1/onboarding/me/buddy/messages", () => HttpResponse.json([])),
@@ -407,6 +414,14 @@ describe("useBuddy", () => {
       });
       await waitFor(() => expect(hook.result.current.messages[1]?.actions?.[0]).toBeDefined());
 
+      // The key a card writes its field under: one action inside one message.
+      const key = `${hook.result.current.messages[1].id}:${hook.result.current.messages[1].actions![0].id}`;
+      if (beforeConfirm) {
+        act(() => {
+          beforeConfirm(hook.result.current, key);
+        });
+      }
+
       act(() => {
         hook.result.current.confirmAction(
           hook.result.current.messages[1].id,
@@ -419,14 +434,14 @@ describe("useBuddy", () => {
         expect(action?.ok).toBe(ok);
       });
 
-      return { result: hook.result, calls: () => calls };
+      return { result: hook.result, calls: () => calls, key };
     }
 
     it("sends a refused hire offer again when the hire retries it", async () => {
       const { result, calls } = await confirmOnce(false);
       expect(calls()).toBe(1);
 
-      // What the "Try again" button does: confirm the resolved action as it stands.
+      // What pressing the card's own button again does: confirm the resolved action as it stands.
       act(() => {
         result.current.confirmAction(
           result.current.messages[1].id,
@@ -454,5 +469,27 @@ describe("useBuddy", () => {
       expect(calls()).toBe(1);
       expect(result.current.messages[1].actions?.[0].status).toBe("resolved");
     });
+
+    /**
+     * The field's wording lives in the session, not in the card — that is what lets it survive a
+     * closed dock and the hand-off to `/buddy` — so the session is what has to let go of it, too:
+     * a refusal keeps it (the card hands it straight back to be corrected), and once the offer
+     * went through it goes, because a card re-rendered later must not offer wording that has
+     * already left the product.
+     */
+    it("keeps the hire's wording for a refused offer and lets go of it once it went through", async () => {
+      const record = (
+        session: { setActionDraft: (key: string, text: string) => void },
+        key: string,
+      ) => {
+        session.setActionDraft(key, "Who owns the staging box?");
+      };
+
+      const refused = await confirmOnce(false, record);
+      expect(refused.result.current.actionDrafts[refused.key]).toBe("Who owns the staging box?");
+
+      const accepted = await confirmOnce(true, record);
+      expect(accepted.result.current.actionDrafts).not.toHaveProperty(accepted.key);
+    });
   });
 });
diff --git a/tests/unit/features/buddy/useHandedOffDraft.test.tsx b/tests/unit/features/buddy/useHandedOffDraft.test.tsx
index 59926d63..84842a24 100644
--- a/tests/unit/features/buddy/useHandedOffDraft.test.tsx
+++ b/tests/unit/features/buddy/useHandedOffDraft.test.tsx
@@ -135,6 +135,8 @@ describe("the dock’s hand-off control", () => {
         handleSubmit={vi.fn()}
         confirmAction={vi.fn()}
         dismissAction={vi.fn()}
+        actionDrafts={{}}
+        setActionDraft={vi.fn()}
         suggestions={[]}
         startFreshVisit={vi.fn()}
         isGreeting={false}
@@ -163,6 +165,8 @@ describe("the dock’s hand-off control", () => {
         handleSubmit={vi.fn()}
         confirmAction={vi.fn()}
         dismissAction={vi.fn()}
+        actionDrafts={{}}
+        setActionDraft={vi.fn()}
         suggestions={[]}
         startFreshVisit={vi.fn()}
         isGreeting={false}

From 81c057b63a855dd0dcaa4db5661a73791aeab505 Mon Sep 17 00:00:00 2001
From: Daniil Perkin <danetschka4pertschik@gmail.com>
Date: Mon, 28 Sep 2026 13:39:12 +0200
Subject: [PATCH 3/4] upgrade(buddy): the flag field says why it is empty, and
 lets go of its wording (#235)

Review round on #272: two "worth a look" points and two nits, all four
confirmed against the code before anything moved.

- `actionDrafts` is now cleared wherever the conversation is reset:
  `startFreshVisit` and the team-mode switch effect reset messages,
  opener, error and composer draft but kept every wording the hire had
  ever typed into a flag. Not a correctness bug -- the keys are
  per-message UUIDs, so nothing could collide -- but a long-lived tab
  accumulated them forever. The file resets every other piece of session
  state on both transitions; the drafts belonged to the offers going
  away, so they go with them (they are not composer drafts).
- The empty field is an announced error instead of a silent dead button:
  it passes `Field`'s `error`, which colours the border, sets
  `aria-invalid` and is read out. A hire who clears the field and tabs
  to the disabled confirm now gets the reason, from a message that
  appears in response to their own clearing.
- What was sent is what the field holds: `handleConfirm` wrote the
  trimmed question back, so a retry after a refusal hands back exactly
  the text the PM would have read, not the padded typing.
- The draft-lifecycle test is one continuous story now (refused, kept,
  retried, sent in one session) instead of two independent hook
  instances; a second test covers the fresh visit, a third the switch,
  and the a11y suite covers the emptied field.
---
 .../buddy/components/BuddyActionProposals.tsx | 23 +++++++----
 .../buddy/hooks/useBuddyConversation.ts       | 16 ++++++--
 .../a11y/BuddyActionProposals.a11y.test.tsx   |  8 ++++
 .../buddy/BuddyActionProposals.test.tsx       | 30 ++++++++++++--
 tests/unit/features/buddy/useBuddy.test.tsx   | 40 +++++++++++++++++--
 .../features/buddy/useBuddyTeamMode.test.tsx  | 27 +++++++++++++
 6 files changed, 126 insertions(+), 18 deletions(-)

diff --git a/src/features/buddy/components/BuddyActionProposals.tsx b/src/features/buddy/components/BuddyActionProposals.tsx
index dc670a9f..37c2c2d4 100644
--- a/src/features/buddy/components/BuddyActionProposals.tsx
+++ b/src/features/buddy/components/BuddyActionProposals.tsx
@@ -114,8 +114,11 @@ function BuddyProposalCard({
   // Until they edit, the field holds the question the buddy composed.
   const editedQuestion = actionDrafts[draftKey] ?? (isFlagToPm ? (action.question ?? "") : "");
   /** A flag with nothing in it is not a question — the confirm stays out of reach rather than
-   *  letting the backend answer with a refusal the hire cannot act on. */
-  const canConfirm = !isConfirming && (!isFlagToPm || editedQuestion.trim().length > 0);
+   *  letting the backend answer with a refusal the hire cannot act on. The field says so out
+   *  loud (`error` below): a disabled button is not a reason, and a screen reader gets nothing
+   *  from it. */
+  const hasQuestion = editedQuestion.trim().length > 0;
+  const canConfirm = !isConfirming && (!isFlagToPm || hasQuestion);
 
   /** The card's only way out: the offer's button before it has run, and the very same button after
    *  a refusal. Both come through here, so neither can send a question other than the one on
@@ -124,6 +127,9 @@ function BuddyProposalCard({
     if (isFlagToPm) {
       const question = editedQuestion.trim();
       if (!question) return;
+      // What was sent is what the field now holds; only the trim can differ. A refused retry
+      // has to hand the wording back exactly as the PM would have read it, not padded.
+      if (question !== editedQuestion) setActionDraft(draftKey, question);
       onConfirm(messageId, { ...action, question });
       return;
     }
@@ -301,15 +307,18 @@ function BuddyProposalCard({
         )}
         {/* The one proposal whose payload is a *message*: the buddy composes the question,
                 the hire sends it under their own name, and a person reads it — so it is shown in
-                full, editable, above the button that sends it. Three things follow from that, and
-                all are enforced: what goes out is the field's own text (`handleConfirm`), an empty
-                field cannot be confirmed at all, and the wording is held by the session rather
-                than by this card (`actionDrafts`) — neither a dock the hire closes nor the
-                hand-off to `/buddy` may throw away a half-worded question. */}
+                full, editable, above the button that sends it. Four things follow from that, and
+                all are enforced: what goes out is the field's own text (`handleConfirm`), the field
+                is then made to hold exactly that, an empty field cannot be confirmed and *says why*
+                (`Field`'s `error` — its presence is the error state, and it is announced), and the
+                wording is held by the session rather than by this card (`actionDrafts`) — neither a
+                dock the hire closes nor the hand-off to `/buddy` may throw away a half-worded
+                question. */}
         {isFlagToPm && (
           <Field
             label="Sends to your PM"
             hint="Edit it if it is not quite right — this exact text is what they will read."
+            error={hasQuestion ? undefined : "Write a question before sending."}
             disabled={isConfirming}
           >
             <Textarea
diff --git a/src/features/buddy/hooks/useBuddyConversation.ts b/src/features/buddy/hooks/useBuddyConversation.ts
index 779fdbb9..318d7f31 100644
--- a/src/features/buddy/hooks/useBuddyConversation.ts
+++ b/src/features/buddy/hooks/useBuddyConversation.ts
@@ -432,7 +432,8 @@ export function useBuddyConversation(
    *
    * Nothing is deleted. The whole transcript stays in `buddy_messages`, and the buddy's durable
    * memory note is untouched — it is what the greeting is written from, which is why starting
-   * fresh does not mean starting over. Only the hire's scrollback moves on.
+   * fresh does not mean starting over. Only the hire's scrollback moves on — together with any
+   * flag wording they had half-edited, which belonged to the offers in it.
    */
   const startFreshVisit = useCallback(async () => {
     // The button stays enabled while the greeting is written, so a second click would run a
@@ -447,6 +448,9 @@ export function useBuddyConversation(
     setOpenerAction(null);
     setOpenError(null);
     setDraft("");
+    // Wording the hire had half-edited belongs to the offers that are going with the
+    // transcript — it is not a composer draft and must not outlive them.
+    setActionDrafts({});
     setIsOpening(true);
     try {
       await greet();
@@ -856,9 +860,10 @@ export function useBuddyConversation(
    * The thread on screen always belongs to exactly one conversation, and when the derived
    * target moves — a switch, a restored preference arriving, an involuntary exit — the thread
    * is cleared and the new conversation opens exactly as an untouched visit would: read first,
-   * then greeted. The backend keeps the conversations separate, so reusing the latch would show
-   * one inside the other. Mid-turn the move waits: the busy flags are in the dependency list,
-   * so the effect re-runs the moment the turn ends and applies then.
+   * then greeted. The drafts of the thread it clears go with it, like every other piece of
+   * state that belonged to those offers. The backend keeps the conversations separate, so
+   * reusing the latch would show one inside the other. Mid-turn the move waits: the busy flags
+   * are in the dependency list, so the effect re-runs the moment the turn ends and applies then.
    */
   const openedForRef = useRef<string>("hire");
   useEffect(() => {
@@ -883,6 +888,9 @@ export function useBuddyConversation(
     setOpenerAction(null);
     setOpenError(null);
     setDraft("");
+    // Bound to the offers of the conversation being left, not to the tab: a switch starts
+    // with no wording of its own, like every other piece of session state here.
+    setActionDrafts({});
     setActiveTool(null);
     setIsThinking(false);
     setIsStreaming(false);
diff --git a/tests/unit/a11y/BuddyActionProposals.a11y.test.tsx b/tests/unit/a11y/BuddyActionProposals.a11y.test.tsx
index b467cbe3..6f63f19b 100644
--- a/tests/unit/a11y/BuddyActionProposals.a11y.test.tsx
+++ b/tests/unit/a11y/BuddyActionProposals.a11y.test.tsx
@@ -47,4 +47,12 @@ describe("BuddyActionProposals Accessibility", () => {
 
     expect(await axe(baseElement)).toHaveNoViolations();
   });
+
+  it("has no violations on a flag the hire has emptied out", async () => {
+    // Emptied is an *error* state, not a silent dead button: the message is announced
+    // (`role="alert"`), and the field is marked invalid and described by it.
+    const { baseElement } = renderFlag(flag({ question: "   " }));
+
+    expect(await axe(baseElement)).toHaveNoViolations();
+  });
 });
diff --git a/tests/unit/features/buddy/BuddyActionProposals.test.tsx b/tests/unit/features/buddy/BuddyActionProposals.test.tsx
index fb652c26..25275df1 100644
--- a/tests/unit/features/buddy/BuddyActionProposals.test.tsx
+++ b/tests/unit/features/buddy/BuddyActionProposals.test.tsx
@@ -221,7 +221,15 @@ describe("BuddyActionProposals", () => {
 
     it("sends the question trimmed — what goes out is a message, not a field value", async () => {
       const onConfirm = vi.fn();
-      render(<Proposals actions={[flag()]} onConfirm={onConfirm} onDismiss={vi.fn()} />);
+      const onDraftChange = vi.fn();
+      render(
+        <Proposals
+          actions={[flag()]}
+          onConfirm={onConfirm}
+          onDraftChange={onDraftChange}
+          onDismiss={vi.fn()}
+        />,
+      );
 
       const field = screen.getByLabelText(/sends to your PM/i);
       await userEvent.clear(field);
@@ -230,18 +238,34 @@ describe("BuddyActionProposals", () => {
       await userEvent.click(screen.getByRole("button", { name: /Flag this to your PM/i }));
 
       expect(onConfirm.mock.calls[0][1]).toMatchObject({ question: "Who owns the staging box?" });
+      // And the field is handed back what it sent: a retry after a refusal has to show the copy
+      // the PM would have read, not the padded one it was typed with.
+      expect(onDraftChange).toHaveBeenLastCalledWith("m1:a1", "Who owns the staging box?");
+      expect(field).toHaveValue("Who owns the staging box?");
     });
 
-    it("cannot be confirmed while the field is empty", async () => {
+    it("cannot be confirmed while the field is empty — and the field says why", async () => {
       const onConfirm = vi.fn();
       render(<Proposals actions={[flag()]} onConfirm={onConfirm} onDismiss={vi.fn()} />);
 
-      await userEvent.clear(screen.getByLabelText(/sends to your PM/i));
+      const field = screen.getByLabelText(/sends to your PM/i);
+      await userEvent.clear(field);
 
       const confirm = screen.getByRole("button", { name: /Flag this to your PM/i });
       expect(confirm).toBeDisabled();
       await userEvent.click(confirm);
       expect(onConfirm).not.toHaveBeenCalled();
+
+      // A disabled button is not a reason anyone can read. The message is `Field`'s `error` —
+      // announced, with the control marked invalid and described by it — and it appears in
+      // response to the hire's own clearing, not on a field they have not touched.
+      expect(screen.getByRole("alert")).toHaveTextContent("Write a question before sending.");
+      expect(field).toHaveAttribute("aria-invalid", "true");
+
+      // It goes the moment there is a question again.
+      await userEvent.type(field, "Who signs off?");
+      expect(screen.queryByRole("alert")).not.toBeInTheDocument();
+      expect(confirm).toBeEnabled();
     });
 
     it("cannot be confirmed on whitespace alone — a blank flag is not a question", async () => {
diff --git a/tests/unit/features/buddy/useBuddy.test.tsx b/tests/unit/features/buddy/useBuddy.test.tsx
index f3faf0de..09f51e62 100644
--- a/tests/unit/features/buddy/useBuddy.test.tsx
+++ b/tests/unit/features/buddy/useBuddy.test.tsx
@@ -485,11 +485,43 @@ describe("useBuddy", () => {
         session.setActionDraft(key, "Who owns the staging box?");
       };
 
-      const refused = await confirmOnce(false, record);
-      expect(refused.result.current.actionDrafts[refused.key]).toBe("Who owns the staging box?");
+      // One session, one offer, the way a hire meets it: refused first, then retried and sent.
+      const { result, key } = await confirmOnce(false, record);
+      expect(result.current.actionDrafts[key]).toBe("Who owns the staging box?");
 
-      const accepted = await confirmOnce(true, record);
-      expect(accepted.result.current.actionDrafts).not.toHaveProperty(accepted.key);
+      // The retry is the same offer in the same conversation — the endpoint answers this time.
+      let retries = 0;
+      server.use(
+        http.post("/api/v1/onboarding/me/buddy/actions", () => {
+          retries += 1;
+          return HttpResponse.json({ ok: true, message: "Kept." });
+        }),
+      );
+      act(() => {
+        result.current.confirmAction(
+          result.current.messages[1].id,
+          result.current.messages[1].actions![0],
+        );
+      });
+      await waitFor(() => expect(result.current.messages[1].actions?.[0].ok).toBe(true));
+
+      expect(retries).toBe(1);
+      expect(result.current.actionDrafts).not.toHaveProperty(key);
+    });
+
+    /** The same reasoning one transition further: a fresh visit leaves its offers behind. */
+    it("starts a fresh visit without the flag wording of the visit before", async () => {
+      const { result, key } = await confirmOnce(false, (session, key) => {
+        session.setActionDraft(key, "Who owns the staging box?");
+      });
+      expect(result.current.actionDrafts[key]).toBe("Who owns the staging box?");
+
+      await act(async () => {
+        await result.current.startFreshVisit();
+      });
+
+      expect(result.current.messages).toHaveLength(0);
+      expect(result.current.actionDrafts).toEqual({});
     });
   });
 });
diff --git a/tests/unit/features/buddy/useBuddyTeamMode.test.tsx b/tests/unit/features/buddy/useBuddyTeamMode.test.tsx
index 36b43c96..d6d7a5a9 100644
--- a/tests/unit/features/buddy/useBuddyTeamMode.test.tsx
+++ b/tests/unit/features/buddy/useBuddyTeamMode.test.tsx
@@ -146,6 +146,33 @@ describe("useBuddyConversation — team mode", () => {
     expect(onLeft).not.toHaveBeenCalled();
   });
 
+  it("leaves the flag wording behind when the conversation switches", async () => {
+    // A draft belongs to the offer it was typed into, not to the tab: the conversation being
+    // switched to starts with no wording of its own, exactly like every other piece of state.
+    const onLeft = vi.fn();
+    const { result, rerender } = renderHook(
+      ({ selection, onLeft }: { selection: ProjectSelectionSlice; onLeft?: () => void }) =>
+        useBuddyConversation(selection, onLeft),
+      { initialProps: { selection: sel("", false), onLeft }, wrapper: authWrapper },
+    );
+    await act(async () => {
+      await result.current.ensureOpened();
+    });
+
+    act(() => {
+      result.current.setActionDraft("m1:a1", "Who owns the staging box?");
+    });
+    expect(result.current.actionDrafts["m1:a1"]).toBe("Who owns the staging box?");
+
+    act(() => {
+      result.current.switchTeamProject("p1");
+      rerender({ selection: sel("p1", true), onLeft });
+    });
+
+    await waitFor(() => expect(result.current.actionDrafts).toEqual({}));
+    expect(result.current.teamProjectId).toBe("p1");
+  });
+
   it("persists the preference per user, restores it on remount, and leaves it audibly", async () => {
     localStorage.setItem("buddyTeamMode:user-1", "true");
     localStorage.setItem("buddyTeamMode:user-2", "true");

From 503e9bb1890b0b13970d03fbd90137b1ba4e82fe Mon Sep 17 00:00:00 2001
From: Daniil Perkin <danetschka4pertschik@gmail.com>
Date: Tue, 29 Sep 2026 17:23:23 +0200
Subject: [PATCH 4/4] upgrade(buddy): the refusal's mark, its last word, and
 the field's required (#235)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Follow-up on the deep review of #272 — its findings 1, 2, 3, 4 and 6, each
re-checked against the code before anything moved:

- Finding 2 (real, and ours): a retry that failed on the wire kept the old
  refusal above the card *and* added "Couldn't reach the server — try again."
  below it — two stories about one press. The outcome line now stands down
  for `status: "error"`, and only there: it still stays while a retry is in
  flight, which is the reason it is kept above the card at all.
- Finding 1 (real mixed signal, inherited from #311): the refusal wore a grey
  checkmark. It now draws `AlertCircle` in the warning tone — the shape says
  "this did not go through", not the colour.
- Finding 4 (`required`): the flag's question *is* mandatory — an empty field
  cannot be sent — so `Field` now gets `required`: the asterisk plus
  `aria-required` on the textarea (dev's reworked `Field` propagates it
  through context; no native validation attribute is set).
- Finding 3 (a claim, not behaviour): the claim that the error appears "in
  response to the hire's own clearing, not on a field they have not touched"
  is true on every path the backend produces — it refuses to compose a flag
  with no question — but overstated for a proposal that arrived without one.
  The wording is corrected; the behaviour stays, because a disabled confirm
  still has to say why.
- Finding 6 (test hygiene, inherited): `BuddyDock.test.tsx`'s `assistant()`
  hardcoded `id: "a1"`, so the one test rendering two assistants emitted
  duplicate React keys. Both helpers take an optional id now and that call
  site passes its own.

Deliberately not touched: Finding 5 — drafts living in the session mean a
keystroke in a flag's field re-renders the session's subscribers; that is the
known trade-off already mitigated with `EMPTY_ACTION_DRAFTS` in the thread
(memoised rows keep their identity), and a provider of their own — the
`BuddyDraftProvider` pattern — is how it would be lifted entirely if flag
editing ever grows. Finding 7 is a merge-time step, not a change.

Tests: three assertions were red-checked against the unfixed source and fail
there (the stale refusal, the refusal's mark, `aria-required`); one new test
covers the transport-error path.
---
 .../buddy/components/BuddyActionProposals.tsx | 26 ++++++++++-----
 .../buddy/BuddyActionProposals.test.tsx       | 33 +++++++++++++++++--
 tests/unit/features/buddy/BuddyDock.test.tsx  | 10 +++---
 3 files changed, 53 insertions(+), 16 deletions(-)

diff --git a/src/features/buddy/components/BuddyActionProposals.tsx b/src/features/buddy/components/BuddyActionProposals.tsx
index d05490bc..bd68f74c 100644
--- a/src/features/buddy/components/BuddyActionProposals.tsx
+++ b/src/features/buddy/components/BuddyActionProposals.tsx
@@ -1,4 +1,4 @@
-import { Check, Info, Loader2, TriangleAlert, Users, X } from "lucide-react";
+import { AlertCircle, Check, Info, Loader2, TriangleAlert, Users, X } from "lucide-react";
 import { Field } from "../../../components/ui/Field";
 import { Textarea } from "../../../components/ui/Textarea";
 import { actionDraftKey } from "../actionDrafts";
@@ -150,20 +150,27 @@ function BuddyProposalCard({
   const isSettled = action.status === "resolved" && (action.ok === true || isStored);
 
   // Kept above the card while a retry is on its way, not just when the refusal arrives: pressing
-  // the button again must not blank out the sentence explaining why it did not work.
+  // the button again must not blank out the sentence explaining why it did not work. The one state
+  // that drops it is a transport error *after* such a retry — the card's own note below is the
+  // newer story, and two messages about one press read as two failures.
   const outcomeLine =
-    action.status === "resolved" || wasRefused ? (
+    action.status === "resolved" || (wasRefused && action.status !== "error") ? (
       <p
         className={`flex min-w-0 items-start gap-1.5 text-sm break-words ${
           action.ok ? "text-app-text" : "text-app-text-muted"
         }`}
       >
-        <Check
-          className={`mt-0.5 h-4 w-4 shrink-0 ${
-            action.ok ? "text-app-success-solid" : "text-app-text-disabled"
-          }`}
-          aria-hidden="true"
-        />
+        {action.ok ? (
+          <Check className="mt-0.5 h-4 w-4 shrink-0 text-app-success-solid" aria-hidden="true" />
+        ) : (
+          /* Not a checkmark: an offer that kept its card for a retry must not wear the mark of
+             something that went through. Icon and sentence say the same thing — the shape carries
+             the meaning, not the colour alone (AGENTS §7). */
+          <AlertCircle
+            className="mt-0.5 h-4 w-4 shrink-0 text-app-warning-text"
+            aria-hidden="true"
+          />
+        )}
         {action.outcome}
       </p>
     ) : null;
@@ -319,6 +326,7 @@ function BuddyProposalCard({
             label="Sends to your PM"
             hint="Edit it if it is not quite right — this exact text is what they will read."
             error={hasQuestion ? undefined : "Write a question before sending."}
+            required
             disabled={isConfirming}
           >
             <Textarea
diff --git a/tests/unit/features/buddy/BuddyActionProposals.test.tsx b/tests/unit/features/buddy/BuddyActionProposals.test.tsx
index 44e590bb..6e05b1dd 100644
--- a/tests/unit/features/buddy/BuddyActionProposals.test.tsx
+++ b/tests/unit/features/buddy/BuddyActionProposals.test.tsx
@@ -257,10 +257,15 @@ describe("BuddyActionProposals", () => {
       expect(onConfirm).not.toHaveBeenCalled();
 
       // A disabled button is not a reason anyone can read. The message is `Field`'s `error` —
-      // announced, with the control marked invalid and described by it — and it appears in
-      // response to the hire's own clearing, not on a field they have not touched.
+      // announced, with the control marked invalid and described by it. On the path the backend
+      // actually produces, it appears in response to the hire's own clearing; a flag that arrived
+      // with no question at all would show it from the first render — which is right, because a
+      // disabled confirm still has to say why.
       expect(screen.getByRole("alert")).toHaveTextContent("Write a question before sending.");
       expect(field).toHaveAttribute("aria-invalid", "true");
+      // Mandatory, and marked as such: the asterisk is the visual half, `aria-required` is what is
+      // read out.
+      expect(field).toHaveAttribute("aria-required", "true");
 
       // It goes the moment there is a question again.
       await userEvent.type(field, "Who signs off?");
@@ -371,10 +376,34 @@ describe("BuddyActionProposals", () => {
       );
 
       expect(screen.getByText("Could not send that just now.")).toBeInTheDocument();
+      // ...and it does not wear a checkmark: the sentence and the mark have to agree, and the
+      // shape is what carries that — colour alone never does (AGENTS §7).
+      const reason = screen.getByText("Could not send that just now.");
+      const mark = reason.querySelector("svg");
+      // An alert mark, not a check — and asserted by name because lucide renamed the icon
+      // (`AlertCircle` is an alias of `CircleAlert`); the shape is what carries the meaning.
+      expect(mark?.getAttribute("class")).toContain("alert");
+      expect(mark?.getAttribute("class")).not.toContain("check");
       // ...frozen on its way out, the way it is on the way in.
       expect(screen.getByLabelText(/sends to your PM/i)).toBeDisabled();
     });
 
+    it("drops the stale refusal once the retry failed on the wire", () => {
+      // A retry's transport error keeps the refusal's residue — the patch merges `ok`/`outcome`
+      // instead of replacing them — and adds its own note below. Both at once would read as two
+      // failures for one press, so the note is what stays.
+      render(
+        <Proposals
+          actions={[flag({ status: "error", ok: false, outcome: "Could not send that just now." })]}
+          onConfirm={vi.fn()}
+          onDismiss={vi.fn()}
+        />,
+      );
+
+      expect(screen.queryByText("Could not send that just now.")).not.toBeInTheDocument();
+      expect(screen.getByText(/Couldn't reach the server/)).toBeInTheDocument();
+    });
+
     it("cannot retry a refusal with an empty field — a blank flag is not a question", async () => {
       render(
         <Proposals
diff --git a/tests/unit/features/buddy/BuddyDock.test.tsx b/tests/unit/features/buddy/BuddyDock.test.tsx
index 2f9d1e1a..abbd674f 100644
--- a/tests/unit/features/buddy/BuddyDock.test.tsx
+++ b/tests/unit/features/buddy/BuddyDock.test.tsx
@@ -72,15 +72,15 @@ function renderDock(
   );
 }
 
-const assistant = (content: string): BuddyMessageView => ({
-  id: "a1",
+const assistant = (content: string, id = "a1"): BuddyMessageView => ({
+  id,
   role: "ASSISTANT",
   content,
   createdAt: "2026-08-03T00:00:00Z",
 });
 
-const user = (content: string): BuddyMessageView => ({
-  id: "u1",
+const user = (content: string, id = "u1"): BuddyMessageView => ({
+  id,
   role: "USER",
   content,
   createdAt: "2026-08-03T00:00:00Z",
@@ -304,7 +304,7 @@ describe("BuddyDock new conversation", () => {
   });
 
   it("comes back once the turn is over", () => {
-    renderDock([assistant("Hello."), user("How do we deploy?"), assistant("Against dev.")]);
+    renderDock([assistant("Hello."), user("How do we deploy?"), assistant("Against dev.", "a2")]);
 
     expect(screen.getByRole("button", { name: "Start a new conversation" })).toBeInTheDocument();
   });