fix: preserve manual title rename over generated title across hosts

Decide the generated-title write from the persisted record inside the
per-file lock instead of the store cache, so a rename committed by
another provider's store is never overwritten.

Author: daewoongoh

src/core/task-persistence/TaskHistoryStore.ts

@@ -1186,6 +1186,78 @@ export class TaskHistoryStore {
 		})
 	}
 
+	/**
+	 * Disk-authoritative conditional write for a generated task title.
+	 *
+	 * The decision reads the persisted record inside the per-file advisory
+	 * lock's merge callback, so a manual rename committed by another store
+	 * (another extension host) after this store's cache was last refreshed is
+	 * preserved instead of overwritten: every provider owns a separate
+	 * TaskHistoryStore with a separate in-process lock and cache, so a
+	 * cache-only existing-title check is not sufficient. An existing disk
+	 * title — a manual rename or an earlier generated title — always wins,
+	 * and the record's other disk fields are preserved when the generated
+	 * title is applied.
+	 *
+	 * @returns The authoritative disk record and whether the generated title
+	 * was applied.
+	 * @throws If the task ID is not present in the cache, so the caller can retry.
+	 */
+	public async setGeneratedTitleIfUnset(
+		taskId: string,
+		title: string,
+	): Promise<{ item: HistoryItem; applied: boolean }> {
+		return this.withLock(async () => {
+			const cached = this.cache.get(taskId)
+			if (!cached) {
+				throw new Error(`[TaskHistoryStore] setGeneratedTitleIfUnset: task ${taskId} not found in cache`)
+			}
+			const trimmed = title.trim()
+			if (!trimmed) {
+				return { item: cached, applied: false }
+			}
+
+			const filePath = await this.getTaskFilePath(taskId)
+			const incoming: HistoryItem = { ...cached, title: trimmed }
+			// Seed the decision from the cache, then let the locked disk record
+			// override it inside the merge callback. When the per-file lock
+			// cannot hand back the disk record (a safeWriteJson double that
+			// never invokes `merge`), the cache decision stands.
+			let applied = !cached.title
+			let authoritative: HistoryItem = cached.title ? cached : incoming
+			await safeWriteJson(filePath, incoming, {
+				merge: (existing) => {
+					if (existing && typeof existing === "object" && "id" in existing) {
+						const disk = existing as HistoryItem
+						if (disk.title) {
+							// A manual rename or an earlier generated title
+							// from any host is already persisted; keep it.
+							applied = false
+							authoritative = disk
+							return disk
+						}
+						// Apply only the title onto the locked disk record so
+						// fields written by another host are preserved.
+						applied = true
+						authoritative = { ...disk, title: trimmed }
+						return authoritative
+					}
+					// No readable disk record; fall back to writing the
+					// cached item with the title applied, matching the
+					// delta-write fallback for a missing file.
+					applied = true
+					authoritative = incoming
+					return incoming
+				},
+			})
+			this.cache.set(taskId, authoritative)
+			if (this.onWrite) {
+				await this.onWrite(this.getAll())
+			}
+			return { item: authoritative, applied }
+		})
+	}
+
 	// ────────────────────────────── Private: Write lock ──────────────────────────────
 
 	/**

src/core/task-persistence/__tests__/TaskHistoryStore.realConcurrency.spec.ts

@@ -421,4 +421,65 @@ describe("TaskHistoryStore real cross-host locking", () => {
 			await fs.rm(storagePath, { recursive: true, force: true })
 		}
 	})
+
+	it("preserves a manual rename committed by another store over a stale-cache generated title", async () => {
+		const storagePath = await fs.mkdtemp(path.join(os.tmpdir(), "task-history-generated-title-"))
+		const storeA = new TaskHistoryStore(storagePath)
+		const storeB = new TaskHistoryStore(storagePath)
+		const filePath = path.join(storagePath, "tasks", "shared-task", "history_item.json")
+
+		try {
+			await storeA.initialize()
+			await storeA.upsert(item("shared-task"))
+			// storeB hydrates its cache before the rename, so its cached copy
+			// never sees the manual title.
+			await storeB.initialize()
+
+			// The manual rename commits to disk through store A before store
+			// B attempts the generated-title write.
+			await storeA.atomicReadAndUpdate("shared-task", (current) => ({ ...current, title: "Manual Title" }))
+
+			const result = await storeB.setGeneratedTitleIfUnset("shared-task", "Generated Title")
+
+			expect(result.applied).toBe(false)
+			expect(result.item.title).toBe("Manual Title")
+			// The stale cache is refreshed with the authoritative disk record.
+			expect(storeB.get("shared-task")?.title).toBe("Manual Title")
+			expect(JSON.parse(await fs.readFile(filePath, "utf8"))).toMatchObject({ title: "Manual Title" })
+		} finally {
+			storeA.dispose()
+			storeB.dispose()
+			await fs.rm(storagePath, { recursive: true, force: true })
+		}
+	})
+
+	it("applies the generated title onto the locked disk record when no disk title exists", async () => {
+		const storagePath = await fs.mkdtemp(path.join(os.tmpdir(), "task-history-generated-title-apply-"))
+		const storeA = new TaskHistoryStore(storagePath)
+		const storeB = new TaskHistoryStore(storagePath)
+		const filePath = path.join(storagePath, "tasks", "shared-task", "history_item.json")
+
+		try {
+			await storeA.initialize()
+			await storeA.upsert(item("shared-task"))
+			await storeB.initialize()
+
+			// Another host persists an unrelated field; storeB's cache stays
+			// stale, so the apply must read the locked disk record.
+			await storeA.atomicReadAndUpdate("shared-task", (current) => ({ ...current, totalCost: 42 }))
+
+			const result = await storeB.setGeneratedTitleIfUnset("shared-task", "Generated Title")
+
+			expect(result.applied).toBe(true)
+			expect(result.item).toMatchObject({ title: "Generated Title", totalCost: 42 })
+			expect(JSON.parse(await fs.readFile(filePath, "utf8"))).toMatchObject({
+				title: "Generated Title",
+				totalCost: 42,
+			})
+		} finally {
+			storeA.dispose()
+			storeB.dispose()
+			await fs.rm(storagePath, { recursive: true, force: true })
+		}
+	})
 })

src/core/webview/ClineProvider.ts

@@ -2833,28 +2833,20 @@ export class ClineProvider
 
 	/*
 	 * Applies an automatically generated title for a history item (issue #2333).
-	 * The existing-title check and the write happen inside one atomic store
-	 * update, so a manual rename queued ahead of this call is never overwritten
-	 * by the generated title. Returns true when the title was applied, false
-	 * when the item already had a title. Throws when the task is not in the
-	 * store yet so the caller can retry.
+	 * The existing-title check reads the persisted record inside the same
+	 * per-file lock as the write, so a manual rename committed by another
+	 * provider's store after this store's cache was last refreshed is never
+	 * overwritten by the generated title. Returns true when the title was
+	 * applied, false when the item already had a title. Throws when the task
+	 * is not in the store yet so the caller can retry.
 	 */
 	async setGeneratedTaskTitle(id: string, title: string): Promise<boolean> {
 		const trimmed = title.trim()
 		if (!trimmed) {
 			return false
 		}
 
-		let applied = false
-		await this.taskHistoryStore.atomicReadAndUpdate(id, (historyItem) => {
-			// Preserve any title set before this write: a manual rename, or an
-			// earlier generated title, always wins over a later generated one.
-			if (historyItem.title) {
-				return historyItem
-			}
-			applied = true
-			return { ...historyItem, title: trimmed }
-		})
+		const { applied } = await this.taskHistoryStore.setGeneratedTitleIfUnset(id, trimmed)
 
 		if (applied) {
 			this.recentTasksCache = undefined