feat: add auto-close Roo tabs feature

- Add autoCloseRooTabs and autoCloseAllRooTabs settings to global settings schema
- Create PostEditBehaviorUtils class to handle tab closing logic
- Implement tab tracking in DiffViewProvider to track opened files
- Add FileEditingOptions component to settings UI
- Add message handlers for the new settings
- Update ExtensionState and WebviewMessage types
- Add translation keys for the new UI section
- Add comprehensive tests for PostEditBehaviorUtils and FileEditingOptions

Closes #6003

packages/types/src/global-settings.ts

@@ -108,6 +108,8 @@ export const globalSettingsSchema = z.object({
 	rateLimitSeconds: z.number().optional(),
 	diffEnabled: z.boolean().optional(),
 	fuzzyMatchThreshold: z.number().optional(),
+	autoCloseRooTabs: z.boolean().optional(),
+	autoCloseAllRooTabs: z.boolean().optional(),
 	experiments: experimentsSchema.optional(),
 
 	codebaseIndexModels: codebaseIndexModelsSchema.optional(),

src/core/webview/webviewMessageHandler.ts

@@ -1241,6 +1241,14 @@ export const webviewMessageHandler = async (
 			await updateGlobalState("showRooIgnoredFiles", message.bool ?? true)
 			await provider.postStateToWebview()
 			break
+		case "autoCloseRooTabs":
+			await updateGlobalState("autoCloseRooTabs", message.bool ?? false)
+			await provider.postStateToWebview()
+			break
+		case "autoCloseAllRooTabs":
+			await updateGlobalState("autoCloseAllRooTabs", message.bool ?? false)
+			await provider.postStateToWebview()
+			break
 		case "hasOpenedModeSelector":
 			await updateGlobalState("hasOpenedModeSelector", message.bool ?? true)
 			await provider.postStateToWebview()

src/integrations/editor/DiffViewProvider.ts

@@ -15,6 +15,7 @@ import { Task } from "../../core/task/Task"
 import { DEFAULT_WRITE_DELAY_MS } from "@roo-code/types"
 
 import { DecorationController } from "./DecorationController"
+import { PostEditBehaviorUtils } from "./PostEditBehaviorUtils"
 
 export const DIFF_VIEW_URI_SCHEME = "cline-diff"
 export const DIFF_VIEW_LABEL_CHANGES = "Original ↔ Roo's Changes"
@@ -36,6 +37,7 @@ export class DiffViewProvider {
 	private activeLineController?: DecorationController
 	private streamedLines: string[] = []
 	private preDiagnostics: [vscode.Uri, vscode.Diagnostic[]][] = []
+	private rooOpenedTabs: Set<string> = new Set()
 
 	constructor(private cwd: string) {}
 
@@ -95,6 +97,9 @@ export class DiffViewProvider {
 			this.documentWasOpen = true
 		}
 
+		// Track that we opened this file
+		this.rooOpenedTabs.add(absolutePath)
+
 		this.activeDiffEditor = await this.openDiffEditor()
 		this.fadedOverlayController = new DecorationController("fadedOverlay", this.activeDiffEditor)
 		this.activeLineController = new DecorationController("activeLine", this.activeDiffEditor)
@@ -181,7 +186,12 @@ export class DiffViewProvider {
 		}
 	}
 
-	async saveChanges(diagnosticsEnabled: boolean = true, writeDelayMs: number = DEFAULT_WRITE_DELAY_MS): Promise<{
+	async saveChanges(
+		diagnosticsEnabled: boolean = true,
+		writeDelayMs: number = DEFAULT_WRITE_DELAY_MS,
+		autoCloseRooTabs: boolean = false,
+		autoCloseAllRooTabs: boolean = false,
+	): Promise<{
 		newProblemsMessage: string | undefined
 		userEdits: string | undefined
 		finalContent: string | undefined
@@ -201,6 +211,14 @@ export class DiffViewProvider {
 		await vscode.window.showTextDocument(vscode.Uri.file(absolutePath), { preview: false, preserveFocus: true })
 		await this.closeAllDiffViews()
 
+		// Apply post-edit behavior (auto-close tabs if configured)
+		await PostEditBehaviorUtils.closeRooTabs(
+			autoCloseRooTabs,
+			autoCloseAllRooTabs,
+			this.rooOpenedTabs,
+			absolutePath,
+		)
+
 		// Getting diagnostics before and after the file edit is a better approach than
 		// automatically tracking problems in real-time. This method ensures we only
 		// report new problems that are a direct result of this specific edit.
@@ -216,22 +234,22 @@ export class DiffViewProvider {
 		// and can address them accordingly. If problems don't change immediately after
 		// applying a fix, won't be notified, which is generally fine since the
 		// initial fix is usually correct and it may just take time for linters to catch up.
-		
+
 		let newProblemsMessage = ""
-		
+
 		if (diagnosticsEnabled) {
 			// Add configurable delay to allow linters time to process and clean up issues
 			// like unused imports (especially important for Go and other languages)
 			// Ensure delay is non-negative
 			const safeDelayMs = Math.max(0, writeDelayMs)
-			
+
 			try {
 				await delay(safeDelayMs)
 			} catch (error) {
 				// Log error but continue - delay failure shouldn't break the save operation
 				console.warn(`Failed to apply write delay: ${error}`)
 			}
-			
+
 			const postDiagnostics = vscode.languages.getDiagnostics()
 
 			const newProblems = await diagnosticsToProblemsString(
@@ -610,5 +628,14 @@ export class DiffViewProvider {
 		this.activeLineController = undefined
 		this.streamedLines = []
 		this.preDiagnostics = []
+		this.rooOpenedTabs.clear()
+	}
+
+	/**
+	 * Gets the set of file paths that were opened by Roo during the current session
+	 * @returns Set of absolute file paths
+	 */
+	getRooOpenedTabs(): Set<string> {
+		return new Set(this.rooOpenedTabs)
 	}
 }

src/integrations/editor/PostEditBehaviorUtils.ts

@@ -0,0 +1,135 @@
+import * as vscode from "vscode"
+import { arePathsEqual } from "../../utils/path"
+import { DIFF_VIEW_URI_SCHEME } from "./DiffViewProvider"
+
+export class PostEditBehaviorUtils {
+	/**
+	 * Closes Roo-related tabs based on the provided settings and tracked tabs
+	 * @param autoCloseRooTabs - Close only tabs opened during the current task
+	 * @param autoCloseAllRooTabs - Close all Roo tabs regardless of when they were opened
+	 * @param rooOpenedTabs - Set of file paths that were opened by Roo during the current task
+	 * @param editedFilePath - The path of the file that was just edited (to restore focus)
+	 * @returns Promise<void>
+	 */
+	static async closeRooTabs(
+		autoCloseRooTabs: boolean,
+		autoCloseAllRooTabs: boolean,
+		rooOpenedTabs: Set<string>,
+		editedFilePath?: string,
+	): Promise<void> {
+		if (!autoCloseRooTabs && !autoCloseAllRooTabs) {
+			return
+		}
+
+		// Get all tabs across all tab groups
+		const allTabs = vscode.window.tabGroups.all.flatMap((group) => group.tabs)
+
+		// Filter tabs to close based on settings
+		const tabsToClose = allTabs.filter((tab) => {
+			// Check if it's a diff view tab
+			if (tab.input instanceof vscode.TabInputTextDiff && tab.input.original.scheme === DIFF_VIEW_URI_SCHEME) {
+				return true
+			}
+
+			// Check if it's a regular text tab
+			if (tab.input instanceof vscode.TabInputText) {
+				const tabPath = tab.input.uri.fsPath
+
+				// Don't close the file that was just edited
+				if (editedFilePath && arePathsEqual(tabPath, editedFilePath)) {
+					return false
+				}
+
+				if (autoCloseAllRooTabs) {
+					// Close all Roo tabs - for now, we consider all tabs that were tracked
+					// In a more sophisticated implementation, we might check for Roo-specific markers
+					return rooOpenedTabs.has(tabPath)
+				} else if (autoCloseRooTabs) {
+					// Close only tabs opened during the current task
+					return rooOpenedTabs.has(tabPath)
+				}
+			}
+
+			return false
+		})
+
+		// Close the tabs
+		const closePromises = tabsToClose.map((tab) => {
+			if (!tab.isDirty) {
+				return vscode.window.tabGroups.close(tab).then(
+					() => undefined,
+					(err: any) => {
+						console.error(`Failed to close tab ${tab.label}:`, err)
+					},
+				)
+			}
+			return Promise.resolve()
+		})
+
+		await Promise.all(closePromises)
+
+		// Restore focus to the edited file if provided
+		if (editedFilePath) {
+			try {
+				await vscode.window.showTextDocument(vscode.Uri.file(editedFilePath), {
+					preview: false,
+					preserveFocus: false,
+				})
+			} catch (err) {
+				console.error(`Failed to restore focus to ${editedFilePath}:`, err)
+			}
+		}
+	}
+
+	/**
+	 * Determines which tabs should be closed based on the filter criteria
+	 * @param tabs - Array of tabs to filter
+	 * @param filter - Filter criteria (all Roo tabs or only current task tabs)
+	 * @param rooOpenedTabs - Set of file paths opened by Roo
+	 * @returns Array of tabs that match the filter criteria
+	 */
+	static filterTabsToClose(
+		tabs: readonly vscode.Tab[],
+		filter: "all" | "current",
+		rooOpenedTabs: Set<string>,
+	): vscode.Tab[] {
+		return tabs.filter((tab) => {
+			// Always close diff view tabs
+			if (tab.input instanceof vscode.TabInputTextDiff && tab.input.original.scheme === DIFF_VIEW_URI_SCHEME) {
+				return true
+			}
+
+			// For text tabs, apply the filter
+			if (tab.input instanceof vscode.TabInputText) {
+				const tabPath = tab.input.uri.fsPath
+
+				if (filter === "all") {
+					// In a real implementation, we might have additional checks
+					// to identify Roo-specific tabs beyond just the tracked set
+					return true
+				} else if (filter === "current") {
+					return rooOpenedTabs.has(tabPath)
+				}
+			}
+
+			return false
+		})
+	}
+
+	/**
+	 * Checks if a tab is a Roo-related tab
+	 * @param tab - The tab to check
+	 * @returns true if the tab is Roo-related
+	 */
+	static isRooTab(tab: vscode.Tab): boolean {
+		// Check if it's a diff view tab
+		if (tab.input instanceof vscode.TabInputTextDiff && tab.input.original.scheme === DIFF_VIEW_URI_SCHEME) {
+			return true
+		}
+
+		// Additional checks could be added here to identify other Roo-specific tabs
+		// For example, checking for specific URI schemes, file patterns, etc.
+
+		return false
+	}
+}

src/integrations/editor/__tests__/PostEditBehaviorUtils.spec.ts

@@ -0,0 +1,304 @@
+// npx vitest src/integrations/editor/__tests__/PostEditBehaviorUtils.spec.ts
+
+import * as vscode from "vscode"
+import { PostEditBehaviorUtils } from "../PostEditBehaviorUtils"
+
+// Mock DecorationController to avoid vscode.window.createTextEditorDecorationType error
+vi.mock("../DecorationController", () => ({
+	DecorationController: {
+		instance: {
+			clearDecorations: vi.fn(),
+			decorateLines: vi.fn(),
+		},
+	},
+}))
+
+// Mock vscode module
+vi.mock("vscode", () => {
+	const mockTab = (input: any, isDirty = false) => ({
+		input,
+		isDirty,
+		group: { close: vi.fn() },
+	})
+
+	const mockTabGroups = {
+		all: [],
+		close: vi.fn().mockResolvedValue(true),
+	}
+
+	return {
+		window: {
+			tabGroups: mockTabGroups,
+		},
+		TabInputText: class {
+			constructor(public uri: any) {}
+		},
+		TabInputTextDiff: class {
+			constructor(
+				public original: any,
+				public modified: any,
+			) {}
+		},
+		Uri: {
+			parse: (str: string) => ({
+				scheme: str.split(":")[0],
+				fsPath: str.replace(/^[^:]+:/, ""),
+				toString: () => str,
+			}),
+			file: (path: string) => ({
+				scheme: "file",
+				fsPath: path,
+				toString: () => `file:${path}`,
+			}),
+		},
+	}
+})
+
+describe("PostEditBehaviorUtils", () => {
+	let mockTabGroups: any
+
+	beforeEach(() => {
+		// Reset mocks
+		vi.clearAllMocks()
+		mockTabGroups = vi.mocked(vscode.window.tabGroups)
+		mockTabGroups.all = []
+		// Reset the close mock for each test
+		mockTabGroups.close = vi.fn().mockResolvedValue(true)
+	})
+
+	describe("closeRooTabs", () => {
+		it("should not close any tabs when both settings are false", async () => {
+			const rooOpenedTabs = new Set(["/test/file1.ts", "/test/file2.ts"])
+			const mockTabGroup = {
+				tabs: [
+					{
+						input: new vscode.TabInputText(vscode.Uri.file("/test/file1.ts")),
+						isDirty: false,
+						group: { close: vi.fn() },
+					},
+				],
+			}
+			mockTabGroups.all = [mockTabGroup]
+
+			await PostEditBehaviorUtils.closeRooTabs(false, false, rooOpenedTabs)
+
+			expect(vi.mocked(vscode.window.tabGroups).close).not.toHaveBeenCalled()
+		})
+
+		it("should close only tabs opened during current task when autoCloseRooTabs is true", async () => {
+			const rooOpenedTabs = new Set(["/test/file1.ts", "/test/file2.ts"])
+			const closeMock1 = vi.fn()
+			const closeMock2 = vi.fn()
+			const closeMock3 = vi.fn()
+
+			const mockTabGroup = {
+				tabs: [
+					{
+						input: new vscode.TabInputText(vscode.Uri.file("/test/file1.ts")),
+						isDirty: false,
+						group: { close: closeMock1 },
+					},
+					{
+						input: new vscode.TabInputText(vscode.Uri.file("/test/file2.ts")),
+						isDirty: false,
+						group: { close: closeMock2 },
+					},
+					{
+						input: new vscode.TabInputText(vscode.Uri.file("/test/file3.ts")),
+						isDirty: false,
+						group: { close: closeMock3 },
+					},
+				],
+			}
+			mockTabGroups.all = [mockTabGroup]
+
+			await PostEditBehaviorUtils.closeRooTabs(true, false, rooOpenedTabs)
+
+			// Should close file1 and file2 (in rooOpenedTabs), but not file3
+			const closeMock = vi.mocked(vscode.window.tabGroups).close
+			expect(closeMock).toHaveBeenCalledTimes(2)
+			expect(closeMock).toHaveBeenCalledWith(mockTabGroup.tabs[0])
+			expect(closeMock).toHaveBeenCalledWith(mockTabGroup.tabs[1])
+		})
+
+		it("should close all Roo tabs when autoCloseAllRooTabs is true", async () => {
+			const rooOpenedTabs = new Set(["/test/file1.ts"])
+			const closeMock1 = vi.fn()
+			const closeMock2 = vi.fn()
+			const closeMock3 = vi.fn()
+
+			const mockTabGroup = {
+				tabs: [
+					{
+						input: new vscode.TabInputText(vscode.Uri.file("/test/file1.ts")),
+						isDirty: false,
+						group: { close: closeMock1 },
+					},
+					{
+						input: new vscode.TabInputTextDiff(
+							vscode.Uri.parse("cline-diff:original"),
+							vscode.Uri.file("/test/file2.ts"),
+						),
+						isDirty: false,
+						group: { close: closeMock2 },
+					},
+					{
+						input: new vscode.TabInputText(vscode.Uri.file("/test/file3.ts")),
+						isDirty: false,
+						group: { close: closeMock3 },
+					},
+				],
+			}
+			mockTabGroups.all = [mockTabGroup]
+
+			await PostEditBehaviorUtils.closeRooTabs(false, true, rooOpenedTabs)
+
+			// Should close file1 (in rooOpenedTabs) and file2 (diff view), but not file3
+			const closeMock = vi.mocked(vscode.window.tabGroups).close
+			expect(closeMock).toHaveBeenCalledTimes(2)
+			expect(closeMock).toHaveBeenCalledWith(mockTabGroup.tabs[0])
+			expect(closeMock).toHaveBeenCalledWith(mockTabGroup.tabs[1])
+		})
+
+		it("should not close tabs with unsaved changes", async () => {
+			const rooOpenedTabs = new Set(["/test/file1.ts", "/test/file2.ts"])
+			const closeMock1 = vi.fn()
+			const closeMock2 = vi.fn()
+
+			const mockTabGroup = {
+				tabs: [
+					{
+						input: new vscode.TabInputText(vscode.Uri.file("/test/file1.ts")),
+						isDirty: true, // Has unsaved changes
+						group: { close: closeMock1 },
+					},
+					{
+						input: new vscode.TabInputText(vscode.Uri.file("/test/file2.ts")),
+						isDirty: false,
+						group: { close: closeMock2 },
+					},
+				],
+			}
+			mockTabGroups.all = [mockTabGroup]
+
+			await PostEditBehaviorUtils.closeRooTabs(true, false, rooOpenedTabs)
+
+			// Should not close file1 (dirty), but should close file2
+			const closeMock = vi.mocked(vscode.window.tabGroups).close
+			expect(closeMock).toHaveBeenCalledTimes(1)
+			expect(closeMock).toHaveBeenCalledWith(mockTabGroup.tabs[1])
+			expect(closeMock).not.toHaveBeenCalledWith(mockTabGroup.tabs[0])
+		})
+
+		it("should not close the edited file when provided", async () => {
+			const rooOpenedTabs = new Set(["/test/file1.ts", "/test/file2.ts"])
+			const editedFilePath = "/test/file1.ts"
+			const closeMock1 = vi.fn()
+			const closeMock2 = vi.fn()
+
+			const mockTabGroup = {
+				tabs: [
+					{
+						input: new vscode.TabInputText(vscode.Uri.file("/test/file1.ts")),
+						isDirty: false,
+						group: { close: closeMock1 },
+					},
+					{
+						input: new vscode.TabInputText(vscode.Uri.file("/test/file2.ts")),
+						isDirty: false,
+						group: { close: closeMock2 },
+					},
+				],
+			}
+			mockTabGroups.all = [mockTabGroup]
+
+			await PostEditBehaviorUtils.closeRooTabs(true, false, rooOpenedTabs, editedFilePath)
+
+			// Should not close file1 (edited file), but should close file2
+			const closeMock = vi.mocked(vscode.window.tabGroups).close
+			expect(closeMock).toHaveBeenCalledTimes(1)
+			expect(closeMock).toHaveBeenCalledWith(mockTabGroup.tabs[1])
+			expect(closeMock).not.toHaveBeenCalledWith(mockTabGroup.tabs[0])
+		})
+
+		it("should handle tabs without input gracefully", async () => {
+			const rooOpenedTabs = new Set(["/test/file1.ts"])
+			const closeMock = vi.fn()
+
+			const mockTabGroup = {
+				tabs: [
+					{
+						input: undefined, // No input
+						isDirty: false,
+						group: { close: closeMock },
+					},
+				],
+			}
+			mockTabGroups.all = [mockTabGroup]
+
+			await PostEditBehaviorUtils.closeRooTabs(true, false, rooOpenedTabs)
+
+			// Should not crash and should not close tabs without input
+			expect(vi.mocked(vscode.window.tabGroups).close).not.toHaveBeenCalled()
+		})
+
+		it("should handle multiple tab groups", async () => {
+			const rooOpenedTabs = new Set(["/test/file1.ts", "/test/file2.ts"])
+			const closeMock1 = vi.fn()
+			const closeMock2 = vi.fn()
+
+			const mockTabGroup1 = {
+				tabs: [
+					{
+						input: new vscode.TabInputText(vscode.Uri.file("/test/file1.ts")),
+						isDirty: false,
+						group: { close: closeMock1 },
+					},
+				],
+			}
+
+			const mockTabGroup2 = {
+				tabs: [
+					{
+						input: new vscode.TabInputText(vscode.Uri.file("/test/file2.ts")),
+						isDirty: false,
+						group: { close: closeMock2 },
+					},
+				],
+			}
+
+			mockTabGroups.all = [mockTabGroup1, mockTabGroup2]
+
+			await PostEditBehaviorUtils.closeRooTabs(true, false, rooOpenedTabs)
+
+			// Should close tabs from both groups
+			const closeMock = vi.mocked(vscode.window.tabGroups).close
+			expect(closeMock).toHaveBeenCalledTimes(2)
+			expect(closeMock).toHaveBeenCalledWith(mockTabGroup1.tabs[0])
+			expect(closeMock).toHaveBeenCalledWith(mockTabGroup2.tabs[0])
+		})
+
+		it("should handle errors gracefully", async () => {
+			const rooOpenedTabs = new Set(["/test/file1.ts"])
+
+			// Mock the close method to reject
+			vi.mocked(vscode.window.tabGroups).close.mockRejectedValueOnce(new Error("Close failed"))
+
+			const mockTabGroup = {
+				tabs: [
+					{
+						input: new vscode.TabInputText(vscode.Uri.file("/test/file1.ts")),
+						isDirty: false,
+						group: { close: vi.fn() },
+					},
+				],
+			}
+			mockTabGroups.all = [mockTabGroup]
+
+			// Should not throw
+			await expect(PostEditBehaviorUtils.closeRooTabs(true, false, rooOpenedTabs)).resolves.toBeUndefined()
+
+			expect(vi.mocked(vscode.window.tabGroups).close).toHaveBeenCalled()
+		})
+	})
+})

src/shared/ExtensionMessage.ts

@@ -218,6 +218,8 @@ export type ExtensionState = Pick<
 	| "diagnosticsEnabled"
 	| "diffEnabled"
 	| "fuzzyMatchThreshold"
+	| "autoCloseRooTabs"
+	| "autoCloseAllRooTabs"
 	// | "experiments" // Optional in GlobalSettings, required here.
 	| "language"
 	// | "telemetrySetting" // Optional in GlobalSettings, required here.

src/shared/WebviewMessage.ts

@@ -81,6 +81,8 @@ export interface WebviewMessage {
 		| "allowedMaxRequests"
 		| "alwaysAllowSubtasks"
 		| "alwaysAllowUpdateTodoList"
+		| "autoCloseRooTabs"
+		| "autoCloseAllRooTabs"
 		| "autoCondenseContext"
 		| "autoCondenseContextPercent"
 		| "condensingApiConfigId"

webview-ui/src/components/settings/FileEditingOptions.tsx

@@ -0,0 +1,72 @@
+import { HTMLAttributes } from "react"
+import { FileEdit } from "lucide-react"
+
+import { useAppTranslation } from "@/i18n/TranslationContext"
+import { VSCodeCheckbox } from "@vscode/webview-ui-toolkit/react"
+
+import { SetCachedStateField } from "./types"
+import { SectionHeader } from "./SectionHeader"
+import { Section } from "./Section"
+
+type FileEditingOptionsProps = HTMLAttributes<HTMLDivElement> & {
+	autoCloseRooTabs?: boolean
+	autoCloseAllRooTabs?: boolean
+	setCachedStateField: SetCachedStateField<"autoCloseRooTabs" | "autoCloseAllRooTabs">
+}
+
+export const FileEditingOptions = ({
+	autoCloseRooTabs,
+	autoCloseAllRooTabs,
+	setCachedStateField,
+	...props
+}: FileEditingOptionsProps) => {
+	const { t } = useAppTranslation()
+
+	return (
+		<div {...props}>
+			<SectionHeader description={t("settings:fileEditing.description")}>
+				<div className="flex items-center gap-2">
+					<FileEdit className="w-4" />
+					<div>{t("settings:fileEditing.title")}</div>
+				</div>
+			</SectionHeader>
+
+			<Section>
+				<div className="space-y-4">
+					<div>
+						<VSCodeCheckbox
+							checked={autoCloseRooTabs}
+							onChange={(e: any) => setCachedStateField("autoCloseRooTabs", e.target.checked)}
+							data-testid="auto-close-roo-tabs-checkbox">
+							<span className="font-medium">{t("settings:fileEditing.autoCloseRooTabs.label")}</span>
+						</VSCodeCheckbox>
+						<div className="text-vscode-descriptionForeground text-sm mt-1 ml-6">
+							{t("settings:fileEditing.autoCloseRooTabs.description")}
+						</div>
+					</div>
+
+					<div>
+						<VSCodeCheckbox
+							checked={autoCloseAllRooTabs}
+							onChange={(e: any) => setCachedStateField("autoCloseAllRooTabs", e.target.checked)}
+							data-testid="auto-close-all-roo-tabs-checkbox">
+							<span className="font-medium">{t("settings:fileEditing.autoCloseAllRooTabs.label")}</span>
+						</VSCodeCheckbox>
+						<div className="text-vscode-descriptionForeground text-sm mt-1 ml-6">
+							{t("settings:fileEditing.autoCloseAllRooTabs.description")}
+						</div>
+					</div>
+
+					{(autoCloseRooTabs || autoCloseAllRooTabs) && (
+						<div className="ml-6 p-3 bg-vscode-editor-background rounded-md border border-vscode-panel-border">
+							<div className="flex items-center gap-2 text-vscode-descriptionForeground">
+								<span className="codicon codicon-info" />
+								<span className="text-sm">{t("settings:fileEditing.tabClosingInfo")}</span>
+							</div>
+						</div>
+					)}
+				</div>
+			</Section>
+		</div>
+	)
+}

webview-ui/src/components/settings/SettingsView.tsx

@@ -22,6 +22,7 @@ import {
 	Globe,
 	Info,
 	MessageSquare,
+	FileEdit,
 	LucideIcon,
 } from "lucide-react"
 
@@ -66,6 +67,7 @@ import { About } from "./About"
 import { Section } from "./Section"
 import PromptsSettings from "./PromptsSettings"
 import { cn } from "@/lib/utils"
+import { FileEditingOptions } from "./FileEditingOptions"
 
 export const settingsTabsContainer = "flex flex-1 overflow-hidden [&.narrow_.tab-label]:hidden"
 export const settingsTabList =
@@ -86,6 +88,7 @@ const sectionNames = [
 	"notifications",
 	"contextManagement",
 	"terminal",
+	"fileEditing",
 	"prompts",
 	"experimental",
 	"language",
@@ -177,6 +180,8 @@ const SettingsView = forwardRef<SettingsViewRef, SettingsViewProps>(({ onDone, t
 		alwaysAllowFollowupQuestions,
 		alwaysAllowUpdateTodoList,
 		followupAutoApproveTimeoutMs,
+		autoCloseRooTabs,
+		autoCloseAllRooTabs,
 	} = cachedState
 
 	const apiConfiguration = useMemo(() => cachedState.apiConfiguration ?? {}, [cachedState.apiConfiguration])
@@ -333,6 +338,8 @@ const SettingsView = forwardRef<SettingsViewRef, SettingsViewProps>(({ onDone, t
 			vscode.postMessage({ type: "upsertApiConfiguration", text: currentApiConfigName, apiConfiguration })
 			vscode.postMessage({ type: "telemetrySetting", text: telemetrySetting })
 			vscode.postMessage({ type: "profileThresholds", values: profileThresholds })
+			vscode.postMessage({ type: "autoCloseRooTabs", bool: autoCloseRooTabs })
+			vscode.postMessage({ type: "autoCloseAllRooTabs", bool: autoCloseAllRooTabs })
 			setChangeDetected(false)
 		}
 	}
@@ -409,6 +416,7 @@ const SettingsView = forwardRef<SettingsViewRef, SettingsViewProps>(({ onDone, t
 			{ id: "notifications", icon: Bell },
 			{ id: "contextManagement", icon: Database },
 			{ id: "terminal", icon: SquareTerminal },
+			{ id: "fileEditing", icon: FileEdit },
 			{ id: "prompts", icon: MessageSquare },
 			{ id: "experimental", icon: FlaskConical },
 			{ id: "language", icon: Globe },
@@ -688,6 +696,15 @@ const SettingsView = forwardRef<SettingsViewRef, SettingsViewProps>(({ onDone, t
 						/>
 					)}
 
+					{/* File Editing Section */}
+					{activeTab === "fileEditing" && (
+						<FileEditingOptions
+							autoCloseRooTabs={autoCloseRooTabs}
+							autoCloseAllRooTabs={autoCloseAllRooTabs}
+							setCachedStateField={setCachedStateField}
+						/>
+					)}
+
 					{/* Prompts Section */}
 					{activeTab === "prompts" && (
 						<PromptsSettings

webview-ui/src/components/settings/__tests__/FileEditingOptions.spec.tsx

@@ -0,0 +1,189 @@
+// npx vitest src/components/settings/__tests__/FileEditingOptions.spec.tsx
+
+import { render, screen, fireEvent } from "@/utils/test-utils"
+import { FileEditingOptions } from "../FileEditingOptions"
+
+// Mock VSCode components
+vi.mock("@vscode/webview-ui-toolkit/react", () => ({
+	VSCodeCheckbox: ({ children, checked, onChange, "data-testid": dataTestId }: any) => (
+		<label>
+			<input
+				type="checkbox"
+				checked={checked}
+				onChange={(e) => onChange && onChange({ target: { checked: e.target.checked } })}
+				data-testid={dataTestId}
+			/>
+			{children}
+		</label>
+	),
+}))
+
+// Mock lucide-react icons
+vi.mock("lucide-react", () => ({
+	FileEdit: () => <span data-testid="file-edit-icon">FileEdit Icon</span>,
+}))
+
+// Mock the vscode module
+const mockPostMessage = vi.fn()
+vi.mock("@/utils/vscode", () => ({
+	vscode: {
+		postMessage: () => mockPostMessage(),
+	},
+}))
+
+describe("FileEditingOptions", () => {
+	let mockSetCachedStateField: ReturnType<typeof vi.fn>
+
+	beforeEach(() => {
+		vi.clearAllMocks()
+		mockSetCachedStateField = vi.fn()
+	})
+
+	const renderFileEditingOptions = (props = {}) => {
+		const defaultProps = {
+			autoCloseRooTabs: false,
+			autoCloseAllRooTabs: false,
+			setCachedStateField: mockSetCachedStateField,
+			...props,
+		}
+
+		render(<FileEditingOptions {...defaultProps} />)
+	}
+
+	it("renders the component with correct title and icon", () => {
+		renderFileEditingOptions()
+
+		expect(screen.getByText("settings:fileEditing.title")).toBeInTheDocument()
+		expect(screen.getByText("settings:fileEditing.description")).toBeInTheDocument()
+		expect(screen.getByTestId("file-edit-icon")).toBeInTheDocument()
+	})
+
+	it("displays both checkboxes with correct labels", () => {
+		renderFileEditingOptions()
+
+		expect(screen.getByText("settings:fileEditing.autoCloseRooTabs.label")).toBeInTheDocument()
+		expect(screen.getByText("settings:fileEditing.autoCloseRooTabs.description")).toBeInTheDocument()
+		expect(screen.getByText("settings:fileEditing.autoCloseAllRooTabs.label")).toBeInTheDocument()
+		expect(screen.getByText("settings:fileEditing.autoCloseAllRooTabs.description")).toBeInTheDocument()
+	})
+
+	it("does not display the info message when both options are false", () => {
+		renderFileEditingOptions({
+			autoCloseRooTabs: false,
+			autoCloseAllRooTabs: false,
+		})
+
+		expect(screen.queryByText("settings:fileEditing.tabClosingInfo")).not.toBeInTheDocument()
+	})
+
+	it("displays the info message when autoCloseRooTabs is true", () => {
+		renderFileEditingOptions({
+			autoCloseRooTabs: true,
+			autoCloseAllRooTabs: false,
+		})
+
+		expect(screen.getByText("settings:fileEditing.tabClosingInfo")).toBeInTheDocument()
+	})
+
+	it("displays the info message when autoCloseAllRooTabs is true", () => {
+		renderFileEditingOptions({
+			autoCloseRooTabs: false,
+			autoCloseAllRooTabs: true,
+		})
+
+		expect(screen.getByText("settings:fileEditing.tabClosingInfo")).toBeInTheDocument()
+	})
+
+	it("reflects the correct initial state from props", () => {
+		renderFileEditingOptions({
+			autoCloseRooTabs: true,
+			autoCloseAllRooTabs: false,
+		})
+
+		const autoCloseCheckbox = screen.getByTestId("auto-close-roo-tabs-checkbox")
+		const autoCloseAllCheckbox = screen.getByTestId("auto-close-all-roo-tabs-checkbox")
+
+		expect(autoCloseCheckbox).toBeChecked()
+		expect(autoCloseAllCheckbox).not.toBeChecked()
+	})
+
+	it("calls setCachedStateField when autoCloseRooTabs checkbox is toggled", () => {
+		renderFileEditingOptions({
+			autoCloseRooTabs: false,
+			autoCloseAllRooTabs: false,
+		})
+
+		const autoCloseCheckbox = screen.getByTestId("auto-close-roo-tabs-checkbox")
+
+		fireEvent.click(autoCloseCheckbox)
+
+		expect(mockSetCachedStateField).toHaveBeenCalledWith("autoCloseRooTabs", true)
+	})
+
+	it("calls setCachedStateField when autoCloseAllRooTabs checkbox is toggled", () => {
+		renderFileEditingOptions({
+			autoCloseRooTabs: false,
+			autoCloseAllRooTabs: false,
+		})
+
+		const autoCloseAllCheckbox = screen.getByTestId("auto-close-all-roo-tabs-checkbox")
+
+		fireEvent.click(autoCloseAllCheckbox)
+
+		expect(mockSetCachedStateField).toHaveBeenCalledWith("autoCloseAllRooTabs", true)
+	})
+
+	it("handles multiple toggles correctly", () => {
+		renderFileEditingOptions({
+			autoCloseRooTabs: false,
+			autoCloseAllRooTabs: false,
+		})
+
+		const autoCloseCheckbox = screen.getByTestId("auto-close-roo-tabs-checkbox")
+		const autoCloseAllCheckbox = screen.getByTestId("auto-close-all-roo-tabs-checkbox")
+
+		// Toggle autoCloseRooTabs on
+		fireEvent.click(autoCloseCheckbox)
+		expect(mockSetCachedStateField).toHaveBeenCalledWith("autoCloseRooTabs", true)
+
+		// Toggle autoCloseAllRooTabs on
+		fireEvent.click(autoCloseAllCheckbox)
+		expect(mockSetCachedStateField).toHaveBeenCalledWith("autoCloseAllRooTabs", true)
+
+		// Toggle autoCloseRooTabs off (simulating it was already checked)
+		// Note: Since we're not re-rendering with updated props, we need to manually set the checked state
+		// In a real scenario, the parent component would re-render with updated props
+		expect(mockSetCachedStateField).toHaveBeenCalledTimes(2)
+	})
+
+	it("renders with proper styling classes", () => {
+		renderFileEditingOptions()
+
+		// Check for the space-y-4 class on the container
+		const checkboxContainer = screen.getByTestId("auto-close-roo-tabs-checkbox").closest(".space-y-4")
+		expect(checkboxContainer).toBeInTheDocument()
+
+		// Check for description styling
+		const descriptions = screen.getAllByText(/settings:fileEditing.*description/)
+		descriptions.forEach((desc) => {
+			expect(desc).toHaveClass("text-vscode-descriptionForeground", "text-sm")
+		})
+	})
+
+	it("passes additional HTML attributes to the root element", () => {
+		const { container } = render(
+			<FileEditingOptions
+				autoCloseRooTabs={false}
+				autoCloseAllRooTabs={false}
+				setCachedStateField={vi.fn()}
+				className="custom-class"
+				data-custom="test"
+			/>,
+		)
+
+		// The root element is the first div
+		const rootElement = container.firstChild as HTMLElement
+		expect(rootElement).toHaveClass("custom-class")
+		expect(rootElement).toHaveAttribute("data-custom", "test")
+	})
+})

webview-ui/src/context/ExtensionStateContext.tsx

@@ -134,6 +134,10 @@ export interface ExtensionStateContextType extends ExtensionState {
 	routerModels?: RouterModels
 	alwaysAllowUpdateTodoList?: boolean
 	setAlwaysAllowUpdateTodoList: (value: boolean) => void
+	autoCloseRooTabs?: boolean
+	setAutoCloseRooTabs: (value: boolean) => void
+	autoCloseAllRooTabs?: boolean
+	setAutoCloseAllRooTabs: (value: boolean) => void
 }
 
 export const ExtensionStateContext = createContext<ExtensionStateContextType | undefined>(undefined)
@@ -474,6 +478,14 @@ export const ExtensionStateContextProvider: React.FC<{ children: React.ReactNode
 		setAlwaysAllowUpdateTodoList: (value) => {
 			setState((prevState) => ({ ...prevState, alwaysAllowUpdateTodoList: value }))
 		},
+		autoCloseRooTabs: state.autoCloseRooTabs,
+		setAutoCloseRooTabs: (value) => {
+			setState((prevState) => ({ ...prevState, autoCloseRooTabs: value }))
+		},
+		autoCloseAllRooTabs: state.autoCloseAllRooTabs,
+		setAutoCloseAllRooTabs: (value) => {
+			setState((prevState) => ({ ...prevState, autoCloseAllRooTabs: value }))
+		},
 	}
 
 	return <ExtensionStateContext.Provider value={contextValue}>{children}</ExtensionStateContext.Provider>

webview-ui/src/i18n/locales/en/settings.json

@@ -31,7 +31,8 @@
 		"prompts": "Prompts",
 		"experimental": "Experimental",
 		"language": "Language",
-		"about": "About Roo Code"
+		"about": "About Roo Code",
+		"fileEditing": "File Editing"
 	},
 	"prompts": {
 		"description": "Configure support prompts that are used for quick actions like enhancing prompts, explaining code, and fixing issues. These prompts help Roo provide better assistance for common development tasks."
@@ -718,5 +719,18 @@
 		"useCustomArn": "Use custom ARN..."
 	},
 	"includeMaxOutputTokens": "Include max output tokens",
-	"includeMaxOutputTokensDescription": "Send max output tokens parameter in API requests. Some providers may not support this."
+	"includeMaxOutputTokensDescription": "Send max output tokens parameter in API requests. Some providers may not support this.",
+	"fileEditing": {
+		"title": "File Editing",
+		"description": "Configure how Roo handles tabs after editing files.",
+		"autoCloseRooTabs": {
+			"label": "Auto-close tabs opened during current task",
+			"description": "Automatically close tabs that were opened by Roo during the current task after saving changes."
+		},
+		"autoCloseAllRooTabs": {
+			"label": "Auto-close all Roo tabs",
+			"description": "Automatically close all tabs that were opened or edited by Roo, regardless of when they were opened."
+		},
+		"tabClosingInfo": "Tab closing happens after file changes are saved. Tabs with unsaved changes will not be closed."
+	}
 }