diff --git a/src-tauri/src/bin/codex_monitor_daemon.rs b/src-tauri/src/bin/codex_monitor_daemon.rs
index 59bfc00bc..b4bc42b4d 100644
--- a/src-tauri/src/bin/codex_monitor_daemon.rs
+++ b/src-tauri/src/bin/codex_monitor_daemon.rs
@@ -786,6 +786,15 @@ impl DaemonState {
         codex_core::archive_thread_core(&self.sessions, workspace_id, thread_id).await
     }
 
+    async fn rollback_thread(
+        &self,
+        workspace_id: String,
+        thread_id: String,
+        turn_id: String,
+    ) -> Result<Value, String> {
+        codex_core::rollback_thread_core(&self.sessions, workspace_id, thread_id, turn_id).await
+    }
+
     async fn compact_thread(
         &self,
         workspace_id: String,
diff --git a/src-tauri/src/bin/codex_monitor_daemon/rpc/codex.rs b/src-tauri/src/bin/codex_monitor_daemon/rpc/codex.rs
index cc278938e..9a8803d7e 100644
--- a/src-tauri/src/bin/codex_monitor_daemon/rpc/codex.rs
+++ b/src-tauri/src/bin/codex_monitor_daemon/rpc/codex.rs
@@ -130,6 +130,21 @@ pub(super) async fn try_handle(
             };
             Some(state.archive_thread(workspace_id, thread_id).await)
         }
+        "rollback_thread" => {
+            let workspace_id = match parse_string(params, "workspaceId") {
+                Ok(value) => value,
+                Err(err) => return Some(Err(err)),
+            };
+            let thread_id = match parse_string(params, "threadId") {
+                Ok(value) => value,
+                Err(err) => return Some(Err(err)),
+            };
+            let turn_id = match parse_string(params, "turnId") {
+                Ok(value) => value,
+                Err(err) => return Some(Err(err)),
+            };
+            Some(state.rollback_thread(workspace_id, thread_id, turn_id).await)
+        }
         "compact_thread" => {
             let workspace_id = match parse_string(params, "workspaceId") {
                 Ok(value) => value,
diff --git a/src-tauri/src/codex/mod.rs b/src-tauri/src/codex/mod.rs
index e55d1e9ee..d9bc9a2de 100644
--- a/src-tauri/src/codex/mod.rs
+++ b/src-tauri/src/codex/mod.rs
@@ -294,6 +294,27 @@ pub(crate) async fn archive_thread(
     codex_core::archive_thread_core(&state.sessions, workspace_id, thread_id).await
 }
 
+#[tauri::command]
+pub(crate) async fn rollback_thread(
+    workspace_id: String,
+    thread_id: String,
+    turn_id: String,
+    state: State<'_, AppState>,
+    app: AppHandle,
+) -> Result<Value, String> {
+    if remote_backend::is_remote_mode(&*state).await {
+        return remote_backend::call_remote(
+            &*state,
+            app,
+            "rollback_thread",
+            json!({ "workspaceId": workspace_id, "threadId": thread_id, "turnId": turn_id }),
+        )
+        .await;
+    }
+
+    codex_core::rollback_thread_core(&state.sessions, workspace_id, thread_id, turn_id).await
+}
+
 #[tauri::command]
 pub(crate) async fn compact_thread(
     workspace_id: String,
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 83e9dacae..49aabc462 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -226,6 +226,7 @@ pub fn run() {
             codex::list_threads,
             codex::list_mcp_server_status,
             codex::archive_thread,
+            codex::rollback_thread,
             codex::compact_thread,
             codex::set_thread_name,
             codex::collaboration_mode_list,
diff --git a/src-tauri/src/shared/codex_core.rs b/src-tauri/src/shared/codex_core.rs
index a0f2a4ea6..38a4bf6b1 100644
--- a/src-tauri/src/shared/codex_core.rs
+++ b/src-tauri/src/shared/codex_core.rs
@@ -372,6 +372,57 @@ pub(crate) async fn archive_thread_core(
         .await
 }
 
+pub(crate) async fn rollback_thread_core(
+    sessions: &Mutex<HashMap<String, Arc<WorkspaceSession>>>,
+    workspace_id: String,
+    thread_id: String,
+    turn_id: String,
+) -> Result<Value, String> {
+    let session = get_session_clone(sessions, &workspace_id).await?;
+    let thread_response = read_thread_core(sessions, workspace_id.clone(), thread_id.clone()).await?;
+    let num_turns = rollback_num_turns_from_response(&thread_response, &turn_id)?;
+    let params = json!({ "threadId": thread_id, "numTurns": num_turns });
+    session
+        .send_request_for_workspace(&workspace_id, "thread/rollback", params)
+        .await
+}
+
+fn rollback_num_turns_from_response(response: &Value, turn_id: &str) -> Result<usize, String> {
+    let thread = extract_thread_from_response(response)
+        .ok_or_else(|| "Rollback failed: thread/read response missing thread payload.".to_string())?;
+    let turns = thread
+        .get("turns")
+        .and_then(Value::as_array)
+        .ok_or_else(|| "Rollback failed: thread/read response missing turns.".to_string())?;
+    let turn_index = turns
+        .iter()
+        .position(|turn| {
+            turn.as_object().is_some_and(|record| {
+                record
+                    .get("id")
+                    .or_else(|| record.get("turnId"))
+                    .or_else(|| record.get("turn_id"))
+                    .and_then(Value::as_str)
+                    .is_some_and(|value| value == turn_id)
+            })
+        })
+        .ok_or_else(|| format!("Rollback failed: turn '{turn_id}' was not found in thread."))?;
+    Ok(turns.len().saturating_sub(turn_index))
+}
+
+fn extract_thread_from_response<'a>(response: &'a Value) -> Option<&'a Map<String, Value>> {
+    response
+        .as_object()
+        .and_then(|record| {
+            record
+                .get("result")
+                .and_then(Value::as_object)
+                .and_then(|result| result.get("thread"))
+                .or_else(|| record.get("thread"))
+        })
+        .and_then(Value::as_object)
+}
+
 pub(crate) async fn compact_thread_core(
     sessions: &Mutex<HashMap<String, Arc<WorkspaceSession>>>,
     workspace_id: String,
@@ -1030,4 +1081,51 @@ mod tests {
         assert!(THREAD_LIST_SOURCE_KINDS.contains(&"subAgentCompact"));
         assert!(THREAD_LIST_SOURCE_KINDS.contains(&"subAgentThreadSpawn"));
     }
+
+    #[test]
+    fn rollback_num_turns_counts_from_target_turn_to_end() {
+        let response = json!({
+            "result": {
+                "thread": {
+                    "turns": [
+                        { "id": "turn-1" },
+                        { "id": "turn-2" },
+                        { "id": "turn-3" }
+                    ]
+                }
+            }
+        });
+
+        let num_turns = rollback_num_turns_from_response(&response, "turn-2").unwrap();
+        assert_eq!(num_turns, 2);
+    }
+
+    #[test]
+    fn rollback_num_turns_supports_turn_id_aliases() {
+        let response = json!({
+            "thread": {
+                "turns": [
+                    { "turn_id": "turn-1" },
+                    { "turnId": "turn-2" }
+                ]
+            }
+        });
+
+        let num_turns = rollback_num_turns_from_response(&response, "turn-2").unwrap();
+        assert_eq!(num_turns, 1);
+    }
+
+    #[test]
+    fn rollback_num_turns_errors_when_turn_is_missing() {
+        let response = json!({
+            "result": {
+                "thread": {
+                    "turns": [{ "id": "turn-1" }]
+                }
+            }
+        });
+
+        let err = rollback_num_turns_from_response(&response, "turn-9").unwrap_err();
+        assert!(err.contains("turn-9"));
+    }
 }
diff --git a/src/features/app/components/MainApp.tsx b/src/features/app/components/MainApp.tsx
index 1ce7cc587..255da6202 100644
--- a/src/features/app/components/MainApp.tsx
+++ b/src/features/app/components/MainApp.tsx
@@ -66,6 +66,7 @@ import { useRemoteThreadLiveConnection } from "@app/hooks/useRemoteThreadLiveCon
 import { useTrayRecentThreads } from "@app/hooks/useTrayRecentThreads";
 import { useTraySessionUsage } from "@app/hooks/useTraySessionUsage";
 import { useTauriEvent } from "@app/hooks/useTauriEvent";
+import { useMessageEdit } from "@/features/messages/hooks/useMessageEdit";
 import { useAppBootstrapOrchestration } from "@app/bootstrap/useAppBootstrapOrchestration";
 import {
   useThreadCodexBootstrapOrchestration,
@@ -494,6 +495,7 @@ export default function MainApp() {
     handleUserInputSubmit,
     refreshAccountInfo,
     refreshAccountRateLimits,
+    editAndRegenerateMessage,
   } = useThreads({
     activeWorkspace,
     onWorkspaceConnected: markWorkspaceConnected,
@@ -516,6 +518,15 @@ export default function MainApp() {
     threadSortKey: threadListSortKey,
     onThreadCodexMetadataDetected: handleThreadCodexMetadataDetected,
   });
+
+  const messageEditState = useMessageEdit({
+    onRegenerate: async (itemId, newText, images) => {
+      if (!activeWorkspace || !activeThreadId) {
+        return;
+      }
+      await editAndRegenerateMessage(activeWorkspace, activeThreadId, itemId, newText, images);
+    },
+  });
   const { connectionState: remoteThreadConnectionState, reconnectLive } =
     useRemoteThreadLiveConnection({
       backendMode: appSettings.backendMode,
@@ -1648,6 +1659,7 @@ export default function MainApp() {
     promptActions,
     worktreeState,
     sidebarHandlers: sidebarMenuOrchestration,
+    messageEditState,
     displayNodes,
     threadPinning: {
       pinThread,
diff --git a/src/features/app/hooks/useAppServerEvents.test.tsx b/src/features/app/hooks/useAppServerEvents.test.tsx
index 92bfb98e3..4e448ee75 100644
--- a/src/features/app/hooks/useAppServerEvents.test.tsx
+++ b/src/features/app/hooks/useAppServerEvents.test.tsx
@@ -61,6 +61,7 @@ describe("useAppServerEvents", () => {
       onPlanDelta: vi.fn(),
       onApprovalRequest: vi.fn(),
       onRequestUserInput: vi.fn(),
+      onItemStarted: vi.fn(),
       onItemCompleted: vi.fn(),
       onAgentMessageCompleted: vi.fn(),
       onAccountRateLimitsUpdated: vi.fn(),
@@ -324,6 +325,7 @@ describe("useAppServerEvents", () => {
           method: "item/completed",
           params: {
             threadId: "thread-1",
+            turnId: "turn-2",
             item: { type: "agentMessage", id: "item-2", text: "Done" },
           },
         },
@@ -332,6 +334,7 @@ describe("useAppServerEvents", () => {
     expect(handlers.onItemCompleted).toHaveBeenCalledWith("ws-1", "thread-1", {
       type: "agentMessage",
       id: "item-2",
+      turnId: "turn-2",
       text: "Done",
     });
     expect(handlers.onAgentMessageCompleted).toHaveBeenCalledWith({
@@ -341,6 +344,25 @@ describe("useAppServerEvents", () => {
       text: "Done",
     });
 
+    act(() => {
+      listener?.({
+        workspace_id: "ws-1",
+        message: {
+          method: "item/started",
+          params: {
+            threadId: "thread-1",
+            turnId: "turn-3",
+            item: { type: "userMessage", id: "item-3" },
+          },
+        },
+      });
+    });
+    expect(handlers.onItemStarted).toHaveBeenCalledWith("ws-1", "thread-1", {
+      type: "userMessage",
+      id: "item-3",
+      turnId: "turn-3",
+    });
+
     act(() => {
       listener?.({
         workspace_id: "ws-1",
diff --git a/src/features/app/hooks/useAppServerEvents.ts b/src/features/app/hooks/useAppServerEvents.ts
index 6f21dafb4..012bbdbf9 100644
--- a/src/features/app/hooks/useAppServerEvents.ts
+++ b/src/features/app/hooks/useAppServerEvents.ts
@@ -467,8 +467,10 @@ export function useAppServerEvents(handlers: AppServerEventHandlers) {
       if (method === "item/completed") {
         const threadId = String(params.threadId ?? params.thread_id ?? "");
         const item = params.item as Record<string, unknown> | undefined;
+        const turnId = String(params.turnId ?? params.turn_id ?? "").trim();
         if (threadId && item) {
-          currentHandlers.onItemCompleted?.(workspace_id, threadId, item);
+          const itemWithTurnId = turnId ? { ...item, turnId } : item;
+          currentHandlers.onItemCompleted?.(workspace_id, threadId, itemWithTurnId);
         }
         if (threadId && item?.type === "agentMessage") {
           const itemId = String(item.id ?? "");
@@ -488,8 +490,10 @@ export function useAppServerEvents(handlers: AppServerEventHandlers) {
       if (method === "item/started") {
         const threadId = String(params.threadId ?? params.thread_id ?? "");
         const item = params.item as Record<string, unknown> | undefined;
+        const turnId = String(params.turnId ?? params.turn_id ?? "").trim();
         if (threadId && item) {
-          currentHandlers.onItemStarted?.(workspace_id, threadId, item);
+          const itemWithTurnId = turnId ? { ...item, turnId } : item;
+          currentHandlers.onItemStarted?.(workspace_id, threadId, itemWithTurnId);
         }
         return;
       }
diff --git a/src/features/app/hooks/useMainAppLayoutSurfaces.ts b/src/features/app/hooks/useMainAppLayoutSurfaces.ts
index b6ac05279..883d2120e 100644
--- a/src/features/app/hooks/useMainAppLayoutSurfaces.ts
+++ b/src/features/app/hooks/useMainAppLayoutSurfaces.ts
@@ -1,5 +1,6 @@
 import type { RefObject } from "react";
-import type { AppSettings, ComposerEditorSettings, WorkspaceInfo } from "@/types";
+import type { AppSettings, ComposerEditorSettings, ConversationItem, WorkspaceInfo } from "@/types";
+import type { UseMessageEditResult } from "@/features/messages/hooks/useMessageEdit";
 import type { ThreadState } from "@/features/threads/hooks/useThreadsReducer";
 import type { WorkspaceLaunchScriptsState } from "@app/hooks/useWorkspaceLaunchScripts";
 import { REMOTE_THREAD_POLL_INTERVAL_MS } from "@app/hooks/useRemoteThreadRefreshOnFocus";
@@ -225,6 +226,7 @@ type UseMainAppLayoutSurfacesArgs = {
   dismissErrorToast: LayoutNodesOptions["primary"]["errorToastsProps"]["onDismiss"];
   showDebugButton: boolean;
   handleDebugClick: () => void;
+  messageEditState?: UseMessageEditResult;
 };
 
 type MainAppLayoutSurfacesContext = UseMainAppLayoutSurfacesArgs & {
@@ -374,6 +376,7 @@ function buildPrimarySurface({
   dismissErrorToast,
   showDebugButton,
   handleDebugClick,
+  messageEditState,
 }: MainAppLayoutSurfacesContext): LayoutNodesOptions["primary"] {
   return {
     sidebarProps: {
@@ -465,6 +468,16 @@ function buildPrimarySurface({
         : null,
       showPollingFetchStatus: showMobilePollingFetchStatus,
       pollingIntervalMs: REMOTE_THREAD_POLL_INTERVAL_MS,
+      editingItemId: messageEditState?.editingItemId,
+      editText: messageEditState?.editText,
+      isConfirmingEdit: messageEditState?.isConfirming,
+      isRegeneratingEdit: messageEditState?.isRegenerating,
+      onStartEdit: messageEditState?.startEdit ? (item: Extract<ConversationItem, { kind: "message" }>) => messageEditState.startEdit(item.id, item.text, item.images) : undefined,
+      onCancelEdit: messageEditState?.cancelEdit,
+      onUpdateEditText: messageEditState?.updateEditText,
+      onRequestRegenerate: messageEditState?.requestRegenerate,
+      onCancelConfirm: messageEditState?.cancelConfirm,
+      onExecuteRegenerate: messageEditState?.executeRegenerate,
     },
     composerProps: composerWorkspaceState.showComposer
       ? {
@@ -1098,6 +1111,7 @@ export function useMainAppLayoutSurfaces({
   dismissErrorToast,
   showDebugButton,
   handleDebugClick,
+  messageEditState,
 }: UseMainAppLayoutSurfacesArgs): LayoutNodesOptions {
   const sidebarRateLimits = activeWorkspace ? activeRateLimits : homeRateLimits;
   const sidebarAccount = activeWorkspace ? activeAccount : homeAccount;
@@ -1260,6 +1274,7 @@ export function useMainAppLayoutSurfaces({
     dismissErrorToast,
     showDebugButton,
     handleDebugClick,
+    messageEditState,
     sidebarRateLimits,
     sidebarAccount,
   };
diff --git a/src/features/messages/components/MessageRows.tsx b/src/features/messages/components/MessageRows.tsx
index 9e2848606..3310e8663 100644
--- a/src/features/messages/components/MessageRows.tsx
+++ b/src/features/messages/components/MessageRows.tsx
@@ -8,9 +8,11 @@ import Diff from "lucide-react/dist/esm/icons/diff";
 import FileDiffIcon from "lucide-react/dist/esm/icons/file-diff";
 import FileText from "lucide-react/dist/esm/icons/file-text";
 import Image from "lucide-react/dist/esm/icons/image";
+import Pencil from "lucide-react/dist/esm/icons/pencil";
 import Quote from "lucide-react/dist/esm/icons/quote";
 import Search from "lucide-react/dist/esm/icons/search";
 import Terminal from "lucide-react/dist/esm/icons/terminal";
+import TriangleAlert from "lucide-react/dist/esm/icons/triangle-alert";
 import Users from "lucide-react/dist/esm/icons/users";
 import Wrench from "lucide-react/dist/esm/icons/wrench";
 import X from "lucide-react/dist/esm/icons/x";
@@ -61,6 +63,16 @@ type MessageRowProps = MarkdownFileLinkProps & {
   onCopy: (item: Extract<ConversationItem, { kind: "message" }>) => void;
   onQuote?: (item: Extract<ConversationItem, { kind: "message" }>, selectedText?: string) => void;
   codeBlockCopyUseModifier?: boolean;
+  isEditing?: boolean;
+  editText?: string;
+  isConfirming?: boolean;
+  isRegenerating?: boolean;
+  onStartEdit?: (item: Extract<ConversationItem, { kind: "message" }>) => void;
+  onCancelEdit?: () => void;
+  onUpdateEditText?: (text: string) => void;
+  onRequestRegenerate?: () => void;
+  onCancelConfirm?: () => void;
+  onExecuteRegenerate?: () => void;
 };
 
 type ReasoningRowProps = MarkdownFileLinkProps & {
@@ -377,11 +389,24 @@ export const MessageRow = memo(function MessageRow({
   onOpenFileLink,
   onOpenFileLinkMenu,
   onOpenThreadLink,
+  isEditing = false,
+  editText = "",
+  isConfirming = false,
+  isRegenerating = false,
+  onStartEdit,
+  onCancelEdit,
+  onUpdateEditText,
+  onRequestRegenerate,
+  onCancelConfirm,
+  onExecuteRegenerate,
 }: MessageRowProps) {
   const [lightboxIndex, setLightboxIndex] = useState<number | null>(null);
   const bubbleRef = useRef<HTMLDivElement | null>(null);
+  const editTextareaRef = useRef<HTMLTextAreaElement | null>(null);
   const selectionSnapshotRef = useRef<string | null>(null);
   const hasText = item.text.trim().length > 0;
+  const isUserMessage = item.role === "user";
+  const canEdit = isUserMessage && Boolean(onStartEdit) && !isRegenerating;
   const imageItems = useMemo(() => {
     if (!item.images || item.images.length === 0) {
       return [];
@@ -402,6 +427,28 @@ export const MessageRow = memo(function MessageRow({
     imageItems.length === 0 &&
     isStandaloneMarkdownTable(item.text);
 
+  useEffect(() => {
+    if (isEditing && editTextareaRef.current) {
+      const textarea = editTextareaRef.current;
+      textarea.focus();
+      textarea.setSelectionRange(textarea.value.length, textarea.value.length);
+    }
+  }, [isEditing]);
+
+  const handleEditKeyDown = useCallback(
+    (event: React.KeyboardEvent<HTMLTextAreaElement>) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        if (isConfirming) {
+          onCancelConfirm?.();
+        } else {
+          onCancelEdit?.();
+        }
+      }
+    },
+    [isConfirming, onCancelConfirm, onCancelEdit],
+  );
+
   const getSelectedMessageText = useCallback(() => {
     const bubble = bubbleRef.current;
     const selection = window.getSelection();
@@ -422,7 +469,7 @@ export const MessageRow = memo(function MessageRow({
         return false;
       }
       const element = node instanceof Element ? node : node.parentElement;
-      return Boolean(element?.closest(".message-quote-button, .message-copy-button"));
+      return Boolean(element?.closest(".message-quote-button, .message-copy-button, .message-edit-button"));
     };
 
     if (isWithinMessageControls(selection.anchorNode) || isWithinMessageControls(selection.focusNode)) {
@@ -440,6 +487,84 @@ export const MessageRow = memo(function MessageRow({
     onQuote(item, selectedText);
   }, [getSelectedMessageText, item, onQuote]);
 
+  if (isEditing) {
+    return (
+      <div className={`message ${item.role}`}>
+        <div className="bubble message-bubble message-bubble-editing">
+          {imageItems.length > 0 && (
+            <MessageImageGrid
+              images={imageItems}
+              onOpen={setLightboxIndex}
+              hasText={hasText}
+            />
+          )}
+          <textarea
+            ref={editTextareaRef}
+            className="message-edit-textarea"
+            value={editText}
+            onChange={(event) => onUpdateEditText?.(event.target.value)}
+            onKeyDown={handleEditKeyDown}
+            rows={Math.min(12, Math.max(3, editText.split("\n").length + 1))}
+            disabled={isRegenerating}
+            aria-label="Edit message"
+          />
+          {isConfirming && (
+            <div className="message-edit-confirm" role="alert">
+              <div className="message-edit-confirm-warning">
+                <TriangleAlert size={14} aria-hidden />
+                <span>All messages after this point will be permanently removed.</span>
+              </div>
+              <div className="message-edit-confirm-actions">
+                <button
+                  type="button"
+                  className="message-edit-confirm-cancel"
+                  onClick={onCancelConfirm}
+                >
+                  Cancel
+                </button>
+                <button
+                  type="button"
+                  className="message-edit-confirm-proceed"
+                  onClick={onExecuteRegenerate}
+                  disabled={isRegenerating}
+                >
+                  {isRegenerating ? "Regenerating…" : "Confirm & Regenerate"}
+                </button>
+              </div>
+            </div>
+          )}
+          {!isConfirming && (
+            <div className="message-edit-actions">
+              <button
+                type="button"
+                className="message-edit-cancel"
+                onClick={onCancelEdit}
+                disabled={isRegenerating}
+              >
+                Cancel
+              </button>
+              <button
+                type="button"
+                className="message-edit-regenerate"
+                onClick={onRequestRegenerate}
+                disabled={isRegenerating || !editText.trim()}
+              >
+                Regenerate
+              </button>
+            </div>
+          )}
+          {lightboxIndex !== null && imageItems.length > 0 && (
+            <ImageLightbox
+              images={imageItems}
+              activeIndex={lightboxIndex}
+              onClose={() => setLightboxIndex(null)}
+            />
+          )}
+        </div>
+      </div>
+    );
+  }
+
   return (
     <div className={`message ${item.role}`}>
       <div
@@ -473,6 +598,17 @@ export const MessageRow = memo(function MessageRow({
             onClose={() => setLightboxIndex(null)}
           />
         )}
+        {canEdit && (
+          <button
+            type="button"
+            className="ghost message-edit-button"
+            onClick={() => onStartEdit?.(item)}
+            aria-label="Edit message"
+            title="Edit message"
+          >
+            <Pencil size={14} aria-hidden />
+          </button>
+        )}
         {onQuote && hasText && (
           <button
             type="button"
diff --git a/src/features/messages/components/Messages.test.tsx b/src/features/messages/components/Messages.test.tsx
index f82e5b803..2c4e4084b 100644
--- a/src/features/messages/components/Messages.test.tsx
+++ b/src/features/messages/components/Messages.test.tsx
@@ -1507,6 +1507,39 @@ describe("Messages", () => {
     expect(screen.getByText("Plan ready")).toBeTruthy();
   });
 
+  it("hides edit entry points while regenerate is in flight", () => {
+    const items: ConversationItem[] = [
+      {
+        id: "msg-1",
+        kind: "message",
+        role: "user",
+        text: "First",
+      },
+      {
+        id: "msg-2",
+        kind: "message",
+        role: "user",
+        text: "Second",
+      },
+    ];
+    const onStartEdit = vi.fn();
+
+    render(
+      <Messages
+        items={items}
+        threadId="thread-1"
+        workspaceId="ws-1"
+        isThinking={false}
+        openTargets={[]}
+        selectedOpenAppId=""
+        isRegeneratingEdit
+        onStartEdit={onStartEdit}
+      />,
+    );
+
+    expect(screen.queryByRole("button", { name: "Edit message" })).toBeNull();
+  });
+
   it("calls the plan follow-up callbacks", () => {
     const onPlanAccept = vi.fn();
     const onPlanSubmitChanges = vi.fn();
diff --git a/src/features/messages/components/Messages.tsx b/src/features/messages/components/Messages.tsx
index da2a318e1..b03b1b002 100644
--- a/src/features/messages/components/Messages.tsx
+++ b/src/features/messages/components/Messages.tsx
@@ -47,6 +47,16 @@ type MessagesProps = {
   onPlanSubmitChanges?: (changes: string) => void;
   onOpenThreadLink?: (threadId: string, workspaceId?: string | null) => void;
   onQuoteMessage?: (text: string) => void;
+  editingItemId?: string | null;
+  editText?: string;
+  isConfirmingEdit?: boolean;
+  isRegeneratingEdit?: boolean;
+  onStartEdit?: (item: Extract<ConversationItem, { kind: "message" }>) => void;
+  onCancelEdit?: () => void;
+  onUpdateEditText?: (text: string) => void;
+  onRequestRegenerate?: () => void;
+  onCancelConfirm?: () => void;
+  onExecuteRegenerate?: () => void;
 };
 
 export const Messages = memo(function Messages({
@@ -70,6 +80,16 @@ export const Messages = memo(function Messages({
   onPlanSubmitChanges,
   onOpenThreadLink,
   onQuoteMessage,
+  editingItemId = null,
+  editText = "",
+  isConfirmingEdit = false,
+  isRegeneratingEdit = false,
+  onStartEdit,
+  onCancelEdit,
+  onUpdateEditText,
+  onRequestRegenerate,
+  onCancelConfirm,
+  onExecuteRegenerate,
 }: MessagesProps) {
   const activeUserInputRequestId =
     threadId && userInputRequests.length
@@ -147,6 +167,8 @@ export const Messages = memo(function Messages({
   const renderItem = (item: ConversationItem) => {
     if (item.kind === "message") {
       const isCopied = copiedMessageId === item.id;
+      const isEditingThis = editingItemId === item.id;
+      const editAction = isThinking || isRegeneratingEdit ? undefined : onStartEdit;
       return (
         <MessageRow
           key={item.id}
@@ -160,6 +182,16 @@ export const Messages = memo(function Messages({
           onOpenFileLink={openFileLink}
           onOpenFileLinkMenu={showFileLinkMenu}
           onOpenThreadLink={handleOpenThreadLink}
+          isEditing={isEditingThis}
+          editText={isEditingThis ? editText : undefined}
+          isConfirming={isEditingThis ? isConfirmingEdit : undefined}
+          isRegenerating={isEditingThis ? isRegeneratingEdit : undefined}
+          onStartEdit={editAction}
+          onCancelEdit={onCancelEdit}
+          onUpdateEditText={onUpdateEditText}
+          onRequestRegenerate={onRequestRegenerate}
+          onCancelConfirm={onCancelConfirm}
+          onExecuteRegenerate={onExecuteRegenerate}
         />
       );
     }
diff --git a/src/features/messages/hooks/useMessageEdit.test.tsx b/src/features/messages/hooks/useMessageEdit.test.tsx
new file mode 100644
index 000000000..9998c0ed8
--- /dev/null
+++ b/src/features/messages/hooks/useMessageEdit.test.tsx
@@ -0,0 +1,211 @@
+// @vitest-environment jsdom
+import { describe, expect, it, vi } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import { useMessageEdit } from "./useMessageEdit";
+
+describe("useMessageEdit", () => {
+  const onRegenerate = vi.fn().mockResolvedValue(undefined);
+
+  function setup() {
+    return renderHook(() => useMessageEdit({ onRegenerate }));
+  }
+
+  it("starts in idle state", () => {
+    const { result } = setup();
+    expect(result.current.editingItemId).toBeNull();
+    expect(result.current.editText).toBe("");
+    expect(result.current.editImages).toEqual([]);
+    expect(result.current.isConfirming).toBe(false);
+    expect(result.current.isRegenerating).toBe(false);
+  });
+
+  it("enters editing state with startEdit", () => {
+    const { result } = setup();
+    act(() => {
+      result.current.startEdit("item-1", "Hello world", ["img.png"]);
+    });
+    expect(result.current.editingItemId).toBe("item-1");
+    expect(result.current.editText).toBe("Hello world");
+    expect(result.current.editImages).toEqual(["img.png"]);
+    expect(result.current.isConfirming).toBe(false);
+    expect(result.current.isRegenerating).toBe(false);
+  });
+
+  it("defaults images to empty array when not provided to startEdit", () => {
+    const { result } = setup();
+    act(() => {
+      result.current.startEdit("item-1", "text");
+    });
+    expect(result.current.editImages).toEqual([]);
+  });
+
+  it("updates edit text via updateEditText", () => {
+    const { result } = setup();
+    act(() => {
+      result.current.startEdit("item-1", "original");
+    });
+    act(() => {
+      result.current.updateEditText("updated");
+    });
+    expect(result.current.editText).toBe("updated");
+  });
+
+  it("ignores updateEditText when not editing", () => {
+    const { result } = setup();
+    act(() => {
+      result.current.updateEditText("should be ignored");
+    });
+    expect(result.current.editText).toBe("");
+    expect(result.current.editingItemId).toBeNull();
+  });
+
+  it("returns to idle on cancelEdit", () => {
+    const { result } = setup();
+    act(() => {
+      result.current.startEdit("item-1", "some text");
+    });
+    act(() => {
+      result.current.cancelEdit();
+    });
+    expect(result.current.editingItemId).toBeNull();
+    expect(result.current.editText).toBe("");
+    expect(result.current.isConfirming).toBe(false);
+    expect(result.current.isRegenerating).toBe(false);
+  });
+
+  it("shows confirmation dialog on requestRegenerate", () => {
+    const { result } = setup();
+    act(() => {
+      result.current.startEdit("item-1", "text");
+    });
+    act(() => {
+      result.current.requestRegenerate();
+    });
+    expect(result.current.isConfirming).toBe(true);
+  });
+
+  it("does nothing on requestRegenerate when not editing", () => {
+    const { result } = setup();
+    act(() => {
+      result.current.requestRegenerate();
+    });
+    expect(result.current.isConfirming).toBe(false);
+  });
+
+  it("dismisses confirmation on cancelConfirm", () => {
+    const { result } = setup();
+    act(() => {
+      result.current.startEdit("item-1", "text");
+    });
+    act(() => {
+      result.current.requestRegenerate();
+    });
+    act(() => {
+      result.current.cancelConfirm();
+    });
+    expect(result.current.isConfirming).toBe(false);
+    expect(result.current.editingItemId).toBe("item-1");
+  });
+
+  it("calls onRegenerate and resets state on executeRegenerate", async () => {
+    onRegenerate.mockClear();
+    const { result } = setup();
+    act(() => {
+      result.current.startEdit("item-1", "  revised text  ", ["img.png"]);
+    });
+    await act(async () => {
+      await result.current.executeRegenerate();
+    });
+    expect(onRegenerate).toHaveBeenCalledWith("item-1", "revised text", ["img.png"]);
+    expect(result.current.editingItemId).toBeNull();
+    expect(result.current.isRegenerating).toBe(false);
+  });
+
+  it("does nothing on executeRegenerate when not editing", async () => {
+    onRegenerate.mockClear();
+    const { result } = setup();
+    await act(async () => {
+      await result.current.executeRegenerate();
+    });
+    expect(onRegenerate).not.toHaveBeenCalled();
+  });
+
+  it("rejects empty text on executeRegenerate", async () => {
+    onRegenerate.mockClear();
+    const { result } = setup();
+    act(() => {
+      result.current.startEdit("item-1", "   ");
+    });
+    await act(async () => {
+      await result.current.executeRegenerate();
+    });
+    expect(onRegenerate).not.toHaveBeenCalled();
+    // State should still be editing (not cleared) since the guard blocked it
+    expect(result.current.editingItemId).toBe("item-1");
+  });
+
+  it("resets state even if onRegenerate throws", async () => {
+    const failingRegenerate = vi.fn().mockRejectedValue(new Error("boom"));
+    const { result } = renderHook(() =>
+      useMessageEdit({ onRegenerate: failingRegenerate }),
+    );
+    act(() => {
+      result.current.startEdit("item-1", "text");
+    });
+    await act(async () => {
+      await result.current.executeRegenerate().catch(() => {});
+    });
+    expect(result.current.editingItemId).toBeNull();
+    expect(result.current.isRegenerating).toBe(false);
+  });
+
+  it("resets confirming and regenerating when a new edit starts", () => {
+    const { result } = setup();
+    act(() => {
+      result.current.startEdit("item-1", "text");
+    });
+    act(() => {
+      result.current.requestRegenerate();
+    });
+    expect(result.current.isConfirming).toBe(true);
+    act(() => {
+      result.current.startEdit("item-2", "other text");
+    });
+    expect(result.current.editingItemId).toBe("item-2");
+    expect(result.current.isConfirming).toBe(false);
+    expect(result.current.isRegenerating).toBe(false);
+  });
+
+  it("ignores startEdit while regenerate is already in flight", async () => {
+    let resolveRegenerate: (() => void) | null = null;
+    const pendingRegenerate = vi.fn(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveRegenerate = resolve;
+        }),
+    );
+    const { result } = renderHook(() =>
+      useMessageEdit({ onRegenerate: pendingRegenerate }),
+    );
+
+    act(() => {
+      result.current.startEdit("item-1", "text");
+    });
+
+    await act(async () => {
+      void result.current.executeRegenerate();
+    });
+
+    expect(result.current.isRegenerating).toBe(true);
+
+    act(() => {
+      result.current.startEdit("item-2", "other text");
+    });
+
+    expect(result.current.editingItemId).toBe("item-1");
+
+    await act(async () => {
+      resolveRegenerate?.();
+    });
+  });
+});
diff --git a/src/features/messages/hooks/useMessageEdit.ts b/src/features/messages/hooks/useMessageEdit.ts
new file mode 100644
index 000000000..5be099975
--- /dev/null
+++ b/src/features/messages/hooks/useMessageEdit.ts
@@ -0,0 +1,113 @@
+import { useCallback, useState } from "react";
+
+type EditState = {
+  itemId: string;
+  originalText: string;
+  editText: string;
+  images: string[];
+};
+
+export type UseMessageEditResult = {
+  /** The item ID currently being edited, or null if no edit is active */
+  editingItemId: string | null;
+  /** The current edited text */
+  editText: string;
+  /** The original images from the message being edited */
+  editImages: string[];
+  /** Whether the confirmation dialog is shown */
+  isConfirming: boolean;
+  /** Whether the regenerate request is in flight */
+  isRegenerating: boolean;
+  /** Start editing a user message */
+  startEdit: (itemId: string, text: string, images?: string[]) => void;
+  /** Cancel editing and return to normal view */
+  cancelEdit: () => void;
+  /** Update the edit text */
+  updateEditText: (text: string) => void;
+  /** Open the confirmation dialog before regenerating */
+  requestRegenerate: () => void;
+  /** Dismiss the confirmation dialog */
+  cancelConfirm: () => void;
+  /** Execute the regenerate after confirmation */
+  executeRegenerate: () => Promise<void>;
+};
+
+type UseMessageEditOptions = {
+  onRegenerate: (itemId: string, newText: string, images: string[]) => Promise<void>;
+};
+
+export function useMessageEdit({ onRegenerate }: UseMessageEditOptions): UseMessageEditResult {
+  const [editState, setEditState] = useState<EditState | null>(null);
+  const [isConfirming, setIsConfirming] = useState(false);
+  const [isRegenerating, setIsRegenerating] = useState(false);
+
+  const startEdit = useCallback(
+    (itemId: string, text: string, images: string[] = []) => {
+      if (isRegenerating) {
+        return;
+      }
+      setEditState({ itemId, originalText: text, editText: text, images });
+      setIsConfirming(false);
+      setIsRegenerating(false);
+    },
+    [isRegenerating],
+  );
+
+  const cancelEdit = useCallback(() => {
+    setEditState(null);
+    setIsConfirming(false);
+    setIsRegenerating(false);
+  }, []);
+
+  const updateEditText = useCallback((text: string) => {
+    setEditState((previous) => {
+      if (!previous) {
+        return previous;
+      }
+      return { ...previous, editText: text };
+    });
+  }, []);
+
+  const requestRegenerate = useCallback(() => {
+    if (!editState) {
+      return;
+    }
+    setIsConfirming(true);
+  }, [editState]);
+
+  const cancelConfirm = useCallback(() => {
+    setIsConfirming(false);
+  }, []);
+
+  const executeRegenerate = useCallback(async () => {
+    if (!editState) {
+      return;
+    }
+    const trimmed = editState.editText.trim();
+    if (!trimmed) {
+      return;
+    }
+    setIsRegenerating(true);
+    setIsConfirming(false);
+    try {
+      await onRegenerate(editState.itemId, trimmed, editState.images);
+    } finally {
+      setEditState(null);
+      setIsRegenerating(false);
+    }
+  }, [editState, onRegenerate]);
+
+  return {
+    editingItemId: editState?.itemId ?? null,
+    editText: editState?.editText ?? "",
+    editImages: editState?.images ?? [],
+    isConfirming,
+    isRegenerating,
+    startEdit,
+    cancelEdit,
+    updateEditText,
+    requestRegenerate,
+    cancelConfirm,
+    executeRegenerate,
+  };
+}
diff --git a/src/features/threads/hooks/threadReducer/threadItemsSlice.ts b/src/features/threads/hooks/threadReducer/threadItemsSlice.ts
index e1b77c6a9..0e77225a3 100644
--- a/src/features/threads/hooks/threadReducer/threadItemsSlice.ts
+++ b/src/features/threads/hooks/threadReducer/threadItemsSlice.ts
@@ -327,6 +327,21 @@ export function reduceThreadItems(state: ThreadState, action: ThreadAction): Thr
         },
       };
     }
+    case "truncateThreadItems": {
+      const list = state.itemsByThread[action.threadId] ?? [];
+      const index = list.findIndex((entry) => entry.id === action.afterItemId);
+      if (index < 0) {
+        return state;
+      }
+      const truncated = list.slice(0, index);
+      return {
+        ...state,
+        itemsByThread: {
+          ...state.itemsByThread,
+          [action.threadId]: prepareThreadItems(truncated, { maxItemsPerThread: state.maxItemsPerThread }),
+        },
+      };
+    }
     default:
       return state;
   }
diff --git a/src/features/threads/hooks/useThreadMessaging.test.tsx b/src/features/threads/hooks/useThreadMessaging.test.tsx
index ecd6a301c..bb20bd69a 100644
--- a/src/features/threads/hooks/useThreadMessaging.test.tsx
+++ b/src/features/threads/hooks/useThreadMessaging.test.tsx
@@ -10,8 +10,9 @@ import {
   getAppsList as getAppsListService,
   listMcpServerStatus as listMcpServerStatusService,
   compactThread as compactThreadService,
+  rollbackThread as rollbackThreadService,
 } from "@services/tauri";
-import type { WorkspaceInfo } from "@/types";
+import type { ConversationItem, WorkspaceInfo } from "@/types";
 import { useThreadMessaging } from "./useThreadMessaging";
 
 vi.mock("@sentry/react", () => ({
@@ -28,6 +29,7 @@ vi.mock("@services/tauri", () => ({
   getAppsList: vi.fn(),
   listMcpServerStatus: vi.fn(),
   compactThread: vi.fn(),
+  rollbackThread: vi.fn(),
 }));
 
 vi.mock("./useReviewPrompt", () => ({
@@ -95,11 +97,13 @@ describe("useThreadMessaging telemetry", () => {
     vi.mocked(compactThreadService).mockResolvedValue(
       {} as Awaited<ReturnType<typeof compactThreadService>>,
     );
+    vi.mocked(rollbackThreadService).mockResolvedValue(
+      undefined as Awaited<ReturnType<typeof rollbackThreadService>>,
+    );
   });
 
-  it("records prompt_sent once for one message send", async () => {
-    const ensureWorkspaceRuntimeCodexArgs = vi.fn(async () => undefined);
-    const { result } = renderHook(() =>
+  function renderUseThreadMessaging(overrides: Partial<Parameters<typeof useThreadMessaging>[0]> = {}) {
+    return renderHook(() =>
       useThreadMessaging({
         activeWorkspace: workspace,
         activeThreadId: "thread-1",
@@ -110,7 +114,6 @@ describe("useThreadMessaging telemetry", () => {
         reviewDeliveryMode: "inline",
         steerEnabled: false,
         customPrompts: [],
-        ensureWorkspaceRuntimeCodexArgs,
         threadStatusById: {},
         activeTurnIdByThread: {},
         rateLimitsByWorkspace: {},
@@ -129,8 +132,17 @@ describe("useThreadMessaging telemetry", () => {
         refreshThread: vi.fn(async () => null),
         forkThreadForWorkspace: vi.fn(async () => null),
         updateThreadParent: vi.fn(),
+        getItemsForThread: vi.fn(() => []),
+        ...overrides,
       }),
     );
+  }
+
+  it("records prompt_sent once for one message send", async () => {
+    const ensureWorkspaceRuntimeCodexArgs = vi.fn(async () => undefined);
+    const { result } = renderUseThreadMessaging({
+      ensureWorkspaceRuntimeCodexArgs,
+    });
 
     await act(async () => {
       await result.current.sendUserMessageToThread(
@@ -159,37 +171,7 @@ describe("useThreadMessaging telemetry", () => {
   });
 
   it("forwards explicit app mentions to turn/start", async () => {
-    const { result } = renderHook(() =>
-      useThreadMessaging({
-        activeWorkspace: workspace,
-        activeThreadId: "thread-1",
-        accessMode: "current",
-        model: null,
-        effort: null,
-        collaborationMode: null,
-        reviewDeliveryMode: "inline",
-        steerEnabled: false,
-        customPrompts: [],
-        threadStatusById: {},
-        activeTurnIdByThread: {},
-        rateLimitsByWorkspace: {},
-        pendingInterruptsRef: { current: new Set<string>() },
-        dispatch: vi.fn(),
-        getCustomName: vi.fn(() => undefined),
-        markProcessing: vi.fn(),
-        markReviewing: vi.fn(),
-        setActiveTurnId: vi.fn(),
-        recordThreadActivity: vi.fn(),
-        safeMessageActivity: vi.fn(),
-        onDebug: vi.fn(),
-        pushThreadErrorMessage: vi.fn(),
-        ensureThreadForActiveWorkspace: vi.fn(async () => "thread-1"),
-        ensureThreadForWorkspace: vi.fn(async () => "thread-1"),
-        refreshThread: vi.fn(async () => null),
-        forkThreadForWorkspace: vi.fn(async () => null),
-        updateThreadParent: vi.fn(),
-      }),
-    );
+    const { result } = renderUseThreadMessaging();
 
     await act(async () => {
       await result.current.sendUserMessage("hello $calendar", [], [
@@ -782,4 +764,91 @@ describe("useThreadMessaging telemetry", () => {
       "Review abcdef1: Tighten sidebar commit…",
     );
   });
+
+  it("rolls back by owning turn id when regenerating an edited message", async () => {
+    const items: ConversationItem[] = [
+      {
+        id: "item-user-1",
+        turnId: "turn-9",
+        kind: "message",
+        role: "user",
+        text: "Original prompt",
+      },
+    ];
+    const dispatch = vi.fn();
+
+    const { result } = renderUseThreadMessaging({
+      dispatch,
+      getItemsForThread: vi.fn(() => items),
+    });
+
+    await act(async () => {
+      await result.current.editAndRegenerateMessage(
+        workspace,
+        "thread-1",
+        "item-user-1",
+        "Edited prompt",
+      );
+    });
+
+    expect(rollbackThreadService).toHaveBeenCalledWith("ws-1", "thread-1", "turn-9");
+    expect(rollbackThreadService).not.toHaveBeenCalledWith("ws-1", "thread-1", "item-user-1");
+    expect(dispatch).toHaveBeenCalledWith({
+      type: "truncateThreadItems",
+      threadId: "thread-1",
+      afterItemId: "item-user-1",
+    });
+    expect(sendUserMessageService).toHaveBeenCalledWith(
+      "ws-1",
+      "thread-1",
+      "Edited prompt",
+      expect.any(Object),
+    );
+  });
+
+  it("does not truncate or resend when rollback returns an rpc error", async () => {
+    const items: ConversationItem[] = [
+      {
+        id: "item-user-1",
+        turnId: "turn-9",
+        kind: "message",
+        role: "user",
+        text: "Original prompt",
+      },
+    ];
+    const dispatch = vi.fn();
+    const pushThreadErrorMessage = vi.fn();
+    vi.mocked(rollbackThreadService).mockResolvedValueOnce({
+      error: { message: "rollback failed" },
+    } as Awaited<ReturnType<typeof rollbackThreadService>>);
+
+    const { result } = renderUseThreadMessaging({
+      dispatch,
+      pushThreadErrorMessage,
+      getItemsForThread: vi.fn(() => items),
+    });
+
+    await act(async () => {
+      await result.current.editAndRegenerateMessage(
+        workspace,
+        "thread-1",
+        "item-user-1",
+        "Edited prompt",
+      );
+    });
+
+    expect(rollbackThreadService).toHaveBeenCalledWith("ws-1", "thread-1", "turn-9");
+    expect(dispatch).not.toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: "truncateThreadItems",
+      }),
+    );
+    expect(sendUserMessageService).not.toHaveBeenCalledWith(
+      "ws-1",
+      "thread-1",
+      "Edited prompt",
+      expect.anything(),
+    );
+    expect(pushThreadErrorMessage).toHaveBeenCalledWith("thread-1", "rollback failed");
+  });
 });
diff --git a/src/features/threads/hooks/useThreadMessaging.ts b/src/features/threads/hooks/useThreadMessaging.ts
index 291f5c8f7..3468568c2 100644
--- a/src/features/threads/hooks/useThreadMessaging.ts
+++ b/src/features/threads/hooks/useThreadMessaging.ts
@@ -4,6 +4,7 @@ import * as Sentry from "@sentry/react";
 import type {
   AppMention,
   ComposerSendIntent,
+  ConversationItem,
   RateLimitSnapshot,
   CustomPromptOption,
   DebugEntry,
@@ -20,6 +21,7 @@ import {
   interruptTurn as interruptTurnService,
   getAppsList as getAppsListService,
   listMcpServerStatus as listMcpServerStatusService,
+  rollbackThread as rollbackThreadService,
 } from "@services/tauri";
 import { expandCustomPromptText } from "@utils/customPrompts";
 import {
@@ -94,6 +96,7 @@ type UseThreadMessagingOptions = {
     childId: string,
   ) => void;
   renameThread?: (workspaceId: string, threadId: string, name: string) => void;
+  getItemsForThread?: (threadId: string) => ConversationItem[];
 };
 
 export function useThreadMessaging({
@@ -130,7 +133,26 @@ export function useThreadMessaging({
   updateThreadParent,
   registerDetachedReviewChild,
   renameThread,
+  getItemsForThread = () => [],
 }: UseThreadMessagingOptions) {
+  const resolveRollbackTurnId = useCallback(
+    async (workspace: WorkspaceInfo, threadId: string, itemId: string) => {
+      const readTurnId = () => {
+        const item = getItemsForThread(threadId).find((entry) => entry.id === itemId);
+        return item?.kind === "message" ? item.turnId?.trim() || null : null;
+      };
+
+      const localTurnId = readTurnId();
+      if (localTurnId) {
+        return localTurnId;
+      }
+
+      await refreshThread(workspace.id, threadId);
+      return readTurnId();
+    },
+    [getItemsForThread, refreshThread],
+  );
+
   const sendMessageToThread = useCallback(
     async (
       workspace: WorkspaceInfo,
@@ -932,10 +954,62 @@ export function useThreadMessaging({
     ],
   );
 
+  const editAndRegenerateMessage = useCallback(
+    async (
+      workspace: WorkspaceInfo,
+      threadId: string,
+      itemId: string,
+      text: string,
+      images: string[] = [],
+    ) => {
+      const isProcessing = threadStatusById[threadId]?.isProcessing ?? false;
+      if (isProcessing) {
+        return;
+      }
+      try {
+        const rollbackTurnId = await resolveRollbackTurnId(workspace, threadId, itemId);
+        if (!rollbackTurnId) {
+          throw new Error("Failed to determine the turn for the edited message.");
+        }
+        const rollbackResponse = await rollbackThreadService(
+          workspace.id,
+          threadId,
+          rollbackTurnId,
+        );
+        const rollbackError = extractRpcErrorMessage(rollbackResponse);
+        if (rollbackError) {
+          throw new Error(rollbackError);
+        }
+        dispatch({
+          type: "truncateThreadItems",
+          threadId,
+          afterItemId: itemId,
+        });
+        await sendMessageToThread(workspace, threadId, text, images);
+      } catch (error) {
+        pushThreadErrorMessage(
+          threadId,
+          error instanceof Error ? error.message : "Failed to rollback thread.",
+        );
+      } finally {
+        safeMessageActivity();
+      }
+    },
+    [
+      dispatch,
+      pushThreadErrorMessage,
+      resolveRollbackTurnId,
+      safeMessageActivity,
+      sendMessageToThread,
+      threadStatusById,
+    ],
+  );
+
   return {
     interruptTurn,
     sendUserMessage,
     sendUserMessageToThread,
+    editAndRegenerateMessage,
     startFork,
     startReview,
     startUncommittedReview,
diff --git a/src/features/threads/hooks/useThreads.ts b/src/features/threads/hooks/useThreads.ts
index 26278651c..b940b5b83 100644
--- a/src/features/threads/hooks/useThreads.ts
+++ b/src/features/threads/hooks/useThreads.ts
@@ -729,6 +729,7 @@ export function useThreads({
     interruptTurn,
     sendUserMessage,
     sendUserMessageToThread,
+    editAndRegenerateMessage,
     startFork,
     startReview,
     startUncommittedReview,
@@ -792,6 +793,7 @@ export function useThreads({
     updateThreadParent,
     registerDetachedReviewChild,
     renameThread,
+    getItemsForThread: (threadId) => itemsByThreadRef.current[threadId] ?? [],
   });
 
   const hasLocalThreadSnapshot = useCallback(
@@ -901,6 +903,7 @@ export function useThreads({
     loadOlderThreadsForWorkspace,
     sendUserMessage,
     sendUserMessageToThread,
+    editAndRegenerateMessage,
     startFork,
     startReview,
     startUncommittedReview,
diff --git a/src/features/threads/hooks/useThreadsReducer.test.ts b/src/features/threads/hooks/useThreadsReducer.test.ts
index 2ec1d98d0..f79f10cee 100644
--- a/src/features/threads/hooks/useThreadsReducer.test.ts
+++ b/src/features/threads/hooks/useThreadsReducer.test.ts
@@ -744,4 +744,81 @@ describe("threadReducer", () => {
     expect(trimmed.itemsByThread["thread-1"]?.[0]?.id).toBe("msg-2");
   });
 
+  it("truncates thread items before a given item id", () => {
+    const items: ConversationItem[] = [
+      { id: "msg-0", kind: "message", role: "user", text: "first" },
+      { id: "msg-1", kind: "message", role: "assistant", text: "second" },
+      { id: "msg-2", kind: "message", role: "user", text: "third" },
+      { id: "msg-3", kind: "message", role: "assistant", text: "fourth" },
+    ];
+
+    const withItems = threadReducer(initialState, {
+      type: "setThreadItems",
+      threadId: "thread-1",
+      items,
+    });
+
+    const truncated = threadReducer(withItems, {
+      type: "truncateThreadItems",
+      threadId: "thread-1",
+      afterItemId: "msg-2",
+    });
+
+    const remaining = truncated.itemsByThread["thread-1"] ?? [];
+    expect(remaining).toHaveLength(2);
+    expect(remaining.map((item) => item.id)).toEqual(["msg-0", "msg-1"]);
+  });
+
+  it("returns unchanged state when afterItemId is not found", () => {
+    const items: ConversationItem[] = [
+      { id: "msg-0", kind: "message", role: "user", text: "first" },
+    ];
+
+    const withItems = threadReducer(initialState, {
+      type: "setThreadItems",
+      threadId: "thread-1",
+      items,
+    });
+
+    const result = threadReducer(withItems, {
+      type: "truncateThreadItems",
+      threadId: "thread-1",
+      afterItemId: "nonexistent",
+    });
+
+    expect(result).toBe(withItems);
+  });
+
+  it("returns unchanged state when truncating on an empty thread", () => {
+    const result = threadReducer(initialState, {
+      type: "truncateThreadItems",
+      threadId: "thread-1",
+      afterItemId: "msg-0",
+    });
+
+    expect(result).toBe(initialState);
+  });
+
+  it("truncates to empty when afterItemId is the first item", () => {
+    const items: ConversationItem[] = [
+      { id: "msg-0", kind: "message", role: "user", text: "first" },
+      { id: "msg-1", kind: "message", role: "assistant", text: "second" },
+    ];
+
+    const withItems = threadReducer(initialState, {
+      type: "setThreadItems",
+      threadId: "thread-1",
+      items,
+    });
+
+    const truncated = threadReducer(withItems, {
+      type: "truncateThreadItems",
+      threadId: "thread-1",
+      afterItemId: "msg-0",
+    });
+
+    const remaining = truncated.itemsByThread["thread-1"] ?? [];
+    expect(remaining).toHaveLength(0);
+  });
+
 });
diff --git a/src/features/threads/hooks/useThreadsReducer.ts b/src/features/threads/hooks/useThreadsReducer.ts
index 044cfe41d..82b3d326e 100644
--- a/src/features/threads/hooks/useThreadsReducer.ts
+++ b/src/features/threads/hooks/useThreadsReducer.ts
@@ -175,6 +175,11 @@ export type ThreadAction =
       threadId: string;
       text: string;
       timestamp: number;
+    }
+  | {
+      type: "truncateThreadItems";
+      threadId: string;
+      afterItemId: string;
     };
 
 const emptyItems: Record<string, ConversationItem[]> = {};
diff --git a/src/services/tauri.ts b/src/services/tauri.ts
index 029e0d31b..c77b5c0d0 100644
--- a/src/services/tauri.ts
+++ b/src/services/tauri.ts
@@ -1077,7 +1077,15 @@ export async function threadLiveUnsubscribe(workspaceId: string, threadId: strin
 }
 
 export async function archiveThread(workspaceId: string, threadId: string) {
-  return invoke<any>("archive_thread", { workspaceId, threadId });
+  return invoke<void>("archive_thread", { workspaceId, threadId });
+}
+
+export async function rollbackThread(
+  workspaceId: string,
+  threadId: string,
+  turnId: string,
+) {
+  return invoke<any>("rollback_thread", { workspaceId, threadId, turnId });
 }
 
 export async function setThreadName(
diff --git a/src/styles/messages.css b/src/styles/messages.css
index 795066974..fe6644e90 100644
--- a/src/styles/messages.css
+++ b/src/styles/messages.css
@@ -230,8 +230,25 @@
   transition: opacity 160ms ease, transform 160ms ease;
 }
 
+.message-edit-button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  position: absolute;
+  right: 62px;
+  bottom: -12px;
+  padding: 4px;
+  border-radius: 999px;
+  background: var(--surface-card-strong);
+  border: 1px solid var(--border-strong);
+  opacity: 0;
+  transform: translateY(4px);
+  transition: opacity 160ms ease, transform 160ms ease;
+}
+
 .message:hover .message-copy-button,
-.message:hover .message-quote-button {
+.message:hover .message-quote-button,
+.message:hover .message-edit-button {
   opacity: 1;
   transform: translateY(0);
 }
@@ -276,6 +293,107 @@
   filter: blur(0);
 }
 
+.message-bubble-editing {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  min-width: 320px;
+}
+
+.message-edit-textarea {
+  width: 100%;
+  background: var(--cm-surface-panel-strong);
+  border: 1px solid var(--cm-border-soft);
+  color: var(--text-stronger);
+  border-radius: 8px;
+  padding: 10px 12px;
+  font-family: inherit;
+  font-size: 14px;
+  line-height: 1.5;
+  resize: vertical;
+  min-height: 80px;
+  max-height: 500px;
+  outline: none;
+}
+
+.message-edit-textarea:focus {
+  border-color: var(--border-accent);
+}
+
+.message-edit-actions {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 8px;
+}
+
+.message-edit-cancel,
+.message-edit-regenerate,
+.message-edit-confirm-cancel,
+.message-edit-confirm-proceed {
+  padding: 6px 12px;
+  border-radius: 6px;
+  font-size: 13px;
+  font-weight: 500;
+  cursor: pointer;
+  border: 1px solid transparent;
+}
+
+.message-edit-cancel,
+.message-edit-confirm-cancel {
+  background: transparent;
+  color: var(--text-muted);
+}
+.message-edit-cancel:hover,
+.message-edit-confirm-cancel:hover {
+  background: var(--cm-surface-hover);
+  color: var(--text-stronger);
+}
+
+.message-edit-regenerate,
+.message-edit-confirm-proceed {
+  background: var(--surface-accent);
+  color: var(--text-on-accent);
+}
+.message-edit-regenerate:hover,
+.message-edit-confirm-proceed:hover {
+  background: var(--surface-accent-hover);
+}
+.message-edit-regenerate:disabled,
+.message-edit-confirm-proceed:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.message-edit-confirm {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  padding: 12px;
+  border-radius: 8px;
+  background: color-mix(in srgb, var(--status-warning) 15%, transparent);
+  border: 1px solid color-mix(in srgb, var(--status-warning) 30%, transparent);
+}
+
+.message-edit-confirm-warning {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  color: var(--text-stronger);
+  font-size: 13px;
+  font-weight: 500;
+}
+
+.message-edit-confirm-warning svg {
+  color: var(--status-warning);
+}
+
+.message-edit-confirm-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+}
+
 .message.user .bubble {
   max-width: min(72%, 560px);
   background: var(--cm-surface-panel-active);
@@ -799,6 +917,7 @@
 .tool-inline-clamp {
   display: -webkit-box;
   -webkit-line-clamp: 3;
+  line-clamp: 3;
   -webkit-box-orient: vertical;
   overflow: hidden;
 }
@@ -806,6 +925,7 @@
 .tool-inline-expanded .tool-inline-clamp {
   display: block;
   -webkit-line-clamp: unset;
+  line-clamp: unset;
   -webkit-box-orient: unset;
   overflow: visible;
 }
diff --git a/src/types.ts b/src/types.ts
index 51b1515c9..8c107af0b 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -100,6 +100,7 @@ export type CollabAgentStatus = CollabAgentRef & {
 export type ConversationItem =
   | {
       id: string;
+      turnId?: string;
       kind: "message";
       role: "user" | "assistant";
       text: string;
diff --git a/src/utils/threadItems.conversion.ts b/src/utils/threadItems.conversion.ts
index efc4a9c39..e2de30d47 100644
--- a/src/utils/threadItems.conversion.ts
+++ b/src/utils/threadItems.conversion.ts
@@ -2,6 +2,10 @@ import type { ConversationItem } from "../types";
 import { parseCollabToolCallItem } from "./threadItems.collab";
 import { asNumber, asString } from "./threadItems.shared";
 
+function extractTurnId(record: Record<string, unknown>) {
+  return asString(record.turnId ?? record.turn_id ?? record.id).trim();
+}
+
 function extractImageInputValue(input: Record<string, unknown>) {
   const value =
     asString(input.url ?? "") ||
@@ -46,6 +50,7 @@ export function buildConversationItem(
 ): ConversationItem | null {
   const type = asString(item.type);
   const id = asString(item.id);
+  const turnId = extractTurnId(item);
   if (!id || !type) {
     return null;
   }
@@ -57,6 +62,7 @@ export function buildConversationItem(
     const { text, images } = parseUserInputs(content as Array<Record<string, unknown>>);
     return {
       id,
+      ...(turnId ? { turnId } : {}),
       kind: "message",
       role: "user",
       text,
@@ -208,9 +214,11 @@ export function buildConversationItem(
 
 export function buildConversationItemFromThreadItem(
   item: Record<string, unknown>,
+  turnIdOverride?: string,
 ): ConversationItem | null {
   const type = asString(item.type);
   const id = asString(item.id);
+  const turnId = turnIdOverride || extractTurnId(item);
   if (!id || !type) {
     return null;
   }
@@ -219,6 +227,7 @@ export function buildConversationItemFromThreadItem(
     const { text, images } = parseUserInputs(content as Array<Record<string, unknown>>);
     return {
       id,
+      ...(turnId ? { turnId } : {}),
       kind: "message",
       role: "user",
       text,
@@ -228,6 +237,7 @@ export function buildConversationItemFromThreadItem(
   if (type === "agentMessage") {
     return {
       id,
+      ...(turnId ? { turnId } : {}),
       kind: "message",
       role: "assistant",
       text: asString(item.text),
@@ -250,11 +260,12 @@ export function buildItemsFromThread(thread: Record<string, unknown>) {
   const items: ConversationItem[] = [];
   turns.forEach((turn) => {
     const turnRecord = turn as Record<string, unknown>;
+    const turnId = extractTurnId(turnRecord);
     const turnItems = Array.isArray(turnRecord.items)
       ? (turnRecord.items as Record<string, unknown>[])
       : [];
     turnItems.forEach((item) => {
-      const converted = buildConversationItemFromThreadItem(item);
+      const converted = buildConversationItemFromThreadItem(item, turnId);
       if (converted) {
         items.push(converted);
       }
diff --git a/src/utils/threadItems.test.ts b/src/utils/threadItems.test.ts
index fcf131192..a6441d122 100644
--- a/src/utils/threadItems.test.ts
+++ b/src/utils/threadItems.test.ts
@@ -3,6 +3,7 @@ import type { ConversationItem } from "../types";
 import {
   buildConversationItem,
   buildConversationItemFromThreadItem,
+  buildItemsFromThread,
   getThreadCreatedTimestamp,
   getThreadTimestamp,
   mergeThreadItems,
@@ -900,6 +901,62 @@ describe("threadItems", () => {
     }
   });
 
+  it("preserves owning turn ids when building items from a thread", () => {
+    const items = buildItemsFromThread({
+      turns: [
+        {
+          id: "turn-1",
+          items: [
+            {
+              id: "item-1",
+              type: "userMessage",
+              content: [{ type: "text", text: "Hello" }],
+            },
+            {
+              id: "item-2",
+              type: "agentMessage",
+              text: "Hi",
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(items).toEqual([
+      {
+        id: "item-1",
+        turnId: "turn-1",
+        kind: "message",
+        role: "user",
+        text: "Hello",
+      },
+      {
+        id: "item-2",
+        turnId: "turn-1",
+        kind: "message",
+        role: "assistant",
+        text: "Hi",
+      },
+    ]);
+  });
+
+  it("prefers explicit turn ids over item ids when both are present", () => {
+    const item = buildConversationItem({
+      id: "item-1",
+      turnId: "turn-1",
+      type: "userMessage",
+      content: [{ type: "text", text: "Hello" }],
+    });
+
+    expect(item).toEqual({
+      id: "item-1",
+      turnId: "turn-1",
+      kind: "message",
+      role: "user",
+      text: "Hello",
+    });
+  });
+
   it("parses ISO timestamps for thread updates", () => {
     const timestamp = getThreadTimestamp({ updated_at: "2025-01-01T00:00:00Z" });
     expect(timestamp).toBe(Date.parse("2025-01-01T00:00:00Z"));