fix(webview): edited messages replace original and send immediately

- Truncate from preceding user_feedback message
- Remove timestamp fallback logic
- Update tests to match new behavior

Author: daniel-lxs

src/core/webview/ClineProvider.ts

@@ -917,23 +917,9 @@ export class ClineProvider
 						// Remove the target message and all subsequent messages
 						await task.overwriteClineMessages(task.clineMessages.slice(0, messageIndex))
 
-						// Apply timestamp-based fallback if exact API index not found
-						let effectiveApiIndex = apiConversationHistoryIndex
-						if (apiConversationHistoryIndex === -1 && task.apiConversationHistory.length > 0) {
-							// Find the first API message with timestamp >= messageTs
-							// This ensures we remove any assistant responses that came after the edited user message
-							const fallbackIndex = task.apiConversationHistory.findIndex((msg: any) => {
-								return msg.ts && msg.ts >= pendingEdit.messageTs
-							})
-
-							if (fallbackIndex !== -1) {
-								effectiveApiIndex = fallbackIndex
-							}
-						}
-
-						if (effectiveApiIndex !== -1) {
+						if (apiConversationHistoryIndex !== -1) {
 							await task.overwriteApiConversationHistory(
-								task.apiConversationHistory.slice(0, effectiveApiIndex),
+								task.apiConversationHistory.slice(0, apiConversationHistoryIndex),
 							)
 						}
 

src/core/webview/__tests__/ClineProvider.spec.ts

@@ -1332,19 +1332,11 @@ describe("ClineProvider", () => {
 				text: "Edited message content",
 			})
 
-			// Verify correct messages were kept (only messages before the edited one)
-			expect(mockCline.overwriteClineMessages).toHaveBeenCalledWith([
-				mockMessages[0],
-				mockMessages[1],
-				mockMessages[2],
-			])
+			// Verify correct messages were kept - delete from the preceding user message to truly replace it
+			expect(mockCline.overwriteClineMessages).toHaveBeenCalledWith([])
 
-			// Verify correct API messages were kept (only messages before the edited one)
-			expect(mockCline.overwriteApiConversationHistory).toHaveBeenCalledWith([
-				mockApiHistory[0],
-				mockApiHistory[1],
-				mockApiHistory[2],
-			])
+			// Verify correct API messages were kept
+			expect(mockCline.overwriteApiConversationHistory).toHaveBeenCalledWith([])
 
 			// The new flow calls webviewMessageHandler recursively with askResponse
 			// We need to verify the recursive call happened by checking if the handler was called again
@@ -3046,9 +3038,9 @@ describe("ClineProvider - Comprehensive Edit/Delete Edge Cases", () => {
 				text: "Edited message with preserved images",
 			})
 
-			// Verify messages were edited correctly - messages up to the edited message should remain
-			expect(mockCline.overwriteClineMessages).toHaveBeenCalledWith([mockMessages[0], mockMessages[1]])
-			expect(mockCline.overwriteApiConversationHistory).toHaveBeenCalledWith([{ ts: 1000 }, { ts: 2000 }])
+			// Verify messages were edited correctly - the ORIGINAL user message and all subsequent messages are removed
+			expect(mockCline.overwriteClineMessages).toHaveBeenCalledWith([mockMessages[0]])
+			expect(mockCline.overwriteApiConversationHistory).toHaveBeenCalledWith([{ ts: 1000 }])
 		})
 
 		test("handles editing messages with file attachments", async () => {

src/test/webviewMessageHandler.delete.spec.ts renamed to src/core/webview/__tests__/webviewMessageHandler.delete.spec.ts

@@ -1,15 +1,15 @@
 import { describe, it, expect, beforeEach, vi } from "vitest"
-import { webviewMessageHandler } from "../core/webview/webviewMessageHandler"
+import { webviewMessageHandler } from "../webviewMessageHandler"
 import * as vscode from "vscode"
-import { ClineProvider } from "../core/webview/ClineProvider"
+import { ClineProvider } from "../ClineProvider"
 
 // Mock the saveTaskMessages function
-vi.mock("../core/task-persistence", () => ({
+vi.mock("../../task-persistence", () => ({
 	saveTaskMessages: vi.fn(),
 }))
 
 // Mock the i18n module
-vi.mock("../i18n", () => ({
+vi.mock("../../../i18n", () => ({
 	t: vi.fn((key: string) => key),
 	changeLanguage: vi.fn(),
 }))
@@ -79,7 +79,7 @@ describe("webviewMessageHandler delete functionality", () => {
 	})
 
 	describe("handleDeleteMessageConfirm", () => {
-		it("should handle deletion when apiConversationHistoryIndex is -1 and use timestamp fallback", async () => {
+		it("should handle deletion when apiConversationHistoryIndex is -1 (message not in API history)", async () => {
 			// Setup test data with a user message and assistant response
 			const userMessageTs = 1000
 			const assistantMessageTs = 1001
@@ -110,12 +110,9 @@ describe("webviewMessageHandler delete functionality", () => {
 			// Verify that clineMessages was truncated at the correct index
 			expect(getCurrentTaskMock.overwriteClineMessages).toHaveBeenCalledWith([])
 
-			// Verify that apiConversationHistory was truncated using the timestamp fallback
-			// Since assistantMessageTs >= userMessageTs, it should be removed
-			// Check if the function was called at all
-			expect(getCurrentTaskMock.overwriteApiConversationHistory).toHaveBeenCalled()
-			// Then check what it was called with
-			expect(getCurrentTaskMock.overwriteApiConversationHistory).toHaveBeenCalledWith([])
+			// When message is not found in API history (index is -1),
+			// API history should not be modified
+			expect(getCurrentTaskMock.overwriteApiConversationHistory).not.toHaveBeenCalled()
 		})
 
 		it("should handle deletion when exact apiConversationHistoryIndex is found", async () => {
@@ -203,11 +200,11 @@ describe("webviewMessageHandler delete functionality", () => {
 				messageTs: userMessageTs,
 			})
 
-			// Verify that both arrays were properly truncated
+			// Verify that clineMessages was truncated
 			expect(getCurrentTaskMock.overwriteClineMessages).toHaveBeenCalledWith([])
 
-			// The timestamp fallback should remove everything >= userMessageTs
-			expect(getCurrentTaskMock.overwriteApiConversationHistory).toHaveBeenCalledWith([])
+			// API history should not be modified when message not found
+			expect(getCurrentTaskMock.overwriteApiConversationHistory).not.toHaveBeenCalled()
 		})
 
 		it("should preserve messages before the deleted one", async () => {
@@ -223,6 +220,7 @@ describe("webviewMessageHandler delete functionality", () => {
 			getCurrentTaskMock.apiConversationHistory = [
 				{ ts: 1000, role: "user", content: { type: "text", text: "First message" } },
 				{ ts: 1500, role: "assistant", content: { type: "text", text: "First response" } },
+				{ ts: messageTs, role: "user", content: { type: "text", text: "Delete this" } },
 				{ ts: 2500, role: "assistant", content: { type: "text", text: "Response to delete" } },
 			]
 
@@ -237,7 +235,7 @@ describe("webviewMessageHandler delete functionality", () => {
 				{ ts: 1500, say: "assistant", text: "First response" },
 			])
 
-			// API history should be truncated using timestamp fallback
+			// API history should be truncated at the exact index
 			expect(getCurrentTaskMock.overwriteApiConversationHistory).toHaveBeenCalledWith([
 				{ ts: 1000, role: "user", content: { type: "text", text: "First message" } },
 				{ ts: 1500, role: "assistant", content: { type: "text", text: "First response" } },

src/core/webview/__tests__/webviewMessageHandler.edit.spec.ts

@@ -71,7 +71,7 @@ describe("webviewMessageHandler - Edit Message with Timestamp Fallback", () => {
 		} as unknown as ClineProvider
 	})
 
-	it("should use timestamp-based fallback when apiConversationHistoryIndex is -1", async () => {
+	it("should not modify API history when apiConversationHistoryIndex is -1", async () => {
 		// Setup: User message followed by attempt_completion
 		const userMessageTs = 1000
 		const assistantMessageTs = 2000
@@ -134,15 +134,11 @@ describe("webviewMessageHandler - Edit Message with Timestamp Fallback", () => {
 			[], // All messages before index 0 (empty array)
 		)
 
-		// Verify that API history was truncated using timestamp fallback
-		// The fallback should find the first message with ts >= userMessageTs (1000)
-		// which is the assistant message at ts=2000
-		expect(mockCurrentTask.overwriteApiConversationHistory).toHaveBeenCalledWith(
-			[], // All messages before the assistant message (empty array)
-		)
+		// API history should not be modified when message not found
+		expect(mockCurrentTask.overwriteApiConversationHistory).not.toHaveBeenCalled()
 	})
 
-	it("should preserve messages before the edited message when using timestamp fallback", async () => {
+	it("should preserve messages before the edited message when message not in API history", async () => {
 		const earlierMessageTs = 500
 		const userMessageTs = 1000
 		const assistantMessageTs = 2000
@@ -200,15 +196,8 @@ describe("webviewMessageHandler - Edit Message with Timestamp Fallback", () => {
 			},
 		])
 
-		// Verify API history was truncated to preserve earlier message
-		// Fallback should find first message with ts >= 1000, which is ts=2000
-		expect(mockCurrentTask.overwriteApiConversationHistory).toHaveBeenCalledWith([
-			{
-				ts: earlierMessageTs,
-				role: "user",
-				content: [{ type: "text", text: "Earlier message" }],
-			},
-		])
+		// API history should not be modified when message not found
+		expect(mockCurrentTask.overwriteApiConversationHistory).not.toHaveBeenCalled()
 	})
 
 	it("should not use fallback when exact apiConversationHistoryIndex is found", async () => {
@@ -292,8 +281,7 @@ describe("webviewMessageHandler - Edit Message with Timestamp Fallback", () => {
 		// UI messages truncated
 		expect(mockCurrentTask.overwriteClineMessages).toHaveBeenCalledWith([])
 
-		// API history should not be truncated when fallback finds no matching messages
-		// The effectiveApiIndex remains -1
+		// API history should not be modified when no matching messages found
 		expect(mockCurrentTask.overwriteApiConversationHistory).not.toHaveBeenCalled()
 	})
 
@@ -321,7 +309,7 @@ describe("webviewMessageHandler - Edit Message with Timestamp Fallback", () => {
 		// UI messages should be truncated
 		expect(mockCurrentTask.overwriteClineMessages).toHaveBeenCalledWith([])
 
-		// API history truncation should not be called with empty history
+		// API history should not be modified when message not found
 		expect(mockCurrentTask.overwriteApiConversationHistory).not.toHaveBeenCalled()
 	})
 
@@ -351,7 +339,7 @@ describe("webviewMessageHandler - Edit Message with Timestamp Fallback", () => {
 			} as ClineMessage,
 		]
 
-		// API history with attempt_completion tool use
+		// API history with attempt_completion tool use (user message missing)
 		mockCurrentTask.apiConversationHistory = [
 			{
 				ts: completionTs,
@@ -390,8 +378,7 @@ describe("webviewMessageHandler - Edit Message with Timestamp Fallback", () => {
 		// UI messages truncated at edited message
 		expect(mockCurrentTask.overwriteClineMessages).toHaveBeenCalledWith([])
 
-		// API history should be truncated to remove the completion and feedback
-		// Fallback finds first message with ts >= 1000, which is completionTs (2000)
-		expect(mockCurrentTask.overwriteApiConversationHistory).toHaveBeenCalledWith([])
+		// API history should not be modified when message not found
+		expect(mockCurrentTask.overwriteApiConversationHistory).not.toHaveBeenCalled()
 	})
 })

src/core/webview/webviewMessageHandler.ts

@@ -91,28 +91,13 @@ export const webviewMessageHandler = async (
 		currentCline: any,
 		messageIndex: number,
 		apiConversationHistoryIndex: number,
-		messageTs?: number,
 	) => {
 		// Delete this message and all that follow
 		await currentCline.overwriteClineMessages(currentCline.clineMessages.slice(0, messageIndex))
 
-		// If apiConversationHistoryIndex is -1, use timestamp-based fallback
-		let effectiveApiIndex = apiConversationHistoryIndex
-		if (apiConversationHistoryIndex === -1 && messageTs && currentCline.apiConversationHistory.length > 0) {
-			// Find the first API message with timestamp >= messageTs
-			// This ensures we remove any assistant responses that came after the deleted user message
-			const fallbackIndex = currentCline.apiConversationHistory.findIndex((msg: ApiMessage) => {
-				return msg.ts && msg.ts >= messageTs
-			})
-
-			if (fallbackIndex !== -1) {
-				effectiveApiIndex = fallbackIndex
-			}
-		}
-
-		if (effectiveApiIndex !== -1) {
+		if (apiConversationHistoryIndex !== -1) {
 			await currentCline.overwriteApiConversationHistory(
-				currentCline.apiConversationHistory.slice(0, effectiveApiIndex),
+				currentCline.apiConversationHistory.slice(0, apiConversationHistoryIndex),
 			)
 		}
 	}
@@ -204,12 +189,7 @@ export const webviewMessageHandler = async (
 				}
 
 				// Delete this message and all subsequent messages
-				await removeMessagesThisAndSubsequent(
-					currentCline,
-					messageIndex,
-					apiConversationHistoryIndex,
-					messageTs,
-				)
+				await removeMessagesThisAndSubsequent(currentCline, messageIndex, apiConversationHistoryIndex)
 
 				// Restore checkpoint associations for preserved messages
 				for (const [ts, checkpoint] of preservedCheckpoints) {
@@ -332,32 +312,41 @@ export const webviewMessageHandler = async (
 				}
 			}
 
-			// For non-checkpoint edits, preserve checkpoint associations for remaining messages
+			// For non-checkpoint edits, remove the ORIGINAL user message being edited and all subsequent messages
+			// Determine the correct starting index to delete from (prefer the last preceding user_feedback message)
+			let deleteFromMessageIndex = messageIndex
+			let deleteFromApiIndex = apiConversationHistoryIndex
+
+			// Find the nearest preceding user message to ensure we replace the original, not just the assistant reply
+			for (let i = messageIndex; i >= 0; i--) {
+				const m = currentCline.clineMessages[i]
+				if (m?.say === "user_feedback") {
+					deleteFromMessageIndex = i
+					// Align API history truncation to the same user message timestamp if present
+					const userTs = m.ts
+					if (typeof userTs === "number") {
+						const apiIdx = currentCline.apiConversationHistory.findIndex(
+							(am: ApiMessage) => am.ts === userTs,
+						)
+						if (apiIdx !== -1) {
+							deleteFromApiIndex = apiIdx
+						}
+					}
+					break
+				}
+			}
+
 			// Store checkpoints from messages that will be preserved
 			const preservedCheckpoints = new Map<number, any>()
-			for (let i = 0; i < messageIndex; i++) {
+			for (let i = 0; i < deleteFromMessageIndex; i++) {
 				const msg = currentCline.clineMessages[i]
 				if (msg?.checkpoint && msg.ts) {
 					preservedCheckpoints.set(msg.ts, msg.checkpoint)
 				}
 			}
 
-			// Edit this message and delete subsequent
-			// If apiConversationHistoryIndex is -1, use timestamp-based fallback
-			let effectiveApiIndex = apiConversationHistoryIndex
-			if (apiConversationHistoryIndex === -1 && currentCline.apiConversationHistory.length > 0) {
-				// Find the first API message with timestamp >= messageTs
-				// This ensures we remove any assistant responses that came after the edited user message
-				const fallbackIndex = currentCline.apiConversationHistory.findIndex((msg: ApiMessage) => {
-					return msg.ts && msg.ts >= messageTs
-				})
-
-				if (fallbackIndex !== -1) {
-					effectiveApiIndex = fallbackIndex
-				}
-			}
-
-			await removeMessagesThisAndSubsequent(currentCline, messageIndex, effectiveApiIndex)
+			// Delete the original (user) message and all subsequent messages
+			await removeMessagesThisAndSubsequent(currentCline, deleteFromMessageIndex, deleteFromApiIndex)
 
 			// Restore checkpoint associations for preserved messages
 			for (const [ts, checkpoint] of preservedCheckpoints) {
@@ -374,16 +363,12 @@ export const webviewMessageHandler = async (
 				globalStoragePath: provider.contextProxy.globalStorageUri.fsPath,
 			})
 
-			// Process the edited message as a regular user message
-			webviewMessageHandler(provider, {
-				type: "askResponse",
-				askResponse: "messageResponse",
-				text: editedContent,
-				images,
-			})
+			// Update the UI to reflect the deletion
+			await provider.postStateToWebview()
 
-			// Don't initialize with history item for edit operations
-			// The webviewMessageHandler will handle the conversation state
+			// Immediately send the edited message as a new user message
+			// This restarts the conversation from the edited point
+			await currentCline.handleWebviewAskResponse("messageResponse", editedContent, images)
 		} catch (error) {
 			console.error("Error in edit message:", error)
 			vscode.window.showErrorMessage(