@@ -4818,6 +4818,40 @@ describe("DiffViewProvider", () => {
 			expect(events).toEqual(["teardown-start", "teardown-end", "joiner-resolved"])
 			expect(diffViewProvider["sessionFinalizationClaimed"]).toBe(true)
 		})
+
+		// The finding's own interleaving, run through the real reset() rather than a stand-in callback:
+		// reset() sets sessionFinalizationClaimed in its synchronous prefix and then awaits the tab
+		// closure (closeOwnDiffView below). A second caller that arrives inside that window has to wait
+		// for the closure the first caller started, and it must not run a second tab close of its own.
+		it("keeps a caller that joined the claim window waiting for reset's own tab closure", async () => {
+			const events: string[] = []
+			let releaseTabClose: () => void = () => {}
+			const tabCloseHeld = new Promise<void>((resolve) => {
+				releaseTabClose = resolve
+			})
+
+			diffViewProvider["relPath"] = "mock-target-file.ts"
+			diffViewProvider["closeOwnDiffView"] = vi.fn(async () => {
+				events.push("tab-close-start")
+				await tabCloseHeld
+				events.push("tab-close-end")
+			})
+
+			const owner = diffViewProvider["finalizeSession"](() => diffViewProvider.reset())
+			const joiner = diffViewProvider["finalizeSession"](() => {
+				events.push("joiner-ran-reset")
+				return diffViewProvider.reset()
+			}).then(() => {
+				events.push("joiner-resolved")
+			})
+
+			releaseTabClose()
+			await Promise.all([owner, joiner])
+
+			expect(events).toEqual(["tab-close-start", "tab-close-end", "joiner-resolved"])
+			expect(diffViewProvider["closeOwnDiffView"]).toHaveBeenCalledTimes(1)
+			expect(diffViewProvider["sessionFinalizationClaimed"]).toBe(true)
+		})
 	})
 
 	describe("userTouchedDiffEditor keep/close behavior", () => {
 
@@ -0,0 +1,30 @@
+import { render } from "@/utils/test-utils"
+
+import CodebaseSearchResult from "../CodebaseSearchResult"
+
+vi.mock("@/utils/vscode", () => ({ vscode: { postMessage: vi.fn() } }))
+
+// The double only answers the key; the recorded call keeps both arguments so the case can assert on
+// the interpolation object the tooltip asks for. `_options` is unused by the double on purpose.
+const { tSpy } = vi.hoisted(() => ({ tSpy: vi.fn((key: string, _options?: Record<string, unknown>) => key) }))
+
+vi.mock("@src/i18n/TranslationContext", () => ({
+	useAppTranslation: () => ({ t: (key: string, options?: Record<string, unknown>) => tSpy(key, options) }),
+}))
+
+describe("CodebaseSearchResult - the tooltip it asks the translator for", () => {
+	it("asks for the result tooltip with the score rounded to three places", () => {
+		render(
+			<CodebaseSearchResult
+				filePath="src/example.ts"
+				score={0.9512}
+				startLine={12}
+				endLine={18}
+				snippet="const example = true"
+				language="typescript"
+			/>,
+		)
+
+		expect(tSpy).toHaveBeenCalledWith("chat:codebaseSearch.resultTooltip", { score: "0.951" })
+	})
+})
@@ -0,0 +1,24 @@
+import { render, screen } from "@/utils/test-utils"
+import type { QueuedMessage } from "@roo-code/types"
+
+import { QueuedMessages } from "../QueuedMessages"
+
+vi.mock("../common/Thumbnails", () => ({ default: () => null }))
+vi.mock("./Mention", () => ({ Mention: () => null }))
+
+const { tSpy } = vi.hoisted(() => ({ tSpy: vi.fn((key: string) => key) }))
+
+vi.mock("@src/i18n/TranslationContext", () => ({
+	useAppTranslation: () => ({ t: (key: string) => tSpy(key) }),
+}))
+
+describe("QueuedMessages - the heading it puts over the queue", () => {
+	it("titles the queue and renders each queued message's text", () => {
+		const queue: QueuedMessage[] = [{ id: "queued-1", text: "keep the diff open" } as QueuedMessage]
+
+		render(<QueuedMessages queue={queue} onRemove={vi.fn()} onUpdate={vi.fn()} />)
+
+		expect(tSpy).toHaveBeenCalledWith("chat:queuedMessages.title")
+		expect(screen.getByTestId("queued-messages")).toHaveTextContent("chat:queuedMessages.title")
+	})
+})
@@ -0,0 +1,104 @@
+import type { ReactNode } from "react"
+
+import { providerIdentifiers, type ProviderSettings } from "@roo-code/types"
+
+import { render, screen } from "@/utils/test-utils"
+
+import { BedrockCustomArn } from "../BedrockCustomArn"
+
+type SelectMockProps = {
+	children: ReactNode
+	value: string
+	onValueChange: (value: string) => void
+	disabled?: boolean
+}
+type TextFieldMockProps = {
+	children: ReactNode
+	value: string
+	onInput: (event: { target: { value: string } }) => void
+	placeholder?: string
+	className?: string
+	"data-testid"?: string
+}
+
+vi.mock("@src/components/ui", () => ({
+	Select: ({ children, value, onValueChange, disabled }: SelectMockProps) => (
+		<select
+			data-testid="base-model-select"
+			value={value}
+			disabled={disabled}
+			onChange={(e) => onValueChange(e.target.value)}>
+			{children}
+		</select>
+	),
+	SelectContent: ({ children }: { children: ReactNode }) => <>{children}</>,
+	SelectItem: ({ children, value }: { children: ReactNode; value: string }) => (
+		<option value={value}>{children}</option>
+	),
+	SelectTrigger: ({ children }: { children: ReactNode }) => <>{children}</>,
+	SelectValue: () => null,
+}))
+
+vi.mock("@vscode/webview-ui-toolkit/react", () => ({
+	VSCodeTextField: ({ children, value, onInput, placeholder, "data-testid": testId }: TextFieldMockProps) => (
+		<label>
+			<input
+				data-testid={testId ?? "text-field"}
+				value={value}
+				placeholder={placeholder}
+				onChange={(e) => onInput({ target: { value: e.target.value } })}
+			/>
+			{children}
+		</label>
+	),
+}))
+
+vi.mock("@src/i18n/TranslationContext", () => ({
+	useAppTranslation: () => ({
+		t: (key: string, options?: Record<string, unknown>) =>
+			options ? Object.entries(options).reduce((acc: string, [k, v]) => `${acc} ${k}=${String(v)}`, key) : key,
+	}),
+}))
+
+describe("BedrockCustomArn - the memoised ARN validation", () => {
+	it("reports no problem for a session with no ARN typed yet", () => {
+		const apiConfiguration: ProviderSettings = {
+			apiProvider: providerIdentifiers.bedrock,
+			awsRegion: "us-east-1",
+		}
+		const setApiConfigurationField = vi.fn()
+
+		render(
+			<BedrockCustomArn
+				apiConfiguration={apiConfiguration}
+				setApiConfigurationField={setApiConfigurationField}
+			/>,
+		)
+
+		expect(screen.queryByText("settings:providers.invalidArnFormat")).toBeNull()
+		expect(screen.queryByText(/regionMismatch/)).toBeNull()
+	})
+
+	it("re-validates when a different ARN arrives, including a region that contradicts the setting", () => {
+		const base: ProviderSettings = { apiProvider: providerIdentifiers.bedrock, awsRegion: "us-east-1" }
+		const setApiConfigurationField = vi.fn()
+		const mismatchedArn =
+			"arn:aws:bedrock:eu-west-1:123456789012:inference-profile/eu.anthropic.claude-3-7-sonnet-20250219-v1:0"
+
+		const { rerender } = render(
+			<BedrockCustomArn apiConfiguration={base} setApiConfigurationField={setApiConfigurationField} />,
+		)
+		expect(screen.queryByText(/regionMismatch/)).toBeNull()
+
+		rerender(
+			<BedrockCustomArn
+				apiConfiguration={{ ...base, awsCustomArn: mismatchedArn }}
+				setApiConfigurationField={setApiConfigurationField}
+			/>,
+		)
+
+		expect(
+			screen.getByText("settings:validation.arn.regionMismatch arnRegion=eu-west-1 region=us-east-1"),
+		).toBeDefined()
+	})
+})
@@ -0,0 +1,40 @@
+import { formatDateOnly, formatTimeOnly, hourCycleOptions } from "../format"
+
+// Wed 27 May 2026, 15:00 local - a time where a 12h/24h difference is visible.
+const timestamp = new Date(2026, 4, 27, 15, 0, 0).getTime()
+
+describe("formatDateOnly - the default order is the auto order", () => {
+	it("leaves an omitted order to the locale, the same as asking for auto", () => {
+		expect(formatDateOnly(timestamp, "en")).toBe(formatDateOnly(timestamp, "en", "auto"))
+	})
+
+	it("uses the fixed numeric orders when they are asked for", () => {
+		expect(formatDateOnly(timestamp, "en", "mdy")).toBe("05/27/2026")
+		expect(formatDateOnly(timestamp, "en", "dmy")).toBe("27/05/2026")
+		expect(formatDateOnly(timestamp, "en", "ymd")).toBe("2026-05-27")
+		expect(formatDateOnly(timestamp, "en")).not.toBe(formatDateOnly(timestamp, "en", "ymd"))
+	})
+})
+
+describe("formatTimeOnly - the default clock is the auto clock", () => {
+	it("leaves an omitted format to the locale, the same as asking for auto", () => {
+		expect(formatTimeOnly(timestamp, "en-US")).toBe(formatTimeOnly(timestamp, "en-US", "auto"))
+	})
+
+	it("honours an explicit 24h clock over the locale default", () => {
+		expect(formatTimeOnly(timestamp, "en-US", "24h")).not.toBe(formatTimeOnly(timestamp, "en-US", "auto"))
+		expect(formatTimeOnly(timestamp, "en-US", "24h")).toContain("15:00")
+	})
+})
+
+describe("hourCycleOptions - what auto hands to the locale", () => {
+	it("hands the locale nothing for auto, whether asked for or left out", () => {
+		expect(hourCycleOptions()).toStrictEqual({})
+		expect(hourCycleOptions("auto")).toStrictEqual({})
+	})
+
+	it("maps the two explicit clocks to their hour-cycle options", () => {
+		expect(hourCycleOptions("12h")).toStrictEqual({ hour12: true })
+		expect(hourCycleOptions("24h")).toStrictEqual({ hourCycle: "h23" })
+	})
+})