feat(ui): add time and date format settings and message timestamps

apps/vscode-e2e/src/visual/electron.visual.ts

@@ -256,8 +256,21 @@ for (const scenario of scenarios) {
 			const tokenCountMask = webviewFrame
 				.frameLocator("iframe")
 				.locator('[data-testid="context-tokens-count"],[data-testid="context-window-size"]')
+			// The time under each message is the real send time, so it changes on every run, and so does the length
+			// of its text ("Today 9:05 AM" and "Yesterday 12:36 PM" are not equally long). A mask covers the
+			// element's box, so that box needs a fixed size as well: without it the masked area differs between
+			// runs, in width and, when the text wraps onto a second line, in height.
+			await contentFrame.evaluate(() => {
+				document.querySelectorAll<HTMLElement>('[data-testid="message-timestamp"]').forEach((time) => {
+					time.style.setProperty("width", "160px", "important")
+					time.style.setProperty("white-space", "nowrap", "important")
+					time.style.setProperty("overflow", "hidden", "important")
+				})
+			})
+			// Mask it, as the token counters above, and keep the rest of the scene byte-stable.
+			const messageTimeMask = webviewFrame.frameLocator("iframe").locator('[data-testid="message-timestamp"]')
 			await expect(sidebar).toHaveScreenshot(`electron-${scenario.name}-sidebar.png`, {
-				mask: [tokenCountMask],
+				mask: [tokenCountMask, messageTimeMask],
 			})
 
 			if (scenario.webviewSnapshot) {

packages/types/src/global-settings.ts

@@ -280,6 +280,21 @@ export const globalSettingsSchema = z.object({
 	 * When unset (or `null`), the webview inherits VS Code's `--vscode-font-size`.
 	 */
 	chatFontSize: z.number().int().min(8).max(32).nullish(),
+	/**
+	 * Clock format used when rendering timestamps. "auto" follows the display language's locale.
+	 * @default "auto"
+	 */
+	timeFormat: z.enum(["auto", "12h", "24h"]).optional(),
+	/**
+	 * How dates are written. "auto" follows the display language's locale.
+	 * @default "auto"
+	 */
+	dateFormat: z.enum(["auto", "mdy", "dmy", "ymd"]).optional(),
+	/**
+	 * Show relative times ("5 min ago") in task history; when off, show the absolute date/time.
+	 * @default true
+	 */
+	showRelativeTimes: z.boolean().optional(),
 	/**
 	 * Controls the keyboard behavior for sending messages in the chat input.
 	 * - "send": Enter sends message, Shift+Enter creates newline (default)

packages/types/src/vscode-extension-host.ts

@@ -339,6 +339,9 @@ export type ExtensionState = Pick<
 	| "includeTaskHistoryInEnhance"
 	| "reasoningBlockCollapsed"
 	| "chatFontSize"
+	| "timeFormat"
+	| "dateFormat"
+	| "showRelativeTimes"
 	| "enterBehavior"
 	| "includeCurrentTime"
 	| "includeCurrentCost"

src/core/config/ContextProxy.ts

@@ -23,6 +23,7 @@ import { TelemetryService } from "@roo-code/telemetry"
 import { logger } from "../../utils/logging"
 import { supportPrompt } from "../../shared/support-prompt"
 import { downgradeLegacyRooConfig } from "./routerRemoval"
+import { forgetSettingStore, isTrackedSetting, noteSettingStored } from "./settingWrites"
 
 type GlobalStateKey = keyof GlobalState
 type SecretStateKey = keyof SecretState
@@ -361,12 +362,27 @@ export class ContextProxy {
 	}
 
 	updateGlobalState<K extends GlobalStateKey>(key: K, value: GlobalState[K]) {
+		const storeNumber = noteSettingStored(key)
+
 		if (isPassThroughStateKey(key)) {
 			return this.originalContext.globalState.update(key, value)
 		}
 
+		const cachedBefore = this.stateCache[key]
 		this.stateCache[key] = value
-		return this.originalContext.globalState.update(key, value)
+		const updated = this.originalContext.globalState.update(key, value)
+		// Annotated, so it is a plain flag: the key is not narrowed to the tracked ones below.
+		const tracked: boolean = isTrackedSetting(key)
+		if (!tracked) return updated
+
+		// A rejected store never reached storage. A rollback must not treat it as someone else's store, and the
+		// cache must not keep a value that storage does not have, which the next save would read as what to restore.
+		return Promise.resolve(updated).catch((error: unknown) => {
+			if (storeNumber !== undefined) forgetSettingStore(key, storeNumber)
+			// Unless a newer store has replaced the value meanwhile: that value stays.
+			if (this.stateCache[key] === value) this.stateCache[key] = cachedBefore
+			throw error
+		})
 	}
 
 	private getAllGlobalState(): GlobalState {

src/core/config/__tests__/ContextProxy.spec.ts

@@ -8,6 +8,7 @@ import { clearAllMocks } from "../../../test-utils/reset"
 import { makeExtensionContext, makeUri } from "../../../test-utils/vscode"
 
 import { ContextProxy } from "../ContextProxy"
+import { beginSettingWrite, finishSettingWrites, performSettingWrite, undoSettingWrite } from "../settingWrites"
 import { providerIdentifiers, retiredProviderIdentifiers } from "@roo-code/types/provider-identifiers"
 
 vi.mock("vscode", () => ({
@@ -157,6 +158,78 @@ describe("ContextProxy", () => {
 	})
 
 	describe("updateGlobalState", () => {
+		it("does not count a store of a tracked setting that was rejected, so a rollback still happens", async () => {
+			await proxy.setValue("timeFormat", "auto")
+			const write = beginSettingWrite("timeFormat", "auto", "24h")
+			await performSettingWrite(proxy, write)
+			mockGlobalState.update.mockRejectedValueOnce(new Error("storage unavailable"))
+
+			await expect(proxy.setValue("timeFormat", "24h")).rejects.toThrow("storage unavailable")
+			await undoSettingWrite(proxy, write)
+
+			expect(mockGlobalState.update).toHaveBeenLastCalledWith("timeFormat", "auto")
+			finishSettingWrites([write])
+		})
+
+		describe("the cache after a rejected store of a tracked setting", () => {
+			it("goes back to what was stored, so the next save does not read a value storage does not have", async () => {
+				await proxy.setValue("timeFormat", "24h")
+				mockGlobalState.update.mockRejectedValueOnce(new Error("storage unavailable"))
+
+				await expect(proxy.setValue("timeFormat", "12h")).rejects.toThrow("storage unavailable")
+
+				expect(proxy.getValue("timeFormat")).toBe("24h")
+				const write = beginSettingWrite("timeFormat", undefined, "auto")
+				await performSettingWrite(proxy, write)
+				expect(write.previous).toBe("24h") // what is really stored, not the rejected 12h
+				finishSettingWrites([write])
+			})
+
+			it("keeps a newer store's value when the older one is rejected afterwards", async () => {
+				await proxy.setValue("timeFormat", "24h")
+				let rejectOlder!: (error: Error) => void
+				mockGlobalState.update.mockImplementationOnce(
+					() => new Promise((_resolve, reject) => (rejectOlder = reject)),
+				)
+				const older = proxy.setValue("timeFormat", "12h").catch(() => undefined) // pending
+				await proxy.setValue("timeFormat", "auto") // a newer store lands
+
+				rejectOlder(new Error("storage unavailable"))
+				await older
+
+				expect(proxy.getValue("timeFormat")).toBe("auto")
+			})
+
+			it("leaves an untracked setting's cache as it always was after a rejection", async () => {
+				mockGlobalState.update.mockRejectedValueOnce(new Error("untracked failure"))
+
+				await expect(proxy.updateGlobalState("apiProvider", "deepseek")).rejects.toThrow("untracked failure")
+
+				expect(proxy.getValue("apiProvider")).toBe("deepseek")
+			})
+		})
+
+		it("rejects with the original error, and only a tracked setting's store is wrapped", async () => {
+			mockGlobalState.update.mockRejectedValueOnce(new Error("untracked failure"))
+
+			await expect(proxy.updateGlobalState("apiProvider", "deepseek")).rejects.toThrow("untracked failure")
+		})
+
+		it.each([
+			["setValue", (p: ContextProxy) => p.setValue("timeFormat", "24h")],
+			["setValues", (p: ContextProxy) => p.setValues({ timeFormat: "24h" })],
+			["updateGlobalState", async (p: ContextProxy) => p.updateGlobalState("timeFormat", "24h")],
+		])("reports a store of a tracked setting made by %s, so a rollback does not undo it", async (_name, store) => {
+			const write = beginSettingWrite("timeFormat", "auto", "24h")
+			await performSettingWrite(proxy, write)
+			await store(proxy) // someone else stores the same value after the save's write
+
+			await undoSettingWrite(proxy, write)
+
+			expect(proxy.getValue("timeFormat")).toBe("24h")
+			finishSettingWrites([write])
+		})
+
 		it("should update state directly in original context", async () => {
 			await proxy.updateGlobalState("apiProvider", "deepseek")