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 9c28b4ec..5b07f12e 100644
--- a/src/features/buddy/components/BuddyActionProposals.tsx
+++ b/src/features/buddy/components/BuddyActionProposals.tsx
@@ -1,4 +1,8 @@
-import { Check, Info, Loader2, RotateCcw, 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";
+import type { ActionDrafts } from "../actionDrafts";
 import type { ProposedAction, ProposalRisk } from "../types";
 import {
   BUDDY_ACTION_AMEND_CHECKLIST,
@@ -16,6 +20,19 @@ 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, action: ProposedAction) => void;
+};
+
+type BuddyProposalCardProps = {
+  messageId: string;
+  action: ProposedAction;
+  actionDrafts: ActionDrafts;
+  setActionDraft: (key: string, text: string) => void;
   onConfirm: (messageId: string, action: ProposedAction) => void;
   onDismiss: (messageId: string, action: ProposedAction) => void;
 };
@@ -35,11 +52,20 @@ type BuddyActionProposalsProps = {
  * 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: 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) {
@@ -47,130 +73,199 @@ 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}
+          actionDrafts={actionDrafts}
+          setActionDraft={setActionDraft}
+          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
-                  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
-                                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>
-          );
-        }
+/**
+ * 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,
+  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";
+  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. 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);
 
-        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. A
-        // hire's board edit follows the same rule: no confirm for a change it cannot show.
-        const isUnsupported = isStored
-          ? action.risk === null || !action.preview
-          : lacksBoardEditDetails(action);
-        const previewId = `buddy-proposal-preview-${action.id}`;
+  /** 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 (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;
+    }
 
-        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"
-          >
-            {/* What confirming would change comes FIRST, in the backend's own words, and the
-                confirm button describes it (aria-describedby). For a stored team proposal the
-                target is the id, so this is the offer's full description; for a hire's board edit
-                it is the part the payload alone would not show — which cards, which lines go.
-                Never a summary the client recomposed, and never read after the button. */}
-            {action.preview && (
-              <p id={previewId} className="text-xs leading-relaxed break-words text-app-text-muted">
-                {action.preview}
-              </p>
-            )}
+    onConfirm(messageId, action);
+  };
+
+  if (action.status === "dismissed") {
+    return <p className="text-xs text-app-text-disabled">Dismissed — nothing changed.</p>;
+  }
+
+  // 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. 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 !== "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"
+        }`}
+      >
+        {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;
+
+  if (isSettled) {
+    return (
+      <div className="flex flex-col items-start">
+        {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 />
+        )}
+      </div>
+    );
+  }
+
+  // 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. A
+  // hire's board edit follows the same rule: no confirm for a change it cannot show.
+  const isUnsupported = isStored
+    ? action.risk === null || !action.preview
+    : lacksBoardEditDetails(action);
+  const previewId = `buddy-proposal-preview-${action.id}`;
+
+  return (
+    <>
+      {/* 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">
+        {/* What confirming would change comes FIRST, in the backend's own words, and the
+            confirm button describes it (aria-describedby). For a stored team proposal the
+            target is the id, so this is the offer's full description; for a hire's board edit
+            it is the part the payload alone would not show — which cards, which lines go.
+            Never a summary the client recomposed, and never read after the button. */}
+        {action.preview && (
+          <p id={previewId} className="text-xs leading-relaxed break-words text-app-text-muted">
+            {action.preview}
+          </p>
+        )}
+
+        {/* Shown before the press, not after it, and only where the payload is *content*.
 
-            {/* 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>
-                )}
-                {/* The whole list as it would read, replacing what is there. What would be lost is
-                    named in the preview above, since a missing line is invisible in this one. */}
-                {action.action === BUDDY_ACTION_EDIT_CHECKLIST && (
-                  <p className="text-xs text-app-text-muted">The list would read:</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>
+            )}
+            {/* The whole list as it would read, replacing what is there. What would be lost is
+                named in the preview above, since a missing line is invisible in this one. */}
+            {action.action === BUDDY_ACTION_EDIT_CHECKLIST && (
+              <p className="text-xs text-app-text-muted">The list would read:</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.
 
@@ -181,111 +276,131 @@ 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>
-            )}
-            {!isStored && <BuddyBoardEditDetails action={action} />}
+        {!isStored && action.noteText && (
+          <p className="min-w-0 text-xs break-words whitespace-pre-wrap text-app-text-muted">
+            {action.noteText}
+          </p>
+        )}
+        {!isStored && <BuddyBoardEditDetails action={action} />}
 
-            {/* 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)}
-                    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)}
+                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. 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."}
+            required
+            disabled={isConfirming}
+          >
+            <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={() => onConfirm(messageId, action)}
-                  disabled={isConfirming}
-                  aria-describedby={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)}
-                  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={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)}
+              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>
-        );
-      })}
-    </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/components/BuddyConversation.tsx b/src/features/buddy/components/BuddyConversation.tsx
index b1c39fa5..14a020ea 100644
--- a/src/features/buddy/components/BuddyConversation.tsx
+++ b/src/features/buddy/components/BuddyConversation.tsx
@@ -1,6 +1,7 @@
 import { memo, useCallback } from "react";
 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";
@@ -19,6 +20,10 @@ type BuddyConversationProps = {
   confirmAction: (messageId: string, action: ProposedAction) => void;
   /** Declines a proposed action; nothing changes. */
   dismissAction: (messageId: string, action: ProposedAction) => 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 under the buddy's most recent reply — the greeting's suggested next step. */
@@ -89,6 +94,8 @@ function BuddyConversationImpl({
   activeTool,
   confirmAction,
   dismissAction,
+  actionDrafts,
+  setActionDraft,
   placeholder,
   lastMessageFooter,
   renderQuestionAction,
@@ -169,6 +176,8 @@ function BuddyConversationImpl({
             activeTool={activeTool}
             confirmAction={confirmAction}
             dismissAction={dismissAction}
+            actionDrafts={actionDrafts}
+            setActionDraft={setActionDraft}
             showNames
             lastMessageFooter={lastMessageFooter}
             renderQuestionAction={renderQuestionAction}
diff --git a/src/features/buddy/components/BuddyDock.tsx b/src/features/buddy/components/BuddyDock.tsx
index 23bb4f80..55975ddd 100644
--- a/src/features/buddy/components/BuddyDock.tsx
+++ b/src/features/buddy/components/BuddyDock.tsx
@@ -45,6 +45,8 @@ type BuddyDockProps = Pick<
   | "activeTool"
   | "confirmAction"
   | "dismissAction"
+  | "actionDrafts"
+  | "setActionDraft"
   | "suggestions"
   | "startFreshVisit"
   | "isGreeting"
@@ -134,6 +136,8 @@ function BuddyDockImpl({
   activeTool,
   confirmAction,
   dismissAction,
+  actionDrafts,
+  setActionDraft,
   suggestions,
   dinoGameActive = false,
   onDinoGameExit,
@@ -356,6 +360,8 @@ function BuddyDockImpl({
             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={renderQuestionAction}
diff --git a/src/features/buddy/components/BuddyThread.tsx b/src/features/buddy/components/BuddyThread.tsx
index fdc93e36..82f28eba 100644
--- a/src/features/buddy/components/BuddyThread.tsx
+++ b/src/features/buddy/components/BuddyThread.tsx
@@ -3,11 +3,15 @@ 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";
 import { BuddyMessage, BuddyTypingMessage } from "./BuddyMessage";
 
+/** The drafts a row without any proposal gets: one shared object, so its memo is never broken. */
+const EMPTY_ACTION_DRAFTS: ActionDrafts = {};
+
 type BuddyThreadProps = {
   messages: BuddyMessageView[];
   isThinking: boolean;
@@ -23,6 +27,10 @@ type BuddyThreadProps = {
   confirmAction: (messageId: string, action: ProposedAction) => void;
   /** Declines a proposed action; nothing changes. */
   dismissAction: (messageId: string, action: ProposedAction) => 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`. */
@@ -101,6 +109,10 @@ type BuddyThreadRowProps = {
   compact: boolean;
   confirmAction: (messageId: string, action: ProposedAction) => void;
   dismissAction: (messageId: string, action: ProposedAction) => void;
+  /** The session's wording for the row's own offers, if any — see `BuddyThreadProps`. */
+  actionDrafts: ActionDrafts;
+  /** Records one, so it outlives whichever surface is on screen. */
+  setActionDraft: (key: string, text: string) => void;
   renderQuestionAction?: (question: string) => ReactNode;
   renderReplyAction?: (reply: string, message: BuddyMessageView) => ReactNode;
   /** The greeting's suggested next step — present on the row it hangs under, nowhere else. */
@@ -132,6 +144,8 @@ function BuddyThreadRowImpl({
   compact,
   confirmAction,
   dismissAction,
+  actionDrafts,
+  setActionDraft,
   renderQuestionAction,
   renderReplyAction,
   lastMessageFooter,
@@ -198,6 +212,8 @@ function BuddyThreadRowImpl({
               <BuddyActionProposals
                 messageId={message.id}
                 actions={message.actions ?? []}
+                actionDrafts={actionDrafts}
+                setActionDraft={setActionDraft}
                 onConfirm={confirmAction}
                 onDismiss={dismissAction}
               />
@@ -244,6 +260,8 @@ function BuddyThreadImpl({
   activeTool,
   confirmAction,
   dismissAction,
+  actionDrafts,
+  setActionDraft,
   showNames = false,
   compact = false,
   lastMessageFooter,
@@ -311,6 +329,11 @@ function BuddyThreadImpl({
           compact={compact}
           confirmAction={confirmAction}
           dismissAction={dismissAction}
+          // Handed only to the rows that actually carry a proposal: the drafts object changes
+          // identity on every keystroke in a flag's field, and each row is memoised (#236), so
+          // the shared empty object keeps that keystroke from re-rendering the whole transcript.
+          actionDrafts={(message.actions?.length ?? 0) > 0 ? actionDrafts : EMPTY_ACTION_DRAFTS}
+          setActionDraft={setActionDraft}
           renderQuestionAction={renderQuestionAction}
           renderReplyAction={renderReplyAction}
           // Resolved here rather than inside the row: only the buddy's latest reply gets it, and
diff --git a/src/features/buddy/components/BuddyWidget.tsx b/src/features/buddy/components/BuddyWidget.tsx
index 0d6fd6e9..08d3e22b 100644
--- a/src/features/buddy/components/BuddyWidget.tsx
+++ b/src/features/buddy/components/BuddyWidget.tsx
@@ -68,6 +68,8 @@ export function BuddyWidget() {
     toggleOpen,
     confirmAction,
     dismissAction,
+    actionDrafts,
+    setActionDraft,
     suggestions,
     dinoGameActive,
     closeDinoGame,
@@ -349,6 +351,8 @@ export function BuddyWidget() {
             activeTool={activeTool}
             confirmAction={confirmAction}
             dismissAction={dismissAction}
+            actionDrafts={actionDrafts}
+            setActionDraft={setActionDraft}
             suggestions={suggestions}
             dinoGameActive={dinoGameActive}
             onDinoGameExit={closeDinoGame}
diff --git a/src/features/buddy/hooks/useBuddyConversation.ts b/src/features/buddy/hooks/useBuddyConversation.ts
index 2a32669f..e17a857a 100644
--- a/src/features/buddy/hooks/useBuddyConversation.ts
+++ b/src/features/buddy/hooks/useBuddyConversation.ts
@@ -10,6 +10,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 { useInvalidateBoard } from "../../board/hooks/useInvalidateBoard";
@@ -198,6 +200,16 @@ export function useBuddyConversation(
    * and a parent cannot reach into a child's setter.
    */
   const [draftResetToken, setDraftResetToken] = useState(0);
+  /**
+   * 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 words are: 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. Unlike the composer's,
+   * nothing below this provider needs to write it, so it lives here rather than in a context.
+   */
+  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
@@ -520,7 +532,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
@@ -546,6 +559,9 @@ export function useBuddyConversation(
     // The box is emptied through the token: a question typed about the conversation being
     // cleared is about a thread that no longer exists. See `draftResetToken`.
     setDraftResetToken((token) => token + 1);
+    // 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();
@@ -774,6 +790,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
@@ -856,6 +895,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)) {
@@ -891,7 +933,7 @@ export function useBuddyConversation(
         }
       })();
     },
-    [beginDecision, endDecision, patchAction, invalidateBoard],
+    [beginDecision, endDecision, patchAction, invalidateBoard, clearActionDraft],
   );
 
   /**
@@ -915,6 +957,9 @@ export function useBuddyConversation(
       // but still worth putting away here.
       if (!("proposalId" in action)) {
         patchAction(messageId, actionId, { status: "dismissed" });
+        // A hire offer is the only kind that carries a draft, and this is the one place one is
+        // declined — the wording goes with the offer it belonged to.
+        clearActionDraft(actionDraftKey(messageId, actionId));
         return;
       }
 
@@ -960,16 +1005,17 @@ export function useBuddyConversation(
         }
       })();
     },
-    [beginDecision, endDecision, patchAction],
+    [beginDecision, endDecision, patchAction, clearActionDraft],
   );
 
   /**
    * 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(() => {
@@ -995,6 +1041,9 @@ export function useBuddyConversation(
     setOpenError(null);
     // Same rule as a fresh visit: the words belonged to the conversation that just went away.
     setDraftResetToken((token) => token + 1);
+    // 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);
@@ -1079,7 +1128,10 @@ export function useBuddyConversation(
     // thing about them the session still owns — the news that the thread they belonged to is
     // gone. See `draftResetToken`.
     draftResetToken,
-
+    // 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,
     confirmAction,
     dismissAction,
diff --git a/src/features/buddy/types.ts b/src/features/buddy/types.ts
index 4c9c8978..c14ef0c0 100644
--- a/src/features/buddy/types.ts
+++ b/src/features/buddy/types.ts
@@ -117,8 +117,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/src/pages/BuddyPage.tsx b/src/pages/BuddyPage.tsx
index 08c48a62..cfc2efe6 100644
--- a/src/pages/BuddyPage.tsx
+++ b/src/pages/BuddyPage.tsx
@@ -171,6 +171,8 @@ function BuddyMentorHome() {
     sendMessage,
     confirmAction,
     dismissAction,
+    actionDrafts,
+    setActionDraft,
     openError,
     dinoGameActive,
     closeDinoGame,
@@ -434,6 +436,8 @@ function BuddyMentorHome() {
         activeTool={activeTool}
         confirmAction={confirmAction}
         dismissAction={dismissAction}
+        actionDrafts={actionDrafts}
+        setActionDraft={setActionDraft}
         dinoGameActive={dinoGameActive}
         onDinoGameExit={closeDinoGame}
         // Both held in one identity above, with the reasons written there — the thread's memo
diff --git a/tests/unit/a11y/BuddyActionProposals.a11y.test.tsx b/tests/unit/a11y/BuddyActionProposals.a11y.test.tsx
new file mode 100644
index 00000000..ae5fd6a1
--- /dev/null
+++ b/tests/unit/a11y/BuddyActionProposals.a11y.test.tsx
@@ -0,0 +1,58 @@
+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 { HireActionProposal } from "../../../src/features/buddy/types";
+
+function flag(overrides: Partial<HireActionProposal> = {}): HireActionProposal {
+  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: HireActionProposal) {
+  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 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 { baseElement } = renderFlag(flag());
+
+    expect(await axe(baseElement)).toHaveNoViolations();
+  });
+
+  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();
+  });
+
+  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 50793a03..aa0539b5 100644
--- a/tests/unit/features/buddy/BuddyActionProposals.test.tsx
+++ b/tests/unit/features/buddy/BuddyActionProposals.test.tsx
@@ -1,5 +1,6 @@
 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 type { HireActionProposal, ProposedAction } from "../../../../src/features/buddy/types";
@@ -19,17 +20,49 @@ function action(overrides: Partial<HireActionProposal> = {}): HireActionProposal
   };
 }
 
+/**
+ * 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, action: ProposedAction) => 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 (
+    <BuddyActionProposals
+      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",
@@ -144,46 +161,317 @@ 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<HireActionProposal> = {}) =>
+      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(<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?",
+      );
+    });
+
+    it("sends the text the hire edited, not the one the buddy composed", async () => {
+      const onConfirm = vi.fn();
+      render(<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, "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(<Proposals 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();
+      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);
+      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?" });
+      // 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 — and the field says why", async () => {
+      const onConfirm = vi.fn();
+      render(<Proposals actions={[flag()]} onConfirm={onConfirm} onDismiss={vi.fn()} />);
+
+      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. 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?");
+      expect(screen.queryByRole("alert")).not.toBeInTheDocument();
+      expect(confirm).toBeEnabled();
+    });
+
+    it("cannot be confirmed on whitespace alone — a blank flag is not a question", async () => {
+      render(<Proposals 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(
+        <Proposals
+          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(<Proposals 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", expect.objectContaining({ id: "a1" }));
+      expect(onConfirm).not.toHaveBeenCalled();
+    });
+
+    it("retries a refusal with the text the hire last edited", async () => {
+      const onConfirm = vi.fn();
+      const { rerender } = render(
+        <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 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(
+        <Proposals
+          actions={[
+            flag({
+              status: "resolved",
+              ok: false,
+              outcome: "I need the question to flag — tell me what to ask.",
+            }),
+          ]}
+          onConfirm={onConfirm}
+          onDismiss={vi.fn()}
+        />,
+      );
+
+      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();
+      // ...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
+          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("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"
+      <Proposals
         actions={[action({ action: "claim_goal", label: "Work toward this task", taskId: "t1" })]}
         onConfirm={vi.fn()}
         onDismiss={vi.fn()}
       />,
     );
 
-    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", () => {
     render(
-      <BuddyActionProposals
-        messageId="m1"
+      <Proposals
         actions={[
           action({
             action: "request_skip",
@@ -217,14 +505,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();
@@ -234,14 +515,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 }));
 
@@ -253,14 +527,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();
     });
@@ -270,8 +537,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",
@@ -292,8 +558,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",
@@ -331,14 +596,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();
@@ -347,14 +605,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 }));
 
@@ -379,12 +630,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.
@@ -396,14 +642,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 }));
 
@@ -416,8 +655,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()}
@@ -434,8 +672,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",
@@ -472,6 +709,8 @@ describe("BuddyActionProposals", () => {
           ]}
           onConfirm={vi.fn()}
           onDismiss={vi.fn()}
+          actionDrafts={{}}
+          setActionDraft={vi.fn()}
         />,
       );
 
@@ -498,6 +737,8 @@ describe("BuddyActionProposals", () => {
           ]}
           onConfirm={vi.fn()}
           onDismiss={vi.fn()}
+          actionDrafts={{}}
+          setActionDraft={vi.fn()}
         />,
       );
 
@@ -520,6 +761,8 @@ describe("BuddyActionProposals", () => {
           ]}
           onConfirm={vi.fn()}
           onDismiss={vi.fn()}
+          actionDrafts={{}}
+          setActionDraft={vi.fn()}
         />,
       );
 
@@ -544,6 +787,8 @@ describe("BuddyActionProposals", () => {
           ]}
           onConfirm={vi.fn()}
           onDismiss={vi.fn()}
+          actionDrafts={{}}
+          setActionDraft={vi.fn()}
         />,
       );
 
@@ -570,6 +815,8 @@ describe("BuddyActionProposals", () => {
           ]}
           onConfirm={vi.fn()}
           onDismiss={vi.fn()}
+          actionDrafts={{}}
+          setActionDraft={vi.fn()}
         />,
       );
 
@@ -593,6 +840,8 @@ describe("BuddyActionProposals", () => {
           ]}
           onConfirm={vi.fn()}
           onDismiss={vi.fn()}
+          actionDrafts={{}}
+          setActionDraft={vi.fn()}
         />,
       );
 
@@ -616,6 +865,8 @@ describe("BuddyActionProposals", () => {
           ]}
           onConfirm={onConfirm}
           onDismiss={vi.fn()}
+          actionDrafts={{}}
+          setActionDraft={vi.fn()}
         />,
       );
 
@@ -645,19 +896,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");
@@ -666,8 +909,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()}
@@ -691,14 +933,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.
@@ -711,8 +946,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}
@@ -733,14 +967,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/ });
@@ -754,8 +981,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()}
@@ -767,8 +993,7 @@ describe("BuddyActionProposals", () => {
 
     it("scales to bulk changes", () => {
       render(
-        <BuddyActionProposals
-          messageId="m1"
+        <Proposals
           actions={[storedAction({ risk: "BULK" })]}
           onConfirm={vi.fn()}
           onDismiss={vi.fn()}
@@ -780,14 +1005,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/ }));
 
@@ -799,14 +1017,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/ }));
 
@@ -820,8 +1031,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 1a98be3f..73f4b9da 100644
--- a/tests/unit/features/buddy/BuddyConversation.test.tsx
+++ b/tests/unit/features/buddy/BuddyConversation.test.tsx
@@ -46,6 +46,8 @@ function renderConversation(overrides: {
         activeTool={overrides.activeTool ?? null}
         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 63d10ddd..abbd674f 100644
--- a/tests/unit/features/buddy/BuddyDock.test.tsx
+++ b/tests/unit/features/buddy/BuddyDock.test.tsx
@@ -58,6 +58,8 @@ function renderDock(
           activeTool={null}
           confirmAction={vi.fn()}
           dismissAction={vi.fn()}
+          actionDrafts={{}}
+          setActionDraft={vi.fn()}
           suggestions={suggestions}
           startFreshVisit={startFreshVisit}
           isGreeting={false}
@@ -70,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",
@@ -302,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();
   });
diff --git a/tests/unit/features/buddy/BuddyThreadFooter.test.tsx b/tests/unit/features/buddy/BuddyThreadFooter.test.tsx
index c8cde3e7..d5427254 100644
--- a/tests/unit/features/buddy/BuddyThreadFooter.test.tsx
+++ b/tests/unit/features/buddy/BuddyThreadFooter.test.tsx
@@ -49,6 +49,8 @@ const BASE_PROPS = {
   activeTool: null,
   confirmAction: vi.fn(),
   dismissAction: vi.fn(),
+  actionDrafts: {},
+  setActionDraft: vi.fn(),
 };
 
 const SUGGESTED_STEP = <button type="button">Start with the packet</button>;
diff --git a/tests/unit/features/buddy/BuddyThreadStreaming.test.tsx b/tests/unit/features/buddy/BuddyThreadStreaming.test.tsx
index 738c2904..91cc7ad3 100644
--- a/tests/unit/features/buddy/BuddyThreadStreaming.test.tsx
+++ b/tests/unit/features/buddy/BuddyThreadStreaming.test.tsx
@@ -54,6 +54,8 @@ const BASE_PROPS = {
   activeTool: null,
   confirmAction: vi.fn(),
   dismissAction: vi.fn(),
+  actionDrafts: {},
+  setActionDraft: vi.fn(),
 };
 
 /** One flag per row, in the order they are on screen. */
diff --git a/tests/unit/features/buddy/buddyDraftAcrossRoutes.test.tsx b/tests/unit/features/buddy/buddyDraftAcrossRoutes.test.tsx
index 7b7b0433..9069f88f 100644
--- a/tests/unit/features/buddy/buddyDraftAcrossRoutes.test.tsx
+++ b/tests/unit/features/buddy/buddyDraftAcrossRoutes.test.tsx
@@ -159,6 +159,8 @@ describe("the dock’s hand-off control", () => {
           activeTool={null}
           confirmAction={vi.fn()}
           dismissAction={vi.fn()}
+          actionDrafts={{}}
+          setActionDraft={vi.fn()}
           suggestions={[]}
           startFreshVisit={vi.fn()}
           isGreeting={false}
@@ -186,6 +188,8 @@ describe("the dock’s hand-off control", () => {
           activeTool={null}
           confirmAction={vi.fn()}
           dismissAction={vi.fn()}
+          actionDrafts={{}}
+          setActionDraft={vi.fn()}
           suggestions={[]}
           startFreshVisit={vi.fn()}
           isGreeting={false}
diff --git a/tests/unit/features/buddy/useBuddy.test.tsx b/tests/unit/features/buddy/useBuddy.test.tsx
index 8a200655..f722ccf9 100644
--- a/tests/unit/features/buddy/useBuddy.test.tsx
+++ b/tests/unit/features/buddy/useBuddy.test.tsx
@@ -358,8 +358,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", () => {
@@ -381,7 +381,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([])),
@@ -409,6 +416,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,
@@ -421,14 +436,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,
@@ -456,6 +471,60 @@ 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?");
+      };
+
+      // 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?");
+
+      // 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 2f571f7f..a655568c 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");