diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 4a26139c7..c23511c23 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -77,6 +77,17 @@ tenant and writes settings rows — no deploy, no host, no anchor instance
 one publish onto the workbench's live stream, so the conversation takes
 messages whether or not any agent process is running.
 
+**Editing an own prompt.** Edit is a composer replace, not a timeline
+mutation and not a thread fork. The timeline offers Edit only on the
+signed-in reader's own prompts that have text
+(`packages/chat-ui/src/timeline.tsx`). Choosing it copies that message's
+text into the composer through `ComposerHandle.setText`
+(`packages/chat-ui/src/composer.tsx`). `setText` replaces the draft and
+clears leftover composer-private state (slash, mention, pending invites,
+attachments, in-flight attachment reads). Sending is the ordinary post
+onto the timeline already in view (root or an open thread). It does not
+PATCH the origin message and it does not call `forkThread`.
+
 A workbench's address is derived, not resolved. Asking an invited agent
 for a turn is a separate act over Interchange mail; the agent replies by
 emitting `connector.reply` events on its own stream, and a reply bridge
diff --git a/DESIGN.md b/DESIGN.md
index 0dbb6d538..cb60a8756 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -277,6 +277,18 @@ short tags or a card, and mirroring them to the right would land next to
 the composer and break the one consistent place a reader looks for
 approvals and tool activity.
 
+## Message actions
+
+A message's compact action cluster — add reaction, reply in thread (or
+Fork inside a thread), Edit on own prompts, and ellipsis — reveals on
+pointer hover or keyboard focus-within. It is not hover-only and not a
+persistent inline row of links. The ellipsis button and a right-click on
+the message open the same menu; Edit appears there too when the row is
+the signed-in reader's own prompt with text.
+
+Edit copies the prompt into the composer. It is not an in-place rewrite
+of the bubble.
+
 ## Connect cards
 
 In-thread cards flip in place: disconnected → connected → next step. The
diff --git a/IMPLEMENTATION.md b/IMPLEMENTATION.md
index 1d3abd7a8..6f1fbaa48 100644
--- a/IMPLEMENTATION.md
+++ b/IMPLEMENTATION.md
@@ -41,6 +41,12 @@ core, reusable components live there; only workbench-specific composition
 is pinned to a specific upstream commit rather than a floating version
 range.
 
+`@corbits/chat-ui` owns the conversation surface. The composer's host
+seam is `ComposerHandle`: `insertText` splices at the caret (Mention);
+`setText` replaces the whole draft (Edit a previous prompt) and is the
+layer that clears leftover slash, mention, invite, and attachment state
+so a replaced draft cannot send under the old picker's rules.
+
 ## Vendored `@intx/*`
 
 Interchange capabilities are consumed as published `@intx/*` npm packages
diff --git a/PRODUCT.md b/PRODUCT.md
index 5e33328ec..7375a46dd 100644
--- a/PRODUCT.md
+++ b/PRODUCT.md
@@ -115,6 +115,14 @@ does not wake an agent. Generic `connections/pending` still wakes the
 asking agent. Neither path posts the connected notice as the connecting
 person.
 
+## Reusing an own prompt
+
+A person can **Edit** their own previous prompt. Edit copies that text
+into the composer, replacing any leftover draft — slash command, mention,
+invite, and attachments. Sending posts a new message on the same
+timeline: it does not rewrite the original, and it does not fork a
+thread. Other people's prompts have no Edit.
+
 ## Plugins and Skills
 
 A **Skill** is a named, reusable capability — instructions an agent can
diff --git a/packages/chat-ui/src/chat-workspace.tsx b/packages/chat-ui/src/chat-workspace.tsx
index d714e45bf..c4a975b94 100644
--- a/packages/chat-ui/src/chat-workspace.tsx
+++ b/packages/chat-ui/src/chat-workspace.tsx
@@ -60,7 +60,12 @@ import { displayWorkbenchTitle } from "./workbench-display-title";
 import { useStreamingReply, typingAgentNames } from "./streaming-reply";
 import { useTurnActivity, TurnActivityStrip } from "./turn-activity";
 import type { StreamingReplyState } from "./streaming-reply";
-import { AgentBadge, WorkbenchTimeline, messageDomId } from "./timeline";
+import {
+  AgentBadge,
+  WorkbenchTimeline,
+  messageDomId,
+  messageText,
+} from "./timeline";
 import { NoUsableModelBanner } from "./no-usable-model-banner";
 import { ResumeFailedBanner } from "./resume-failed-banner";
 import type {
@@ -1541,6 +1546,14 @@ function ChatWorkspaceInner({
                     onOpenThread={
                       inThreadView ? forkMessage : openThreadForMessage
                     }
+                    onEditMessage={(messageId) => {
+                      if (messagesState.kind !== "ready") return;
+                      const item = messagesState.items.find(
+                        (message) => message.id === messageId,
+                      );
+                      if (item === undefined) return;
+                      composerRef.current?.setText(messageText(item));
+                    }}
                     {...(onOpenProfile !== undefined ? { onOpenProfile } : {})}
                     {...(onOpenArtifact !== undefined
                       ? { onOpenArtifact }
diff --git a/packages/chat-ui/src/composer.tsx b/packages/chat-ui/src/composer.tsx
index 534608694..152751c2c 100644
--- a/packages/chat-ui/src/composer.tsx
+++ b/packages/chat-ui/src/composer.tsx
@@ -60,10 +60,11 @@ export type ComposerSendPayload = {
 };
 
 /** Imperative seam a host can grab a ref to, so content from outside the
- * composer's own tree — the profile card's Mention action (CL-5914) — can
- * land in the active draft at the caret. */
+ * composer's own tree — the profile card's Mention action (CL-5914) or
+ * hover-edit of a previous prompt — can land in the active draft. */
 export type ComposerHandle = {
   readonly insertText: (text: string) => void;
+  readonly setText: (text: string) => void;
 };
 
 /** Splice `insertion` in at `caret`, pure and independent of any DOM state
@@ -367,6 +368,7 @@ export const Composer = forwardRef<
   const [focused, setFocused] = useState(false);
   const textareaRef = useRef<HTMLTextAreaElement>(null);
   const fileInputRef = useRef<HTMLInputElement>(null);
+  const attachGenerationRef = useRef(0);
 
   /** Auto-grow: the textarea reports its own content height, so the
    * measurement resets to the CSS-declared min-height before reading
@@ -380,6 +382,21 @@ export const Composer = forwardRef<
     textarea.style.height = `${textarea.scrollHeight}px`;
   }, [value]);
 
+  function syncComposerSuggestState(text: string, caret: number) {
+    setHelpOpen(false);
+    const openSlash = activeSlashQuery(text, caret);
+    if (openSlash !== null) {
+      setSlash(openSlash);
+      setSlashHighlight(0);
+      setMention(null);
+      return;
+    }
+    setSlash(null);
+    const openMention = activeMentionQuery(text, caret);
+    setMention(openMention);
+    setHighlight(0);
+  }
+
   useImperativeHandle(
     ref,
     () => ({
@@ -393,6 +410,22 @@ export const Composer = forwardRef<
           textarea?.setSelectionRange(result.caret, result.caret);
         });
       },
+      setText: (text: string) => {
+        attachGenerationRef.current += 1;
+        setValue(text);
+        setMention(null);
+        setSlash(null);
+        setHelpOpen(false);
+        setPendingInvites([]);
+        setAttachments([]);
+        setErrorMessage(null);
+        setPreparing(false);
+        requestAnimationFrame(() => {
+          const textarea = textareaRef.current;
+          textarea?.focus();
+          textarea?.setSelectionRange(text.length, text.length);
+        });
+      },
     }),
     [value],
   );
@@ -413,21 +446,6 @@ export const Composer = forwardRef<
     sending,
   });
 
-  function syncComposerSuggestState(text: string, caret: number) {
-    setHelpOpen(false);
-    const openSlash = activeSlashQuery(text, caret);
-    if (openSlash !== null) {
-      setSlash(openSlash);
-      setSlashHighlight(0);
-      setMention(null);
-      return;
-    }
-    setSlash(null);
-    const openMention = activeMentionQuery(text, caret);
-    setMention(openMention);
-    setHighlight(0);
-  }
-
   /**
    * Fires the send and tracks its flight for the button's spinner —
    * nothing here decides what the timeline shows on success or failure.
@@ -537,6 +555,7 @@ export const Composer = forwardRef<
     if (!canAttachComposer({ sending, preparing })) return;
 
     const files = Array.from(fileList);
+    const generation = attachGenerationRef.current;
     const validation = validateAttachmentPick(
       attachments.length,
       attachmentBytesOnComposer(attachments),
@@ -563,11 +582,15 @@ export const Composer = forwardRef<
         });
       }
       // All-or-nothing: only commit once every file in the pick has read.
+      if (attachGenerationRef.current !== generation) return;
       setAttachments((previous) => [...previous, ...next]);
     } catch {
+      if (attachGenerationRef.current !== generation) return;
       setErrorMessage(CHAT_STRINGS.composerAttachmentReadError);
     } finally {
-      setPreparing(false);
+      if (attachGenerationRef.current === generation) {
+        setPreparing(false);
+      }
       resetFileInput();
     }
   }
diff --git a/packages/chat-ui/src/strings.ts b/packages/chat-ui/src/strings.ts
index f6e6760ce..7fcb26e96 100644
--- a/packages/chat-ui/src/strings.ts
+++ b/packages/chat-ui/src/strings.ts
@@ -132,6 +132,7 @@ export const CHAT_STRINGS = {
   forkThreadAction: "Fork",
   forkThreadError: "Couldn't fork that message into a thread — try again.",
   replyInThreadAction: "Reply in thread",
+  editMessageAction: "Edit",
   messageActionsMenuLabel: "Message actions",
   copyTextAction: "Copy text",
   copyTextCopiedToast: "Copied",
diff --git a/packages/chat-ui/src/styles.css b/packages/chat-ui/src/styles.css
index 57df5848b..fc6e6a00b 100644
--- a/packages/chat-ui/src/styles.css
+++ b/packages/chat-ui/src/styles.css
@@ -3105,9 +3105,11 @@
 /* Mock's hover toolbar: the compact trailing-edge cluster (add-reaction,
    reply-in-thread, ellipsis) that replaces the old persistent inline
    "Reply in thread" link and the standalone add-reaction trigger. Floats
-   over the message's top-right corner, fading in on hover/focus-within
-   like `.chat-pin-toggle` above, plus `data-open` so it stays put while its
-   own picker or menu is open even if focus moves into a portaled menu.
+   over the inboard (trailing) corner — top-right on others' left-aligned
+   rows, top-left on own right-aligned rows so Edit does not sit on the
+   prompt — fading in on hover/focus-within like `.chat-pin-toggle` above,
+   plus `data-open` so it stays put while its own picker or menu is open
+   even if focus moves into a portaled menu.
    Positioned relative to `.chat-message-row` (CL-6376) — the wrapper
    around this one message's own content, siblings-with but excluding its
    optional `.chat-day-divider` — rather than `.chat-message-group` as a
@@ -3162,6 +3164,13 @@
   transition: opacity 120ms var(--chat-ease);
 }
 
+/* Own (right-aligned) rows: inboard edge is the left of the row, matching
+   how `[data-own="true"] .chat-artifact-chip` already mirrors. */
+.chat-message-group[data-own="true"] .chat-hover-toolbar {
+  right: auto;
+  left: 0.4rem;
+}
+
 .chat-message-group:hover .chat-hover-toolbar,
 .chat-message-group:focus-within .chat-hover-toolbar,
 .chat-hover-toolbar[data-open="true"] {
@@ -3171,6 +3180,7 @@
 
 .chat-hover-toolbar .chat-reaction-add,
 .chat-hover-reply,
+.chat-hover-edit,
 .chat-hover-ellipsis {
   position: relative;
   display: inline-flex;
@@ -3191,6 +3201,7 @@
 
 .chat-hover-toolbar .chat-reaction-add::after,
 .chat-hover-reply::after,
+.chat-hover-edit::after,
 .chat-hover-ellipsis::after {
   content: "";
   position: absolute;
@@ -3199,6 +3210,7 @@
 
 .chat-hover-toolbar .chat-reaction-add svg,
 .chat-hover-reply svg,
+.chat-hover-edit svg,
 .chat-hover-ellipsis svg {
   width: 0.9rem;
   height: 0.9rem;
@@ -3206,6 +3218,7 @@
 
 .chat-hover-toolbar .chat-reaction-add:hover,
 .chat-hover-reply:hover,
+.chat-hover-edit:hover,
 .chat-hover-ellipsis:hover,
 .chat-hover-toolbar .chat-reaction-add[aria-expanded="true"],
 .chat-hover-ellipsis[aria-expanded="true"] {
diff --git a/packages/chat-ui/src/timeline.tsx b/packages/chat-ui/src/timeline.tsx
index e06703b59..31caa8b1d 100644
--- a/packages/chat-ui/src/timeline.tsx
+++ b/packages/chat-ui/src/timeline.tsx
@@ -34,6 +34,7 @@ import {
   Clock,
   Copy,
   DotsThree,
+  PencilSimple,
   PushPin,
   PushPinSlash,
   Smiley,
@@ -936,7 +937,7 @@ async function copyMessageText(text: string): Promise<void> {
   }
 }
 
-function messageText(item: MessageItem): string {
+export function messageText(item: MessageItem): string {
   return item.parts
     .filter((part): part is Part & { kind: "text" } => part.kind === "text")
     .map((part) => part.text)
@@ -1155,20 +1156,21 @@ function StreamingMessageGroup({
 }
 
 /**
- * The ellipsis/right-click menu for a message: everything that used to be
- * a persistent inline affordance (reply-in-thread) plus copy and pin, all
- * in one place so the two triggers (the hover toolbar's ellipsis button and
- * a right-click anywhere on the message) always offer the same actions.
+ * The ellipsis/right-click menu for a message: reply-in-thread, copy, pin,
+ * and Edit (own prompts) in one place so the hover ellipsis and a
+ * right-click always offer the same actions.
  */
 function buildMessageMenu({
   item,
   threadAffordanceMode,
   onOpenThread,
+  onEditMessage,
   pinActions,
 }: {
   readonly item: MessageItem;
   readonly threadAffordanceMode: ThreadAffordanceMode;
   readonly onOpenThread: ((messageId: string) => void) | undefined;
+  readonly onEditMessage: ((messageId: string) => void) | undefined;
   readonly pinActions: PinActions | undefined;
 }): ContextMenu {
   const entries: ContextMenuEntry[] = [];
@@ -1187,6 +1189,17 @@ function buildMessageMenu({
     );
   }
 
+  if (onEditMessage !== undefined) {
+    entries.push(
+      contextMenuItem({
+        id: "edit-message",
+        label: CHAT_STRINGS.editMessageAction,
+        icon: <PencilSimple aria-hidden="true" />,
+        onSelect: () => onEditMessage(item.id),
+      }),
+    );
+  }
+
   const text = messageText(item);
   if (text.length > 0) {
     entries.push(
@@ -1225,11 +1238,11 @@ function buildMessageMenu({
 
 /**
  * The compact trailing-edge action cluster a message reveals on hover or
- * keyboard focus-within — add-reaction, reply-in-thread, and the ellipsis
- * menu (see `buildMessageMenu`). Nothing here renders permanently; a quiet
- * conversation shows plain text until a reader hovers a line, matching the
- * reference pattern this replaces (a persistent inline "Reply in thread"
- * link under every message).
+ * keyboard focus-within — add-reaction, reply-in-thread, edit-own-prompt,
+ * and the ellipsis menu (see `buildMessageMenu`). Nothing here renders
+ * permanently; a quiet conversation shows plain text until a reader hovers
+ * a line, matching the reference pattern this replaces (a persistent inline
+ * "Reply in thread" link under every message).
  */
 function MessageHoverToolbar({
   messageId,
@@ -1238,6 +1251,7 @@ function MessageHoverToolbar({
   onOpenMenu,
   threadAffordanceMode,
   onOpenThread,
+  onEditMessage,
   reactionActions,
 }: {
   readonly messageId: string;
@@ -1246,6 +1260,7 @@ function MessageHoverToolbar({
   readonly onOpenMenu: (x: number, y: number, origin: Element) => void;
   readonly threadAffordanceMode: ThreadAffordanceMode;
   readonly onOpenThread?: (messageId: string) => void;
+  readonly onEditMessage?: (messageId: string) => void;
   readonly reactionActions?: ReactionActions;
 }) {
   const [pickerOpen, setPickerOpen] = useState(false);
@@ -1277,6 +1292,7 @@ function MessageHoverToolbar({
   if (
     reactionActions === undefined &&
     onOpenThread === undefined &&
+    onEditMessage === undefined &&
     !menuHasEntries
   ) {
     return null;
@@ -1338,6 +1354,16 @@ function MessageHoverToolbar({
           <ArrowBendUpLeft aria-hidden="true" />
         </button>
       ) : null}
+      {onEditMessage !== undefined ? (
+        <button
+          type="button"
+          className="chat-hover-edit"
+          aria-label={CHAT_STRINGS.editMessageAction}
+          onClick={() => onEditMessage(messageId)}
+        >
+          <PencilSimple aria-hidden="true" />
+        </button>
+      ) : null}
       {menuHasEntries ? (
         <button
           type="button"
@@ -1437,6 +1463,7 @@ function MessagePartsInner({
   threadMeta,
   threadAffordanceMode = "reply",
   onOpenThread,
+  onEditMessage,
   onOpenProfile,
   onOpenArtifact,
   onOpenArtifactInLibrary,
@@ -1468,6 +1495,7 @@ function MessagePartsInner({
   readonly threadMeta?: ThreadAffordanceMeta | undefined;
   readonly threadAffordanceMode?: ThreadAffordanceMode;
   readonly onOpenThread?: (messageId: string) => void;
+  readonly onEditMessage?: (messageId: string) => void;
   readonly onOpenProfile?: (subject: ProfileSubject) => void;
   readonly onOpenArtifact?: (part: Part & { kind: "file" }) => void;
   readonly onOpenArtifactInLibrary?: (part: Part & { kind: "file" }) => void;
@@ -1521,12 +1549,17 @@ function MessagePartsInner({
     !isSystemNoticeItem(item) &&
     !isSystemSenderItem(item) &&
     localPartOf(item.sender.address) === currentUser.principalId;
+  const ownEdit =
+    isOwn && onEditMessage !== undefined && messageText(item).length > 0
+      ? onEditMessage
+      : undefined;
   const contextMenu = useContextMenuState();
   const menu = offersSocialChrome
     ? buildMessageMenu({
         item,
         threadAffordanceMode,
         onOpenThread,
+        onEditMessage: ownEdit,
         pinActions,
       })
     : { entries: [] };
@@ -1716,6 +1749,7 @@ function MessagePartsInner({
             onOpenMenu={(x, y, origin) => contextMenu.show(x, y, menu, origin)}
             threadAffordanceMode={threadAffordanceMode}
             {...(onOpenThread !== undefined ? { onOpenThread } : {})}
+            {...(ownEdit !== undefined ? { onEditMessage: ownEdit } : {})}
             {...(reactionActions !== undefined ? { reactionActions } : {})}
           />
         ) : null}
@@ -1856,6 +1890,7 @@ export function WorkbenchTimeline({
   threadMetaByMessageId,
   threadAffordanceMode = "reply",
   onOpenThread,
+  onEditMessage,
   onOpenProfile,
   onOpenArtifact,
   onOpenArtifactInLibrary,
@@ -1888,6 +1923,7 @@ export function WorkbenchTimeline({
    * see `ThreadAffordanceMode`. */
   readonly threadAffordanceMode?: ThreadAffordanceMode;
   readonly onOpenThread?: (messageId: string) => void;
+  readonly onEditMessage?: (messageId: string) => void;
   readonly onOpenProfile?: (subject: ProfileSubject) => void;
   /** Open a message's artifact chip — the host resolves where that goes
    * (Library today; canvas is a follow-up). No chat-ui component owns
@@ -2115,6 +2151,7 @@ export function WorkbenchTimeline({
             threadMeta={threadMetaByMessageId?.get(item.id)}
             threadAffordanceMode={threadAffordanceMode}
             {...(onOpenThread !== undefined ? { onOpenThread } : {})}
+            {...(onEditMessage !== undefined ? { onEditMessage } : {})}
             {...(onOpenProfile !== undefined ? { onOpenProfile } : {})}
             {...(onOpenArtifact !== undefined ? { onOpenArtifact } : {})}
             {...(onFixConnection !== undefined ? { onFixConnection } : {})}
diff --git a/packages/chat-ui/test/chat-workspace.test.tsx b/packages/chat-ui/test/chat-workspace.test.tsx
index 6874635d3..df2e9af84 100644
--- a/packages/chat-ui/test/chat-workspace.test.tsx
+++ b/packages/chat-ui/test/chat-workspace.test.tsx
@@ -427,7 +427,13 @@ const THREADED_MESSAGES = [
   },
 ];
 
-function stubThreadedFetch() {
+function stubThreadedFetch({
+  sentMessages = [],
+  forkCalls = [],
+}: {
+  sentMessages?: unknown[];
+  forkCalls?: string[];
+} = {}) {
   globalThis.EventSource = StubEventSource as unknown as typeof EventSource;
   let forked = false;
   globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
@@ -443,6 +449,7 @@ function stubThreadedFetch() {
     if (/\/chat\/workbenches\?kind=chat$/.test(path))
       return json({ items: [] });
     if (/\/chat\/workbenches\/[^/]+\/threads\/fork$/.test(path)) {
+      forkCalls.push(path);
       forked = true;
       const body = JSON.parse(String(init?.body)) as {
         parentMessageId: string;
@@ -495,6 +502,7 @@ function stubThreadedFetch() {
     }
     if (/\/chat\/workbenches\/[^/]+\/messages/.test(path)) {
       if (init?.method === "POST") {
+        sentMessages.push(JSON.parse(String(init.body)));
         return json({ id: "msg_new", createdAt: "2026-01-01T00:00:00.000Z" });
       }
       return json({ items: THREADED_MESSAGES });
@@ -572,6 +580,58 @@ describe("Thread breadcrumb and fork (CL-5908, CL-5948)", () => {
     harness.unmount();
   });
 
+  test("editing an own prompt in an open reply thread resends into that thread without replacing history", async () => {
+    const sentMessages: unknown[] = [];
+    const forkCalls: string[] = [];
+    stubThreadedFetch({ sentMessages, forkCalls });
+    const harness = await mount({
+      tenant: { kind: "ready", tenantId: "tnt_1" },
+      workbenchId: "ch_1",
+      currentUser: { principalId: "prn_alice" },
+    });
+    await harness.settle();
+
+    const openButton = harness.container.querySelector(
+      ".chat-thread-open",
+    ) as HTMLButtonElement;
+    await act(async () => {
+      openButton.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+      await sleep(30);
+    });
+
+    const originalRow = harness.container.querySelector("#chat-message-msg_2");
+    expect(originalRow?.textContent).toContain("inside the thread");
+    const editButton = originalRow?.querySelector(
+      ".chat-hover-edit",
+    ) as HTMLButtonElement;
+    expect(editButton).not.toBeNull();
+    await act(async () => {
+      editButton.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+      await sleep(30);
+    });
+
+    const editedPrompt = "inside the thread, revised";
+    typeInComposer(harness.container, editedPrompt);
+    const sendButton = harness.container.querySelector(
+      'button[aria-label="Send"]',
+    ) as HTMLButtonElement;
+    await act(async () => {
+      sendButton.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+      await sleep(30);
+    });
+
+    expect(sentMessages).toHaveLength(1);
+    expect(sentMessages[0]).toMatchObject({
+      threadId: DEPTH1_THREAD.id,
+      parts: [{ kind: "text", text: editedPrompt }],
+    });
+    expect(forkCalls).toEqual([]);
+    expect(
+      harness.container.querySelector("#chat-message-msg_2")?.textContent,
+    ).toContain("inside the thread");
+    harness.unmount();
+  });
+
   test("forking a message inside a thread opens a sub-thread with a three-segment breadcrumb and an origin banner", async () => {
     stubThreadedFetch();
     const harness = await mount({
@@ -651,6 +711,139 @@ describe("Thread breadcrumb and fork (CL-5908, CL-5948)", () => {
   });
 });
 
+describe("hover Edit copies an own prompt into the composer", () => {
+  const OWN_PROMPT = "rewrite this prompt";
+
+  function stubFetchWithOwnPrompt(
+    sentMessages: unknown[],
+    forkCalls: string[],
+  ) {
+    globalThis.EventSource = StubEventSource as unknown as typeof EventSource;
+    globalThis.fetch = (async (
+      input: RequestInfo | URL,
+      init?: RequestInit,
+    ) => {
+      const path = typeof input === "string" ? input : String(input);
+      const json = (body: unknown) =>
+        new Response(JSON.stringify(body), {
+          status: 200,
+          headers: { "content-type": "application/json" },
+        });
+      if (/\/chat\/workbenches\?kind=workbench$/.test(path)) {
+        return json({ items: [WORKBENCH_WIRE] });
+      }
+      if (/\/chat\/workbenches\?kind=chat$/.test(path))
+        return json({ items: [] });
+      if (/\/chat\/workbenches\/[^/]+\/threads\/fork$/.test(path)) {
+        forkCalls.push(path);
+        return json({ id: "thr_should_not_fork" });
+      }
+      if (/\/chat\/workbenches\/[^/]+\/threads$/.test(path)) {
+        return json({ rootThreadId: "", items: [] });
+      }
+      if (/\/chat\/workbenches\/[^/]+\/messages/.test(path)) {
+        if (init?.method === "POST") {
+          sentMessages.push(JSON.parse(String(init.body)));
+          return json({ id: "msg_new", createdAt: "2026-01-01T00:00:00.000Z" });
+        }
+        return json({
+          items: [
+            {
+              id: "msg_own",
+              createdAt: "2026-01-01T00:00:00.000Z",
+              parts: [{ kind: "text", text: OWN_PROMPT }],
+              sender: { name: null, address: "prn_alice@acme.example" },
+            },
+            {
+              id: "msg_agent",
+              createdAt: "2026-01-01T00:00:01.000Z",
+              parts: [{ kind: "text", text: "agent reply" }],
+              sender: {
+                name: "Researcher",
+                address: "researcher@agents.example",
+              },
+            },
+          ],
+        });
+      }
+      if (/\/chat\/workbenches\/[^/]+\/read-state$/.test(path)) return json({});
+      if (/\/chat\/workbenches\/[^/]+\/invitable$/.test(path)) {
+        return json({ items: [] });
+      }
+      if (/\/chat\/workbenches\/[^/]+\/turns(?:\/|$|\?)/.test(path)) {
+        return json({ items: [] });
+      }
+      if (/\/chat\/workbenches\/[^/]+\/settings$/.test(path)) {
+        return json({
+          ...WORKBENCH_WIRE,
+          settings: {},
+          contextWindow: { value: 20, source: "inherit" },
+        });
+      }
+      if (/\/chat\/bench\/settings$/.test(path)) {
+        return json({ settings: {}, contextWindow: 20 });
+      }
+      throw new Error(`unstubbed fetch: ${path}`);
+    }) as typeof fetch;
+  }
+
+  test("clicking Edit fills the composer; send posts a new message and does not fork", async () => {
+    const sentMessages: unknown[] = [];
+    const forkCalls: string[] = [];
+    stubFetchWithOwnPrompt(sentMessages, forkCalls);
+    const harness = await mount({
+      tenant: { kind: "ready", tenantId: "tnt_1" },
+      workbenchId: "ch_1",
+      currentUser: { principalId: "prn_alice" },
+    });
+    await harness.settle();
+
+    const ownGroup = harness.container.querySelector("#chat-message-msg_own");
+    const agentGroup = harness.container.querySelector(
+      "#chat-message-msg_agent",
+    );
+    expect(ownGroup?.getAttribute("data-own")).toBe("true");
+    expect(agentGroup?.querySelector(".chat-hover-edit")).toBeNull();
+
+    typeInComposer(harness.container, "unsent draft");
+    const edit = ownGroup?.querySelector(
+      ".chat-hover-edit",
+    ) as HTMLButtonElement;
+    expect(edit).not.toBeNull();
+    await act(async () => {
+      edit.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+      await sleep(30);
+    });
+
+    const composer = harness.container.querySelector(
+      ".chat-composer-input",
+    ) as HTMLTextAreaElement;
+    expect(composer.value).toBe(OWN_PROMPT);
+    expect(ownGroup?.textContent).toContain(OWN_PROMPT);
+
+    const sendButton = harness.container.querySelector(
+      'button[aria-label="Send"]',
+    ) as HTMLButtonElement;
+    await act(async () => {
+      sendButton.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+      await sleep(30);
+    });
+
+    expect(forkCalls).toEqual([]);
+    expect(sentMessages).toHaveLength(1);
+    expect(sentMessages[0]).toMatchObject({
+      parts: [{ kind: "text", text: OWN_PROMPT }],
+    });
+    expect(
+      harness.container.querySelector("#chat-message-msg_own"),
+    ).not.toBeNull();
+    expect(
+      harness.container.querySelector("#chat-message-msg_own")?.textContent,
+    ).toContain(OWN_PROMPT);
+    harness.unmount();
+  });
+});
+
 const WORKBENCH_WITH_AGENT_WIRE = {
   ...WORKBENCH_WIRE,
   participants: [
diff --git a/packages/chat-ui/test/composer.test.tsx b/packages/chat-ui/test/composer.test.tsx
index 518d18777..82e324f32 100644
--- a/packages/chat-ui/test/composer.test.tsx
+++ b/packages/chat-ui/test/composer.test.tsx
@@ -408,3 +408,276 @@ describe("Composer mention bring-in load error (CL-6839)", () => {
     expect(handles).toEqual(["@researcher"]);
   });
 });
+
+describe("ComposerHandle.setText", () => {
+  test("replaces the existing draft and focuses with the caret at the end", async () => {
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+    const ref = createRef<ComposerHandle>();
+    act(() => {
+      root?.render(
+        createElement(Composer, {
+          ref,
+          agents: [],
+          onSend: () => Promise.resolve(true),
+          onInviteAgent: () => undefined,
+          onOpenAgentsSettings: () => undefined,
+          onCreateRoutineInSpace: () => undefined,
+        }),
+      );
+    });
+
+    typeInto(textarea(), "unsent draft");
+    await settle();
+    expect(textarea().value).toBe("unsent draft");
+
+    await act(async () => {
+      ref.current?.setText("previous prompt");
+      await new Promise<void>((resolve) => {
+        requestAnimationFrame(() => resolve());
+      });
+    });
+
+    expect(textarea().value).toBe("previous prompt");
+    expect(document.activeElement).toBe(textarea());
+    expect(textarea().selectionStart).toBe("previous prompt".length);
+    expect(textarea().selectionEnd).toBe("previous prompt".length);
+  });
+
+  test("Enter after setText sends the copied prompt instead of running a slash command", async () => {
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+    const ref = createRef<ComposerHandle>();
+    const sent: ComposerSendPayload[] = [];
+    let inviteAgentCalls = 0;
+    act(() => {
+      root?.render(
+        createElement(Composer, {
+          ref,
+          agents: [],
+          onSend: (payload) => {
+            sent.push(payload);
+            return Promise.resolve(true);
+          },
+          onInviteAgent: () => {
+            inviteAgentCalls += 1;
+          },
+          onOpenAgentsSettings: () => undefined,
+          onCreateRoutineInSpace: () => undefined,
+        }),
+      );
+    });
+
+    typeInto(textarea(), "/");
+    await settle();
+    expect(container?.querySelector(".chat-mention-popover")).not.toBeNull();
+
+    await act(async () => {
+      ref.current?.setText("copied prompt");
+      await new Promise<void>((resolve) => {
+        requestAnimationFrame(() => resolve());
+      });
+    });
+    await settle();
+
+    expect(textarea().value).toBe("copied prompt");
+    expect(container?.querySelector(".chat-mention-popover")).toBeNull();
+
+    act(() => {
+      textarea().dispatchEvent(
+        new KeyboardEvent("keydown", {
+          key: "Enter",
+          bubbles: true,
+          cancelable: true,
+        }),
+      );
+    });
+    await settle();
+
+    expect(inviteAgentCalls).toBe(0);
+    expect(sent).toEqual([{ text: "copied prompt", attachments: [] }]);
+  });
+
+  test("Enter after setText of an @handle prompt sends instead of opening mention", async () => {
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+    const ref = createRef<ComposerHandle>();
+    const sent: ComposerSendPayload[] = [];
+    act(() => {
+      root?.render(
+        createElement(Composer, {
+          ref,
+          agents: [],
+          participants: [
+            { address: "researcher@agents.example", handle: "researcher" },
+          ],
+          onSend: (payload) => {
+            sent.push(payload);
+            return Promise.resolve(true);
+          },
+          onInviteAgent: () => undefined,
+          onOpenAgentsSettings: () => undefined,
+          onCreateRoutineInSpace: () => undefined,
+        }),
+      );
+    });
+
+    await act(async () => {
+      ref.current?.setText("@researcher");
+      await new Promise<void>((resolve) => {
+        requestAnimationFrame(() => resolve());
+      });
+    });
+    await settle();
+
+    expect(container?.querySelector(".chat-mention-popover")).toBeNull();
+
+    act(() => {
+      textarea().dispatchEvent(
+        new KeyboardEvent("keydown", {
+          key: "Enter",
+          bubbles: true,
+          cancelable: true,
+        }),
+      );
+    });
+    await settle();
+
+    expect(sent).toEqual([{ text: "@researcher", attachments: [] }]);
+  });
+
+  test("Send after setText does not carry leftover bring-in invite intent", async () => {
+    const sent: { payload: ComposerSendPayload | null } = { payload: null };
+    const ref = createRef<ComposerHandle>();
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+    act(() => {
+      root?.render(
+        createElement(Composer, {
+          ref,
+          agents: [],
+          participants: [
+            { address: "researcher@agents.example", handle: "researcher" },
+          ],
+          members: [{ id: "prn_bob", displayName: "Bob" }],
+          invitableAgents: [
+            { id: "wfd_echo", name: "echo", description: "Echo" },
+          ],
+          onSend: (payload) => {
+            sent.payload = payload;
+            return Promise.resolve(true);
+          },
+          onInviteAgent: () => undefined,
+          onOpenAgentsSettings: () => undefined,
+          onCreateRoutineInSpace: () => undefined,
+        }),
+      );
+    });
+
+    typeInto(textarea(), "@bo");
+    await settle();
+    const options = Array.from(
+      container?.querySelectorAll<HTMLButtonElement>(".chat-mention-option") ??
+        [],
+    );
+    const bobOption = options.find(
+      (option) =>
+        option.querySelector(".chat-mention-handle")?.textContent === "@bob",
+    );
+    if (bobOption === undefined) throw new Error("bob option not found");
+    act(() => {
+      bobOption.dispatchEvent(
+        new MouseEvent("mousedown", { bubbles: true, cancelable: true }),
+      );
+    });
+    await settle();
+    expect(textarea().value).toBe("@bob ");
+
+    await act(async () => {
+      ref.current?.setText("copied prompt");
+      await new Promise<void>((resolve) => {
+        requestAnimationFrame(() => resolve());
+      });
+    });
+    await settle();
+
+    act(() => {
+      sendButton().click();
+    });
+    await settle();
+
+    if (sent.payload === null) throw new Error("payload not sent");
+    expect(sent.payload.text).toBe("copied prompt");
+    expect(sent.payload.invite).toBeUndefined();
+  });
+
+  test("Send after setText does not carry leftover attachments", async () => {
+    const sent: ComposerSendPayload[] = [];
+    const ref = createRef<ComposerHandle>();
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+    act(() => {
+      root?.render(
+        createElement(Composer, {
+          ref,
+          agents: [],
+          onSend: (payload) => {
+            sent.push(payload);
+            return Promise.resolve(true);
+          },
+          onInviteAgent: () => undefined,
+          onOpenAgentsSettings: () => undefined,
+          onCreateRoutineInSpace: () => undefined,
+        }),
+      );
+    });
+
+    const fileInput = container.querySelector<HTMLInputElement>(
+      ".chat-composer-file-input",
+    );
+    if (fileInput === null) throw new Error("file input not found");
+
+    const file = new File(["hello"], "notes.txt", { type: "text/plain" });
+    Object.defineProperty(fileInput, "files", {
+      configurable: true,
+      value: {
+        0: file,
+        length: 1,
+        item: (index: number) => (index === 0 ? file : null),
+        [Symbol.iterator]: function* () {
+          yield file;
+        },
+      },
+    });
+    act(() => {
+      fileInput.dispatchEvent(new Event("change", { bubbles: true }));
+    });
+    await settle();
+    await settle();
+    expect(
+      container.querySelector(".chat-composer-attachments"),
+    ).not.toBeNull();
+
+    await act(async () => {
+      ref.current?.setText("copied prompt");
+      await new Promise<void>((resolve) => {
+        requestAnimationFrame(() => resolve());
+      });
+    });
+    await settle();
+
+    expect(container.querySelector(".chat-composer-attachments")).toBeNull();
+
+    act(() => {
+      sendButton().click();
+    });
+    await settle();
+
+    expect(sent).toEqual([{ text: "copied prompt", attachments: [] }]);
+  });
+});
diff --git a/packages/chat-ui/test/message-hover-toolbar.test.tsx b/packages/chat-ui/test/message-hover-toolbar.test.tsx
index 9c8c0f54d..603d0fdfd 100644
--- a/packages/chat-ui/test/message-hover-toolbar.test.tsx
+++ b/packages/chat-ui/test/message-hover-toolbar.test.tsx
@@ -1,19 +1,38 @@
-// DOM tests for the compact hover toolbar (CL-6077): a message's
-// add-reaction / reply-in-thread / ellipsis cluster that only reveals on
-// hover or keyboard focus-within, replacing the old persistent inline
-// "Reply in thread" link. The ellipsis button and a right-click on the
-// message open the same menu — see `buildMessageMenu` in `timeline.tsx`.
+// Hover toolbar: add-reaction / reply-in-thread / Edit (own prompts) /
+// ellipsis. The ellipsis button and a right-click on the message open the
+// same menu — see `buildMessageMenu` in `timeline.tsx`.
 import { afterEach, describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { act } from "react";
 import { createRoot } from "react-dom/client";
 import type { Root } from "react-dom/client";
 
-import type { MessageItem } from "../src/api";
 import { WorkbenchTimeline } from "../src/timeline";
-import type { PinActions, ReactionActions } from "../src/timeline";
+import type {
+  CurrentUser,
+  PinActions,
+  ReactionActions,
+  TimelineMessageItem,
+} from "../src/timeline";
 
 const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 
+const chatUiCss = readFileSync(
+  join(dirname(fileURLToPath(import.meta.url)), "../src/styles.css"),
+  "utf8",
+);
+
+function cssRuleBodies(selector: string): string[] {
+  const escaped = selector.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return [
+    ...chatUiCss.matchAll(
+      new RegExp(`(?:^|\\n)\\s*${escaped}\\s*\\{([^}]+)\\}`, "g"),
+    ),
+  ].map((match) => match[1] ?? "");
+}
+
 /** Radix's exit-animation handling runs through a couple of microtasks even
  * with no real CSS animation configured — see the identical helper in
  * `@corbits/context-menu`'s own `context-menu-view.test.tsx`. */
@@ -24,7 +43,9 @@ async function flush(): Promise<void> {
   });
 }
 
-function textMessage(overrides: Partial<MessageItem> = {}): MessageItem[] {
+function textMessage(
+  overrides: Partial<TimelineMessageItem> = {},
+): TimelineMessageItem[] {
   return [
     {
       id: "m1",
@@ -32,7 +53,7 @@ function textMessage(overrides: Partial<MessageItem> = {}): MessageItem[] {
       parts: [{ kind: "text", text: "ship it" }],
       sender: { name: "Researcher", address: "researcher@agents.example" },
       ...overrides,
-    } as MessageItem,
+    },
   ];
 }
 
@@ -47,8 +68,10 @@ afterEach(() => {
 });
 
 async function mount(props: {
-  items: MessageItem[];
+  items: TimelineMessageItem[];
   onOpenThread?: (messageId: string) => void;
+  onEditMessage?: (messageId: string) => void;
+  currentUser?: CurrentUser;
   reactionActions?: ReactionActions;
   pinActions?: PinActions;
 }) {
@@ -62,6 +85,12 @@ async function mount(props: {
         {...(props.onOpenThread !== undefined
           ? { onOpenThread: props.onOpenThread }
           : {})}
+        {...(props.onEditMessage !== undefined
+          ? { onEditMessage: props.onEditMessage }
+          : {})}
+        {...(props.currentUser !== undefined
+          ? { currentUser: props.currentUser }
+          : {})}
         {...(props.reactionActions !== undefined
           ? { reactionActions: props.reactionActions }
           : {})}
@@ -112,6 +141,144 @@ describe("message hover toolbar", () => {
   });
 });
 
+describe("hover Edit on own prompts", () => {
+  test("Edit appears only when the row is the signed-in user's own prompt", async () => {
+    const el = await mount({
+      items: textMessage(),
+      currentUser: { principalId: "researcher" },
+      onEditMessage: () => undefined,
+    });
+
+    const group = el.querySelector(".chat-message-group");
+    expect(group?.getAttribute("data-own")).toBe("true");
+    const edit = el.querySelector(".chat-hover-edit");
+    expect(edit).not.toBeNull();
+    expect(edit?.tagName).toBe("BUTTON");
+    expect(edit?.getAttribute("aria-label")).toBe("Edit");
+  });
+
+  test("Edit is absent on someone else's prompt even when onEditMessage is wired", async () => {
+    const el = await mount({
+      items: textMessage(),
+      currentUser: { principalId: "someone-else" },
+      onEditMessage: () => undefined,
+    });
+
+    expect(
+      el.querySelector(".chat-message-group")?.getAttribute("data-own"),
+    ).toBe("false");
+    expect(el.querySelector(".chat-hover-edit")).toBeNull();
+  });
+
+  test("Edit is absent on a pending own send", async () => {
+    const el = await mount({
+      items: textMessage({ pendingStatus: "sending" }),
+      currentUser: { principalId: "researcher" },
+      onEditMessage: () => undefined,
+    });
+
+    expect(el.querySelector(".chat-hover-toolbar")).toBeNull();
+    expect(el.querySelector(".chat-hover-edit")).toBeNull();
+  });
+
+  test("Edit is absent on a streaming row", async () => {
+    const el = await mount({
+      items: textMessage({ streaming: true }),
+      currentUser: { principalId: "researcher" },
+      onEditMessage: () => undefined,
+    });
+
+    expect(el.querySelector(".chat-hover-toolbar")).toBeNull();
+    expect(el.querySelector(".chat-hover-edit")).toBeNull();
+  });
+
+  test("Edit is absent on a file-only own row", async () => {
+    const el = await mount({
+      items: textMessage({
+        parts: [
+          {
+            kind: "file",
+            name: "report.pdf",
+            mediaType: "application/pdf",
+            data: "JVBERi0xLjQK",
+          },
+        ],
+      }),
+      currentUser: { principalId: "researcher" },
+      onEditMessage: () => undefined,
+    });
+
+    expect(
+      el.querySelector(".chat-message-group")?.getAttribute("data-own"),
+    ).toBe("true");
+    expect(el.querySelector(".chat-hover-edit")).toBeNull();
+  });
+
+  test("clicking Edit calls onEditMessage with the message id and does not open a thread", async () => {
+    const edited: string[] = [];
+    const opened: string[] = [];
+    const el = await mount({
+      items: textMessage(),
+      currentUser: { principalId: "researcher" },
+      onEditMessage: (id) => edited.push(id),
+      onOpenThread: (id) => opened.push(id),
+    });
+
+    const edit = el.querySelector(".chat-hover-edit") as HTMLButtonElement;
+    await act(async () => edit.click());
+
+    expect(edited).toEqual(["m1"]);
+    expect(opened).toEqual([]);
+  });
+
+  test("the hover reply button still only opens a thread", async () => {
+    const edited: string[] = [];
+    const opened: string[] = [];
+    const el = await mount({
+      items: textMessage(),
+      currentUser: { principalId: "researcher" },
+      onEditMessage: (id) => edited.push(id),
+      onOpenThread: (id) => opened.push(id),
+    });
+
+    const reply = el.querySelector(".chat-hover-reply") as HTMLButtonElement;
+    await act(async () => reply.click());
+
+    expect(opened).toEqual(["m1"]);
+    expect(edited).toEqual([]);
+  });
+});
+
+describe("own-prompt hover toolbar is mirrored off the prompt", () => {
+  test("own rows pin the toolbar to the inboard (left) edge", () => {
+    const bodies = cssRuleBodies(
+      '.chat-message-group[data-own="true"] .chat-hover-toolbar',
+    );
+    expect(bodies.length).toBeGreaterThan(0);
+    const body = bodies[0] ?? "";
+    expect(body).toMatch(/right:\s*auto/);
+    expect(body).toMatch(/left:\s*0\.4rem/);
+  });
+
+  test("other rows keep the default trailing (right) edge", () => {
+    const bodies = cssRuleBodies(".chat-hover-toolbar");
+    expect(bodies.length).toBeGreaterThan(0);
+    const body = bodies[0] ?? "";
+    expect(body).toMatch(/right:\s*0\.4rem/);
+    expect(body).not.toMatch(/left:/);
+  });
+
+  test("hover, focus-within, and data-open still reveal the toolbar", () => {
+    expect(chatUiCss).toMatch(
+      /\.chat-message-group:hover\s+\.chat-hover-toolbar/,
+    );
+    expect(chatUiCss).toMatch(
+      /\.chat-message-group:focus-within\s+\.chat-hover-toolbar/,
+    );
+    expect(chatUiCss).toMatch(/\.chat-hover-toolbar\[data-open="true"\]/);
+  });
+});
+
 describe("the persistent inline 'Reply in thread' link is gone", () => {
   test("a message with no replies yet renders no .chat-thread-affordance row", async () => {
     const el = await mount({