feat: summarize initial prompt to generate task title in background

src/core/task-persistence/TaskHistoryStore.ts

@@ -1186,6 +1186,78 @@
 		})
 	}
 
+	/**
+	 * 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/task/Task.ts

@@ -143,6 +143,7 @@
 import { mergeConsecutiveApiMessages } from "./mergeConsecutiveApiMessages"
 import { prepareApiConversationMessage } from "./apiConversationHistory"
 import { shouldAddUserMessageToHistory } from "./messageCounting"
+import { DEFAULT_TITLE_TIMEOUT_MS, fallbackTaskTitle, generateTaskTitle } from "./taskTitleGenerator"
 import { type TaskExecutionContext } from "./providerHandoff"
 import { abort, abortReason, initialRunState, type Ask, type RunEvent, type RunState } from "./run-state/runState"
 import { applyRunEvent, type RunRejection } from "./run-state/runStateShadow"
@@ -242,6 +243,9 @@
 const FORCED_CONTEXT_REDUCTION_PERCENT = 75 // Keep 75% of context (remove 25%) on context window errors
 const MAX_CONTEXT_WINDOW_RETRIES = 3 // Maximum retries for context window errors
 
+// Literal, not the vscode enum: specs that mock "vscode" without ExtensionMode would throw on the read.
+const EXTENSION_MODE_TEST = 3
+
 export interface ToolExecutionContext {
 	toolCallId: string
 	didReject: boolean
@@ -393,6 +397,11 @@
 	providerRef: WeakRef<ClineProvider>
 	private readonly globalStoragePath: string
 	currentRequestAbortController?: AbortController
+	/**
+	 * Controller for background title summarization of the initial user prompt.
+	 * Aborted when the task is cancelled, disposed, or explicitly aborted.
+	 */
+	titleAbortController?: AbortController
 	/**
 	 * Controller for the waiter on an in-flight `ensureModelFetched()` call (see
 	 * safeEnsureModelFetched). Aborting it detaches this task from the provider-side
@@ -3108,6 +3117,11 @@
 
 			await this.say("text", task, images)
 
+			// Generate a concise task title in the background for new top-level tasks.
+			if (task && !this.parentTask) {
+				void this.generateTitleInBackground(task)
+			}
+
 			// Check for too many MCP tools and warn the user
 			const { enabledToolCount, enabledServerCount } = await this.getEnabledMcpToolsCount()
 			if (enabledToolCount > MAX_MCP_TOOLS_THRESHOLD) {
@@ -3181,6 +3195,106 @@
 		}
 	}
 
+	// Issue #2333: bounded attempts for the atomic generated-title write. The
+	// task may not be recorded in the history store yet when the title is
+	// ready; each attempt retries the atomic check-and-write under the lock.
+	private static readonly TITLE_WRITE_ATTEMPTS = 3
+	private static readonly TITLE_WRITE_RETRY_DELAY_MS = 50
+
+	/**
+	 * Generates a concise title for the task in the background using the initial prompt.
+	 * When generation fails, times out, or returns no title, the title falls back to
+	 * the first 42 characters of the initial prompt (issue #2333). If the user cancels
+	 * the task, no title is written. A manual rename always wins: the existing-title
+	 * check and the write happen inside one atomic store update, so a rename queued
+	 * ahead of this write is never overwritten.
+	 */
+	private async generateTitleInBackground(taskText: string): Promise<void> {
+		if (this.abort || this.abandoned) {
+			return
+		}
+
+		const provider = this.providerRef.deref()
+		if (!provider || provider.context?.extensionMode === EXTENSION_MODE_TEST) {
+			return
+		}
+
+		const controller = new AbortController()
+		this.titleAbortController = controller
+
+		try {
+			// The title request participates in the same provider rate-limit
+			// coordination as task requests: it waits out the configured window
+			// (silently — the countdown say UX belongs to the task loop) and
+			// records on the shared clock so subsequent task/subtask requests
+			// honour it. `startTask` schedules this method with `void`, so the
+			// agent never waits on the title result.
+			await this.waitForProviderRateLimitWindow(controller.signal)
+
+			if (controller.signal.aborted || this.abort || this.abandoned) {
+				return
+			}
+
+			this.rateLimitClock.recordRequest()
+
+			const generated = await generateTaskTitle(taskText, this.apiConfiguration, {
+				abortSignal: controller.signal,
+				timeoutMs: DEFAULT_TITLE_TIMEOUT_MS,
+				taskId: this.taskId,
+			})
+
+			if (controller.signal.aborted || this.abort || this.abandoned) {
+				return
+			}
+
+			// Issue #2333 fallback: when generation fails, times out, or returns
+			// no usable title, use the first 42 characters of the initial prompt.
+			const fallback = fallbackTaskTitle(taskText)
+			const desiredTitle = generated ?? fallback
+
+			// The atomic write only applies while the item has no title. A
+			// failure (e.g. the task not yet recorded in the store) is retried a
+			// bounded number of times before the truncated-prompt fallback title
+			// gets a final attempt.
+			for (let attempt = 1; attempt <= Task.TITLE_WRITE_ATTEMPTS; attempt++) {
+				if (controller.signal.aborted || this.abort || this.abandoned) {
+					return
+				}
+
+				try {
+					await provider.setGeneratedTaskTitle(this.taskId, desiredTitle)
+					return
+				} catch (error) {
+					console.debug(
+						`[Task#generateTitleInBackground] Title write attempt ${attempt} failed for ${this.taskId}:`,
+						error,
+					)
+
+					if (attempt === Task.TITLE_WRITE_ATTEMPTS) {
+						// Retries exhausted: final attempt with the truncated-prompt
+						// fallback title (issue #2333).
+						try {
+							await provider.setGeneratedTaskTitle(this.taskId, fallback)
+						} catch (fallbackError) {
+							console.error(
+								`[Task#generateTitleInBackground] Fallback title failed for ${this.taskId}:`,
+								fallbackError,
+							)
+						}
+					} else {
+						await delay(Task.TITLE_WRITE_RETRY_DELAY_MS)
+					}
+				}
+			}
+		} catch (error) {
+			console.error(`[Task#generateTitleInBackground] Failed for ${this.taskId}:`, error)
+		} finally {
+			if (this.titleAbortController === controller) {
+				this.titleAbortController = undefined
+			}
+		}
+	}
+
 	private async resumeTaskFromHistory() {
 		try {
 			const modifiedClineMessages = [...(await this.getSavedClineMessages())]
@@ -3534,6 +3648,10 @@
 			this.metadataFetchAbortController.abort()
 			this.metadataFetchAbortController = undefined
 		}
+		if (this.titleAbortController) {
+			this.titleAbortController.abort()
+			this.titleAbortController = undefined
+		}
 	}
 
 	/**
@@ -3595,6 +3713,10 @@
 		if (isAbandoned) {
 			this.abandoned = true
 		}
+		if (this.titleAbortController) {
+			this.titleAbortController.abort()
+			this.titleAbortController = undefined
+		}
 		this.driveRunEvent({ tag: "abortRequested", abandoned: isAbandoned })
 	}
 
@@ -5684,6 +5806,33 @@
 		}
 	}
 
+	/**
+	 * Silent companion to `maybeWaitForProviderRateLimit` for background provider
+	 * requests (e.g. title generation): waits out the remaining provider
+	 * rate-limit window without emitting the task-loop countdown UX, since a
+	 * second concurrent partial `api_req_rate_limit_wait` say would interleave
+	 * with the task's own countdown. Resolves early (not rejects) when the given
+	 * signal aborts; callers must still re-check abort state after the wait and
+	 * call `rateLimitClock.recordRequest()` right before issuing the request,
+	 * mirroring the task loop.
+	 */
+	private async waitForProviderRateLimitWindow(signal: AbortSignal): Promise<void> {
+		const rateLimitSeconds = this.apiConfiguration?.rateLimitSeconds ?? 0
+		const lastRequestTime = this.rateLimitClock.getLastRequestTime()
+		if (rateLimitSeconds <= 0 || !lastRequestTime) {
+			return
+		}
+
+		const remainingMs = rateLimitSeconds * 1000 - (performance.now() - lastRequestTime)
+		if (remainingMs <= 0) {
+			return
+		}
+
+		await delay(remainingMs, { signal }).catch(() => {
+			// Aborted mid-wait: cancellation, not a failure.
+		})
+	}
+
 	public async *attemptApiRequest(
 		retryAttempt: number = 0,
 		options: { skipProviderRateLimit?: boolean; requestModelInfo?: ModelInfo } = {},