diff --git a/apps/desktop/docs/LANGUAGE_SERVICES.md b/apps/desktop/docs/LANGUAGE_SERVICES.md
new file mode 100644
index 00000000000..19e5742edf5
--- /dev/null
+++ b/apps/desktop/docs/LANGUAGE_SERVICES.md
@@ -0,0 +1,64 @@
+# Desktop Language Services
+
+This document tracks the IDE-oriented diagnostics stack used by the desktop app.
+
+## Goals
+
+- Keep editor and sidebar UI stable while adding language-specific diagnostics.
+- Match VS Code behavior as closely as practical for each language.
+- Make it easy to add new providers behind the same manager/store/router flow.
+
+## Current Providers
+
+### TypeScript / JavaScript / TSX / JSX
+
+- Backend: `tsserver`
+- Reason: VS Code uses `tsserver` for TypeScript and JavaScript language features, so this is the closest path to parity.
+- Source:
+  - https://github.com/microsoft/TypeScript/wiki/Standalone-Server-%28tsserver%29
+
+### JSON / JSONC
+
+- Backend: `vscode-json-languageservice`
+- Reason: This is the JSON language service used in the VS Code ecosystem and supports schema-backed validation.
+- Source:
+  - https://github.com/microsoft/vscode-json-languageservice
+
+### TOML
+
+- Backend: `@taplo/lib`
+- Reason: Taplo is the de facto TOML toolkit with a maintained JavaScript/WASM entrypoint suitable for desktop embedding.
+- Source:
+  - https://taplo.tamasfe.dev/lib/javascript/lib.html
+
+### Dart / Flutter
+
+- Backend: Dart language server via `dart language-server`
+- Reason: This matches the official Dart analysis server/LSP flow and works for both Dart and Flutter projects.
+- Sources:
+  - https://dart.dev/tools/analysis-server
+  - https://raw.githubusercontent.com/dart-lang/sdk/main/pkg/analysis_server/tool/lsp_spec/README.md
+
+## Architecture
+
+- `main/lib/language-services/manager.ts`
+  - Registers providers
+  - Tracks provider enable/disable state
+  - Produces workspace snapshots for the Problems view
+- `main/lib/language-services/diagnostics-store.ts`
+  - Holds normalized diagnostics per provider/file/workspace
+- `main/lib/language-services/lsp/StdioJsonRpcClient.ts`
+  - Shared stdio JSON-RPC transport for LSP-based providers
+- `renderer/providers/LanguageServicesProvider`
+  - Syncs open editor documents to enabled providers
+- `renderer/routes/_authenticated/settings/behavior/components/DiagnosticsSettings`
+  - Lets users toggle providers on or off
+
+## Adding a New Provider
+
+1. Implement `LanguageServiceProvider`.
+2. Normalize diagnostics into `LanguageServiceDiagnostic`.
+3. Register the provider in `LanguageServiceManager`.
+4. Add a renderer-side language mapping in `LanguageServicesProvider`.
+5. Add syntax highlighting support if needed in `detect-language.ts` and `loadLanguageSupport.ts`.
+6. Extend the settings store/provider ID union if the provider should be user-toggleable.
diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index c5361fdb94a..45e607d54ef 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -18,7 +18,7 @@
 		"start": "electron-vite preview",
 		"generate:icons": "bun run scripts/generate-file-icons.ts",
 		"predev": "cross-env NODE_ENV=development bun run clean:dev && bun run generate:icons && cross-env NODE_ENV=development bun run scripts/clean-launch-services.ts && cross-env NODE_ENV=development bun run scripts/patch-dev-protocol.ts",
-		"dev": "cross-env NODE_ENV=development electron-vite dev --watch",
+		"dev": "cross-env NODE_ENV=development NODE_OPTIONS=--max-old-space-size=8192 electron-vite dev --watch",
 		"compile:app": "cross-env NODE_OPTIONS=--max-old-space-size=8192 electron-vite build",
 		"copy:native-modules": "bun run scripts/copy-native-modules.ts",
 		"validate:native-runtime": "bun run scripts/validate-native-runtime.ts",
@@ -99,6 +99,7 @@
 		"@tanstack/react-router": "^1.147.3",
 		"@tanstack/react-table": "^8.21.3",
 		"@tanstack/react-virtual": "^3.13.18",
+		"@taplo/lib": "^0.5.0",
 		"@tiptap/core": "^3.17.1",
 		"@tiptap/extension-blockquote": "^3.17.1",
 		"@tiptap/extension-bold": "^3.17.1",
@@ -187,6 +188,7 @@
 		"node-addon-api": "^7.1.0",
 		"node-pty": "1.1.0",
 		"os-locale": "^6.0.2",
+		"pg": "8.20.0",
 		"pidtree": "^0.6.0",
 		"pidusage": "^4.0.1",
 		"posthog-js": "1.310.1",
@@ -222,6 +224,8 @@
 		"use-resize-observer": "^9.1.0",
 		"utf-8-validate": "^6.0.6",
 		"uuid": "^13.0.0",
+		"vscode-json-languageservice": "^5.7.2",
+		"vscode-languageserver-textdocument": "^1.0.12",
 		"zod": "^4.3.5",
 		"zustand": "^5.0.8"
 	},
@@ -238,6 +242,7 @@
 		"@types/http-proxy": "^1.17.17",
 		"@types/lodash": "^4.17.20",
 		"@types/node": "^24.9.1",
+		"@types/pg": "8.15.6",
 		"@types/react": "~19.2.2",
 		"@types/react-dom": "^19.2.3",
 		"@types/react-syntax-highlighter": "^15.5.13",
diff --git a/apps/desktop/src/lib/trpc/routers/databases/index.ts b/apps/desktop/src/lib/trpc/routers/databases/index.ts
new file mode 100644
index 00000000000..099dd928750
--- /dev/null
+++ b/apps/desktop/src/lib/trpc/routers/databases/index.ts
@@ -0,0 +1,871 @@
+import type { Stats } from "node:fs";
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { TRPCError } from "@trpc/server";
+import Database from "better-sqlite3";
+import fg from "fast-glob";
+import { Client } from "pg";
+import { z } from "zod";
+import { publicProcedure, router } from "../..";
+
+const SQLITE_FILE_GLOBS = [
+	"**/*.db",
+	"**/*.sqlite",
+	"**/*.sqlite3",
+	"**/*.db3",
+	"**/*.duckdb",
+];
+
+const SQLITE_ROW_ID_COLUMN = "__superset_rowid";
+const SQLITE_PRIMARY_KEY_COLUMN = "__superset_primary_key";
+const POSTGRES_ROW_ID_COLUMN = "__superset_ctid";
+const PREVIEW_TEXT_LIMIT = 180;
+
+function isAbsoluteFilesystemPath(inputPath: string): boolean {
+	return path.isAbsolute(inputPath) || /^[A-Za-z]:[\\/]/.test(inputPath);
+}
+
+function ensureAbsoluteFilesystemPath(inputPath: string): void {
+	if (!isAbsoluteFilesystemPath(inputPath)) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Database path must be absolute.",
+		});
+	}
+}
+
+async function ensureExistingFile(inputPath: string): Promise<void> {
+	let metadata: Stats;
+	try {
+		metadata = await stat(inputPath);
+	} catch {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: `Database file not found: ${inputPath}`,
+		});
+	}
+
+	if (!metadata.isFile()) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: `Path is not a file: ${inputPath}`,
+		});
+	}
+}
+
+async function ensureExistingDirectory(inputPath: string): Promise<void> {
+	let metadata: Stats;
+	try {
+		metadata = await stat(inputPath);
+	} catch {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: `Workspace path not found: ${inputPath}`,
+		});
+	}
+
+	if (!metadata.isDirectory()) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: `Path is not a directory: ${inputPath}`,
+		});
+	}
+}
+
+function quoteSqliteIdentifier(identifier: string): string {
+	return `"${identifier.replaceAll('"', '""')}"`;
+}
+
+function quotePostgresIdentifier(identifier: string): string {
+	return `"${identifier.replaceAll('"', '""')}"`;
+}
+
+function quoteSqlStringLiteral(value: string): string {
+	return `'${value.replaceAll("'", "''")}'`;
+}
+
+function buildSqlitePreviewExpression(
+	columnName: string,
+	declaredType: string | null | undefined,
+): string {
+	const quotedColumn = quoteSqliteIdentifier(columnName);
+	const normalizedType = (declaredType ?? "").toLowerCase();
+
+	if (normalizedType.includes("blob")) {
+		return `CASE WHEN ${quotedColumn} IS NULL THEN NULL ELSE '<blob ' || length(${quotedColumn}) || ' bytes>' END AS ${quoteSqliteIdentifier(columnName)}`;
+	}
+
+	if (
+		normalizedType.includes("text") ||
+		normalizedType.includes("char") ||
+		normalizedType.includes("clob") ||
+		normalizedType.includes("json") ||
+		normalizedType.length === 0
+	) {
+		return `CASE
+			WHEN ${quotedColumn} IS NULL THEN NULL
+			WHEN typeof(${quotedColumn}) = 'text' AND length(CAST(${quotedColumn} AS TEXT)) > ${PREVIEW_TEXT_LIMIT}
+				THEN substr(CAST(${quotedColumn} AS TEXT), 1, ${PREVIEW_TEXT_LIMIT}) || '…'
+			ELSE ${quotedColumn}
+		END AS ${quoteSqliteIdentifier(columnName)}`;
+	}
+
+	return `${quotedColumn} AS ${quoteSqliteIdentifier(columnName)}`;
+}
+
+function buildPostgresPreviewExpression(input: {
+	columnName: string;
+	dataType: string;
+	udtName: string;
+}): string {
+	const quotedColumn = quotePostgresIdentifier(input.columnName);
+	const outputAlias = quotePostgresIdentifier(input.columnName);
+	const normalizedType = input.dataType.toLowerCase();
+	const normalizedUdtName = input.udtName.toLowerCase();
+
+	if (normalizedType === "bytea") {
+		return `CASE WHEN ${quotedColumn} IS NULL THEN NULL ELSE '<bytea ' || octet_length(${quotedColumn})::text || ' bytes>' END AS ${outputAlias}`;
+	}
+
+	if (normalizedType === "json" || normalizedType === "jsonb") {
+		return `CASE
+			WHEN ${quotedColumn} IS NULL THEN NULL
+			ELSE '<${normalizedType}> ' || left(${quotedColumn}::text, ${PREVIEW_TEXT_LIMIT}) ||
+				CASE WHEN length(${quotedColumn}::text) > ${PREVIEW_TEXT_LIMIT} THEN '…' ELSE '' END
+		END AS ${outputAlias}`;
+	}
+
+	if (normalizedType === "array") {
+		return `CASE
+			WHEN ${quotedColumn} IS NULL THEN NULL
+			ELSE 'Array(' || coalesce(cardinality(${quotedColumn}), 0)::text || ') ' ||
+				left(${quotedColumn}::text, ${PREVIEW_TEXT_LIMIT}) ||
+				CASE WHEN length(${quotedColumn}::text) > ${PREVIEW_TEXT_LIMIT} THEN '…' ELSE '' END
+		END AS ${outputAlias}`;
+	}
+
+	if (
+		normalizedType === "text" ||
+		normalizedType === "character varying" ||
+		normalizedType === "character" ||
+		normalizedType === "xml" ||
+		normalizedType === "citext" ||
+		normalizedType === "tsvector" ||
+		normalizedType === "tsquery" ||
+		normalizedUdtName === "vector" ||
+		normalizedUdtName === "halfvec" ||
+		normalizedUdtName === "sparsevec" ||
+		normalizedUdtName === "geometry" ||
+		normalizedUdtName === "geography" ||
+		normalizedUdtName === "hstore"
+	) {
+		return `CASE
+			WHEN ${quotedColumn} IS NULL THEN NULL
+			WHEN length(${quotedColumn}::text) > ${PREVIEW_TEXT_LIMIT}
+				THEN left(${quotedColumn}::text, ${PREVIEW_TEXT_LIMIT}) || '…'
+			ELSE ${quotedColumn}::text
+		END AS ${outputAlias}`;
+	}
+
+	return `${quotedColumn} AS ${outputAlias}`;
+}
+
+function getSqliteTableMetadata(
+	db: Database.Database,
+	tableName: string,
+): {
+	columns: Array<{
+		cid: number;
+		name: string;
+		type: string | null;
+		notnull: 0 | 1;
+		dflt_value: string | null;
+		pk: number;
+	}>;
+	primaryKeyColumns: Array<{
+		cid: number;
+		name: string;
+		type: string | null;
+		notnull: 0 | 1;
+		dflt_value: string | null;
+		pk: number;
+	}>;
+	hasRowId: boolean;
+} {
+	const columns = db
+		.prepare(`PRAGMA table_info(${quoteSqliteIdentifier(tableName)})`)
+		.all() as Array<{
+		cid: number;
+		name: string;
+		type: string | null;
+		notnull: 0 | 1;
+		dflt_value: string | null;
+		pk: number;
+	}>;
+	const primaryKeyColumns = columns
+		.filter((column) => column.pk > 0)
+		.sort((left, right) => left.pk - right.pk);
+	const tableDefinition = db
+		.prepare(
+			"SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1",
+		)
+		.get(tableName) as { sql?: string | null } | undefined;
+
+	return {
+		columns,
+		primaryKeyColumns,
+		hasRowId: !/without\s+rowid/i.test(tableDefinition?.sql ?? ""),
+	};
+}
+
+function buildSqlitePrimaryKeyPreviewExpression(
+	primaryKeyColumns: Array<{ name: string }>,
+): string {
+	if (primaryKeyColumns.length === 0) {
+		return `NULL AS ${quoteSqliteIdentifier(SQLITE_PRIMARY_KEY_COLUMN)}`;
+	}
+
+	const jsonEntries = primaryKeyColumns.flatMap((column) => [
+		quoteSqlStringLiteral(column.name),
+		quoteSqliteIdentifier(column.name),
+	]);
+
+	return `json_object(${jsonEntries.join(", ")}) AS ${quoteSqliteIdentifier(SQLITE_PRIMARY_KEY_COLUMN)}`;
+}
+
+function openSqliteDatabase(databasePath: string): Database.Database {
+	try {
+		return new Database(databasePath, {
+			fileMustExist: true,
+		});
+	} catch (error) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message:
+				error instanceof Error
+					? error.message
+					: "Failed to open SQLite database.",
+		});
+	}
+}
+
+async function withPostgresClient<T>(
+	connectionString: string,
+	callback: (client: Client) => Promise<T>,
+): Promise<T> {
+	const client = new Client({ connectionString });
+
+	try {
+		await client.connect();
+		return await callback(client);
+	} catch (error) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message:
+				error instanceof Error
+					? error.message
+					: "Failed to connect to PostgreSQL.",
+		});
+	} finally {
+		await client.end().catch(() => undefined);
+	}
+}
+
+function stripTrailingSemicolon(sql: string): string {
+	return sql.replace(/;\s*$/, "");
+}
+
+function canApplyPostgresReadLimit(sql: string): boolean {
+	return /^(select|with|values|table)\b/i.test(sql.trim());
+}
+
+export const createDatabasesRouter = () => {
+	return router({
+		discoverSqliteFiles: publicProcedure
+			.input(
+				z.object({
+					worktreePath: z.string().min(1),
+					limit: z.number().int().positive().max(200).optional(),
+				}),
+			)
+			.query(async ({ input }) => {
+				ensureAbsoluteFilesystemPath(input.worktreePath);
+				await ensureExistingDirectory(input.worktreePath);
+
+				const limit = input.limit ?? 50;
+				const files = await fg(SQLITE_FILE_GLOBS, {
+					absolute: true,
+					cwd: input.worktreePath,
+					onlyFiles: true,
+					unique: true,
+					suppressErrors: true,
+					ignore: [
+						"**/.git/**",
+						"**/.next/**",
+						"**/.turbo/**",
+						"**/dist/**",
+						"**/node_modules/**",
+					],
+				});
+
+				return {
+					files: files
+						.sort((left, right) => left.localeCompare(right))
+						.slice(0, limit)
+						.map((absolutePath) => ({
+							absolutePath,
+							relativePath: path.relative(input.worktreePath, absolutePath),
+						})),
+				};
+			}),
+
+		inspectSqlite: publicProcedure
+			.input(
+				z.object({
+					databasePath: z.string().min(1),
+				}),
+			)
+			.query(async ({ input }) => {
+				ensureAbsoluteFilesystemPath(input.databasePath);
+				await ensureExistingFile(input.databasePath);
+
+				const db = openSqliteDatabase(input.databasePath);
+
+				try {
+					const tables = db
+						.prepare(
+							`
+								SELECT name, type
+								FROM sqlite_master
+								WHERE type IN ('table', 'view')
+									AND name NOT LIKE 'sqlite_%'
+								ORDER BY type, name
+							`,
+						)
+						.all() as Array<{
+						name: string;
+						type: "table" | "view";
+					}>;
+
+					return {
+						tables: tables.map((table) => ({
+							schema: null,
+							name: table.name,
+							type: table.type,
+							columns: db
+								.prepare(
+									`PRAGMA table_info(${quoteSqliteIdentifier(table.name)})`,
+								)
+								.all() as Array<{
+								cid: number;
+								name: string;
+								type: string;
+								notnull: 0 | 1;
+								dflt_value: string | null;
+								pk: 0 | 1;
+							}>,
+						})),
+					};
+				} finally {
+					db.close();
+				}
+			}),
+
+		inspectPostgres: publicProcedure
+			.input(
+				z.object({
+					connectionString: z.string().min(1),
+				}),
+			)
+			.query(async ({ input }) => {
+				return await withPostgresClient(
+					input.connectionString,
+					async (client) => {
+						const result = await client.query<{
+							table_schema: string;
+							table_name: string;
+							table_type: string;
+							column_name: string;
+							data_type: string;
+							is_nullable: "YES" | "NO";
+							ordinal_position: number;
+						}>(`
+						SELECT
+							t.table_schema,
+							t.table_name,
+							t.table_type,
+							c.column_name,
+							c.data_type,
+							c.is_nullable,
+							c.ordinal_position
+						FROM information_schema.tables t
+						JOIN information_schema.columns c
+							ON t.table_schema = c.table_schema
+							AND t.table_name = c.table_name
+						WHERE t.table_schema NOT IN ('pg_catalog', 'information_schema')
+						ORDER BY t.table_schema, t.table_name, c.ordinal_position
+					`);
+
+						const tables = new Map<
+							string,
+							{
+								schema: string;
+								name: string;
+								type: string;
+								columns: {
+									cid: number;
+									name: string;
+									type: string;
+									notnull: 0 | 1;
+									dflt_value: string | null;
+									pk: 0 | 1;
+								}[];
+							}
+						>();
+
+						for (const row of result.rows) {
+							const key = `${row.table_schema}.${row.table_name}`;
+							const current:
+								| {
+										schema: string;
+										name: string;
+										type: string;
+										columns: {
+											cid: number;
+											name: string;
+											type: string;
+											notnull: 0 | 1;
+											dflt_value: string | null;
+											pk: 0 | 1;
+										}[];
+								  }
+								| undefined = tables.get(key);
+							const nextTable = current ?? {
+								schema: row.table_schema,
+								name: row.table_name,
+								type: row.table_type.toLowerCase(),
+								columns: [] as {
+									cid: number;
+									name: string;
+									type: string;
+									notnull: 0 | 1;
+									dflt_value: string | null;
+									pk: 0 | 1;
+								}[],
+							};
+							nextTable.columns.push({
+								cid: row.ordinal_position,
+								name: row.column_name,
+								type: row.data_type,
+								notnull: row.is_nullable === "NO" ? 1 : 0,
+								dflt_value: null,
+								pk: 0,
+							});
+							tables.set(key, nextTable);
+						}
+
+						return {
+							tables: Array.from(tables.values()),
+						};
+					},
+				);
+			}),
+
+		previewSqliteTable: publicProcedure
+			.input(
+				z.object({
+					databasePath: z.string().min(1),
+					tableName: z.string().min(1),
+					limit: z.number().int().positive().max(200).optional(),
+					offset: z.number().int().min(0).optional(),
+				}),
+			)
+			.query(async ({ input }) => {
+				try {
+					ensureAbsoluteFilesystemPath(input.databasePath);
+					await ensureExistingFile(input.databasePath);
+
+					const db = openSqliteDatabase(input.databasePath);
+					const limit = input.limit ?? 50;
+					const offset = input.offset ?? 0;
+					const startedAt = performance.now();
+					try {
+						const metadata = getSqliteTableMetadata(db, input.tableName);
+						const previewSelect = metadata.columns
+							.map((column) =>
+								buildSqlitePreviewExpression(column.name, column.type),
+							)
+							.join(", ");
+						const selectColumns = [
+							metadata.hasRowId
+								? `rowid AS ${quoteSqliteIdentifier(SQLITE_ROW_ID_COLUMN)}`
+								: null,
+							buildSqlitePrimaryKeyPreviewExpression(
+								metadata.primaryKeyColumns,
+							),
+							previewSelect,
+						].filter(Boolean);
+						const statement = db.prepare(
+							`SELECT ${selectColumns.join(", ")} FROM ${quoteSqliteIdentifier(input.tableName)} LIMIT ? OFFSET ?`,
+						);
+						const previewRows = statement.all(limit + 1, offset) as Array<
+							Record<string, unknown>
+						>;
+						const hasMore = previewRows.length > limit;
+						const rows = hasMore ? previewRows.slice(0, limit) : previewRows;
+
+						return {
+							columns: statement
+								.columns()
+								.map((column) => column.name)
+								.filter(
+									(column) =>
+										column !== SQLITE_ROW_ID_COLUMN &&
+										column !== SQLITE_PRIMARY_KEY_COLUMN,
+								),
+							rows,
+							rowCount: rows.length,
+							totalRows: null,
+							hasMore,
+							offset,
+							limit,
+							elapsedMs: Math.round(performance.now() - startedAt),
+						};
+					} finally {
+						db.close();
+					}
+				} catch (error) {
+					throw new TRPCError({
+						code: "BAD_REQUEST",
+						message:
+							error instanceof Error
+								? error.message
+								: "Failed to preview SQLite table.",
+					});
+				}
+			}),
+
+		getSqliteRowDetail: publicProcedure
+			.input(
+				z.object({
+					databasePath: z.string().min(1),
+					tableName: z.string().min(1),
+					rowId: z.union([z.string(), z.number()]).optional(),
+					primaryKey: z.string().optional(),
+				}),
+			)
+			.query(async ({ input }) => {
+				ensureAbsoluteFilesystemPath(input.databasePath);
+				await ensureExistingFile(input.databasePath);
+
+				const db = openSqliteDatabase(input.databasePath);
+				try {
+					const metadata = getSqliteTableMetadata(db, input.tableName);
+					let whereClause = "";
+					const parameters: Array<string | number | null> = [];
+
+					if (metadata.primaryKeyColumns.length > 0) {
+						if (!input.primaryKey) {
+							throw new TRPCError({
+								code: "BAD_REQUEST",
+								message:
+									"Primary key payload is required for this SQLite table.",
+							});
+						}
+
+						let parsedPrimaryKey: Record<string, unknown>;
+						try {
+							parsedPrimaryKey = JSON.parse(input.primaryKey) as Record<
+								string,
+								unknown
+							>;
+						} catch {
+							throw new TRPCError({
+								code: "BAD_REQUEST",
+								message: "Invalid SQLite primary key payload.",
+							});
+						}
+						whereClause = metadata.primaryKeyColumns
+							.map((column) => {
+								const value = parsedPrimaryKey[column.name];
+								if (value === null) {
+									return `${quoteSqliteIdentifier(column.name)} IS NULL`;
+								}
+								parameters.push((value ?? null) as string | number | null);
+								return `${quoteSqliteIdentifier(column.name)} = ?`;
+							})
+							.join(" AND ");
+					} else if (metadata.hasRowId) {
+						if (input.rowId === undefined) {
+							throw new TRPCError({
+								code: "BAD_REQUEST",
+								message: "rowid is required for this SQLite table.",
+							});
+						}
+						whereClause = "rowid = ?";
+						parameters.push(input.rowId);
+					} else {
+						throw new TRPCError({
+							code: "BAD_REQUEST",
+							message:
+								"This SQLite table has neither a rowid nor a primary key.",
+						});
+					}
+
+					const row = db
+						.prepare(
+							`SELECT * FROM ${quoteSqliteIdentifier(input.tableName)} WHERE ${whereClause} LIMIT 1`,
+						)
+						.get(...parameters) as Record<string, unknown> | undefined;
+
+					if (!row) {
+						throw new TRPCError({
+							code: "NOT_FOUND",
+							message: "Row not found.",
+						});
+					}
+
+					return { row };
+				} finally {
+					db.close();
+				}
+			}),
+
+		previewPostgresTable: publicProcedure
+			.input(
+				z.object({
+					connectionString: z.string().min(1),
+					schema: z.string().min(1),
+					tableName: z.string().min(1),
+					limit: z.number().int().positive().max(200).optional(),
+					offset: z.number().int().min(0).optional(),
+				}),
+			)
+			.query(async ({ input }) => {
+				const limit = input.limit ?? 50;
+				const offset = input.offset ?? 0;
+				const startedAt = performance.now();
+
+				return await withPostgresClient(
+					input.connectionString,
+					async (client) => {
+						const columnInfo = await client.query<{
+							column_name: string;
+							data_type: string;
+							udt_name: string;
+							ordinal_position: number;
+						}>(
+							`
+								SELECT column_name, data_type, udt_name, ordinal_position
+								FROM information_schema.columns
+								WHERE table_schema = $1 AND table_name = $2
+								ORDER BY ordinal_position
+							`,
+							[input.schema, input.tableName],
+						);
+						const qualifiedTableName = `${quotePostgresIdentifier(input.schema)}.${quotePostgresIdentifier(input.tableName)}`;
+						const previewSelect = columnInfo.rows
+							.map((column) =>
+								buildPostgresPreviewExpression({
+									columnName: column.column_name,
+									dataType: column.data_type,
+									udtName: column.udt_name,
+								}),
+							)
+							.join(", ");
+						const dataResult = await client.query(
+							`SELECT ctid::text AS ${quotePostgresIdentifier(POSTGRES_ROW_ID_COLUMN)}, ${previewSelect} FROM ${qualifiedTableName} LIMIT $1 OFFSET $2`,
+							[limit + 1, offset],
+						);
+						const hasMore = dataResult.rows.length > limit;
+						const rows = hasMore
+							? dataResult.rows.slice(0, limit)
+							: dataResult.rows;
+
+						return {
+							columns: dataResult.fields
+								.map((field: { name: string }) => field.name)
+								.filter((column) => column !== POSTGRES_ROW_ID_COLUMN),
+							rows,
+							rowCount: rows.length,
+							totalRows: null,
+							hasMore,
+							offset,
+							limit,
+							elapsedMs: Math.round(performance.now() - startedAt),
+						};
+					},
+				);
+			}),
+
+		getPostgresRowDetail: publicProcedure
+			.input(
+				z.object({
+					connectionString: z.string().min(1),
+					schema: z.string().min(1),
+					tableName: z.string().min(1),
+					ctid: z.string().min(1),
+				}),
+			)
+			.query(async ({ input }) => {
+				return await withPostgresClient(
+					input.connectionString,
+					async (client) => {
+						const qualifiedTableName = `${quotePostgresIdentifier(input.schema)}.${quotePostgresIdentifier(input.tableName)}`;
+						const result = await client.query(
+							`SELECT ctid::text AS ${quotePostgresIdentifier(POSTGRES_ROW_ID_COLUMN)}, * FROM ${qualifiedTableName} WHERE ctid = $1::tid LIMIT 1`,
+							[input.ctid],
+						);
+
+						const row = result.rows[0] as Record<string, unknown> | undefined;
+						if (!row) {
+							throw new TRPCError({
+								code: "NOT_FOUND",
+								message: "Row not found.",
+							});
+						}
+
+						return { row };
+					},
+				);
+			}),
+
+		executeSqlite: publicProcedure
+			.input(
+				z.object({
+					databasePath: z.string().min(1),
+					sql: z.string().min(1),
+					limit: z.number().int().positive().max(1000).optional(),
+				}),
+			)
+			.mutation(async ({ input }) => {
+				ensureAbsoluteFilesystemPath(input.databasePath);
+				await ensureExistingFile(input.databasePath);
+
+				const sql = input.sql.trim();
+				if (!sql) {
+					throw new TRPCError({
+						code: "BAD_REQUEST",
+						message: "SQL is required.",
+					});
+				}
+
+				const db = openSqliteDatabase(input.databasePath);
+				const startedAt = performance.now();
+
+				try {
+					const statement = db.prepare(sql);
+					const limit = input.limit ?? 200;
+
+					if (!statement.reader) {
+						const result = statement.run();
+						return {
+							columns: [] as string[],
+							rows: [] as Array<Record<string, unknown>>,
+							rowCount: result.changes,
+							truncated: false,
+							elapsedMs: Math.round(performance.now() - startedAt),
+							command: "write",
+							lastInsertRowid:
+								typeof result.lastInsertRowid === "bigint"
+									? result.lastInsertRowid.toString()
+									: result.lastInsertRowid,
+						};
+					}
+
+					const rows: Array<Record<string, unknown>> = [];
+					let truncated = false;
+					for (const row of statement.iterate() as Iterable<
+						Record<string, unknown>
+					>) {
+						if (rows.length >= limit) {
+							truncated = true;
+							break;
+						}
+						rows.push(row);
+					}
+
+					return {
+						columns: statement.columns().map((column) => column.name),
+						rows,
+						rowCount: rows.length,
+						truncated,
+						elapsedMs: Math.round(performance.now() - startedAt),
+						command: "read",
+					};
+				} catch (error) {
+					if (error instanceof TRPCError) {
+						throw error;
+					}
+
+					throw new TRPCError({
+						code: "BAD_REQUEST",
+						message:
+							error instanceof Error ? error.message : "Failed to execute SQL.",
+					});
+				} finally {
+					db.close();
+				}
+			}),
+
+		executePostgres: publicProcedure
+			.input(
+				z.object({
+					connectionString: z.string().min(1),
+					sql: z.string().min(1),
+					limit: z.number().int().positive().max(1000).optional(),
+				}),
+			)
+			.mutation(async ({ input }) => {
+				const sql = input.sql.trim();
+				if (!sql) {
+					throw new TRPCError({
+						code: "BAD_REQUEST",
+						message: "SQL is required.",
+					});
+				}
+
+				const startedAt = performance.now();
+				return await withPostgresClient(
+					input.connectionString,
+					async (client) => {
+						const limit = input.limit ?? 200;
+						if (canApplyPostgresReadLimit(sql)) {
+							const limitedSql = `SELECT * FROM (${stripTrailingSemicolon(
+								sql,
+							)}) AS __superset_query LIMIT ${limit + 1}`;
+							const limitedResult = await client.query(limitedSql);
+							const truncated = limitedResult.rows.length > limit;
+							const rows = truncated
+								? limitedResult.rows.slice(0, limit)
+								: limitedResult.rows;
+
+							return {
+								columns: limitedResult.fields.map(
+									(field: { name: string }) => field.name,
+								),
+								rows,
+								rowCount: rows.length,
+								truncated,
+								elapsedMs: Math.round(performance.now() - startedAt),
+								command: "SELECT",
+							};
+						}
+
+						const result = await client.query(sql);
+
+						return {
+							columns: result.fields.map(
+								(field: { name: string }) => field.name,
+							),
+							rows: result.rows.slice(0, limit),
+							rowCount: result.rowCount ?? result.rows.length,
+							truncated: result.rows.length > limit,
+							elapsedMs: Math.round(performance.now() - startedAt),
+							command: result.command,
+						};
+					},
+				);
+			}),
+	});
+};
diff --git a/apps/desktop/src/lib/trpc/routers/diagnostics/index.ts b/apps/desktop/src/lib/trpc/routers/diagnostics/index.ts
new file mode 100644
index 00000000000..e68297cdcf1
--- /dev/null
+++ b/apps/desktop/src/lib/trpc/routers/diagnostics/index.ts
@@ -0,0 +1,562 @@
+import path from "node:path";
+import { TRPCError } from "@trpc/server";
+import * as ts from "typescript";
+import { z } from "zod";
+import { publicProcedure, router } from "../..";
+import { getWorkspace } from "../workspaces/utils/db-helpers";
+import { getWorkspacePath } from "../workspaces/utils/worktree";
+
+const MAX_PROBLEMS = 500;
+
+const openDocumentSchema = z.object({
+	relativePath: z.string(),
+	content: z.string().nullable(),
+});
+
+const typeScriptProblemSchema = z.object({
+	relativePath: z.string().nullable(),
+	line: z.number().nullable(),
+	column: z.number().nullable(),
+	endLine: z.number().nullable(),
+	endColumn: z.number().nullable(),
+	message: z.string(),
+	code: z.union([z.string(), z.number()]).nullable(),
+	severity: z.enum(["error", "warning", "info", "hint"]),
+	source: z.string(),
+});
+
+function resolveConfigPath(workspacePath: string): string | null {
+	const tsconfigPath = path.join(workspacePath, "tsconfig.json");
+	if (ts.sys.fileExists(tsconfigPath)) {
+		return tsconfigPath;
+	}
+
+	const jsconfigPath = path.join(workspacePath, "jsconfig.json");
+	if (ts.sys.fileExists(jsconfigPath)) {
+		return jsconfigPath;
+	}
+
+	return null;
+}
+
+function findNearestConfigPath(
+	workspacePath: string,
+	relativePath: string,
+): string | null {
+	let currentDirectory = path.resolve(
+		workspacePath,
+		path.dirname(relativePath),
+	);
+	const normalizedWorkspacePath = path.resolve(workspacePath);
+
+	while (true) {
+		const tsconfigPath = path.join(currentDirectory, "tsconfig.json");
+		if (ts.sys.fileExists(tsconfigPath)) {
+			return tsconfigPath;
+		}
+
+		const jsconfigPath = path.join(currentDirectory, "jsconfig.json");
+		if (ts.sys.fileExists(jsconfigPath)) {
+			return jsconfigPath;
+		}
+
+		if (currentDirectory === normalizedWorkspacePath) {
+			return null;
+		}
+
+		const parentDirectory = path.dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) {
+			return null;
+		}
+
+		currentDirectory = parentDirectory;
+	}
+}
+
+function mapSeverity(
+	category: ts.DiagnosticCategory,
+): "error" | "warning" | "info" | "hint" {
+	switch (category) {
+		case ts.DiagnosticCategory.Error:
+			return "error";
+		case ts.DiagnosticCategory.Warning:
+			return "warning";
+		case ts.DiagnosticCategory.Suggestion:
+			return "hint";
+		default:
+			return "info";
+	}
+}
+
+function normalizeRelativePath(
+	workspacePath: string,
+	fileName: string,
+): string | null {
+	const relativePath = path.relative(workspacePath, fileName);
+	if (
+		!relativePath ||
+		relativePath.startsWith("..") ||
+		path.isAbsolute(relativePath)
+	) {
+		return null;
+	}
+
+	return relativePath.split(path.sep).join("/");
+}
+
+function diagnosticSortValue(severity: string): number {
+	switch (severity) {
+		case "error":
+			return 0;
+		case "warning":
+			return 1;
+		case "info":
+			return 2;
+		default:
+			return 3;
+	}
+}
+
+function createOpenDocumentMap(
+	workspacePath: string,
+	openDocuments: Array<{ relativePath: string; content: string | null }>,
+): Map<string, string> {
+	return openDocuments.reduce((map, document) => {
+		if (document.content === null) {
+			return map;
+		}
+
+		map.set(
+			path.resolve(workspacePath, document.relativePath),
+			document.content,
+		);
+		return map;
+	}, new Map<string, string>());
+}
+
+function createCompilerHostWithOpenDocuments(
+	options: ts.CompilerOptions,
+	openDocumentMap: Map<string, string>,
+): ts.CompilerHost {
+	const compilerHost = ts.createCompilerHost(options, true);
+	const originalReadFile = compilerHost.readFile.bind(compilerHost);
+	const originalFileExists = compilerHost.fileExists.bind(compilerHost);
+	const originalGetSourceFile = compilerHost.getSourceFile.bind(compilerHost);
+
+	compilerHost.readFile = (fileName) => {
+		const override = openDocumentMap.get(path.resolve(fileName));
+		if (override !== undefined) {
+			return override;
+		}
+
+		return originalReadFile(fileName);
+	};
+
+	compilerHost.fileExists = (fileName) => {
+		if (openDocumentMap.has(path.resolve(fileName))) {
+			return true;
+		}
+
+		return originalFileExists(fileName);
+	};
+
+	compilerHost.getSourceFile = (
+		fileName,
+		languageVersionOrOptions,
+		onError,
+		shouldCreateNewSourceFile,
+	) => {
+		const override = openDocumentMap.get(path.resolve(fileName));
+		if (override !== undefined) {
+			return ts.createSourceFile(
+				fileName,
+				override,
+				languageVersionOrOptions,
+				true,
+			);
+		}
+
+		return originalGetSourceFile(
+			fileName,
+			languageVersionOrOptions,
+			onError,
+			shouldCreateNewSourceFile,
+		);
+	};
+
+	return compilerHost;
+}
+
+function getStandaloneCompilerOptions(filePath: string): ts.CompilerOptions {
+	const extension = path.extname(filePath).toLowerCase();
+	return {
+		noEmit: true,
+		allowJs: [".js", ".jsx", ".mjs", ".cjs"].includes(extension),
+		checkJs: [".js", ".jsx", ".mjs", ".cjs"].includes(extension),
+		jsx: [".jsx", ".tsx"].includes(extension) ? ts.JsxEmit.Preserve : undefined,
+		target: ts.ScriptTarget.ESNext,
+		module: ts.ModuleKind.ESNext,
+		skipLibCheck: true,
+		moduleResolution: ts.ModuleResolutionKind.Bundler,
+	};
+}
+
+function createProblemKey(problem: {
+	relativePath: string | null;
+	line: number | null;
+	column: number | null;
+	message: string;
+	code: string | number | null;
+	severity: string;
+	source: string;
+}): string {
+	return [
+		problem.relativePath ?? "workspace",
+		problem.line ?? 0,
+		problem.column ?? 0,
+		problem.code ?? "no-code",
+		problem.severity,
+		problem.source,
+		problem.message,
+	].join("::");
+}
+
+function mapDiagnosticsToProblems(
+	diagnostics: readonly ts.Diagnostic[],
+	workspacePath: string,
+) {
+	return diagnostics
+		.map((diagnostic) => {
+			const message = ts.flattenDiagnosticMessageText(
+				diagnostic.messageText,
+				"\n",
+			);
+			const severity = mapSeverity(diagnostic.category);
+			const relativePath = diagnostic.file?.fileName
+				? normalizeRelativePath(workspacePath, diagnostic.file.fileName)
+				: null;
+
+			if (diagnostic.file?.fileName && relativePath === null) {
+				return null;
+			}
+
+			const start =
+				diagnostic.file && typeof diagnostic.start === "number"
+					? diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start)
+					: null;
+			const end =
+				diagnostic.file &&
+				typeof diagnostic.start === "number" &&
+				typeof diagnostic.length === "number"
+					? diagnostic.file.getLineAndCharacterOfPosition(
+							diagnostic.start + diagnostic.length,
+						)
+					: null;
+
+			return {
+				relativePath,
+				line: start ? start.line + 1 : null,
+				column: start ? start.character + 1 : null,
+				endLine: end ? end.line + 1 : null,
+				endColumn: end ? end.character + 1 : null,
+				message,
+				code: diagnostic.code ?? null,
+				severity,
+				source: "typescript",
+			};
+		})
+		.filter(
+			(problem): problem is NonNullable<typeof problem> => problem !== null,
+		);
+}
+
+function filterProblemsForOpenDocuments(
+	problems: Array<z.infer<typeof typeScriptProblemSchema>>,
+	openDocuments: Array<{ relativePath: string; content: string | null }>,
+) {
+	if (openDocuments.length === 0) {
+		return problems;
+	}
+
+	const openDocumentPaths = new Set(
+		openDocuments.map((document) => document.relativePath),
+	);
+
+	return problems.filter((problem) => {
+		if (problem.relativePath === null) {
+			return false;
+		}
+
+		return openDocumentPaths.has(problem.relativePath);
+	});
+}
+
+export const createDiagnosticsRouter = () => {
+	return router({
+		getTypeScriptProblems: publicProcedure
+			.input(
+				z.object({
+					workspaceId: z.string(),
+					openDocuments: z.array(openDocumentSchema).default([]),
+				}),
+			)
+			.output(
+				z.object({
+					status: z.enum(["ready", "no-config"]),
+					workspacePath: z.string(),
+					configPath: z.string().nullable(),
+					problems: z.array(typeScriptProblemSchema),
+					totalCount: z.number(),
+					truncated: z.boolean(),
+					summary: z.object({
+						errorCount: z.number(),
+						warningCount: z.number(),
+						infoCount: z.number(),
+						hintCount: z.number(),
+					}),
+				}),
+			)
+			.query(({ input }) => {
+				const workspace = getWorkspace(input.workspaceId);
+				if (!workspace) {
+					throw new TRPCError({
+						code: "NOT_FOUND",
+						message: `Workspace ${input.workspaceId} not found`,
+					});
+				}
+
+				const workspacePath = getWorkspacePath(workspace);
+				if (!workspacePath) {
+					throw new TRPCError({
+						code: "PRECONDITION_FAILED",
+						message: `Workspace ${input.workspaceId} has no filesystem path`,
+					});
+				}
+
+				const rootConfigPath = resolveConfigPath(workspacePath);
+				const configPaths = new Set<string>();
+				const standaloneFiles: string[] = [];
+				const openDocumentMap = createOpenDocumentMap(
+					workspacePath,
+					input.openDocuments,
+				);
+
+				if (input.openDocuments.length > 0) {
+					for (const document of input.openDocuments) {
+						const configPath = findNearestConfigPath(
+							workspacePath,
+							document.relativePath,
+						);
+						if (configPath) {
+							configPaths.add(configPath);
+						} else {
+							standaloneFiles.push(
+								path.resolve(workspacePath, document.relativePath),
+							);
+						}
+					}
+				} else if (rootConfigPath) {
+					configPaths.add(rootConfigPath);
+				}
+
+				if (configPaths.size === 0 && standaloneFiles.length === 0) {
+					console.log("[diagnostics] no config found", {
+						workspaceId: input.workspaceId,
+						workspacePath,
+						openDocuments: input.openDocuments.map(
+							(document) => document.relativePath,
+						),
+					});
+					return {
+						status: "no-config" as const,
+						workspacePath,
+						configPath: null,
+						problems: [],
+						totalCount: 0,
+						truncated: false,
+						summary: {
+							errorCount: 0,
+							warningCount: 0,
+							infoCount: 0,
+							hintCount: 0,
+						},
+					};
+				}
+
+				const collectedProblems = new Map<
+					string,
+					z.infer<typeof typeScriptProblemSchema>
+				>();
+				const configPathList = Array.from(configPaths);
+
+				console.log("[diagnostics] target documents", {
+					workspaceId: input.workspaceId,
+					workspacePath,
+					openDocuments: input.openDocuments.map((document) => ({
+						relativePath: document.relativePath,
+						hasOverride: document.content !== null,
+					})),
+					configPaths: configPathList,
+					standaloneFiles: standaloneFiles.map((filePath) =>
+						normalizeRelativePath(workspacePath, filePath),
+					),
+				});
+
+				for (const configPath of configPathList) {
+					const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+					if (configFile.error) {
+						const problem = {
+							relativePath: normalizeRelativePath(workspacePath, configPath),
+							line: null,
+							column: null,
+							endLine: null,
+							endColumn: null,
+							message: ts.flattenDiagnosticMessageText(
+								configFile.error.messageText,
+								"\n",
+							),
+							code: configFile.error.code,
+							severity: mapSeverity(configFile.error.category),
+							source: "typescript",
+						};
+						collectedProblems.set(createProblemKey(problem), problem);
+						continue;
+					}
+
+					const parsedConfig = ts.parseJsonConfigFileContent(
+						configFile.config,
+						ts.sys,
+						path.dirname(configPath),
+						{ noEmit: true },
+						configPath,
+					);
+					const configOpenFiles = input.openDocuments
+						.filter(
+							(document) =>
+								findNearestConfigPath(workspacePath, document.relativePath) ===
+								configPath,
+						)
+						.map((document) =>
+							path.resolve(workspacePath, document.relativePath),
+						);
+					const rootNames = Array.from(
+						new Set([...parsedConfig.fileNames, ...configOpenFiles]),
+					);
+					console.log("[diagnostics] parsed config", {
+						workspaceId: input.workspaceId,
+						workspacePath,
+						configPath,
+						openDocumentCount: input.openDocuments.length,
+						rootFileCount: rootNames.length,
+						sampleRootFiles: rootNames
+							.slice(0, 20)
+							.map((fileName) =>
+								normalizeRelativePath(workspacePath, fileName),
+							),
+					});
+
+					const compilerHost = createCompilerHostWithOpenDocuments(
+						parsedConfig.options,
+						openDocumentMap,
+					);
+					const program = ts.createProgram({
+						rootNames,
+						options: parsedConfig.options,
+						projectReferences: parsedConfig.projectReferences,
+						host: compilerHost,
+					});
+					const diagnostics = [
+						...parsedConfig.errors,
+						...ts.getPreEmitDiagnostics(program),
+					];
+					for (const problem of mapDiagnosticsToProblems(
+						diagnostics,
+						workspacePath,
+					)) {
+						collectedProblems.set(createProblemKey(problem), problem);
+					}
+				}
+
+				for (const standaloneFilePath of standaloneFiles) {
+					const compilerOptions =
+						getStandaloneCompilerOptions(standaloneFilePath);
+					const compilerHost = createCompilerHostWithOpenDocuments(
+						compilerOptions,
+						openDocumentMap,
+					);
+					const program = ts.createProgram({
+						rootNames: [standaloneFilePath],
+						options: compilerOptions,
+						host: compilerHost,
+					});
+					for (const problem of mapDiagnosticsToProblems(
+						ts.getPreEmitDiagnostics(program),
+						workspacePath,
+					)) {
+						collectedProblems.set(createProblemKey(problem), problem);
+					}
+				}
+
+				const mappedProblems = filterProblemsForOpenDocuments(
+					Array.from(collectedProblems.values()),
+					input.openDocuments,
+				).sort((left, right) => {
+					const severityDiff =
+						diagnosticSortValue(left.severity) -
+						diagnosticSortValue(right.severity);
+					if (severityDiff !== 0) {
+						return severityDiff;
+					}
+
+					const pathDiff = (left.relativePath ?? "").localeCompare(
+						right.relativePath ?? "",
+					);
+					if (pathDiff !== 0) {
+						return pathDiff;
+					}
+					return (left.line ?? 0) - (right.line ?? 0);
+				});
+
+				const summary = mappedProblems.reduce(
+					(acc, problem) => {
+						if (problem.severity === "error") acc.errorCount += 1;
+						if (problem.severity === "warning") acc.warningCount += 1;
+						if (problem.severity === "info") acc.infoCount += 1;
+						if (problem.severity === "hint") acc.hintCount += 1;
+						return acc;
+					},
+					{
+						errorCount: 0,
+						warningCount: 0,
+						infoCount: 0,
+						hintCount: 0,
+					},
+				);
+
+				console.log("[diagnostics] result", {
+					workspaceId: input.workspaceId,
+					configPaths: configPathList,
+					totalCount: mappedProblems.length,
+					problemFiles: Array.from(
+						new Set(
+							mappedProblems.map(
+								(problem) => problem.relativePath ?? "Workspace",
+							),
+						),
+					),
+				});
+
+				return {
+					status: "ready" as const,
+					workspacePath,
+					configPath: configPathList.length === 1 ? configPathList[0] : null,
+					problems: mappedProblems.slice(0, MAX_PROBLEMS),
+					totalCount: mappedProblems.length,
+					truncated: mappedProblems.length > MAX_PROBLEMS,
+					summary,
+				};
+			}),
+	});
+};
+
+export type DiagnosticsRouter = ReturnType<typeof createDiagnosticsRouter>;
diff --git a/apps/desktop/src/lib/trpc/routers/filesystem/index.ts b/apps/desktop/src/lib/trpc/routers/filesystem/index.ts
index 933b4dfaeeb..539f068d31a 100644
--- a/apps/desktop/src/lib/trpc/routers/filesystem/index.ts
+++ b/apps/desktop/src/lib/trpc/routers/filesystem/index.ts
@@ -28,6 +28,29 @@ type WatchPathEventBatch = {
 	}>;
 };
 
+const searchContentInputSchema = z.object({
+	workspaceId: z.string(),
+	query: z.string(),
+	includeHidden: z.boolean().optional(),
+	includePattern: z.string().optional(),
+	excludePattern: z.string().optional(),
+	limit: z.number().optional(),
+	isRegex: z.boolean().optional(),
+	caseSensitive: z.boolean().optional(),
+});
+
+const replaceContentInputSchema = z.object({
+	workspaceId: z.string(),
+	query: z.string(),
+	replacement: z.string(),
+	includeHidden: z.boolean().optional(),
+	includePattern: z.string().optional(),
+	excludePattern: z.string().optional(),
+	isRegex: z.boolean().optional(),
+	caseSensitive: z.boolean().optional(),
+	paths: z.array(z.string()).optional(),
+});
+
 export const createFilesystemRouter = () => {
 	return router({
 		listDirectory: publicProcedure
@@ -215,16 +238,7 @@ export const createFilesystemRouter = () => {
 			}),
 
 		searchContent: publicProcedure
-			.input(
-				z.object({
-					workspaceId: z.string(),
-					query: z.string(),
-					includeHidden: z.boolean().optional(),
-					includePattern: z.string().optional(),
-					excludePattern: z.string().optional(),
-					limit: z.number().optional(),
-				}),
-			)
+			.input(searchContentInputSchema)
 			.query(async ({ input }) => {
 				const trimmedQuery = input.query.trim();
 				if (!trimmedQuery) {
@@ -238,6 +252,34 @@ export const createFilesystemRouter = () => {
 					includePattern: input.includePattern,
 					excludePattern: input.excludePattern,
 					limit: input.limit,
+					isRegex: input.isRegex,
+					caseSensitive: input.caseSensitive,
+				});
+			}),
+
+		replaceContent: publicProcedure
+			.input(replaceContentInputSchema)
+			.mutation(async ({ input }) => {
+				if (input.query.length === 0) {
+					return {
+						replacements: 0,
+						filesUpdated: 0,
+						updated: [],
+						conflicts: [],
+						failed: [],
+					};
+				}
+
+				const service = getServiceForWorkspace(input.workspaceId);
+				return await service.replaceContent({
+					query: input.query,
+					replacement: input.replacement,
+					includeHidden: input.includeHidden,
+					includePattern: input.includePattern,
+					excludePattern: input.excludePattern,
+					isRegex: input.isRegex,
+					caseSensitive: input.caseSensitive,
+					paths: input.paths,
 				});
 			}),
 
diff --git a/apps/desktop/src/lib/trpc/routers/index.ts b/apps/desktop/src/lib/trpc/routers/index.ts
index 3112bba4e28..1fac06958d6 100644
--- a/apps/desktop/src/lib/trpc/routers/index.ts
+++ b/apps/desktop/src/lib/trpc/routers/index.ts
@@ -11,11 +11,14 @@ import { createChangesRouter } from "./changes";
 import { createChatRuntimeServiceRouter } from "./chat-runtime-service";
 import { createChatServiceRouter } from "./chat-service";
 import { createConfigRouter } from "./config";
+import { createDatabasesRouter } from "./databases";
+import { createDiagnosticsRouter } from "./diagnostics";
 import { createExtensionsRouter } from "./extensions";
 import { createExternalRouter } from "./external";
 import { createFilesystemRouter } from "./filesystem";
 import { createHostServiceManagerRouter } from "./host-service-manager";
 import { createHotkeysRouter } from "./hotkeys";
+import { createLanguageServicesRouter } from "./language-services";
 import { createMenuRouter } from "./menu";
 import { createModelProvidersRouter } from "./model-providers";
 import { createNotificationsRouter } from "./notifications";
@@ -57,9 +60,12 @@ export const createAppRouter = (
 		resourceMetrics: createResourceMetricsRouter(),
 		menu: createMenuRouter(),
 		hotkeys: createHotkeysRouter(getWindow),
+		languageServices: createLanguageServicesRouter(),
 		external: createExternalRouter(),
 		settings: createSettingsRouter(),
 		config: createConfigRouter(),
+		databases: createDatabasesRouter(),
+		diagnostics: createDiagnosticsRouter(),
 		uiState: createUiStateRouter(),
 		ringtone: createRingtoneRouter(getWindow),
 		hostServiceManager: createHostServiceManagerRouter(),
diff --git a/apps/desktop/src/lib/trpc/routers/language-services/index.ts b/apps/desktop/src/lib/trpc/routers/language-services/index.ts
new file mode 100644
index 00000000000..e9985be940d
--- /dev/null
+++ b/apps/desktop/src/lib/trpc/routers/language-services/index.ts
@@ -0,0 +1,154 @@
+import { TRPCError } from "@trpc/server";
+import { observable } from "@trpc/server/observable";
+import { languageServiceManager } from "main/lib/language-services/manager";
+import { z } from "zod";
+import { publicProcedure, router } from "../..";
+import { getWorkspace } from "../workspaces/utils/db-helpers";
+import { getWorkspacePath } from "../workspaces/utils/worktree";
+
+const languageServiceDocumentSchema = z.object({
+	workspaceId: z.string(),
+	absolutePath: z.string(),
+	languageId: z.string(),
+	content: z.string(),
+	version: z.number().int().nonnegative(),
+});
+
+function resolveWorkspacePath(workspaceId: string): string {
+	const workspace = getWorkspace(workspaceId);
+	if (!workspace) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: `Workspace ${workspaceId} not found`,
+		});
+	}
+
+	const workspacePath = getWorkspacePath(workspace);
+	if (!workspacePath) {
+		throw new TRPCError({
+			code: "PRECONDITION_FAILED",
+			message: `Workspace ${workspaceId} has no filesystem path`,
+		});
+	}
+
+	return workspacePath;
+}
+
+export const createLanguageServicesRouter = () => {
+	return router({
+		openDocument: publicProcedure
+			.input(languageServiceDocumentSchema)
+			.mutation(async ({ input }) => {
+				const workspacePath = resolveWorkspacePath(input.workspaceId);
+				await languageServiceManager.openDocument({
+					...input,
+					workspacePath,
+				});
+				return { ok: true };
+			}),
+
+		changeDocument: publicProcedure
+			.input(languageServiceDocumentSchema)
+			.mutation(async ({ input }) => {
+				const workspacePath = resolveWorkspacePath(input.workspaceId);
+				await languageServiceManager.syncDocument({
+					...input,
+					workspacePath,
+				});
+				return { ok: true };
+			}),
+
+		closeDocument: publicProcedure
+			.input(
+				z.object({
+					workspaceId: z.string(),
+					absolutePath: z.string(),
+					languageId: z.string(),
+				}),
+			)
+			.mutation(async ({ input }) => {
+				const workspacePath = resolveWorkspacePath(input.workspaceId);
+				await languageServiceManager.closeDocument({
+					...input,
+					workspacePath,
+				});
+				return { ok: true };
+			}),
+
+		refreshWorkspace: publicProcedure
+			.input(
+				z.object({
+					workspaceId: z.string(),
+				}),
+			)
+			.mutation(async ({ input }) => {
+				const workspacePath = resolveWorkspacePath(input.workspaceId);
+				await languageServiceManager.refreshWorkspace({
+					workspaceId: input.workspaceId,
+					workspacePath,
+				});
+				return { ok: true };
+			}),
+
+		getWorkspaceDiagnostics: publicProcedure
+			.input(
+				z.object({
+					workspaceId: z.string(),
+				}),
+			)
+			.query(({ input }) => {
+				const workspacePath = resolveWorkspacePath(input.workspaceId);
+				return languageServiceManager.getWorkspaceSnapshot({
+					workspaceId: input.workspaceId,
+					workspacePath,
+				});
+			}),
+
+		getProviders: publicProcedure.query(() => {
+			return languageServiceManager.getProviders();
+		}),
+
+		setProviderEnabled: publicProcedure
+			.input(
+				z.object({
+					providerId: z.string(),
+					enabled: z.boolean(),
+				}),
+			)
+			.mutation(async ({ input }) => {
+				const provider = await languageServiceManager.setProviderEnabled(
+					input.providerId,
+					input.enabled,
+				);
+				if (!provider) {
+					throw new TRPCError({
+						code: "NOT_FOUND",
+						message: `Language service provider ${input.providerId} not found`,
+					});
+				}
+
+				return provider;
+			}),
+
+		subscribeDiagnostics: publicProcedure
+			.input(
+				z.object({
+					workspaceId: z.string(),
+				}),
+			)
+			.subscription(({ input }) => {
+				return observable<{ version: number }>((emit) => {
+					const unsubscribe = languageServiceManager.subscribeToWorkspace(
+						input.workspaceId,
+						(payload) => {
+							emit.next(payload);
+						},
+					);
+
+					return () => {
+						unsubscribe();
+					};
+				});
+			}),
+	});
+};
diff --git a/apps/desktop/src/lib/trpc/routers/menu.ts b/apps/desktop/src/lib/trpc/routers/menu.ts
index 7310d5f6a12..d775038d681 100644
--- a/apps/desktop/src/lib/trpc/routers/menu.ts
+++ b/apps/desktop/src/lib/trpc/routers/menu.ts
@@ -1,15 +1,18 @@
 import { observable } from "@trpc/server/observable";
 import {
+	type BrowserActionEvent,
 	menuEmitter,
 	type OpenSettingsEvent,
 	type OpenWorkspaceEvent,
 	type SettingsSection,
 } from "main/lib/menu-events";
+import type { BrowserShortcutAction } from "shared/browser-shortcuts";
 import { publicProcedure, router } from "..";
 
 type MenuEvent =
 	| { type: "open-settings"; data: OpenSettingsEvent }
-	| { type: "open-workspace"; data: OpenWorkspaceEvent };
+	| { type: "open-workspace"; data: OpenWorkspaceEvent }
+	| { type: "browser-action"; data: BrowserActionEvent };
 
 export const createMenuRouter = () => {
 	return router({
@@ -23,12 +26,18 @@ export const createMenuRouter = () => {
 					emit.next({ type: "open-workspace", data: { workspaceId } });
 				};
 
+				const onBrowserAction = (action: BrowserShortcutAction) => {
+					emit.next({ type: "browser-action", data: { action } });
+				};
+
 				menuEmitter.on("open-settings", onOpenSettings);
 				menuEmitter.on("open-workspace", onOpenWorkspace);
+				menuEmitter.on("browser-action", onBrowserAction);
 
 				return () => {
 					menuEmitter.off("open-settings", onOpenSettings);
 					menuEmitter.off("open-workspace", onOpenWorkspace);
+					menuEmitter.off("browser-action", onBrowserAction);
 				};
 			});
 		}),
diff --git a/apps/desktop/src/lib/trpc/routers/settings/index.ts b/apps/desktop/src/lib/trpc/routers/settings/index.ts
index 7e86917e93b..ad15a94444b 100644
--- a/apps/desktop/src/lib/trpc/routers/settings/index.ts
+++ b/apps/desktop/src/lib/trpc/routers/settings/index.ts
@@ -25,6 +25,7 @@ import {
 	DEFAULT_CONFIRM_ON_QUIT,
 	DEFAULT_FILE_OPEN_MODE,
 	DEFAULT_OPEN_LINKS_IN_APP,
+	DEFAULT_PREVENT_AGENT_SLEEP,
 	DEFAULT_SHOW_PRESETS_BAR,
 	DEFAULT_SHOW_RESOURCE_MONITOR,
 	DEFAULT_TERMINAL_LINK_BEHAVIOR,
@@ -591,6 +592,26 @@ export const createSettingsRouter = () => {
 				return { success: true };
 			}),
 
+		getPreventAgentSleep: publicProcedure.query(() => {
+			const row = getSettings();
+			return row.preventAgentSleep ?? DEFAULT_PREVENT_AGENT_SLEEP;
+		}),
+
+		setPreventAgentSleep: publicProcedure
+			.input(z.object({ enabled: z.boolean() }))
+			.mutation(({ input }) => {
+				localDb
+					.insert(settings)
+					.values({ id: 1, preventAgentSleep: input.enabled })
+					.onConflictDoUpdate({
+						target: settings.id,
+						set: { preventAgentSleep: input.enabled },
+					})
+					.run();
+
+				return { success: true };
+			}),
+
 		getShowPresetsBar: publicProcedure.query(() => {
 			const row = getSettings();
 			return row.showPresetsBar ?? DEFAULT_SHOW_PRESETS_BAR;
diff --git a/apps/desktop/src/lib/trpc/routers/ui-state/index.ts b/apps/desktop/src/lib/trpc/routers/ui-state/index.ts
index 27fe6b71d2a..4710ed60be8 100644
--- a/apps/desktop/src/lib/trpc/routers/ui-state/index.ts
+++ b/apps/desktop/src/lib/trpc/routers/ui-state/index.ts
@@ -50,6 +50,7 @@ const paneSchema = z.object({
 		"chat",
 		"devtools",
 		"git-graph",
+		"database-explorer",
 	]),
 	name: z.string(),
 	isNew: z.boolean().optional(),
@@ -93,6 +94,11 @@ const paneSchema = z.object({
 			targetPaneId: z.string(),
 		})
 		.optional(),
+	databaseExplorer: z
+		.object({
+			connectionId: z.string().nullable(),
+		})
+		.optional(),
 	workspaceRun: z
 		.object({
 			workspaceId: z.string(),
diff --git a/apps/desktop/src/lib/trpc/routers/workspaces/procedures/git-status.ts b/apps/desktop/src/lib/trpc/routers/workspaces/procedures/git-status.ts
index 91d2ce5dddb..7cb48317fdf 100644
--- a/apps/desktop/src/lib/trpc/routers/workspaces/procedures/git-status.ts
+++ b/apps/desktop/src/lib/trpc/routers/workspaces/procedures/git-status.ts
@@ -1,4 +1,5 @@
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
 import type { GitHubStatus } from "@superset/local-db";
 import { workspaces, worktrees } from "@superset/local-db";
 import { TRPCError } from "@trpc/server";
@@ -13,8 +14,10 @@ import {
 	updateProjectDefaultBranch,
 } from "../utils/db-helpers";
 import {
+	branchExistsOnRemote,
 	fetchDefaultBranch,
 	getAheadBehindCount,
+	getCurrentBranch,
 	getDefaultBranch,
 	listExternalWorktrees,
 	refreshDefaultBranch,
@@ -25,6 +28,7 @@ import {
 	fetchCheckJobSteps,
 	fetchGitHubPRComments,
 	fetchGitHubPRStatus,
+	getRepoContext,
 	type PullRequestCommentsTarget,
 } from "../utils/github";
 import { GHIdentityCandidatesResponseSchema } from "../utils/github/types";
@@ -40,6 +44,229 @@ const gitHubPRCommentsInputSchema = z.object({
 	forceFresh: z.boolean().optional(),
 });
 
+const ghRepositoryPullRequestSchema = z.object({
+	number: z.number(),
+	title: z.string(),
+	url: z.string(),
+	state: z.enum(["OPEN", "CLOSED", "MERGED"]),
+	isDraft: z.boolean().optional().default(false),
+	headRefName: z.string().optional(),
+	updatedAt: z.string().nullable().optional(),
+	author: z
+		.object({
+			login: z.string().optional(),
+		})
+		.nullable()
+		.optional(),
+});
+
+const ghRepositoryWorkflowSchema = z.object({
+	id: z.number(),
+	name: z.string(),
+	path: z.string().optional(),
+	state: z.string().optional(),
+});
+
+const ghRepositoryWorkflowsResponseSchema = z.object({
+	workflows: z.array(ghRepositoryWorkflowSchema).optional(),
+});
+
+const ghRepositoryWorkflowRunSchema = z.object({
+	id: z.number(),
+	name: z.string().nullable().optional(),
+	display_title: z.string().nullable().optional(),
+	html_url: z.string().optional(),
+	status: z.string().nullable().optional(),
+	conclusion: z.string().nullable().optional(),
+	event: z.string().nullable().optional(),
+	created_at: z.string().nullable().optional(),
+	updated_at: z.string().nullable().optional(),
+	run_started_at: z.string().nullable().optional(),
+	head_branch: z.string().nullable().optional(),
+	head_sha: z.string().nullable().optional(),
+	run_number: z.number().optional(),
+	workflow_id: z.number().optional(),
+});
+
+const ghRepositoryWorkflowRunsResponseSchema = z.object({
+	workflow_runs: z.array(ghRepositoryWorkflowRunSchema).optional(),
+});
+
+const ghRepositoryLabelSchema = z.object({
+	name: z.string(),
+	color: z.string().optional(),
+	description: z.string().nullable().optional(),
+});
+
+const ghRepositoryAssigneeSchema = z.object({
+	login: z.string(),
+	avatar_url: z.string().optional(),
+});
+
+function sanitizeIssueAssetBasename(value: string): string {
+	return value
+		.toLowerCase()
+		.replace(/[^a-z0-9._-]+/g, "-")
+		.replace(/-+/g, "-")
+		.replace(/^-|-$/g, "")
+		.slice(0, 80);
+}
+
+function getIssueAssetExtension({
+	filename,
+	mimeType,
+}: {
+	filename?: string;
+	mimeType?: string;
+}): string {
+	const lower = filename?.toLowerCase() ?? "";
+	if (lower.endsWith(".png")) return "png";
+	if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "jpg";
+	if (lower.endsWith(".gif")) return "gif";
+	if (lower.endsWith(".webp")) return "webp";
+
+	if (mimeType === "image/jpeg") return "jpg";
+	if (mimeType === "image/gif") return "gif";
+	if (mimeType === "image/webp") return "webp";
+	return "png";
+}
+
+async function ensureGitHubBranchExists({
+	repoPath,
+	repositoryNameWithOwner,
+	branchName,
+	baseBranch,
+}: {
+	repoPath: string;
+	repositoryNameWithOwner: string;
+	branchName: string;
+	baseBranch: string;
+}) {
+	try {
+		await execWithShellEnv(
+			"gh",
+			["api", `repos/${repositoryNameWithOwner}/git/ref/heads/${branchName}`],
+			{ cwd: repoPath },
+		);
+		return;
+	} catch (error) {
+		const errorText =
+			error instanceof Error
+				? [
+						error.message,
+						"stderr" in error && typeof error.stderr === "string"
+							? error.stderr
+							: "",
+						"stdout" in error && typeof error.stdout === "string"
+							? error.stdout
+							: "",
+					]
+						.join("\n")
+						.toLowerCase()
+				: String(error).toLowerCase();
+		const isMissingRefError =
+			errorText.includes("404") ||
+			errorText.includes("not found") ||
+			errorText.includes("no ref found");
+
+		if (!isMissingRefError) {
+			console.warn("[git-status] GitHub branch probe failed", {
+				repoPath,
+				repositoryNameWithOwner,
+				branchName,
+				baseBranch,
+				error,
+			});
+			throw error;
+		}
+
+		console.warn("[git-status] GitHub branch not found, creating branch", {
+			repoPath,
+			repositoryNameWithOwner,
+			branchName,
+			baseBranch,
+			error,
+		});
+	}
+
+	const { stdout } = await execWithShellEnv(
+		"gh",
+		["api", `repos/${repositoryNameWithOwner}/git/ref/heads/${baseBranch}`],
+		{ cwd: repoPath },
+	);
+	const raw = JSON.parse(stdout) as {
+		object?: { sha?: string };
+	};
+	const sha = raw.object?.sha;
+	if (!sha) {
+		throw new TRPCError({
+			code: "INTERNAL_SERVER_ERROR",
+			message: "Could not determine the base branch SHA for issue assets.",
+		});
+	}
+
+	await execWithShellEnv(
+		"gh",
+		[
+			"api",
+			"--method",
+			"POST",
+			`repos/${repositoryNameWithOwner}/git/refs`,
+			"-f",
+			`ref=refs/heads/${branchName}`,
+			"-f",
+			`sha=${sha}`,
+		],
+		{ cwd: repoPath },
+	);
+}
+
+function parseRunIdFromActionsUrl(detailsUrl?: string): string | null {
+	if (!detailsUrl) {
+		return null;
+	}
+
+	try {
+		const url = new URL(detailsUrl);
+		const match = url.pathname.match(/\/actions\/runs\/(\d+)(?:\/|$)/);
+		return match?.[1] ?? null;
+	} catch {
+		return null;
+	}
+}
+
+function isGitHubActionsUrl(url?: string): boolean {
+	return parseRunIdFromActionsUrl(url) !== null;
+}
+
+function workflowSupportsDispatch({
+	repoPath,
+	workflowPath,
+}: {
+	repoPath: string;
+	workflowPath?: string;
+}): boolean {
+	if (!workflowPath) {
+		return false;
+	}
+
+	const absolutePath = path.join(repoPath, workflowPath);
+	if (!existsSync(absolutePath)) {
+		return false;
+	}
+
+	try {
+		const content = readFileSync(absolutePath, "utf8");
+		return (
+			/^\s*workflow_dispatch\s*:/m.test(content) ||
+			/^\s*on\s*:\s*workflow_dispatch\s*$/m.test(content) ||
+			/^\s*on\s*:\s*\[[^\]]*\bworkflow_dispatch\b[^\]]*\]/m.test(content)
+		);
+	} catch {
+		return false;
+	}
+}
+
 function resolveCommentsPullRequestTarget({
 	input,
 	githubStatus,
@@ -150,6 +377,459 @@ async function getFreshPullRequestForWorkspace(workspaceId: string): Promise<{
 	return { repoPath, worktree, pullRequest };
 }
 
+async function resolveRepositoryTargetForWorkspace(
+	workspaceId: string,
+): Promise<{
+	repoPath: string;
+	worktree: NonNullable<ReturnType<typeof getWorktree>> | null;
+	repositoryUrl: string;
+	repositoryNameWithOwner: string;
+	upstreamUrl: string;
+	upstreamNameWithOwner: string;
+	isFork: boolean;
+	branchExistsOnRemote: boolean;
+	currentBranch: string;
+	defaultBranch: string;
+}> {
+	const { repoPath, worktree } = resolveRepoPathForWorkspace(workspaceId);
+	const [githubStatus, repoContext, currentBranch, defaultBranch] =
+		await Promise.all([
+			fetchGitHubPRStatus(repoPath),
+			getRepoContext(repoPath),
+			getCurrentBranch(repoPath),
+			getDefaultBranch(repoPath),
+		]);
+
+	const repoUrl = githubStatus?.repoUrl ?? repoContext?.repoUrl;
+	const upstreamUrl =
+		githubStatus?.upstreamUrl ?? repoContext?.upstreamUrl ?? repoUrl;
+	const isFork = githubStatus?.isFork ?? repoContext?.isFork ?? false;
+	const repositoryUrl = repoUrl;
+	const repositoryNameWithOwner = repositoryUrl
+		? extractNwoFromUrl(repositoryUrl)
+		: null;
+	const upstreamNameWithOwner = upstreamUrl
+		? extractNwoFromUrl(upstreamUrl)
+		: null;
+
+	if (
+		!repoUrl ||
+		!upstreamUrl ||
+		!repositoryUrl ||
+		!repositoryNameWithOwner ||
+		!upstreamNameWithOwner
+	) {
+		throw new TRPCError({
+			code: "PRECONDITION_FAILED",
+			message: "Could not determine the GitHub repository for this workspace.",
+		});
+	}
+
+	if (!currentBranch) {
+		throw new TRPCError({
+			code: "PRECONDITION_FAILED",
+			message: "Could not determine the current branch for this workspace.",
+		});
+	}
+
+	return {
+		repoPath,
+		worktree,
+		repositoryUrl,
+		repositoryNameWithOwner,
+		upstreamUrl,
+		upstreamNameWithOwner,
+		isFork,
+		branchExistsOnRemote: githubStatus?.branchExistsOnRemote ?? false,
+		currentBranch,
+		defaultBranch,
+	};
+}
+
+async function getGitHubRepositoryOverview(workspaceId: string) {
+	const {
+		repoPath,
+		repositoryNameWithOwner,
+		repositoryUrl,
+		upstreamUrl,
+		upstreamNameWithOwner,
+		isFork,
+		branchExistsOnRemote,
+		currentBranch,
+		defaultBranch,
+	} = await resolveRepositoryTargetForWorkspace(workspaceId);
+
+	const [pullRequestsResult, workflowsResult, labelsResult, assigneesResult] =
+		await Promise.all([
+			execWithShellEnv(
+				"gh",
+				[
+					"pr",
+					"list",
+					"--repo",
+					repositoryNameWithOwner,
+					"--state",
+					"open",
+					"--limit",
+					"8",
+					"--json",
+					"number,title,url,state,isDraft,headRefName,updatedAt,author",
+				],
+				{ cwd: repoPath },
+			),
+			execWithShellEnv(
+				"gh",
+				[
+					"api",
+					`repos/${repositoryNameWithOwner}/actions/workflows?per_page=100`,
+				],
+				{ cwd: repoPath },
+			),
+			execWithShellEnv(
+				"gh",
+				["api", `repos/${repositoryNameWithOwner}/labels?per_page=100`],
+				{ cwd: repoPath },
+			),
+			execWithShellEnv(
+				"gh",
+				["api", `repos/${repositoryNameWithOwner}/assignees?per_page=100`],
+				{ cwd: repoPath },
+			),
+		]);
+
+	const rawPullRequests = JSON.parse(pullRequestsResult.stdout) as unknown;
+	const pullRequests = z
+		.array(ghRepositoryPullRequestSchema)
+		.parse(rawPullRequests);
+
+	const rawWorkflows = JSON.parse(workflowsResult.stdout) as unknown;
+	const workflows =
+		ghRepositoryWorkflowsResponseSchema.parse(rawWorkflows).workflows ?? [];
+	const rawLabels = JSON.parse(labelsResult.stdout) as unknown;
+	const labels = z.array(ghRepositoryLabelSchema).parse(rawLabels);
+	const rawAssignees = JSON.parse(assigneesResult.stdout) as unknown;
+	const assignees = z.array(ghRepositoryAssigneeSchema).parse(rawAssignees);
+
+	return {
+		repositoryNameWithOwner,
+		repositoryUrl,
+		upstreamUrl,
+		upstreamNameWithOwner,
+		isFork,
+		branchExistsOnRemote,
+		currentBranch,
+		defaultBranch,
+		issueAssignees: assignees.map((assignee) => ({
+			login: assignee.login,
+			avatarUrl: assignee.avatar_url ?? null,
+		})),
+		issueLabels: labels.map((label) => ({
+			name: label.name,
+			color: label.color ?? "",
+			description: label.description ?? "",
+		})),
+		pullsUrl: `${repositoryUrl}/pulls`,
+		issuesUrl: `${repositoryUrl}/issues`,
+		actionsUrl: `${repositoryUrl}/actions`,
+		newIssueUrl: `${repositoryUrl}/issues/new`,
+		pullRequests: pullRequests.map((pullRequest) => ({
+			number: pullRequest.number,
+			title: pullRequest.title,
+			url: pullRequest.url,
+			state: pullRequest.isDraft ? "draft" : pullRequest.state.toLowerCase(),
+			headRefName: pullRequest.headRefName ?? "",
+			updatedAt: pullRequest.updatedAt ?? null,
+			authorLogin: pullRequest.author?.login ?? null,
+		})),
+		workflows: workflows
+			.filter((workflow) => workflow.state !== "disabled_manually")
+			.filter((workflow) =>
+				workflowSupportsDispatch({
+					repoPath,
+					workflowPath: workflow.path,
+				}),
+			)
+			.map((workflow) => ({
+				id: workflow.id,
+				name: workflow.name,
+				path: workflow.path ?? "",
+				state: workflow.state ?? "unknown",
+			})),
+	};
+}
+
+async function createGitHubIssueForWorkspace({
+	workspaceId,
+	title,
+	body,
+	assignees,
+	labels,
+}: {
+	workspaceId: string;
+	title: string;
+	body?: string;
+	assignees?: string[];
+	labels?: string[];
+}) {
+	const { repoPath, repositoryNameWithOwner } =
+		await resolveRepositoryTargetForWorkspace(workspaceId);
+	const args = [
+		"issue",
+		"create",
+		"--repo",
+		repositoryNameWithOwner,
+		"--title",
+		title.trim(),
+		"--body",
+		body?.trim() || "",
+	];
+	const normalizedAssignees = normalizeIdentityList(assignees ?? []);
+	const normalizedLabels = normalizeIdentityList(labels ?? []);
+	if (normalizedAssignees.length > 0) {
+		args.push("--assignee", normalizedAssignees.join(","));
+	}
+	if (normalizedLabels.length > 0) {
+		args.push("--label", normalizedLabels.join(","));
+	}
+	const { stdout } = await execWithShellEnv("gh", args, { cwd: repoPath });
+
+	return {
+		url: stdout.trim(),
+	};
+}
+
+async function uploadIssueAssetForWorkspace({
+	workspaceId,
+	filename,
+	contentBase64,
+	mimeType,
+}: {
+	workspaceId: string;
+	filename: string;
+	contentBase64: string;
+	mimeType?: string;
+}) {
+	const { repoPath, repositoryNameWithOwner, defaultBranch } =
+		await resolveRepositoryTargetForWorkspace(workspaceId);
+	const assetBranch = "superset-issue-assets";
+	await ensureGitHubBranchExists({
+		repoPath,
+		repositoryNameWithOwner,
+		branchName: assetBranch,
+		baseBranch: defaultBranch,
+	});
+
+	const now = new Date();
+	const extension = getIssueAssetExtension({ filename, mimeType });
+	const basename =
+		sanitizeIssueAssetBasename(filename.replace(/\.[^.]+$/, "")) ||
+		"pasted-image";
+	const timestamp = now.toISOString().replace(/[:.]/g, "-");
+	const assetPath = [
+		".superset",
+		"issue-assets",
+		String(now.getUTCFullYear()),
+		String(now.getUTCMonth() + 1).padStart(2, "0"),
+		`${timestamp}-${basename}.${extension}`,
+	].join("/");
+
+	await execWithShellEnv(
+		"gh",
+		[
+			"api",
+			"--method",
+			"PUT",
+			`repos/${repositoryNameWithOwner}/contents/${assetPath}`,
+			"-f",
+			`message=Add issue asset ${assetPath}`,
+			"-f",
+			`content=${contentBase64}`,
+			"-f",
+			`branch=${assetBranch}`,
+		],
+		{ cwd: repoPath },
+	);
+
+	const assetUrl = `https://github.com/${repositoryNameWithOwner}/raw/${assetBranch}/${assetPath}`;
+
+	return {
+		name: `${basename}.${extension}`,
+		url: assetUrl,
+		markdown: `![${basename}](${assetUrl})`,
+	};
+}
+
+async function dispatchGitHubWorkflowForWorkspace({
+	workspaceId,
+	workflowId,
+	ref,
+}: {
+	workspaceId: string;
+	workflowId: number;
+	ref?: string;
+}) {
+	const { repoPath, repositoryNameWithOwner, currentBranch, defaultBranch } =
+		await resolveRepositoryTargetForWorkspace(workspaceId);
+	const requestedRef = ref?.trim() || currentBranch || defaultBranch;
+	let targetRef = requestedRef;
+	if (requestedRef === currentBranch) {
+		const branchCheck = await branchExistsOnRemote(
+			repoPath,
+			currentBranch,
+			"origin",
+		);
+		if (branchCheck.status !== "exists") {
+			targetRef = defaultBranch;
+		}
+	}
+
+	await execWithShellEnv(
+		"gh",
+		[
+			"api",
+			"--method",
+			"POST",
+			`repos/${repositoryNameWithOwner}/actions/workflows/${workflowId}/dispatches`,
+			"-f",
+			`ref=${targetRef}`,
+		],
+		{ cwd: repoPath },
+	);
+
+	return {
+		success: true as const,
+		ref: targetRef,
+		dispatchedAt: new Date().toISOString(),
+	};
+}
+
+async function getGitHubWorkflowRunsForWorkspace({
+	workspaceId,
+	workflowId,
+}: {
+	workspaceId: string;
+	workflowId: number;
+}) {
+	const { repoPath, repositoryNameWithOwner } =
+		await resolveRepositoryTargetForWorkspace(workspaceId);
+	const { stdout } = await execWithShellEnv(
+		"gh",
+		[
+			"api",
+			`repos/${repositoryNameWithOwner}/actions/workflows/${workflowId}/runs?per_page=10&event=workflow_dispatch`,
+		],
+		{ cwd: repoPath },
+	);
+
+	const rawRuns = JSON.parse(stdout) as unknown;
+	const runs =
+		ghRepositoryWorkflowRunsResponseSchema.parse(rawRuns).workflow_runs ?? [];
+
+	return runs.map((run) => ({
+		id: run.id,
+		name: run.name ?? "",
+		displayTitle: run.display_title ?? "",
+		url: run.html_url ?? "",
+		status: run.status ?? "unknown",
+		conclusion: run.conclusion ?? null,
+		event: run.event ?? null,
+		createdAt: run.created_at ?? null,
+		updatedAt: run.updated_at ?? null,
+		runStartedAt: run.run_started_at ?? null,
+		headBranch: run.head_branch ?? null,
+		headSha: run.head_sha ?? null,
+		runNumber: run.run_number ?? null,
+		workflowId: run.workflow_id ?? workflowId,
+	}));
+}
+
+async function rerunPullRequestChecksForWorkspace({
+	workspaceId,
+	mode,
+}: {
+	workspaceId: string;
+	mode: "all" | "failed";
+}) {
+	const { repoPath, worktree, pullRequest } =
+		await getFreshPullRequestForWorkspace(workspaceId);
+	const checksToRerun = pullRequest.checks.filter((check) => {
+		if (!isGitHubActionsUrl(check.url)) {
+			return false;
+		}
+
+		if (mode === "failed") {
+			return check.status === "failure";
+		}
+
+		return true;
+	});
+
+	if (checksToRerun.length === 0) {
+		throw new TRPCError({
+			code: "PRECONDITION_FAILED",
+			message:
+				mode === "failed"
+					? "No failed GitHub Actions jobs found for this pull request."
+					: "No GitHub Actions jobs found for this pull request.",
+		});
+	}
+
+	const runTargets = new Map<string, string>();
+	for (const check of checksToRerun) {
+		const runId = parseRunIdFromActionsUrl(check.url);
+		const repositoryNameWithOwner = check.url
+			? extractNwoFromUrl(check.url)
+			: null;
+		if (!runId || !repositoryNameWithOwner) {
+			continue;
+		}
+
+		runTargets.set(
+			`${repositoryNameWithOwner}:${runId}`,
+			`${repositoryNameWithOwner}:${runId}`,
+		);
+	}
+
+	if (runTargets.size === 0) {
+		throw new TRPCError({
+			code: "PRECONDITION_FAILED",
+			message: "No rerunnable GitHub Actions runs were found.",
+		});
+	}
+
+	for (const target of runTargets.values()) {
+		const [repositoryNameWithOwner, runId] = target.split(":");
+		if (!repositoryNameWithOwner || !runId) {
+			continue;
+		}
+
+		await execWithShellEnv(
+			"gh",
+			[
+				"api",
+				"--method",
+				"POST",
+				`repos/${repositoryNameWithOwner}/actions/runs/${runId}/${mode === "failed" ? "rerun-failed-jobs" : "rerun"}`,
+			],
+			{ cwd: repoPath },
+		);
+	}
+
+	clearGitHubCachesForWorktree(repoPath);
+	if (worktree) {
+		localDb
+			.update(worktrees)
+			.set({ githubStatus: null })
+			.where(eq(worktrees.id, worktree.id))
+			.run();
+	}
+
+	return {
+		success: true as const,
+		rerunCount: runTargets.size,
+	};
+}
+
 function resolvePullRequestTarget({
 	workspaceId,
 	pullRequestNumber,
@@ -291,7 +971,7 @@ async function getPullRequestIdentityCandidates({
 	workspaceId: string;
 	kind: "reviewer" | "assignee";
 	pullRequestUrl?: string;
-}): Promise<string[]> {
+}): Promise<Array<{ login: string; avatarUrl: string | null }>> {
 	const { repoPath, repoNameWithOwner } = resolvePullRequestRepoTarget({
 		workspaceId,
 		pullRequestUrl,
@@ -309,6 +989,7 @@ async function getPullRequestIdentityCandidates({
     users: ${fieldName}(first: 100, after: $after) {
       nodes {
         login
+        avatarUrl
       }
       pageInfo {
         hasNextPage
@@ -318,7 +999,7 @@ async function getPullRequestIdentityCandidates({
   }
 }`;
 
-	const logins = new Set<string>();
+	const usersByLogin = new Map<string, string | null>();
 	let afterCursor: string | null = null;
 
 	while (true) {
@@ -354,7 +1035,7 @@ async function getPullRequestIdentityCandidates({
 
 		for (const user of users.nodes ?? []) {
 			if (user?.login) {
-				logins.add(user.login);
+				usersByLogin.set(user.login, user.avatarUrl ?? null);
 			}
 		}
 
@@ -365,7 +1046,10 @@ async function getPullRequestIdentityCandidates({
 		afterCursor = users.pageInfo.endCursor;
 	}
 
-	return [...logins];
+	return [...usersByLogin.entries()].map(([login, avatarUrl]) => ({
+		login,
+		avatarUrl,
+	}));
 }
 
 export const createGitStatusProcedures = () => {
@@ -550,6 +1234,77 @@ export const createGitStatusProcedures = () => {
 				return getPullRequestIdentityCandidates(input);
 			}),
 
+		getGitHubRepositoryOverview: publicProcedure
+			.input(
+				z.object({
+					workspaceId: z.string(),
+				}),
+			)
+			.query(async ({ input }) => {
+				return getGitHubRepositoryOverview(input.workspaceId);
+			}),
+
+		createGitHubIssue: publicProcedure
+			.input(
+				z.object({
+					workspaceId: z.string(),
+					title: z.string().trim().min(1),
+					body: z.string().optional(),
+					assignees: z.array(z.string()).optional(),
+					labels: z.array(z.string()).optional(),
+				}),
+			)
+			.mutation(async ({ input }) => {
+				return createGitHubIssueForWorkspace(input);
+			}),
+
+		uploadGitHubIssueAsset: publicProcedure
+			.input(
+				z.object({
+					workspaceId: z.string(),
+					filename: z.string().trim().min(1),
+					contentBase64: z.string().trim().min(1),
+					mimeType: z.string().optional(),
+				}),
+			)
+			.mutation(async ({ input }) => {
+				return uploadIssueAssetForWorkspace(input);
+			}),
+
+		dispatchGitHubWorkflow: publicProcedure
+			.input(
+				z.object({
+					workspaceId: z.string(),
+					workflowId: z.number().int().positive(),
+					ref: z.string().optional(),
+				}),
+			)
+			.mutation(async ({ input }) => {
+				return dispatchGitHubWorkflowForWorkspace(input);
+			}),
+
+		getGitHubWorkflowRuns: publicProcedure
+			.input(
+				z.object({
+					workspaceId: z.string(),
+					workflowId: z.number().int().positive(),
+				}),
+			)
+			.query(async ({ input }) => {
+				return getGitHubWorkflowRunsForWorkspace(input);
+			}),
+
+		rerunPullRequestChecks: publicProcedure
+			.input(
+				z.object({
+					workspaceId: z.string(),
+					mode: z.enum(["all", "failed"]),
+				}),
+			)
+			.mutation(async ({ input }) => {
+				return rerunPullRequestChecksForWorkspace(input);
+			}),
+
 		setPullRequestDraftState: publicProcedure
 			.input(
 				z.object({
diff --git a/apps/desktop/src/lib/trpc/routers/workspaces/utils/github/types.ts b/apps/desktop/src/lib/trpc/routers/workspaces/utils/github/types.ts
index b72420472de..391a16115da 100644
--- a/apps/desktop/src/lib/trpc/routers/workspaces/utils/github/types.ts
+++ b/apps/desktop/src/lib/trpc/routers/workspaces/utils/github/types.ts
@@ -36,6 +36,11 @@ export const GHUserSchema = z.object({
 	login: z.string().optional(),
 });
 
+export const GHIdentityCandidateUserSchema = z.object({
+	login: z.string().optional(),
+	avatarUrl: z.string().optional(),
+});
+
 export const GHCommentAuthorSchema = z.object({
 	login: z.string().optional(),
 	avatar_url: z.string().optional(),
@@ -83,7 +88,7 @@ export const GHPageInfoSchema = z.object({
 });
 
 export const GHUsersConnectionSchema = z.object({
-	nodes: z.array(GHUserSchema.nullable()).optional(),
+	nodes: z.array(GHIdentityCandidateUserSchema.nullable()).optional(),
 	pageInfo: GHPageInfoSchema,
 });
 
diff --git a/apps/desktop/src/main/lib/agent-setup/agent-wrappers-common.ts b/apps/desktop/src/main/lib/agent-setup/agent-wrappers-common.ts
index 55a2f14ab8a..90af90ebb64 100644
--- a/apps/desktop/src/main/lib/agent-setup/agent-wrappers-common.ts
+++ b/apps/desktop/src/main/lib/agent-setup/agent-wrappers-common.ts
@@ -120,6 +120,8 @@ if [ -z "$REAL_BIN" ]; then
   exit 127
 fi
 
+export SUPERSET_WRAPPER_PID="$$"
+
 ${execLine}
 `;
 }
diff --git a/apps/desktop/src/main/lib/agent-setup/templates/copilot-hook.template.sh b/apps/desktop/src/main/lib/agent-setup/templates/copilot-hook.template.sh
index cdfb1581084..310257a8ec8 100644
--- a/apps/desktop/src/main/lib/agent-setup/templates/copilot-hook.template.sh
+++ b/apps/desktop/src/main/lib/agent-setup/templates/copilot-hook.template.sh
@@ -29,6 +29,40 @@ printf '{}\n'
 
 [ -z "$SUPERSET_TAB_ID" ] && exit 0
 
+if [ -n "$SUPERSET_WRAPPER_PID" ] && [ "$SUPERSET_PREVENT_AGENT_SLEEP" = "1" ] && [ "$(uname -s 2>/dev/null)" = "Darwin" ] && command -v caffeinate >/dev/null 2>&1; then
+  _superset_sleep_dir="${TMPDIR:-/tmp}/superset-sleep-inhibitors"
+  mkdir -p "$_superset_sleep_dir" >/dev/null 2>&1 || true
+  _superset_pid_file="$_superset_sleep_dir/${SUPERSET_WRAPPER_PID}.pid"
+  case "$EVENT_TYPE" in
+    Start|PermissionRequest)
+      if [ -f "$_superset_pid_file" ]; then
+        _superset_caffeinate_pid=$(cat "$_superset_pid_file" 2>/dev/null)
+        if [ -n "$_superset_caffeinate_pid" ] && kill -0 "$_superset_caffeinate_pid" 2>/dev/null; then
+          :
+        else
+          rm -f "$_superset_pid_file" >/dev/null 2>&1 || true
+          if kill -0 "$SUPERSET_WRAPPER_PID" 2>/dev/null; then
+            caffeinate -i -w "$SUPERSET_WRAPPER_PID" >/dev/null 2>&1 &
+            echo "$!" > "$_superset_pid_file"
+          fi
+        fi
+      elif kill -0 "$SUPERSET_WRAPPER_PID" 2>/dev/null; then
+        caffeinate -i -w "$SUPERSET_WRAPPER_PID" >/dev/null 2>&1 &
+        echo "$!" > "$_superset_pid_file"
+      fi
+      ;;
+    Stop)
+      if [ -f "$_superset_pid_file" ]; then
+        _superset_caffeinate_pid=$(cat "$_superset_pid_file" 2>/dev/null)
+        if [ -n "$_superset_caffeinate_pid" ] && kill -0 "$_superset_caffeinate_pid" 2>/dev/null; then
+          kill "$_superset_caffeinate_pid" >/dev/null 2>&1 || true
+        fi
+        rm -f "$_superset_pid_file" >/dev/null 2>&1 || true
+      fi
+      ;;
+  esac
+fi
+
 curl -sG "http://127.0.0.1:${SUPERSET_PORT:-{{DEFAULT_PORT}}}/hook/complete" \
   --connect-timeout 1 --max-time 2 \
   --data-urlencode "paneId=$SUPERSET_PANE_ID" \
diff --git a/apps/desktop/src/main/lib/agent-setup/templates/cursor-hook.template.sh b/apps/desktop/src/main/lib/agent-setup/templates/cursor-hook.template.sh
index f2e2483ffa9..3e435ab376e 100644
--- a/apps/desktop/src/main/lib/agent-setup/templates/cursor-hook.template.sh
+++ b/apps/desktop/src/main/lib/agent-setup/templates/cursor-hook.template.sh
@@ -27,6 +27,40 @@ fi
 # cursor-agent runs inside a Superset terminal, so env vars are inherited directly
 [ -z "$SUPERSET_TAB_ID" ] && exit 0
 
+if [ -n "$SUPERSET_WRAPPER_PID" ] && [ "$SUPERSET_PREVENT_AGENT_SLEEP" = "1" ] && [ "$(uname -s 2>/dev/null)" = "Darwin" ] && command -v caffeinate >/dev/null 2>&1; then
+  _superset_sleep_dir="${TMPDIR:-/tmp}/superset-sleep-inhibitors"
+  mkdir -p "$_superset_sleep_dir" >/dev/null 2>&1 || true
+  _superset_pid_file="$_superset_sleep_dir/${SUPERSET_WRAPPER_PID}.pid"
+  case "$EVENT_TYPE" in
+    Start|PermissionRequest)
+      if [ -f "$_superset_pid_file" ]; then
+        _superset_caffeinate_pid=$(cat "$_superset_pid_file" 2>/dev/null)
+        if [ -n "$_superset_caffeinate_pid" ] && kill -0 "$_superset_caffeinate_pid" 2>/dev/null; then
+          :
+        else
+          rm -f "$_superset_pid_file" >/dev/null 2>&1 || true
+          if kill -0 "$SUPERSET_WRAPPER_PID" 2>/dev/null; then
+            caffeinate -i -w "$SUPERSET_WRAPPER_PID" >/dev/null 2>&1 &
+            echo "$!" > "$_superset_pid_file"
+          fi
+        fi
+      elif kill -0 "$SUPERSET_WRAPPER_PID" 2>/dev/null; then
+        caffeinate -i -w "$SUPERSET_WRAPPER_PID" >/dev/null 2>&1 &
+        echo "$!" > "$_superset_pid_file"
+      fi
+      ;;
+    Stop)
+      if [ -f "$_superset_pid_file" ]; then
+        _superset_caffeinate_pid=$(cat "$_superset_pid_file" 2>/dev/null)
+        if [ -n "$_superset_caffeinate_pid" ] && kill -0 "$_superset_caffeinate_pid" 2>/dev/null; then
+          kill "$_superset_caffeinate_pid" >/dev/null 2>&1 || true
+        fi
+        rm -f "$_superset_pid_file" >/dev/null 2>&1 || true
+      fi
+      ;;
+  esac
+fi
+
 curl -sG "http://127.0.0.1:${SUPERSET_PORT:-{{DEFAULT_PORT}}}/hook/complete" \
   --connect-timeout 1 --max-time 2 \
   --data-urlencode "paneId=$SUPERSET_PANE_ID" \
diff --git a/apps/desktop/src/main/lib/agent-setup/templates/gemini-hook.template.sh b/apps/desktop/src/main/lib/agent-setup/templates/gemini-hook.template.sh
index a54e780c99a..950d372d483 100644
--- a/apps/desktop/src/main/lib/agent-setup/templates/gemini-hook.template.sh
+++ b/apps/desktop/src/main/lib/agent-setup/templates/gemini-hook.template.sh
@@ -28,6 +28,40 @@ printf '{}\n'
 # Skip notification if not inside a Superset terminal
 [ -z "$SUPERSET_TAB_ID" ] && exit 0
 
+if [ -n "$SUPERSET_WRAPPER_PID" ] && [ "$SUPERSET_PREVENT_AGENT_SLEEP" = "1" ] && [ "$(uname -s 2>/dev/null)" = "Darwin" ] && command -v caffeinate >/dev/null 2>&1; then
+  _superset_sleep_dir="${TMPDIR:-/tmp}/superset-sleep-inhibitors"
+  mkdir -p "$_superset_sleep_dir" >/dev/null 2>&1 || true
+  _superset_pid_file="$_superset_sleep_dir/${SUPERSET_WRAPPER_PID}.pid"
+  case "$EVENT_TYPE" in
+    Start|PermissionRequest)
+      if [ -f "$_superset_pid_file" ]; then
+        _superset_caffeinate_pid=$(cat "$_superset_pid_file" 2>/dev/null)
+        if [ -n "$_superset_caffeinate_pid" ] && kill -0 "$_superset_caffeinate_pid" 2>/dev/null; then
+          :
+        else
+          rm -f "$_superset_pid_file" >/dev/null 2>&1 || true
+          if kill -0 "$SUPERSET_WRAPPER_PID" 2>/dev/null; then
+            caffeinate -i -w "$SUPERSET_WRAPPER_PID" >/dev/null 2>&1 &
+            echo "$!" > "$_superset_pid_file"
+          fi
+        fi
+      elif kill -0 "$SUPERSET_WRAPPER_PID" 2>/dev/null; then
+        caffeinate -i -w "$SUPERSET_WRAPPER_PID" >/dev/null 2>&1 &
+        echo "$!" > "$_superset_pid_file"
+      fi
+      ;;
+    Stop)
+      if [ -f "$_superset_pid_file" ]; then
+        _superset_caffeinate_pid=$(cat "$_superset_pid_file" 2>/dev/null)
+        if [ -n "$_superset_caffeinate_pid" ] && kill -0 "$_superset_caffeinate_pid" 2>/dev/null; then
+          kill "$_superset_caffeinate_pid" >/dev/null 2>&1 || true
+        fi
+        rm -f "$_superset_pid_file" >/dev/null 2>&1 || true
+      fi
+      ;;
+  esac
+fi
+
 curl -sG "http://127.0.0.1:${SUPERSET_PORT:-{{DEFAULT_PORT}}}/hook/complete" \
   --connect-timeout 1 --max-time 2 \
   --data-urlencode "paneId=$SUPERSET_PANE_ID" \
diff --git a/apps/desktop/src/main/lib/agent-setup/templates/notify-hook.template.sh b/apps/desktop/src/main/lib/agent-setup/templates/notify-hook.template.sh
index 925702abf4b..7aebb075293 100644
--- a/apps/desktop/src/main/lib/agent-setup/templates/notify-hook.template.sh
+++ b/apps/desktop/src/main/lib/agent-setup/templates/notify-hook.template.sh
@@ -53,6 +53,43 @@ fi
 # This prevents parse failures from causing false completion notifications
 [ -z "$EVENT_TYPE" ] && exit 0
 
+_superset_manage_sleep_inhibitor() {
+  [ -n "$SUPERSET_WRAPPER_PID" ] || return 0
+  [ "$SUPERSET_PREVENT_AGENT_SLEEP" = "1" ] || return 0
+  [ "$(uname -s 2>/dev/null)" = "Darwin" ] || return 0
+  command -v caffeinate >/dev/null 2>&1 || return 0
+
+  _superset_sleep_dir="${TMPDIR:-/tmp}/superset-sleep-inhibitors"
+  mkdir -p "$_superset_sleep_dir" >/dev/null 2>&1 || return 0
+  _superset_pid_file="$_superset_sleep_dir/${SUPERSET_WRAPPER_PID}.pid"
+
+  case "$EVENT_TYPE" in
+    Start|PermissionRequest)
+      if [ -f "$_superset_pid_file" ]; then
+        _superset_caffeinate_pid=$(cat "$_superset_pid_file" 2>/dev/null)
+        if [ -n "$_superset_caffeinate_pid" ] && kill -0 "$_superset_caffeinate_pid" 2>/dev/null; then
+          return 0
+        fi
+        rm -f "$_superset_pid_file" >/dev/null 2>&1 || true
+      fi
+      kill -0 "$SUPERSET_WRAPPER_PID" 2>/dev/null || return 0
+      caffeinate -i -w "$SUPERSET_WRAPPER_PID" >/dev/null 2>&1 &
+      echo "$!" > "$_superset_pid_file"
+      ;;
+    Stop)
+      if [ -f "$_superset_pid_file" ]; then
+        _superset_caffeinate_pid=$(cat "$_superset_pid_file" 2>/dev/null)
+        if [ -n "$_superset_caffeinate_pid" ] && kill -0 "$_superset_caffeinate_pid" 2>/dev/null; then
+          kill "$_superset_caffeinate_pid" >/dev/null 2>&1 || true
+        fi
+        rm -f "$_superset_pid_file" >/dev/null 2>&1 || true
+      fi
+      ;;
+  esac
+}
+
+_superset_manage_sleep_inhibitor
+
 DEBUG_HOOKS_ENABLED="0"
 if [ -n "$SUPERSET_DEBUG_HOOKS" ]; then
   case "$SUPERSET_DEBUG_HOOKS" in
@@ -68,7 +105,7 @@ elif [ "$SUPERSET_ENV" = "development" ] || [ "$NODE_ENV" = "development" ]; the
 fi
 
 if [ "$DEBUG_HOOKS_ENABLED" = "1" ]; then
-  echo "[notify-hook] event=$EVENT_TYPE sessionId=$SESSION_ID hookSessionId=$HOOK_SESSION_ID resourceId=$RESOURCE_ID paneId=$SUPERSET_PANE_ID tabId=$SUPERSET_TAB_ID workspaceId=$SUPERSET_WORKSPACE_ID" >&2
+  echo "[notify-hook] event=$EVENT_TYPE sessionId=$SESSION_ID hookSessionId=$HOOK_SESSION_ID resourceId=$RESOURCE_ID paneId=$SUPERSET_PANE_ID tabId=$SUPERSET_TAB_ID workspaceId=$SUPERSET_WORKSPACE_ID wrapperPid=$SUPERSET_WRAPPER_PID" >&2
 fi
 
 # Timeouts prevent blocking agent completion if notification server is unresponsive
diff --git a/apps/desktop/src/main/lib/language-services/diagnostics-store.ts b/apps/desktop/src/main/lib/language-services/diagnostics-store.ts
new file mode 100644
index 00000000000..d728ce240ae
--- /dev/null
+++ b/apps/desktop/src/main/lib/language-services/diagnostics-store.ts
@@ -0,0 +1,184 @@
+import { EventEmitter } from "node:events";
+import type {
+	LanguageServiceDiagnostic,
+	LanguageServiceWorkspaceSnapshot,
+} from "./types";
+
+const MAX_PROBLEMS = 500;
+
+function diagnosticSortValue(severity: string): number {
+	switch (severity) {
+		case "error":
+			return 0;
+		case "warning":
+			return 1;
+		case "info":
+			return 2;
+		default:
+			return 3;
+	}
+}
+
+type WorkspaceDiagnostics = Map<string, LanguageServiceDiagnostic[]>;
+
+export class LanguageDiagnosticsStore {
+	private readonly workspaces = new Map<string, WorkspaceDiagnostics>();
+
+	private readonly versions = new Map<string, number>();
+
+	private readonly emitter = new EventEmitter();
+
+	setFileDiagnostics(
+		workspaceId: string,
+		fileKey: string,
+		diagnostics: LanguageServiceDiagnostic[],
+	): void {
+		const workspaceDiagnostics =
+			this.workspaces.get(workspaceId) ??
+			new Map<string, LanguageServiceDiagnostic[]>();
+		workspaceDiagnostics.set(fileKey, diagnostics);
+		this.workspaces.set(workspaceId, workspaceDiagnostics);
+		this.bump(workspaceId);
+	}
+
+	clearFileDiagnostics(workspaceId: string, fileKey: string): void {
+		const workspaceDiagnostics = this.workspaces.get(workspaceId);
+		if (!workspaceDiagnostics) {
+			return;
+		}
+
+		if (!workspaceDiagnostics.delete(fileKey)) {
+			return;
+		}
+
+		if (workspaceDiagnostics.size === 0) {
+			this.workspaces.delete(workspaceId);
+		}
+
+		this.bump(workspaceId);
+	}
+
+	clearWorkspace(workspaceId: string): void {
+		if (!this.workspaces.delete(workspaceId)) {
+			return;
+		}
+
+		this.bump(workspaceId);
+	}
+
+	clearProviderDiagnostics(providerId: string, workspaceId?: string): void {
+		const fileKeyPrefix = `${providerId}::`;
+		const targetWorkspaceIds = workspaceId
+			? [workspaceId]
+			: Array.from(this.workspaces.keys());
+
+		for (const targetWorkspaceId of targetWorkspaceIds) {
+			const workspaceDiagnostics = this.workspaces.get(targetWorkspaceId);
+			if (!workspaceDiagnostics) {
+				continue;
+			}
+
+			let changed = false;
+			for (const fileKey of Array.from(workspaceDiagnostics.keys())) {
+				if (!fileKey.startsWith(fileKeyPrefix)) {
+					continue;
+				}
+
+				workspaceDiagnostics.delete(fileKey);
+				changed = true;
+			}
+
+			if (!changed) {
+				continue;
+			}
+
+			if (workspaceDiagnostics.size === 0) {
+				this.workspaces.delete(targetWorkspaceId);
+			}
+
+			this.bump(targetWorkspaceId);
+		}
+	}
+
+	getVersion(workspaceId: string): number {
+		return this.versions.get(workspaceId) ?? 0;
+	}
+
+	subscribe(
+		workspaceId: string,
+		listener: (payload: { version: number }) => void,
+	) {
+		const eventName = this.eventName(workspaceId);
+		this.emitter.on(eventName, listener);
+		return () => {
+			this.emitter.off(eventName, listener);
+		};
+	}
+
+	createSnapshot(args: {
+		workspaceId: string;
+		workspacePath: string;
+		providers: LanguageServiceWorkspaceSnapshot["providers"];
+	}): LanguageServiceWorkspaceSnapshot {
+		const flattened = Array.from(
+			this.workspaces.get(args.workspaceId)?.values() ?? [],
+		)
+			.flat()
+			.sort((left, right) => {
+				const severityDelta =
+					diagnosticSortValue(left.severity) -
+					diagnosticSortValue(right.severity);
+				if (severityDelta !== 0) {
+					return severityDelta;
+				}
+
+				const pathDelta = (left.relativePath ?? "").localeCompare(
+					right.relativePath ?? "",
+				);
+				if (pathDelta !== 0) {
+					return pathDelta;
+				}
+
+				const lineDelta = (left.line ?? 0) - (right.line ?? 0);
+				if (lineDelta !== 0) {
+					return lineDelta;
+				}
+
+				return (left.column ?? 0) - (right.column ?? 0);
+			});
+
+		const problems = flattened.slice(0, MAX_PROBLEMS);
+		return {
+			status: "ready",
+			workspaceId: args.workspaceId,
+			workspacePath: args.workspacePath,
+			providers: args.providers,
+			problems,
+			totalCount: flattened.length,
+			truncated: flattened.length > problems.length,
+			summary: {
+				errorCount: flattened.filter((problem) => problem.severity === "error")
+					.length,
+				warningCount: flattened.filter(
+					(problem) => problem.severity === "warning",
+				).length,
+				infoCount: flattened.filter((problem) => problem.severity === "info")
+					.length,
+				hintCount: flattened.filter((problem) => problem.severity === "hint")
+					.length,
+			},
+		};
+	}
+
+	private bump(workspaceId: string): void {
+		const version = (this.versions.get(workspaceId) ?? 0) + 1;
+		this.versions.set(workspaceId, version);
+		this.emitter.emit(this.eventName(workspaceId), { version });
+	}
+
+	private eventName(workspaceId: string): string {
+		return `workspace:${workspaceId}`;
+	}
+}
+
+export const languageDiagnosticsStore = new LanguageDiagnosticsStore();
diff --git a/apps/desktop/src/main/lib/language-services/lsp/StdioJsonRpcClient.ts b/apps/desktop/src/main/lib/language-services/lsp/StdioJsonRpcClient.ts
new file mode 100644
index 00000000000..61fba479bc0
--- /dev/null
+++ b/apps/desktop/src/main/lib/language-services/lsp/StdioJsonRpcClient.ts
@@ -0,0 +1,306 @@
+import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
+
+type JsonRpcId = number | string | null;
+
+type JsonRpcRequestMessage = {
+	jsonrpc: "2.0";
+	id: JsonRpcId;
+	method: string;
+	params?: unknown;
+};
+
+type JsonRpcNotificationMessage = {
+	jsonrpc: "2.0";
+	method: string;
+	params?: unknown;
+};
+
+type JsonRpcResponseMessage = {
+	jsonrpc: "2.0";
+	id: JsonRpcId;
+	result?: unknown;
+	error?: {
+		code: number;
+		message: string;
+		data?: unknown;
+	};
+};
+
+type JsonRpcMessage =
+	| JsonRpcRequestMessage
+	| JsonRpcNotificationMessage
+	| JsonRpcResponseMessage;
+
+type PendingRequest = {
+	resolve: (value: unknown) => void;
+	reject: (error: Error) => void;
+};
+
+type StdioJsonRpcClientOptions = {
+	name: string;
+	command: string;
+	args?: string[];
+	cwd?: string;
+	env?: NodeJS.ProcessEnv;
+	shell?: boolean;
+	onNotification?: (message: JsonRpcNotificationMessage) => void;
+	onRequest?: (message: JsonRpcRequestMessage) => Promise<unknown> | unknown;
+	onExit?: (payload: {
+		code: number | null;
+		signal: NodeJS.Signals | null;
+	}) => void;
+	onStderr?: (chunk: string) => void;
+};
+
+function isJsonRpcResponseMessage(
+	message: JsonRpcMessage,
+): message is JsonRpcResponseMessage {
+	return "id" in message && !("method" in message);
+}
+
+function isJsonRpcRequestMessage(
+	message: JsonRpcMessage,
+): message is JsonRpcRequestMessage {
+	return "id" in message && "method" in message;
+}
+
+function consumeMessage(
+	buffer: Buffer<ArrayBufferLike>,
+): { body: string; rest: Buffer<ArrayBufferLike> } | null {
+	const separatorIndex = buffer.indexOf("\r\n\r\n");
+	if (separatorIndex === -1) {
+		return null;
+	}
+
+	const header = buffer.subarray(0, separatorIndex).toString("utf8");
+	const contentLengthMatch = /Content-Length:\s*(\d+)/i.exec(header);
+	if (!contentLengthMatch) {
+		return null;
+	}
+
+	const contentLength = Number(contentLengthMatch[1]);
+	const bodyStart = separatorIndex + 4;
+	const bodyEnd = bodyStart + contentLength;
+	if (buffer.length < bodyEnd) {
+		return null;
+	}
+
+	return {
+		body: buffer.subarray(bodyStart, bodyEnd).toString("utf8"),
+		rest: buffer.subarray(bodyEnd),
+	};
+}
+
+export class StdioJsonRpcClient {
+	private process: ChildProcessWithoutNullStreams | null = null;
+
+	private nextId = 0;
+
+	private buffer: Buffer<ArrayBufferLike> = Buffer.alloc(0);
+
+	private readonly pendingRequests = new Map<number, PendingRequest>();
+
+	constructor(private readonly options: StdioJsonRpcClientOptions) {}
+
+	async start(): Promise<void> {
+		if (this.process) {
+			return;
+		}
+
+		const child = spawn(this.options.command, this.options.args ?? [], {
+			cwd: this.options.cwd,
+			env: this.options.env,
+			shell: this.options.shell,
+			stdio: ["pipe", "pipe", "pipe"],
+		});
+
+		this.process = child;
+		child.stdout.on("data", (chunk: Buffer) => {
+			this.handleStdout(chunk);
+		});
+		child.stderr.setEncoding("utf8");
+		child.stderr.on("data", (chunk: string) => {
+			this.options.onStderr?.(chunk);
+		});
+		child.on("exit", (code, signal) => {
+			this.process = null;
+			for (const pendingRequest of this.pendingRequests.values()) {
+				pendingRequest.reject(
+					new Error(
+						`${this.options.name} exited (${code ?? "null"}${signal ? `, ${signal}` : ""})`,
+					),
+				);
+			}
+			this.pendingRequests.clear();
+			this.options.onExit?.({ code, signal });
+		});
+		child.on("error", (error) => {
+			this.process = null;
+			for (const pendingRequest of this.pendingRequests.values()) {
+				pendingRequest.reject(error);
+			}
+			this.pendingRequests.clear();
+		});
+	}
+
+	async request(method: string, params?: unknown): Promise<unknown> {
+		const id = ++this.nextId;
+		return await new Promise<unknown>((resolve, reject) => {
+			this.pendingRequests.set(id, { resolve, reject });
+			void this.writeMessage({
+				jsonrpc: "2.0",
+				id,
+				method,
+				params,
+			}).catch((error) => {
+				this.pendingRequests.delete(id);
+				reject(error);
+			});
+		});
+	}
+
+	async notify(method: string, params?: unknown): Promise<void> {
+		await this.writeMessage({
+			jsonrpc: "2.0",
+			method,
+			params,
+		});
+	}
+
+	async stop(): Promise<void> {
+		if (!this.process) {
+			return;
+		}
+
+		const child = this.process;
+		this.process = null;
+		child.removeAllListeners();
+		if (!child.killed) {
+			child.kill();
+		}
+
+		for (const pendingRequest of this.pendingRequests.values()) {
+			pendingRequest.reject(new Error(`${this.options.name} stopped`));
+		}
+		this.pendingRequests.clear();
+	}
+
+	private handleStdout(chunk: Buffer<ArrayBufferLike>): void {
+		this.buffer = Buffer.concat([this.buffer, chunk]);
+		while (true) {
+			const message = consumeMessage(this.buffer);
+			if (!message) {
+				return;
+			}
+
+			this.buffer = message.rest;
+			if (!message.body.trim()) {
+				continue;
+			}
+
+			try {
+				const parsed = JSON.parse(message.body) as JsonRpcMessage;
+				this.handleMessage(parsed);
+			} catch (error) {
+				console.error(
+					"[language-services/lsp] Failed to parse JSON-RPC payload",
+					{
+						name: this.options.name,
+						error,
+						body: message.body,
+					},
+				);
+			}
+		}
+	}
+
+	private handleMessage(message: JsonRpcMessage): void {
+		if (isJsonRpcResponseMessage(message)) {
+			const requestId = Number(message.id);
+			const pendingRequest = Number.isNaN(requestId)
+				? null
+				: this.pendingRequests.get(requestId);
+			if (!pendingRequest) {
+				return;
+			}
+
+			this.pendingRequests.delete(requestId);
+			if (message.error) {
+				pendingRequest.reject(new Error(message.error.message));
+				return;
+			}
+
+			pendingRequest.resolve(message.result);
+			return;
+		}
+
+		if (isJsonRpcRequestMessage(message)) {
+			void this.handleServerRequest(message);
+			return;
+		}
+
+		this.options.onNotification?.(message);
+	}
+
+	private async handleServerRequest(
+		message: JsonRpcRequestMessage,
+	): Promise<void> {
+		try {
+			const result =
+				(await this.options.onRequest?.(message)) ??
+				this.defaultRequestResult(message.method);
+			await this.writeMessage({
+				jsonrpc: "2.0",
+				id: message.id,
+				result: result ?? null,
+			});
+		} catch (error) {
+			await this.writeMessage({
+				jsonrpc: "2.0",
+				id: message.id,
+				error: {
+					code: -32603,
+					message: error instanceof Error ? error.message : String(error),
+				},
+			});
+		}
+	}
+
+	private defaultRequestResult(method: string): unknown {
+		switch (method) {
+			case "client/registerCapability":
+			case "client/unregisterCapability":
+			case "window/workDoneProgress/create":
+				return null;
+			case "workspace/configuration":
+				return [];
+			default:
+				throw new Error(`Unhandled JSON-RPC request: ${method}`);
+		}
+	}
+
+	private async writeMessage(message: JsonRpcMessage): Promise<void> {
+		const child = this.process;
+		if (!child) {
+			throw new Error(`${this.options.name} is not running`);
+		}
+
+		const payload = Buffer.from(JSON.stringify(message), "utf8");
+		const header = Buffer.from(
+			`Content-Length: ${payload.byteLength}\r\n\r\n`,
+			"utf8",
+		);
+		const combined = Buffer.concat([header, payload]);
+
+		await new Promise<void>((resolve, reject) => {
+			child.stdin.write(combined, (error) => {
+				if (error) {
+					reject(error);
+					return;
+				}
+
+				resolve();
+			});
+		});
+	}
+}
diff --git a/apps/desktop/src/main/lib/language-services/manager.ts b/apps/desktop/src/main/lib/language-services/manager.ts
new file mode 100644
index 00000000000..1b0491f8db6
--- /dev/null
+++ b/apps/desktop/src/main/lib/language-services/manager.ts
@@ -0,0 +1,183 @@
+import { languageDiagnosticsStore } from "./diagnostics-store";
+import { DartLanguageProvider } from "./providers/dart/DartLanguageProvider";
+import { JsonLanguageProvider } from "./providers/json/JsonLanguageProvider";
+import { TomlLanguageProvider } from "./providers/toml/TomlLanguageProvider";
+import { TypeScriptLanguageProvider } from "./providers/typescript/TypeScriptLanguageProvider";
+import type {
+	LanguageServiceDocument,
+	LanguageServiceProvider,
+	LanguageServiceProviderDescriptor,
+	LanguageServiceWorkspaceSnapshot,
+} from "./types";
+
+export class LanguageServiceManager {
+	private readonly providers: LanguageServiceProvider[] = [
+		new TypeScriptLanguageProvider(),
+		new JsonLanguageProvider(),
+		new TomlLanguageProvider(),
+		new DartLanguageProvider(),
+	];
+
+	private readonly enabledProviders = new Map<string, boolean>(
+		this.providers.map((provider) => [provider.id, true] as const),
+	);
+
+	private readonly knownWorkspaces = new Map<string, string>();
+
+	async syncDocument(document: LanguageServiceDocument): Promise<void> {
+		this.rememberWorkspace(document.workspaceId, document.workspacePath);
+		const provider = this.resolveProvider(document.languageId);
+		if (!provider || !this.isProviderEnabled(provider.id)) {
+			return;
+		}
+
+		await provider.changeDocument(document);
+	}
+
+	async openDocument(document: LanguageServiceDocument): Promise<void> {
+		this.rememberWorkspace(document.workspaceId, document.workspacePath);
+		const provider = this.resolveProvider(document.languageId);
+		if (!provider || !this.isProviderEnabled(provider.id)) {
+			return;
+		}
+
+		await provider.openDocument(document);
+	}
+
+	async closeDocument(args: {
+		workspaceId: string;
+		workspacePath: string;
+		absolutePath: string;
+		languageId: string;
+	}): Promise<void> {
+		const provider = this.resolveProvider(args.languageId);
+		if (!provider) {
+			return;
+		}
+
+		await provider.closeDocument(args);
+	}
+
+	async refreshWorkspace(args: {
+		workspaceId: string;
+		workspacePath: string;
+	}): Promise<void> {
+		this.rememberWorkspace(args.workspaceId, args.workspacePath);
+		await Promise.all(
+			this.providers
+				.filter((provider) => this.isProviderEnabled(provider.id))
+				.map((provider) => provider.refreshWorkspace(args)),
+		);
+	}
+
+	async disposeWorkspace(args: {
+		workspaceId: string;
+		workspacePath: string;
+	}): Promise<void> {
+		this.knownWorkspaces.delete(args.workspaceId);
+		await Promise.all(
+			this.providers.map((provider) => provider.disposeWorkspace(args)),
+		);
+		languageDiagnosticsStore.clearWorkspace(args.workspaceId);
+	}
+
+	getWorkspaceSnapshot(args: {
+		workspaceId: string;
+		workspacePath: string;
+	}): LanguageServiceWorkspaceSnapshot {
+		this.rememberWorkspace(args.workspaceId, args.workspacePath);
+		return languageDiagnosticsStore.createSnapshot({
+			workspaceId: args.workspaceId,
+			workspacePath: args.workspacePath,
+			providers: this.providers.map((provider) =>
+				provider.getWorkspaceSummary({
+					workspaceId: args.workspaceId,
+					workspacePath: args.workspacePath,
+					enabled: this.isProviderEnabled(provider.id),
+				}),
+			),
+		});
+	}
+
+	getProviders(): LanguageServiceProviderDescriptor[] {
+		return this.providers.map((provider) => ({
+			providerId: provider.id,
+			label: provider.label,
+			description: provider.description,
+			languageIds: provider.languageIds,
+			enabled: this.isProviderEnabled(provider.id),
+		}));
+	}
+
+	async setProviderEnabled(
+		providerId: string,
+		enabled: boolean,
+	): Promise<LanguageServiceProviderDescriptor | null> {
+		const provider = this.providers.find(
+			(candidate) => candidate.id === providerId,
+		);
+		if (!provider) {
+			return null;
+		}
+
+		const previous = this.isProviderEnabled(providerId);
+		if (previous === enabled) {
+			return {
+				providerId: provider.id,
+				label: provider.label,
+				description: provider.description,
+				languageIds: provider.languageIds,
+				enabled,
+			};
+		}
+
+		this.enabledProviders.set(providerId, enabled);
+
+		if (!enabled) {
+			await Promise.all(
+				Array.from(this.knownWorkspaces.entries()).map(
+					async ([workspaceId, workspacePath]) => {
+						await provider.disposeWorkspace({
+							workspaceId,
+							workspacePath,
+						});
+					},
+				),
+			);
+			languageDiagnosticsStore.clearProviderDiagnostics(providerId);
+		}
+
+		return {
+			providerId: provider.id,
+			label: provider.label,
+			description: provider.description,
+			languageIds: provider.languageIds,
+			enabled,
+		};
+	}
+
+	subscribeToWorkspace(
+		workspaceId: string,
+		listener: (payload: { version: number }) => void,
+	) {
+		return languageDiagnosticsStore.subscribe(workspaceId, listener);
+	}
+
+	private isProviderEnabled(providerId: string): boolean {
+		return this.enabledProviders.get(providerId) ?? false;
+	}
+
+	private rememberWorkspace(workspaceId: string, workspacePath: string): void {
+		this.knownWorkspaces.set(workspaceId, workspacePath);
+	}
+
+	private resolveProvider(languageId: string): LanguageServiceProvider | null {
+		return (
+			this.providers.find((provider) =>
+				provider.supportsLanguage(languageId),
+			) ?? null
+		);
+	}
+}
+
+export const languageServiceManager = new LanguageServiceManager();
diff --git a/apps/desktop/src/main/lib/language-services/providers/dart/DartLanguageProvider.ts b/apps/desktop/src/main/lib/language-services/providers/dart/DartLanguageProvider.ts
new file mode 100644
index 00000000000..011f4ae2a8a
--- /dev/null
+++ b/apps/desktop/src/main/lib/language-services/providers/dart/DartLanguageProvider.ts
@@ -0,0 +1,572 @@
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { languageDiagnosticsStore } from "../../diagnostics-store";
+import { StdioJsonRpcClient } from "../../lsp/StdioJsonRpcClient";
+import type {
+	LanguageServiceDiagnostic,
+	LanguageServiceDocument,
+	LanguageServiceProvider,
+	LanguageServiceProviderSummary,
+	LanguageServiceRelatedInformation,
+} from "../../types";
+import {
+	absolutePathToFileUri,
+	fileUriToAbsolutePath,
+	lspSeverityToLanguageServiceSeverity,
+	offsetToLspPosition,
+	toRelativeWorkspacePath,
+} from "../../utils";
+
+type OpenDocumentEntry = {
+	languageId: string;
+	version: number;
+	content: string;
+	uri: string;
+};
+
+type DartDiagnostic = {
+	range: {
+		start: { line: number; character: number };
+		end: { line: number; character: number };
+	};
+	severity?: number;
+	code?: string | number;
+	source?: string;
+	message: string;
+	relatedInformation?: Array<{
+		location: {
+			uri: string;
+			range: {
+				start: { line: number; character: number };
+				end: { line: number; character: number };
+			};
+		};
+		message: string;
+	}>;
+};
+
+type WorkspaceSession = {
+	workspaceId: string;
+	workspacePath: string;
+	dartCommand: string;
+	client: StdioJsonRpcClient;
+	openDocuments: Map<string, OpenDocumentEntry>;
+	lastError: string | null;
+	textDocumentSyncMode: "full" | "incremental";
+};
+
+type ResolvedDartCommand = {
+	command: string;
+	shell: boolean;
+};
+
+function canExecute(command: string, shell: boolean): boolean {
+	const probe = spawnSync(command, ["--version"], {
+		stdio: "ignore",
+		shell,
+	});
+	return probe.status === 0;
+}
+
+function getEnvCandidateCommands(): string[] {
+	const executableName = process.platform === "win32" ? "dart.exe" : "dart";
+	const wrapperName = process.platform === "win32" ? "dart.bat" : "dart";
+	return [
+		process.env.DART_SDK
+			? path.join(process.env.DART_SDK, "bin", executableName)
+			: null,
+		process.env.FLUTTER_ROOT
+			? path.join(process.env.FLUTTER_ROOT, "bin", wrapperName)
+			: null,
+		process.env.FLUTTER_ROOT
+			? path.join(
+					process.env.FLUTTER_ROOT,
+					"bin",
+					"cache",
+					"dart-sdk",
+					"bin",
+					executableName,
+				)
+			: null,
+	].filter((candidate): candidate is string => Boolean(candidate));
+}
+
+function resolveFlutterSdkCommands(): string[] {
+	const flutterCommand =
+		process.platform === "win32" ? "flutter.bat" : "flutter";
+	const locateCommand = process.platform === "win32" ? "where" : "which";
+	const locateResult = spawnSync(locateCommand, [flutterCommand], {
+		encoding: "utf8",
+		shell: process.platform === "win32",
+	});
+	if (locateResult.status !== 0 || !locateResult.stdout) {
+		return [];
+	}
+
+	const flutterExecutablePath = locateResult.stdout
+		.split(/\r?\n/)
+		.map((line) => line.trim())
+		.find(Boolean);
+	if (!flutterExecutablePath) {
+		return [];
+	}
+
+	const flutterBinDir = path.dirname(flutterExecutablePath);
+	const executableName = process.platform === "win32" ? "dart.exe" : "dart";
+	const wrapperName = process.platform === "win32" ? "dart.bat" : "dart";
+
+	return [
+		path.join(flutterBinDir, wrapperName),
+		path.join(flutterBinDir, "cache", "dart-sdk", "bin", executableName),
+	];
+}
+
+function resolveDartCommand(): ResolvedDartCommand | null {
+	const pathCommand = process.platform === "win32" ? "dart.bat" : "dart";
+	const shell = process.platform === "win32";
+	if (canExecute(pathCommand, shell)) {
+		return {
+			command: pathCommand,
+			shell,
+		};
+	}
+
+	for (const candidate of [
+		...getEnvCandidateCommands(),
+		...resolveFlutterSdkCommands(),
+	]) {
+		if (!canExecute(candidate, false)) {
+			continue;
+		}
+
+		return {
+			command: candidate,
+			shell: false,
+		};
+	}
+
+	return null;
+}
+
+function resolveTextDocumentSyncMode(result: unknown): "full" | "incremental" {
+	const textDocumentSync = (
+		result as {
+			capabilities?: {
+				textDocumentSync?:
+					| number
+					| {
+							change?: number;
+					  };
+			};
+		}
+	)?.capabilities?.textDocumentSync;
+
+	if (typeof textDocumentSync === "number") {
+		return textDocumentSync === 2 ? "incremental" : "full";
+	}
+
+	if (
+		textDocumentSync &&
+		typeof textDocumentSync === "object" &&
+		textDocumentSync.change === 2
+	) {
+		return "incremental";
+	}
+
+	return "full";
+}
+
+export class DartLanguageProvider implements LanguageServiceProvider {
+	readonly id = "dart";
+
+	readonly label = "Dart";
+
+	readonly description =
+		"Dart and Flutter diagnostics via the Dart language server.";
+
+	readonly languageIds = ["dart"];
+
+	private readonly sessions = new Map<string, WorkspaceSession>();
+
+	private readonly workspaceErrors = new Map<string, string | null>();
+
+	supportsLanguage(languageId: string): boolean {
+		return languageId === "dart";
+	}
+
+	async openDocument(document: LanguageServiceDocument): Promise<void> {
+		const session = await this.ensureSession(
+			document.workspaceId,
+			document.workspacePath,
+		);
+		const uri = absolutePathToFileUri(document.absolutePath);
+		session.openDocuments.set(document.absolutePath, {
+			languageId: document.languageId,
+			version: document.version,
+			content: document.content,
+			uri,
+		});
+		await session.client.notify("textDocument/didOpen", {
+			textDocument: {
+				uri,
+				languageId: "dart",
+				version: document.version,
+				text: document.content,
+			},
+		});
+	}
+
+	async changeDocument(document: LanguageServiceDocument): Promise<void> {
+		const session = await this.ensureSession(
+			document.workspaceId,
+			document.workspacePath,
+		);
+		const previous = session.openDocuments.get(document.absolutePath);
+		if (!previous) {
+			await this.openDocument(document);
+			return;
+		}
+
+		session.openDocuments.set(document.absolutePath, {
+			languageId: document.languageId,
+			version: document.version,
+			content: document.content,
+			uri: previous.uri,
+		});
+
+		await session.client.notify("textDocument/didChange", {
+			textDocument: {
+				uri: previous.uri,
+				version: document.version,
+			},
+			contentChanges:
+				session.textDocumentSyncMode === "incremental"
+					? [
+							{
+								range: {
+									start: { line: 0, character: 0 },
+									end: offsetToLspPosition(
+										previous.content,
+										previous.content.length,
+									),
+								},
+								text: document.content,
+							},
+						]
+					: [
+							{
+								text: document.content,
+							},
+						],
+		});
+	}
+
+	async closeDocument(args: {
+		workspaceId: string;
+		workspacePath: string;
+		absolutePath: string;
+		languageId: string;
+	}): Promise<void> {
+		const session = this.sessions.get(args.workspaceId);
+		if (!session) {
+			return;
+		}
+
+		const existing = session.openDocuments.get(args.absolutePath);
+		session.openDocuments.delete(args.absolutePath);
+		languageDiagnosticsStore.clearFileDiagnostics(
+			args.workspaceId,
+			this.fileKey(args.absolutePath),
+		);
+
+		if (existing) {
+			await session.client.notify("textDocument/didClose", {
+				textDocument: {
+					uri: existing.uri,
+				},
+			});
+		}
+
+		if (session.openDocuments.size === 0) {
+			await this.disposeWorkspace(args);
+		}
+	}
+
+	async refreshWorkspace(args: {
+		workspaceId: string;
+		workspacePath: string;
+	}): Promise<void> {
+		const session = this.sessions.get(args.workspaceId);
+		if (!session) {
+			return;
+		}
+
+		try {
+			await session.client.request("dart/reanalyze");
+			session.lastError = null;
+		} catch (error) {
+			session.lastError =
+				error instanceof Error ? error.message : String(error);
+			this.workspaceErrors.set(args.workspaceId, session.lastError);
+		}
+	}
+
+	getWorkspaceSummary(args: {
+		workspaceId: string;
+		workspacePath: string;
+		enabled: boolean;
+	}): LanguageServiceProviderSummary {
+		const session = this.sessions.get(args.workspaceId);
+		const lastError =
+			session?.lastError ?? this.workspaceErrors.get(args.workspaceId) ?? null;
+
+		if (!args.enabled) {
+			return {
+				providerId: this.id,
+				label: this.label,
+				status: "disabled",
+				details: null,
+				documentCount: 0,
+			};
+		}
+
+		if (!session) {
+			return {
+				providerId: this.id,
+				label: this.label,
+				status: lastError ? "error" : "idle",
+				details: lastError,
+				documentCount: 0,
+			};
+		}
+
+		return {
+			providerId: this.id,
+			label: this.label,
+			status: lastError ? "error" : "ready",
+			details: lastError,
+			documentCount: session.openDocuments.size,
+		};
+	}
+
+	async disposeWorkspace(args: {
+		workspaceId: string;
+		workspacePath: string;
+	}): Promise<void> {
+		const session = this.sessions.get(args.workspaceId);
+		if (session) {
+			await session.client.stop();
+			this.sessions.delete(args.workspaceId);
+		}
+
+		this.workspaceErrors.delete(args.workspaceId);
+	}
+
+	private async ensureSession(
+		workspaceId: string,
+		workspacePath: string,
+	): Promise<WorkspaceSession> {
+		const existing = this.sessions.get(workspaceId);
+		if (existing) {
+			return existing;
+		}
+
+		const resolvedDartCommand = resolveDartCommand();
+		if (!resolvedDartCommand) {
+			const error =
+				"dart command not found. Install Dart or Flutter, or set DART_SDK / FLUTTER_ROOT.";
+			this.workspaceErrors.set(workspaceId, error);
+			throw new Error(error);
+		}
+
+		let session!: WorkspaceSession;
+		const client = new StdioJsonRpcClient({
+			name: `dart:${workspaceId}`,
+			command: resolvedDartCommand.command,
+			args: [
+				"language-server",
+				"--client-id",
+				"superset.desktop",
+				"--client-version",
+				"1.4.6",
+			],
+			cwd: workspacePath,
+			env: process.env,
+			shell: resolvedDartCommand.shell,
+			onNotification: (message) => {
+				this.handleNotification(session, message);
+			},
+			onRequest: async (message) => await this.handleServerRequest(message),
+			onExit: ({ code, signal }) => {
+				const error = `dart language-server exited (${code ?? "null"}${signal ? `, ${signal}` : ""})`;
+				session.lastError = error;
+				this.workspaceErrors.set(workspaceId, error);
+				this.sessions.delete(workspaceId);
+			},
+			onStderr: (chunk) => {
+				console.error("[language-services/dart] stderr", {
+					workspaceId,
+					chunk,
+				});
+			},
+		});
+
+		session = {
+			workspaceId,
+			workspacePath,
+			dartCommand: resolvedDartCommand.command,
+			client,
+			openDocuments: new Map(),
+			lastError: null,
+			textDocumentSyncMode: "full",
+		};
+
+		try {
+			await client.start();
+			const workspaceUri = absolutePathToFileUri(workspacePath);
+			const initializeResult = await client.request("initialize", {
+				processId: process.pid,
+				clientInfo: {
+					name: "Superset Desktop",
+					version: "1.4.6",
+				},
+				rootUri: workspaceUri,
+				rootPath: workspacePath,
+				workspaceFolders: [
+					{
+						uri: workspaceUri,
+						name: path.basename(workspacePath),
+					},
+				],
+				capabilities: {
+					workspace: {
+						configuration: true,
+						workspaceFolders: true,
+					},
+					textDocument: {
+						publishDiagnostics: {
+							relatedInformation: true,
+						},
+					},
+				},
+				initializationOptions: {
+					onlyAnalyzeProjectsWithOpenFiles: true,
+				},
+			});
+			await client.notify("initialized", {});
+			session.textDocumentSyncMode =
+				resolveTextDocumentSyncMode(initializeResult);
+			session.lastError = null;
+			this.workspaceErrors.delete(workspaceId);
+			this.sessions.set(workspaceId, session);
+			return session;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			session.lastError = message;
+			this.workspaceErrors.set(workspaceId, message);
+			await client.stop();
+			throw error;
+		}
+	}
+
+	private handleNotification(
+		session: WorkspaceSession,
+		message: {
+			method: string;
+			params?: unknown;
+		},
+	): void {
+		if (message.method !== "textDocument/publishDiagnostics") {
+			return;
+		}
+
+		const params = message.params as
+			| {
+					uri?: string;
+					diagnostics?: DartDiagnostic[];
+			  }
+			| undefined;
+		if (!params?.uri) {
+			return;
+		}
+
+		const absolutePath = fileUriToAbsolutePath(params.uri);
+		if (!absolutePath) {
+			return;
+		}
+
+		languageDiagnosticsStore.setFileDiagnostics(
+			session.workspaceId,
+			this.fileKey(absolutePath),
+			(params.diagnostics ?? []).map((diagnostic) =>
+				this.mapDiagnostic(session.workspacePath, absolutePath, diagnostic),
+			),
+		);
+	}
+
+	private async handleServerRequest(message: {
+		method: string;
+		params?: unknown;
+	}): Promise<unknown> {
+		if (message.method !== "workspace/configuration") {
+			return undefined;
+		}
+
+		const items = ((
+			message.params as { items?: Array<{ section?: string | null }> | null }
+		)?.items ?? []) as Array<{ section?: string | null }>;
+		return items.map((item) => {
+			if (item.section === "dart") {
+				return {
+					showTodos: false,
+				};
+			}
+
+			return null;
+		});
+	}
+
+	private mapDiagnostic(
+		workspacePath: string,
+		absolutePath: string,
+		diagnostic: DartDiagnostic,
+	): LanguageServiceDiagnostic {
+		const relatedInformation = (
+			diagnostic.relatedInformation ?? []
+		).map<LanguageServiceRelatedInformation>((item) => {
+			const relatedAbsolutePath =
+				fileUriToAbsolutePath(item.location.uri) ?? absolutePath;
+			return {
+				absolutePath: relatedAbsolutePath,
+				relativePath: toRelativeWorkspacePath(
+					workspacePath,
+					relatedAbsolutePath,
+				),
+				line: item.location.range.start.line + 1,
+				column: item.location.range.start.character + 1,
+				endLine: item.location.range.end.line + 1,
+				endColumn: item.location.range.end.character + 1,
+				message: item.message,
+			};
+		});
+
+		return {
+			providerId: this.id,
+			source: diagnostic.source ?? "dart",
+			absolutePath,
+			relativePath: toRelativeWorkspacePath(workspacePath, absolutePath),
+			line: diagnostic.range.start.line + 1,
+			column: diagnostic.range.start.character + 1,
+			endLine: diagnostic.range.end.line + 1,
+			endColumn: diagnostic.range.end.character + 1,
+			message: diagnostic.message,
+			code: diagnostic.code ?? null,
+			severity: lspSeverityToLanguageServiceSeverity(diagnostic.severity),
+			relatedInformation,
+		};
+	}
+
+	private fileKey(absolutePath: string): string {
+		return `${this.id}::${absolutePath}`;
+	}
+}
diff --git a/apps/desktop/src/main/lib/language-services/providers/json/JsonLanguageProvider.ts b/apps/desktop/src/main/lib/language-services/providers/json/JsonLanguageProvider.ts
new file mode 100644
index 00000000000..d8307306d69
--- /dev/null
+++ b/apps/desktop/src/main/lib/language-services/providers/json/JsonLanguageProvider.ts
@@ -0,0 +1,306 @@
+import fs from "node:fs/promises";
+import {
+	type Diagnostic,
+	getLanguageService,
+} from "vscode-json-languageservice";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { languageDiagnosticsStore } from "../../diagnostics-store";
+import type {
+	LanguageServiceDiagnostic,
+	LanguageServiceDocument,
+	LanguageServiceProvider,
+	LanguageServiceProviderSummary,
+} from "../../types";
+import {
+	absolutePathToFileUri,
+	fileUriToAbsolutePath,
+	lspSeverityToLanguageServiceSeverity,
+	toRelativeWorkspacePath,
+} from "../../utils";
+
+type OpenDocumentEntry = {
+	languageId: string;
+	version: number;
+	content: string;
+};
+
+type WorkspaceState = {
+	documents: Map<string, OpenDocumentEntry>;
+	lastError: string | null;
+};
+
+const KNOWN_JSON_SCHEMAS = [
+	{
+		uri: "https://json.schemastore.org/package.json",
+		fileMatch: ["package.json"],
+	},
+	{
+		uri: "https://json.schemastore.org/tsconfig.json",
+		fileMatch: ["tsconfig.json", "tsconfig.*.json"],
+	},
+	{
+		uri: "https://json.schemastore.org/jsconfig.json",
+		fileMatch: ["jsconfig.json"],
+	},
+	{
+		uri: "https://json.schemastore.org/bunfig.json",
+		fileMatch: ["bunfig.json", "bunfig.*.json"],
+	},
+	{
+		uri: "https://json.schemastore.org/turbo.json",
+		fileMatch: ["turbo.json"],
+	},
+];
+
+export class JsonLanguageProvider implements LanguageServiceProvider {
+	readonly id = "json";
+
+	readonly label = "JSON";
+
+	readonly description =
+		"JSON and JSONC diagnostics via vscode-json-languageservice.";
+
+	readonly languageIds = ["json", "jsonc"];
+
+	private readonly workspaces = new Map<string, WorkspaceState>();
+
+	private readonly jsonService = getLanguageService({
+		schemaRequestService: async (uri) => {
+			if (uri.startsWith("file://")) {
+				return await fs.readFile(new URL(uri), "utf8");
+			}
+
+			const response = await fetch(uri);
+			if (!response.ok) {
+				throw new Error(`Failed to load schema: ${uri} (${response.status})`);
+			}
+
+			return await response.text();
+		},
+	});
+
+	constructor() {
+		this.jsonService.configure({
+			validate: true,
+			allowComments: false,
+			schemas: KNOWN_JSON_SCHEMAS,
+		});
+	}
+
+	supportsLanguage(languageId: string): boolean {
+		return languageId === "json" || languageId === "jsonc";
+	}
+
+	async openDocument(document: LanguageServiceDocument): Promise<void> {
+		const workspaceState = this.getOrCreateWorkspaceState(document.workspaceId);
+		workspaceState.documents.set(document.absolutePath, {
+			languageId: document.languageId,
+			version: document.version,
+			content: document.content,
+		});
+		await this.validateDocument(document, workspaceState);
+	}
+
+	async changeDocument(document: LanguageServiceDocument): Promise<void> {
+		const workspaceState = this.getOrCreateWorkspaceState(document.workspaceId);
+		workspaceState.documents.set(document.absolutePath, {
+			languageId: document.languageId,
+			version: document.version,
+			content: document.content,
+		});
+		await this.validateDocument(document, workspaceState);
+	}
+
+	async closeDocument(args: {
+		workspaceId: string;
+		workspacePath: string;
+		absolutePath: string;
+		languageId: string;
+	}): Promise<void> {
+		const workspaceState = this.workspaces.get(args.workspaceId);
+		if (!workspaceState) {
+			return;
+		}
+
+		workspaceState.documents.delete(args.absolutePath);
+		languageDiagnosticsStore.clearFileDiagnostics(
+			args.workspaceId,
+			this.fileKey(args.absolutePath),
+		);
+
+		if (workspaceState.documents.size === 0) {
+			this.workspaces.delete(args.workspaceId);
+		}
+	}
+
+	async refreshWorkspace(args: {
+		workspaceId: string;
+		workspacePath: string;
+	}): Promise<void> {
+		const workspaceState = this.workspaces.get(args.workspaceId);
+		if (!workspaceState) {
+			return;
+		}
+
+		for (const [absolutePath, entry] of workspaceState.documents.entries()) {
+			await this.validateDocument(
+				{
+					workspaceId: args.workspaceId,
+					workspacePath: args.workspacePath,
+					absolutePath,
+					languageId: entry.languageId,
+					content: entry.content,
+					version: entry.version,
+				},
+				workspaceState,
+			);
+		}
+	}
+
+	getWorkspaceSummary(args: {
+		workspaceId: string;
+		workspacePath: string;
+		enabled: boolean;
+	}): LanguageServiceProviderSummary {
+		const workspaceState = this.workspaces.get(args.workspaceId);
+		if (!args.enabled) {
+			return {
+				providerId: this.id,
+				label: this.label,
+				status: "disabled",
+				details: null,
+				documentCount: 0,
+			};
+		}
+
+		if (!workspaceState) {
+			return {
+				providerId: this.id,
+				label: this.label,
+				status: "idle",
+				details: null,
+				documentCount: 0,
+			};
+		}
+
+		return {
+			providerId: this.id,
+			label: this.label,
+			status: workspaceState.lastError ? "error" : "ready",
+			details: workspaceState.lastError,
+			documentCount: workspaceState.documents.size,
+		};
+	}
+
+	async disposeWorkspace(args: {
+		workspaceId: string;
+		workspacePath: string;
+	}): Promise<void> {
+		this.workspaces.delete(args.workspaceId);
+	}
+
+	private getOrCreateWorkspaceState(workspaceId: string): WorkspaceState {
+		const existing = this.workspaces.get(workspaceId);
+		if (existing) {
+			return existing;
+		}
+
+		const next: WorkspaceState = {
+			documents: new Map(),
+			lastError: null,
+		};
+		this.workspaces.set(workspaceId, next);
+		return next;
+	}
+
+	private async validateDocument(
+		document: LanguageServiceDocument,
+		workspaceState: WorkspaceState,
+	): Promise<void> {
+		try {
+			const textDocument = TextDocument.create(
+				absolutePathToFileUri(document.absolutePath),
+				document.languageId,
+				document.version,
+				document.content,
+			);
+			const jsonDocument = this.jsonService.parseJSONDocument(textDocument);
+			const diagnostics = await this.jsonService.doValidation(
+				textDocument,
+				jsonDocument,
+				document.languageId === "jsonc"
+					? {
+							comments: "ignore",
+							trailingCommas: "ignore",
+							schemaRequest: "ignore",
+						}
+					: {
+							comments: "error",
+							trailingCommas: "error",
+							schemaRequest: "ignore",
+						},
+			);
+			workspaceState.lastError = null;
+			languageDiagnosticsStore.setFileDiagnostics(
+				document.workspaceId,
+				this.fileKey(document.absolutePath),
+				diagnostics.map((diagnostic) =>
+					this.mapDiagnostic(
+						document.workspacePath,
+						document.absolutePath,
+						diagnostic,
+					),
+				),
+			);
+		} catch (error) {
+			workspaceState.lastError =
+				error instanceof Error ? error.message : String(error);
+			languageDiagnosticsStore.setFileDiagnostics(
+				document.workspaceId,
+				this.fileKey(document.absolutePath),
+				[],
+			);
+		}
+	}
+
+	private mapDiagnostic(
+		workspacePath: string,
+		absolutePath: string,
+		diagnostic: Diagnostic,
+	): LanguageServiceDiagnostic {
+		return {
+			providerId: this.id,
+			source: diagnostic.source ?? "json",
+			absolutePath,
+			relativePath: toRelativeWorkspacePath(workspacePath, absolutePath),
+			line: diagnostic.range.start.line + 1,
+			column: diagnostic.range.start.character + 1,
+			endLine: diagnostic.range.end.line + 1,
+			endColumn: diagnostic.range.end.character + 1,
+			message: diagnostic.message,
+			code: diagnostic.code ?? null,
+			severity: lspSeverityToLanguageServiceSeverity(diagnostic.severity),
+			relatedInformation:
+				diagnostic.relatedInformation?.map((item) => {
+					const relatedAbsolutePath =
+						fileUriToAbsolutePath(item.location.uri) ?? absolutePath;
+					return {
+						absolutePath: relatedAbsolutePath,
+						relativePath: toRelativeWorkspacePath(
+							workspacePath,
+							relatedAbsolutePath,
+						),
+						line: item.location.range.start.line + 1,
+						column: item.location.range.start.character + 1,
+						endLine: item.location.range.end.line + 1,
+						endColumn: item.location.range.end.character + 1,
+						message: item.message,
+					};
+				}) ?? [],
+		};
+	}
+
+	private fileKey(absolutePath: string): string {
+		return `${this.id}::${absolutePath}`;
+	}
+}
diff --git a/apps/desktop/src/main/lib/language-services/providers/toml/TomlLanguageProvider.ts b/apps/desktop/src/main/lib/language-services/providers/toml/TomlLanguageProvider.ts
new file mode 100644
index 00000000000..4d73136bc66
--- /dev/null
+++ b/apps/desktop/src/main/lib/language-services/providers/toml/TomlLanguageProvider.ts
@@ -0,0 +1,270 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { TextDecoder } from "node:util";
+import { type LintError, Taplo } from "@taplo/lib";
+import { languageDiagnosticsStore } from "../../diagnostics-store";
+import type {
+	LanguageServiceDiagnostic,
+	LanguageServiceDocument,
+	LanguageServiceProvider,
+	LanguageServiceProviderSummary,
+} from "../../types";
+import { offsetToLineColumn, toRelativeWorkspacePath } from "../../utils";
+
+type OpenDocumentEntry = {
+	languageId: string;
+	version: number;
+	content: string;
+};
+
+type WorkspaceState = {
+	documents: Map<string, OpenDocumentEntry>;
+	taploPromise: Promise<Taplo>;
+	lastError: string | null;
+};
+
+const decoder = new TextDecoder();
+
+function createTaploInstance(workspacePath: string): Promise<Taplo> {
+	return Taplo.initialize({
+		cwd: () => workspacePath,
+		envVar: (key) => process.env[key] ?? "",
+		envVars: () =>
+			Object.entries(process.env).filter(
+				(entry): entry is [string, string] => typeof entry[1] === "string",
+			),
+		findConfigFile: () => undefined,
+		glob: () => [],
+		isAbsolute: (candidate) => path.isAbsolute(candidate),
+		now: () => new Date(),
+		readFile: async (target) => await fs.readFile(target),
+		writeFile: async () => {
+			throw new Error("Taplo writeFile is not implemented");
+		},
+		stderr: async (chunk) => {
+			console.error(
+				"[language-services/toml] taplo stderr",
+				decoder.decode(chunk),
+			);
+			return chunk.length;
+		},
+		stdErrAtty: () => false,
+		stdin: async () => {
+			throw new Error("Taplo stdin is not implemented");
+		},
+		stdout: async (chunk) => chunk.length,
+		urlToFilePath: (uri) => fileURLToPath(uri),
+	});
+}
+
+export class TomlLanguageProvider implements LanguageServiceProvider {
+	readonly id = "toml";
+
+	readonly label = "TOML";
+
+	readonly description = "TOML diagnostics via Taplo.";
+
+	readonly languageIds = ["toml"];
+
+	private readonly workspaces = new Map<string, WorkspaceState>();
+
+	supportsLanguage(languageId: string): boolean {
+		return languageId === "toml";
+	}
+
+	async openDocument(document: LanguageServiceDocument): Promise<void> {
+		const workspaceState = this.getOrCreateWorkspaceState(
+			document.workspaceId,
+			document.workspacePath,
+		);
+		workspaceState.documents.set(document.absolutePath, {
+			languageId: document.languageId,
+			version: document.version,
+			content: document.content,
+		});
+		await this.validateDocument(document, workspaceState);
+	}
+
+	async changeDocument(document: LanguageServiceDocument): Promise<void> {
+		const workspaceState = this.getOrCreateWorkspaceState(
+			document.workspaceId,
+			document.workspacePath,
+		);
+		workspaceState.documents.set(document.absolutePath, {
+			languageId: document.languageId,
+			version: document.version,
+			content: document.content,
+		});
+		await this.validateDocument(document, workspaceState);
+	}
+
+	async closeDocument(args: {
+		workspaceId: string;
+		workspacePath: string;
+		absolutePath: string;
+		languageId: string;
+	}): Promise<void> {
+		const workspaceState = this.workspaces.get(args.workspaceId);
+		if (!workspaceState) {
+			return;
+		}
+
+		workspaceState.documents.delete(args.absolutePath);
+		languageDiagnosticsStore.clearFileDiagnostics(
+			args.workspaceId,
+			this.fileKey(args.absolutePath),
+		);
+
+		if (workspaceState.documents.size === 0) {
+			this.workspaces.delete(args.workspaceId);
+		}
+	}
+
+	async refreshWorkspace(args: {
+		workspaceId: string;
+		workspacePath: string;
+	}): Promise<void> {
+		const workspaceState = this.workspaces.get(args.workspaceId);
+		if (!workspaceState) {
+			return;
+		}
+
+		for (const [absolutePath, entry] of workspaceState.documents.entries()) {
+			await this.validateDocument(
+				{
+					workspaceId: args.workspaceId,
+					workspacePath: args.workspacePath,
+					absolutePath,
+					languageId: entry.languageId,
+					content: entry.content,
+					version: entry.version,
+				},
+				workspaceState,
+			);
+		}
+	}
+
+	getWorkspaceSummary(args: {
+		workspaceId: string;
+		workspacePath: string;
+		enabled: boolean;
+	}): LanguageServiceProviderSummary {
+		const workspaceState = this.workspaces.get(args.workspaceId);
+		if (!args.enabled) {
+			return {
+				providerId: this.id,
+				label: this.label,
+				status: "disabled",
+				details: null,
+				documentCount: 0,
+			};
+		}
+
+		if (!workspaceState) {
+			return {
+				providerId: this.id,
+				label: this.label,
+				status: "idle",
+				details: null,
+				documentCount: 0,
+			};
+		}
+
+		return {
+			providerId: this.id,
+			label: this.label,
+			status: workspaceState.lastError ? "error" : "ready",
+			details: workspaceState.lastError,
+			documentCount: workspaceState.documents.size,
+		};
+	}
+
+	async disposeWorkspace(args: {
+		workspaceId: string;
+		workspacePath: string;
+	}): Promise<void> {
+		this.workspaces.delete(args.workspaceId);
+	}
+
+	private getOrCreateWorkspaceState(
+		workspaceId: string,
+		workspacePath: string,
+	): WorkspaceState {
+		const existing = this.workspaces.get(workspaceId);
+		if (existing) {
+			return existing;
+		}
+
+		const next: WorkspaceState = {
+			documents: new Map(),
+			taploPromise: createTaploInstance(workspacePath),
+			lastError: null,
+		};
+		this.workspaces.set(workspaceId, next);
+		return next;
+	}
+
+	private async validateDocument(
+		document: LanguageServiceDocument,
+		workspaceState: WorkspaceState,
+	): Promise<void> {
+		try {
+			const taplo = await workspaceState.taploPromise;
+			const result = await taplo.lint(document.content);
+			workspaceState.lastError = null;
+			languageDiagnosticsStore.setFileDiagnostics(
+				document.workspaceId,
+				this.fileKey(document.absolutePath),
+				result.errors.map((error) => this.mapDiagnostic(document, error)),
+			);
+		} catch (error) {
+			workspaceState.lastError =
+				error instanceof Error ? error.message : String(error);
+			languageDiagnosticsStore.setFileDiagnostics(
+				document.workspaceId,
+				this.fileKey(document.absolutePath),
+				[],
+			);
+		}
+	}
+
+	private mapDiagnostic(
+		document: LanguageServiceDocument,
+		error: LintError,
+	): LanguageServiceDiagnostic {
+		const byteRange = error.range as
+			| {
+					start?: number;
+					end?: number;
+			  }
+			| undefined;
+		const start = offsetToLineColumn(
+			document.content,
+			byteRange?.start ?? null,
+		);
+		const end = offsetToLineColumn(document.content, byteRange?.end ?? null);
+
+		return {
+			providerId: this.id,
+			source: "toml",
+			absolutePath: document.absolutePath,
+			relativePath: toRelativeWorkspacePath(
+				document.workspacePath,
+				document.absolutePath,
+			),
+			line: start.line,
+			column: start.column,
+			endLine: end.line,
+			endColumn: end.column,
+			message: error.error,
+			code: null,
+			severity: "error",
+			relatedInformation: [],
+		};
+	}
+
+	private fileKey(absolutePath: string): string {
+		return `${this.id}::${absolutePath}`;
+	}
+}
diff --git a/apps/desktop/src/main/lib/language-services/providers/typescript/TypeScriptLanguageProvider.ts b/apps/desktop/src/main/lib/language-services/providers/typescript/TypeScriptLanguageProvider.ts
new file mode 100644
index 00000000000..422574d7fab
--- /dev/null
+++ b/apps/desktop/src/main/lib/language-services/providers/typescript/TypeScriptLanguageProvider.ts
@@ -0,0 +1,734 @@
+import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { languageDiagnosticsStore } from "../../diagnostics-store";
+import type {
+	LanguageServiceDiagnostic,
+	LanguageServiceDocument,
+	LanguageServiceProvider,
+	LanguageServiceProviderSummary,
+	LanguageServiceRelatedInformation,
+	LanguageServiceSeverity,
+} from "../../types";
+
+const require = createRequire(import.meta.url);
+
+type TsServerRequest = {
+	seq: number;
+	type: "request";
+	command: string;
+	arguments?: unknown;
+};
+
+type TsServerEvent = {
+	type: "event";
+	event: string;
+	body?: unknown;
+};
+
+type TsServerResponse = {
+	type: "response";
+	request_seq: number;
+	success: boolean;
+	command: string;
+	body?: unknown;
+	message?: string;
+};
+
+type TsServerMessage = TsServerEvent | TsServerResponse;
+
+type TsServerDiagnostic = {
+	start?: { line: number; offset: number };
+	end?: { line: number; offset: number };
+	text?: string;
+	message?: string;
+	code?: number;
+	category?: string;
+	relatedInformation?: Array<{
+		span?: {
+			file?: string;
+			start?: { line: number; offset: number };
+			end?: { line: number; offset: number };
+		};
+		message?: string;
+		text?: string;
+	}>;
+};
+
+type DiagnosticBucketKey = "syntax" | "semantic" | "suggestion" | "config";
+
+type FileDiagnosticBuckets = {
+	syntax: LanguageServiceDiagnostic[];
+	semantic: LanguageServiceDiagnostic[];
+	suggestion: LanguageServiceDiagnostic[];
+	config: LanguageServiceDiagnostic[];
+};
+
+type OpenDocumentEntry = {
+	languageId: string;
+	version: number;
+	content: string;
+};
+
+type WorkspaceSession = {
+	workspaceId: string;
+	workspacePath: string;
+	tsserverPath: string;
+	process: ChildProcessWithoutNullStreams;
+	seq: number;
+	buffer: string;
+	requestResolvers: Map<
+		number,
+		{
+			resolve: (value: TsServerResponse) => void;
+			reject: (error: Error) => void;
+		}
+	>;
+	openDocuments: Map<string, OpenDocumentEntry>;
+	diagnosticBuckets: Map<string, FileDiagnosticBuckets>;
+	getErrTimer: ReturnType<typeof setTimeout> | null;
+	lastError: string | null;
+};
+
+function createEmptyBuckets(): FileDiagnosticBuckets {
+	return {
+		syntax: [],
+		semantic: [],
+		suggestion: [],
+		config: [],
+	};
+}
+
+function tryConsumeContentLengthMessage(
+	buffer: string,
+): { body: string; rest: string } | null {
+	const normalizedBuffer = buffer.replace(/^(?:\r?\n)+/, "");
+	if (normalizedBuffer !== buffer) {
+		return tryConsumeContentLengthMessage(normalizedBuffer);
+	}
+
+	const separatorIndex = buffer.indexOf("\r\n\r\n");
+	if (separatorIndex === -1) {
+		return null;
+	}
+
+	const header = buffer.slice(0, separatorIndex);
+	const contentLengthMatch = /Content-Length: (\d+)/i.exec(header);
+	if (!contentLengthMatch) {
+		return null;
+	}
+
+	const contentLength = Number(contentLengthMatch[1]);
+	const bodyStart = separatorIndex + 4;
+	const bodyEnd = bodyStart + contentLength;
+	if (buffer.length < bodyEnd) {
+		return null;
+	}
+
+	return {
+		body: buffer.slice(bodyStart, bodyEnd),
+		rest: buffer.slice(bodyEnd),
+	};
+}
+
+function tryConsumeLineMessage(
+	buffer: string,
+): { body: string; rest: string } | null {
+	const normalizedBuffer = buffer.replace(/^(?:\r?\n)+/, "");
+	if (normalizedBuffer !== buffer) {
+		return tryConsumeLineMessage(normalizedBuffer);
+	}
+
+	if (!normalizedBuffer.trimStart().startsWith("{")) {
+		return null;
+	}
+
+	const newlineIndex = buffer.indexOf("\n");
+	if (newlineIndex === -1) {
+		return null;
+	}
+
+	return {
+		body: buffer.slice(0, newlineIndex).trim(),
+		rest: buffer.slice(newlineIndex + 1),
+	};
+}
+
+function toRelativeWorkspacePath(
+	workspacePath: string,
+	absolutePath: string,
+): string | null {
+	const relativePath = path.relative(workspacePath, absolutePath);
+	if (
+		!relativePath ||
+		relativePath.startsWith("..") ||
+		path.isAbsolute(relativePath)
+	) {
+		return null;
+	}
+
+	return relativePath.split(path.sep).join("/");
+}
+
+function toSeverity(category: string | undefined): LanguageServiceSeverity {
+	switch (category) {
+		case "error":
+			return "error";
+		case "warning":
+			return "warning";
+		case "suggestion":
+			return "hint";
+		default:
+			return "info";
+	}
+}
+
+function resolveBundledTsServerPath(): string {
+	return require.resolve("typescript/lib/tsserver.js");
+}
+
+function resolveWorkspaceTsServerPath(workspacePath: string): string | null {
+	const candidate = path.join(
+		workspacePath,
+		"node_modules",
+		"typescript",
+		"lib",
+		"tsserver.js",
+	);
+	return fs.existsSync(candidate) ? candidate : null;
+}
+
+function computeEndPosition(content: string): {
+	endLine: number;
+	endOffset: number;
+} {
+	const lines = content.split(/\r\n|\r|\n/);
+	return {
+		endLine: lines.length,
+		endOffset: (lines.at(-1)?.length ?? 0) + 1,
+	};
+}
+
+export class TypeScriptLanguageProvider implements LanguageServiceProvider {
+	readonly id = "typescript";
+
+	readonly label = "TypeScript";
+
+	readonly description =
+		"TypeScript, JavaScript, TSX, JSX diagnostics via tsserver.";
+
+	readonly languageIds = [
+		"typescript",
+		"typescriptreact",
+		"javascript",
+		"javascriptreact",
+	];
+
+	private readonly sessions = new Map<string, WorkspaceSession>();
+
+	supportsLanguage(languageId: string): boolean {
+		return [
+			"typescript",
+			"typescriptreact",
+			"javascript",
+			"javascriptreact",
+		].includes(languageId);
+	}
+
+	async openDocument(document: LanguageServiceDocument): Promise<void> {
+		const session = await this.ensureSession(
+			document.workspaceId,
+			document.workspacePath,
+		);
+		session.openDocuments.set(document.absolutePath, {
+			languageId: document.languageId,
+			version: document.version,
+			content: document.content,
+		});
+		await this.sendRequest(session, "open", {
+			file: document.absolutePath,
+			fileContent: document.content,
+			projectRootPath: document.workspacePath,
+		});
+		this.scheduleGetErr(session);
+	}
+
+	async changeDocument(document: LanguageServiceDocument): Promise<void> {
+		const session = await this.ensureSession(
+			document.workspaceId,
+			document.workspacePath,
+		);
+		const previous = session.openDocuments.get(document.absolutePath);
+		if (!previous) {
+			await this.openDocument(document);
+			return;
+		}
+
+		session.openDocuments.set(document.absolutePath, {
+			languageId: document.languageId,
+			version: document.version,
+			content: document.content,
+		});
+
+		await this.sendRequest(session, "change", {
+			file: document.absolutePath,
+			line: 1,
+			offset: 1,
+			...computeEndPosition(previous.content),
+			insertString: document.content,
+		});
+		this.scheduleGetErr(session);
+	}
+
+	async closeDocument(args: {
+		workspaceId: string;
+		workspacePath: string;
+		absolutePath: string;
+		languageId: string;
+	}): Promise<void> {
+		const session = this.sessions.get(args.workspaceId);
+		if (!session) {
+			return;
+		}
+
+		session.openDocuments.delete(args.absolutePath);
+		session.diagnosticBuckets.delete(args.absolutePath);
+		languageDiagnosticsStore.clearFileDiagnostics(
+			args.workspaceId,
+			this.fileKey(args.absolutePath),
+		);
+
+		try {
+			await this.sendRequest(session, "close", {
+				file: args.absolutePath,
+			});
+		} catch (error) {
+			console.error("[language-services/typescript] Failed to close document", {
+				workspaceId: args.workspaceId,
+				absolutePath: args.absolutePath,
+				error,
+			});
+		}
+
+		if (session.openDocuments.size === 0) {
+			await this.disposeWorkspace(args);
+			return;
+		}
+
+		this.scheduleGetErr(session);
+	}
+
+	async refreshWorkspace(args: {
+		workspaceId: string;
+		workspacePath: string;
+	}): Promise<void> {
+		const session = this.sessions.get(args.workspaceId);
+		if (!session || session.openDocuments.size === 0) {
+			return;
+		}
+
+		this.scheduleGetErr(session, 0);
+	}
+
+	getWorkspaceSummary(args: {
+		workspaceId: string;
+		workspacePath: string;
+		enabled: boolean;
+	}): LanguageServiceProviderSummary {
+		const session = this.sessions.get(args.workspaceId);
+		if (!args.enabled) {
+			return {
+				providerId: this.id,
+				label: this.label,
+				status: "disabled",
+				details: null,
+				documentCount: 0,
+			};
+		}
+
+		if (!session) {
+			return {
+				providerId: this.id,
+				label: this.label,
+				status: "idle",
+				details: null,
+				documentCount: 0,
+			};
+		}
+
+		return {
+			providerId: this.id,
+			label: this.label,
+			status: session.lastError ? "error" : "ready",
+			details: session.lastError,
+			documentCount: session.openDocuments.size,
+		};
+	}
+
+	async disposeWorkspace(args: {
+		workspaceId: string;
+		workspacePath: string;
+	}): Promise<void> {
+		const session = this.sessions.get(args.workspaceId);
+		if (!session) {
+			return;
+		}
+
+		if (session.getErrTimer) {
+			clearTimeout(session.getErrTimer);
+			session.getErrTimer = null;
+		}
+
+		for (const request of session.requestResolvers.values()) {
+			request.reject(new Error("TypeScript session disposed"));
+		}
+		session.requestResolvers.clear();
+
+		session.process.removeAllListeners();
+		if (!session.process.killed) {
+			session.process.kill();
+		}
+
+		this.sessions.delete(args.workspaceId);
+	}
+
+	private async ensureSession(
+		workspaceId: string,
+		workspacePath: string,
+	): Promise<WorkspaceSession> {
+		const existing = this.sessions.get(workspaceId);
+		if (existing) {
+			return existing;
+		}
+
+		const tsserverPath =
+			resolveWorkspaceTsServerPath(workspacePath) ??
+			resolveBundledTsServerPath();
+		const child = spawn(process.execPath, [tsserverPath, "--stdio"], {
+			env: {
+				...process.env,
+				ELECTRON_RUN_AS_NODE: "1",
+			},
+			stdio: ["pipe", "pipe", "pipe"],
+		});
+
+		const session: WorkspaceSession = {
+			workspaceId,
+			workspacePath,
+			tsserverPath,
+			process: child,
+			seq: 0,
+			buffer: "",
+			requestResolvers: new Map(),
+			openDocuments: new Map(),
+			diagnosticBuckets: new Map(),
+			getErrTimer: null,
+			lastError: null,
+		};
+		let isSessionClosed = false;
+		const closeSession = (message: string) => {
+			if (isSessionClosed) {
+				return;
+			}
+			isSessionClosed = true;
+			session.lastError = message;
+			if (session.getErrTimer) {
+				clearTimeout(session.getErrTimer);
+				session.getErrTimer = null;
+			}
+			for (const request of session.requestResolvers.values()) {
+				request.reject(new Error(message));
+			}
+			session.requestResolvers.clear();
+			this.sessions.delete(workspaceId);
+		};
+
+		child.stdout.setEncoding("utf8");
+		child.stdout.on("data", (chunk: string) => {
+			this.handleStdout(session, chunk);
+		});
+		child.stderr.setEncoding("utf8");
+		child.stderr.on("data", (chunk: string) => {
+			console.error("[language-services/typescript] tsserver stderr", {
+				workspaceId,
+				chunk,
+			});
+		});
+		child.on("error", (error) => {
+			console.error("[language-services/typescript] tsserver process error", {
+				workspaceId,
+				error,
+			});
+			closeSession(
+				error instanceof Error
+					? `tsserver process error: ${error.message}`
+					: "tsserver process error",
+			);
+		});
+		child.on("exit", (code, signal) => {
+			closeSession(
+				`TypeScript server exited: ${code ?? "null"}${signal ? ` ${signal}` : ""}`,
+			);
+		});
+
+		this.sessions.set(workspaceId, session);
+		await this.sendRequest(session, "configure", {
+			preferences: {
+				includeCompletionsForModuleExports: true,
+				includeCompletionsWithInsertText: true,
+			},
+		});
+		return session;
+	}
+
+	private handleStdout(session: WorkspaceSession, chunk: string): void {
+		session.buffer += chunk;
+		while (true) {
+			const framedMessage = tryConsumeContentLengthMessage(session.buffer);
+			const lineMessage =
+				framedMessage === null ? tryConsumeLineMessage(session.buffer) : null;
+			const message = framedMessage ?? lineMessage;
+			if (!message) {
+				return;
+			}
+
+			session.buffer = message.rest;
+			const body = message.body.trim();
+			if (!body) {
+				continue;
+			}
+
+			try {
+				const message = JSON.parse(body) as TsServerMessage;
+				this.handleMessage(session, message);
+			} catch (error) {
+				console.error(
+					"[language-services/typescript] Failed to parse tsserver payload",
+					{
+						workspaceId: session.workspaceId,
+						error,
+						body,
+					},
+				);
+			}
+		}
+	}
+
+	private handleMessage(
+		session: WorkspaceSession,
+		message: TsServerMessage,
+	): void {
+		if (message.type === "response") {
+			const resolver = session.requestResolvers.get(message.request_seq);
+			if (!resolver) {
+				return;
+			}
+			session.requestResolvers.delete(message.request_seq);
+			if (message.success) {
+				session.lastError = null;
+				resolver.resolve(message);
+			} else {
+				const error = new Error(
+					message.message ?? `tsserver command failed: ${message.command}`,
+				);
+				session.lastError = error.message;
+				resolver.reject(error);
+			}
+			return;
+		}
+
+		switch (message.event) {
+			case "syntaxDiag":
+				this.applyDiagnosticsEvent(session, "syntax", message.body);
+				return;
+			case "semanticDiag":
+				this.applyDiagnosticsEvent(session, "semantic", message.body);
+				return;
+			case "suggestionDiag":
+				this.applyDiagnosticsEvent(session, "suggestion", message.body);
+				return;
+			case "configFileDiag":
+				this.applyConfigDiagnosticsEvent(session, message.body);
+				return;
+			default:
+				return;
+		}
+	}
+
+	private applyDiagnosticsEvent(
+		session: WorkspaceSession,
+		bucketKey: DiagnosticBucketKey,
+		body: unknown,
+	): void {
+		const payload = body as
+			| { file?: string; diagnostics?: TsServerDiagnostic[] }
+			| undefined;
+		if (!payload?.file) {
+			return;
+		}
+
+		const absolutePath = payload.file;
+		const buckets =
+			session.diagnosticBuckets.get(absolutePath) ?? createEmptyBuckets();
+		buckets[bucketKey] = (payload.diagnostics ?? []).map((diagnostic) =>
+			this.mapDiagnostic(session.workspacePath, absolutePath, diagnostic),
+		);
+		session.diagnosticBuckets.set(absolutePath, buckets);
+		this.publishDiagnostics(session, absolutePath, buckets);
+	}
+
+	private applyConfigDiagnosticsEvent(
+		session: WorkspaceSession,
+		body: unknown,
+	): void {
+		const payload = body as
+			| {
+					triggerFile?: string;
+					configFile?: string;
+					diagnostics?: TsServerDiagnostic[];
+			  }
+			| undefined;
+		const absolutePath = payload?.configFile ?? payload?.triggerFile;
+		if (!absolutePath) {
+			return;
+		}
+		if (!payload) {
+			return;
+		}
+
+		const buckets =
+			session.diagnosticBuckets.get(absolutePath) ?? createEmptyBuckets();
+		buckets.config = (payload.diagnostics ?? []).map((diagnostic) =>
+			this.mapDiagnostic(session.workspacePath, absolutePath, diagnostic),
+		);
+		session.diagnosticBuckets.set(absolutePath, buckets);
+		this.publishDiagnostics(session, absolutePath, buckets);
+	}
+
+	private publishDiagnostics(
+		session: WorkspaceSession,
+		absolutePath: string,
+		buckets: FileDiagnosticBuckets,
+	): void {
+		const diagnostics = [
+			...buckets.syntax,
+			...buckets.semantic,
+			...buckets.suggestion,
+			...buckets.config,
+		];
+		languageDiagnosticsStore.setFileDiagnostics(
+			session.workspaceId,
+			this.fileKey(absolutePath),
+			diagnostics,
+		);
+	}
+
+	private mapDiagnostic(
+		workspacePath: string,
+		absolutePath: string,
+		diagnostic: TsServerDiagnostic,
+	): LanguageServiceDiagnostic {
+		const relatedInformation = diagnostic.relatedInformation
+			?.map((item) =>
+				this.mapRelatedInformation(workspacePath, absolutePath, item),
+			)
+			.filter(
+				(item): item is LanguageServiceRelatedInformation => item !== null,
+			);
+
+		return {
+			providerId: this.id,
+			source: "typescript",
+			absolutePath,
+			relativePath: toRelativeWorkspacePath(workspacePath, absolutePath),
+			line: diagnostic.start?.line ?? null,
+			column: diagnostic.start?.offset ?? null,
+			endLine: diagnostic.end?.line ?? null,
+			endColumn: diagnostic.end?.offset ?? null,
+			message:
+				diagnostic.text ?? diagnostic.message ?? "Unknown TypeScript error",
+			code: diagnostic.code ?? null,
+			severity: toSeverity(diagnostic.category),
+			relatedInformation,
+		};
+	}
+
+	private mapRelatedInformation(
+		workspacePath: string,
+		fallbackAbsolutePath: string,
+		item: NonNullable<TsServerDiagnostic["relatedInformation"]>[number],
+	): LanguageServiceRelatedInformation | null {
+		const absolutePath = item.span?.file ?? fallbackAbsolutePath;
+		const message = item.text ?? item.message ?? "";
+		if (!message) {
+			return null;
+		}
+
+		return {
+			absolutePath,
+			relativePath: toRelativeWorkspacePath(workspacePath, absolutePath),
+			line: item.span?.start?.line ?? null,
+			column: item.span?.start?.offset ?? null,
+			endLine: item.span?.end?.line ?? null,
+			endColumn: item.span?.end?.offset ?? null,
+			message,
+		};
+	}
+
+	private scheduleGetErr(session: WorkspaceSession, delay = 150): void {
+		if (session.getErrTimer) {
+			clearTimeout(session.getErrTimer);
+		}
+
+		session.getErrTimer = setTimeout(() => {
+			session.getErrTimer = null;
+			if (session.openDocuments.size === 0) {
+				return;
+			}
+
+			void this.sendRequest(session, "geterr", {
+				files: Array.from(session.openDocuments.keys()),
+				delay: 0,
+			}).catch((error) => {
+				session.lastError =
+					error instanceof Error ? error.message : String(error);
+				console.error("[language-services/typescript] geterr failed", {
+					workspaceId: session.workspaceId,
+					error,
+				});
+			});
+		}, delay);
+	}
+
+	private async sendRequest(
+		session: WorkspaceSession,
+		command: string,
+		args?: unknown,
+	): Promise<TsServerResponse> {
+		const seq = ++session.seq;
+		const payload: TsServerRequest = {
+			seq,
+			type: "request",
+			command,
+			arguments: args,
+		};
+		const content = `${JSON.stringify(payload)}\n`;
+
+		return await new Promise<TsServerResponse>((resolve, reject) => {
+			session.requestResolvers.set(seq, { resolve, reject });
+			session.process.stdin.write(content, "utf8", (error) => {
+				if (!error) {
+					return;
+				}
+
+				session.requestResolvers.delete(seq);
+				reject(error);
+			});
+		});
+	}
+
+	private fileKey(absolutePath: string): string {
+		return `${this.id}::${absolutePath}`;
+	}
+}
diff --git a/apps/desktop/src/main/lib/language-services/types.ts b/apps/desktop/src/main/lib/language-services/types.ts
new file mode 100644
index 00000000000..df3aeb7cffe
--- /dev/null
+++ b/apps/desktop/src/main/lib/language-services/types.ts
@@ -0,0 +1,96 @@
+export type LanguageServiceSeverity = "error" | "warning" | "info" | "hint";
+
+export interface LanguageServiceRelatedInformation {
+	absolutePath: string | null;
+	relativePath: string | null;
+	line: number | null;
+	column: number | null;
+	endLine: number | null;
+	endColumn: number | null;
+	message: string;
+}
+
+export interface LanguageServiceDocument {
+	workspaceId: string;
+	workspacePath: string;
+	absolutePath: string;
+	languageId: string;
+	content: string;
+	version: number;
+}
+
+export interface LanguageServiceDiagnostic {
+	providerId: string;
+	source: string;
+	absolutePath: string | null;
+	relativePath: string | null;
+	line: number | null;
+	column: number | null;
+	endLine: number | null;
+	endColumn: number | null;
+	message: string;
+	code: string | number | null;
+	severity: LanguageServiceSeverity;
+	relatedInformation?: LanguageServiceRelatedInformation[];
+}
+
+export interface LanguageServiceProviderSummary {
+	providerId: string;
+	label: string;
+	status: "ready" | "disabled" | "idle" | "error";
+	details?: string | null;
+	documentCount: number;
+}
+
+export interface LanguageServiceProviderDescriptor {
+	providerId: string;
+	label: string;
+	description: string;
+	languageIds: string[];
+	enabled: boolean;
+}
+
+export interface LanguageServiceWorkspaceSnapshot {
+	status: "ready";
+	workspaceId: string;
+	workspacePath: string;
+	providers: LanguageServiceProviderSummary[];
+	problems: LanguageServiceDiagnostic[];
+	totalCount: number;
+	truncated: boolean;
+	summary: {
+		errorCount: number;
+		warningCount: number;
+		infoCount: number;
+		hintCount: number;
+	};
+}
+
+export interface LanguageServiceProvider {
+	readonly id: string;
+	readonly label: string;
+	readonly description: string;
+	readonly languageIds: string[];
+	supportsLanguage(languageId: string): boolean;
+	openDocument(document: LanguageServiceDocument): Promise<void>;
+	changeDocument(document: LanguageServiceDocument): Promise<void>;
+	closeDocument(args: {
+		workspaceId: string;
+		workspacePath: string;
+		absolutePath: string;
+		languageId: string;
+	}): Promise<void>;
+	refreshWorkspace(args: {
+		workspaceId: string;
+		workspacePath: string;
+	}): Promise<void>;
+	getWorkspaceSummary(args: {
+		workspaceId: string;
+		workspacePath: string;
+		enabled: boolean;
+	}): LanguageServiceProviderSummary;
+	disposeWorkspace(args: {
+		workspaceId: string;
+		workspacePath: string;
+	}): Promise<void>;
+}
diff --git a/apps/desktop/src/main/lib/language-services/utils.ts b/apps/desktop/src/main/lib/language-services/utils.ts
new file mode 100644
index 00000000000..11db9d2f396
--- /dev/null
+++ b/apps/desktop/src/main/lib/language-services/utils.ts
@@ -0,0 +1,105 @@
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import type { LanguageServiceSeverity } from "./types";
+
+export function toRelativeWorkspacePath(
+	workspacePath: string,
+	absolutePath: string,
+): string | null {
+	const relativePath = path.relative(workspacePath, absolutePath);
+	if (
+		!relativePath ||
+		relativePath.startsWith("..") ||
+		path.isAbsolute(relativePath)
+	) {
+		return null;
+	}
+
+	return relativePath.split(path.sep).join("/");
+}
+
+export function absolutePathToFileUri(absolutePath: string): string {
+	return pathToFileURL(absolutePath).toString();
+}
+
+export function fileUriToAbsolutePath(uri: string): string | null {
+	if (!uri.startsWith("file://")) {
+		return null;
+	}
+
+	try {
+		return fileURLToPath(uri);
+	} catch {
+		return null;
+	}
+}
+
+export function offsetToLineColumn(
+	content: string,
+	offset: number | null | undefined,
+): { line: number | null; column: number | null } {
+	if (offset === null || offset === undefined || Number.isNaN(offset)) {
+		return {
+			line: null,
+			column: null,
+		};
+	}
+
+	const boundedOffset = Math.max(0, Math.min(offset, content.length));
+	let line = 1;
+	let column = 1;
+
+	for (let index = 0; index < boundedOffset; index += 1) {
+		const char = content[index];
+		if (char === "\n") {
+			line += 1;
+			column = 1;
+			continue;
+		}
+
+		if (char === "\r") {
+			if (content[index + 1] === "\n") {
+				index += 1;
+			}
+			line += 1;
+			column = 1;
+			continue;
+		}
+
+		column += 1;
+	}
+
+	return {
+		line,
+		column,
+	};
+}
+
+export function offsetToLspPosition(
+	content: string,
+	offset: number,
+): {
+	line: number;
+	character: number;
+} {
+	const position = offsetToLineColumn(content, offset);
+	return {
+		line: Math.max((position.line ?? 1) - 1, 0),
+		character: Math.max((position.column ?? 1) - 1, 0),
+	};
+}
+
+export function lspSeverityToLanguageServiceSeverity(
+	severity: number | null | undefined,
+): LanguageServiceSeverity {
+	switch (severity) {
+		case 1:
+			return "error";
+		case 2:
+			return "warning";
+		case 3:
+			return "info";
+		default:
+			return "hint";
+	}
+}
diff --git a/apps/desktop/src/main/lib/menu-events.ts b/apps/desktop/src/main/lib/menu-events.ts
index 7798b468b57..7e848731bb8 100644
--- a/apps/desktop/src/main/lib/menu-events.ts
+++ b/apps/desktop/src/main/lib/menu-events.ts
@@ -1,4 +1,5 @@
 import { EventEmitter } from "node:events";
+import type { BrowserShortcutAction } from "shared/browser-shortcuts";
 export type SettingsSection =
 	| "project"
 	| "workspace"
@@ -17,4 +18,8 @@ export interface OpenWorkspaceEvent {
 	workspaceId: string;
 }
 
+export interface BrowserActionEvent {
+	action: BrowserShortcutAction;
+}
+
 export const menuEmitter = new EventEmitter();
diff --git a/apps/desktop/src/main/lib/menu.ts b/apps/desktop/src/main/lib/menu.ts
index a312d4124ac..bedd0517719 100644
--- a/apps/desktop/src/main/lib/menu.ts
+++ b/apps/desktop/src/main/lib/menu.ts
@@ -1,9 +1,10 @@
 import { COMPANY } from "@superset/shared/constants";
-import { app, BrowserWindow, Menu, shell } from "electron";
+import { app, BrowserWindow, Menu, shell, webContents } from "electron";
 import { env } from "main/env.main";
 import { appState } from "main/lib/app-state";
 import { hotkeysEmitter } from "main/lib/hotkeys-events";
 import { resetTerminalStateDev } from "main/lib/terminal/dev-reset";
+import type { BrowserShortcutAction } from "shared/browser-shortcuts";
 import {
 	getCurrentPlatform,
 	getEffectiveHotkey,
@@ -20,6 +21,26 @@ import { menuEmitter } from "./menu-events";
 
 let isHotkeyListenerRegistered = false;
 
+function getFocusedWebview() {
+	return webContents
+		.getAllWebContents()
+		.find((wc) => wc.getType() === "webview" && wc.isFocused());
+}
+
+function triggerBrowserShortcut(action: BrowserShortcutAction) {
+	const focusedGuest = getFocusedWebview();
+	if (focusedGuest) {
+		if (action === "hard-reload") {
+			focusedGuest.reloadIgnoringCache();
+		} else {
+			focusedGuest.reload();
+		}
+		return;
+	}
+
+	menuEmitter.emit("browser-action", action);
+}
+
 function getMenuAccelerator(id: HotkeyId): string | undefined {
 	const platform = getCurrentPlatform();
 	const overrides = appState.data.hotkeysState.byPlatform[platform];
@@ -38,6 +59,10 @@ export function registerMenuHotkeyUpdates() {
 
 export function createApplicationMenu() {
 	const reloadAccelerator = getMenuAccelerator("RELOAD_WINDOW");
+	const browserReloadAccelerator = getMenuAccelerator("BROWSER_RELOAD");
+	const browserHardReloadAccelerator = getMenuAccelerator(
+		"BROWSER_HARD_RELOAD",
+	);
 	const closeAccelerator = getMenuAccelerator("CLOSE_WINDOW");
 	const showHotkeysAccelerator = getMenuAccelerator("SHOW_HOTKEYS");
 	const openSettingsAccelerator = getMenuAccelerator("OPEN_SETTINGS");
@@ -75,6 +100,25 @@ export function createApplicationMenu() {
 				{ role: "togglefullscreen" },
 			],
 		},
+		{
+			label: "Browser",
+			submenu: [
+				{
+					label: "Reload Browser",
+					accelerator: browserReloadAccelerator,
+					click: () => {
+						triggerBrowserShortcut("reload");
+					},
+				},
+				{
+					label: "Hard Reload Browser",
+					accelerator: browserHardReloadAccelerator,
+					click: () => {
+						triggerBrowserShortcut("hard-reload");
+					},
+				},
+			],
+		},
 		{
 			label: "Window",
 			submenu: [
diff --git a/apps/desktop/src/main/lib/terminal/env.ts b/apps/desktop/src/main/lib/terminal/env.ts
index 883582ba935..4d2c1d46001 100644
--- a/apps/desktop/src/main/lib/terminal/env.ts
+++ b/apps/desktop/src/main/lib/terminal/env.ts
@@ -1,9 +1,12 @@
 import { exec } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
+import { settings } from "@superset/local-db";
 import defaultShell from "default-shell";
+import { DEFAULT_PREVENT_AGENT_SLEEP } from "shared/constants";
 import { env } from "shared/env.shared";
 import { getShellEnv } from "../agent-setup/shell-wrappers";
+import { localDb } from "../local-db";
 
 const MACOS_SYSTEM_CERT_FILE = "/etc/ssl/cert.pem";
 let cachedUtf8Locale: string | null = null;
@@ -460,6 +463,9 @@ export function buildTerminalEnv(params: {
 
 	// COLORFGBG: "foreground;background" ANSI color indices — TUI apps use this to detect light/dark
 	const colorFgBg = themeType === "light" ? "0;15" : "15;0";
+	const preventAgentSleepSetting =
+		localDb.select().from(settings).get()?.preventAgentSleep ??
+		DEFAULT_PREVENT_AGENT_SLEEP;
 
 	const terminalEnv: Record<string, string> = {
 		...baseEnv,
@@ -480,6 +486,7 @@ export function buildTerminalEnv(params: {
 		SUPERSET_ENV: env.NODE_ENV === "development" ? "development" : "production",
 		// Hook protocol version for forward compatibility
 		SUPERSET_HOOK_VERSION: HOOK_PROTOCOL_VERSION,
+		SUPERSET_PREVENT_AGENT_SLEEP: preventAgentSleepSetting ? "1" : "0",
 	};
 
 	delete terminalEnv.GOOGLE_API_KEY;
diff --git a/apps/desktop/src/renderer/components/MarkdownRenderer/MarkdownRenderer.tsx b/apps/desktop/src/renderer/components/MarkdownRenderer/MarkdownRenderer.tsx
index 7ca1d194c71..4d2567d72f0 100644
--- a/apps/desktop/src/renderer/components/MarkdownRenderer/MarkdownRenderer.tsx
+++ b/apps/desktop/src/renderer/components/MarkdownRenderer/MarkdownRenderer.tsx
@@ -18,12 +18,14 @@ interface MarkdownRendererProps {
 	content: string;
 	style?: keyof typeof styleConfigs;
 	className?: string;
+	scrollable?: boolean;
 }
 
 export function MarkdownRenderer({
 	content,
 	style: styleProp,
 	className,
+	scrollable = true,
 }: MarkdownRendererProps) {
 	const globalStyle = useMarkdownStyle();
 	const style = styleProp ?? globalStyle;
@@ -34,7 +36,8 @@ export function MarkdownRenderer({
 		<SelectionContextMenu selectAllContainerRef={articleRef}>
 			<div
 				className={cn(
-					"markdown-renderer h-full overflow-y-auto select-text",
+					"markdown-renderer select-text",
+					scrollable && "h-full overflow-y-auto",
 					config.wrapperClass,
 					className,
 				)}
diff --git a/apps/desktop/src/renderer/lib/browser-shortcut-events.ts b/apps/desktop/src/renderer/lib/browser-shortcut-events.ts
new file mode 100644
index 00000000000..dac403f71cf
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/browser-shortcut-events.ts
@@ -0,0 +1,42 @@
+import type { BrowserShortcutAction } from "shared/browser-shortcuts";
+
+const BROWSER_SHORTCUT_EVENT = "superset:browser-shortcut";
+
+interface BrowserShortcutEventDetail {
+	action: BrowserShortcutAction;
+}
+
+export function dispatchBrowserShortcutEvent(
+	action: BrowserShortcutAction,
+): void {
+	if (typeof window === "undefined") return;
+
+	window.dispatchEvent(
+		new CustomEvent<BrowserShortcutEventDetail>(BROWSER_SHORTCUT_EVENT, {
+			detail: { action },
+		}),
+	);
+}
+
+export function addBrowserShortcutListener(
+	listener: (action: BrowserShortcutAction) => void,
+): () => void {
+	if (
+		typeof window === "undefined" ||
+		typeof window.addEventListener !== "function"
+	) {
+		return () => {};
+	}
+
+	const handleEvent = (event: Event) => {
+		const detail = (event as CustomEvent<BrowserShortcutEventDetail>).detail;
+		if (!detail) return;
+		listener(detail.action);
+	};
+
+	window.addEventListener(BROWSER_SHORTCUT_EVENT, handleEvent);
+
+	return () => {
+		window.removeEventListener(BROWSER_SHORTCUT_EVENT, handleEvent);
+	};
+}
diff --git a/apps/desktop/src/renderer/providers/LanguageServicesProvider/LanguageServicesProvider.tsx b/apps/desktop/src/renderer/providers/LanguageServicesProvider/LanguageServicesProvider.tsx
new file mode 100644
index 00000000000..bbf7c1c6f97
--- /dev/null
+++ b/apps/desktop/src/renderer/providers/LanguageServicesProvider/LanguageServicesProvider.tsx
@@ -0,0 +1,234 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { electronTrpcClient } from "renderer/lib/trpc-client";
+import {
+	getDocumentCurrentContent,
+	hasInitializedDocumentBuffer,
+} from "renderer/stores/editor-state/editorBufferRegistry";
+import { useEditorDocumentsStore } from "renderer/stores/editor-state/useEditorDocumentsStore";
+import {
+	type LanguageServiceProviderId,
+	useLanguageServicePreferencesStore,
+} from "renderer/stores/language-service-preferences";
+
+type TrackedDocument = {
+	documentKey: string;
+	workspaceId: string;
+	absolutePath: string;
+	languageId: string;
+	content: string;
+	version: number;
+};
+
+function resolveLanguageId(absolutePath: string): string | null {
+	const normalizedPath = absolutePath.toLowerCase().replaceAll("\\", "/");
+	const fileName = normalizedPath.split("/").at(-1) ?? normalizedPath;
+	if (normalizedPath.endsWith(".tsx")) {
+		return "typescriptreact";
+	}
+	if (
+		normalizedPath.endsWith(".ts") ||
+		normalizedPath.endsWith(".mts") ||
+		normalizedPath.endsWith(".cts")
+	) {
+		return "typescript";
+	}
+	if (normalizedPath.endsWith(".jsx")) {
+		return "javascriptreact";
+	}
+	if (
+		normalizedPath.endsWith(".js") ||
+		normalizedPath.endsWith(".mjs") ||
+		normalizedPath.endsWith(".cjs")
+	) {
+		return "javascript";
+	}
+	if (
+		normalizedPath.endsWith(".jsonc") ||
+		fileName === "jsconfig.json" ||
+		fileName === "settings.json" ||
+		fileName === "extensions.json" ||
+		fileName === "launch.json" ||
+		fileName === "tasks.json" ||
+		fileName === "keybindings.json" ||
+		/^tsconfig\..+\.json$/.test(fileName) ||
+		fileName === "tsconfig.json"
+	) {
+		return "jsonc";
+	}
+	if (normalizedPath.endsWith(".json")) {
+		return "json";
+	}
+	if (normalizedPath.endsWith(".toml")) {
+		return "toml";
+	}
+	if (normalizedPath.endsWith(".dart")) {
+		return "dart";
+	}
+	return null;
+}
+
+function resolveProviderId(
+	languageId: string,
+): LanguageServiceProviderId | null {
+	switch (languageId) {
+		case "typescript":
+		case "typescriptreact":
+		case "javascript":
+		case "javascriptreact":
+			return "typescript";
+		case "json":
+		case "jsonc":
+			return "json";
+		case "toml":
+			return "toml";
+		case "dart":
+			return "dart";
+		default:
+			return null;
+	}
+}
+
+export function LanguageServicesProvider() {
+	const documentsByKey = useEditorDocumentsStore((state) => state.documents);
+	const enabledProviders = useLanguageServicePreferencesStore(
+		(state) => state.enabledProviders,
+	);
+	const hasHydratedPreferences = useLanguageServicePreferencesStore(
+		(state) => state.hasHydrated,
+	);
+	const previousRef = useRef<Map<string, TrackedDocument>>(new Map());
+	const hasAppliedInitialProviderPreferencesRef = useRef(false);
+	const [isProviderPreferenceSyncReady, setIsProviderPreferenceSyncReady] =
+		useState(false);
+
+	useEffect(() => {
+		if (
+			!hasHydratedPreferences ||
+			hasAppliedInitialProviderPreferencesRef.current
+		) {
+			return;
+		}
+
+		hasAppliedInitialProviderPreferencesRef.current = true;
+		void Promise.allSettled(
+			Object.entries(enabledProviders).map(([providerId, enabled]) =>
+				electronTrpcClient.languageServices.setProviderEnabled.mutate({
+					providerId,
+					enabled,
+				}),
+			),
+		).finally(() => {
+			setIsProviderPreferenceSyncReady(true);
+		});
+	}, [enabledProviders, hasHydratedPreferences]);
+
+	const trackedDocuments = useMemo(() => {
+		const next = new Map<string, TrackedDocument>();
+		if (!hasHydratedPreferences || !isProviderPreferenceSyncReady) {
+			return next;
+		}
+
+		for (const document of Object.values(documentsByKey)) {
+			if (
+				document.sessionPaneIds.length === 0 ||
+				document.status === "loading" ||
+				!hasInitializedDocumentBuffer(document.documentKey)
+			) {
+				continue;
+			}
+
+			const languageId = resolveLanguageId(document.filePath);
+			if (!languageId) {
+				continue;
+			}
+
+			const providerId = resolveProviderId(languageId);
+			if (providerId && !enabledProviders[providerId]) {
+				continue;
+			}
+
+			next.set(document.documentKey, {
+				documentKey: document.documentKey,
+				workspaceId: document.workspaceId,
+				absolutePath: document.filePath,
+				languageId,
+				content: getDocumentCurrentContent(document.documentKey),
+				version: document.contentVersion,
+			});
+		}
+
+		for (const [documentKey, tracked] of next.entries()) {
+			if (tracked.version === 0 && tracked.content.length === 0) {
+				next.delete(documentKey);
+			}
+		}
+
+		return next;
+	}, [
+		documentsByKey,
+		enabledProviders,
+		hasHydratedPreferences,
+		isProviderPreferenceSyncReady,
+	]);
+
+	useEffect(() => {
+		const previous = previousRef.current;
+
+		for (const [documentKey, tracked] of trackedDocuments.entries()) {
+			const prev = previous.get(documentKey);
+			if (!prev) {
+				void electronTrpcClient.languageServices.openDocument.mutate({
+					workspaceId: tracked.workspaceId,
+					absolutePath: tracked.absolutePath,
+					languageId: tracked.languageId,
+					content: tracked.content,
+					version: tracked.version,
+				});
+				continue;
+			}
+
+			if (
+				prev.version !== tracked.version ||
+				prev.absolutePath !== tracked.absolutePath ||
+				prev.languageId !== tracked.languageId ||
+				prev.workspaceId !== tracked.workspaceId
+			) {
+				void electronTrpcClient.languageServices.changeDocument.mutate({
+					workspaceId: tracked.workspaceId,
+					absolutePath: tracked.absolutePath,
+					languageId: tracked.languageId,
+					content: tracked.content,
+					version: tracked.version,
+				});
+			}
+		}
+
+		for (const [documentKey, tracked] of previous.entries()) {
+			if (trackedDocuments.has(documentKey)) {
+				continue;
+			}
+
+			void electronTrpcClient.languageServices.closeDocument.mutate({
+				workspaceId: tracked.workspaceId,
+				absolutePath: tracked.absolutePath,
+				languageId: tracked.languageId,
+			});
+		}
+
+		previousRef.current = trackedDocuments;
+	}, [trackedDocuments]);
+
+	useEffect(() => {
+		return () => {
+			for (const tracked of previousRef.current.values()) {
+				void electronTrpcClient.languageServices.closeDocument.mutate({
+					workspaceId: tracked.workspaceId,
+					absolutePath: tracked.absolutePath,
+					languageId: tracked.languageId,
+				});
+			}
+		};
+	}, []);
+
+	return null;
+}
diff --git a/apps/desktop/src/renderer/providers/LanguageServicesProvider/index.ts b/apps/desktop/src/renderer/providers/LanguageServicesProvider/index.ts
new file mode 100644
index 00000000000..94c7bd1ef0a
--- /dev/null
+++ b/apps/desktop/src/renderer/providers/LanguageServicesProvider/index.ts
@@ -0,0 +1 @@
+export { LanguageServicesProvider } from "./LanguageServicesProvider";
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/TopBar/components/ResourceConsumption/ResourceConsumption.tsx b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/TopBar/components/ResourceConsumption/ResourceConsumption.tsx
index 46b7d39e635..0a834419eef 100644
--- a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/TopBar/components/ResourceConsumption/ResourceConsumption.tsx
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/TopBar/components/ResourceConsumption/ResourceConsumption.tsx
@@ -179,9 +179,11 @@ export function ResourceConsumption() {
 						>
 							<HiOutlineCpuChip className="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
 							{normalizedSnapshot && (
-								<span className="text-xs font-medium tabular-nums text-muted-foreground hidden md:inline">
-									{formatMemory(normalizedSnapshot.totalMemory)}
-								</span>
+								<div className="hidden md:flex items-center gap-1.5 text-xs font-medium tabular-nums text-muted-foreground">
+									<span>{formatCpu(normalizedSnapshot.totalCpu)}</span>
+									<span className="text-muted-foreground/60">/</span>
+									<span>{formatMemory(normalizedSnapshot.totalMemory)}</span>
+								</div>
 							)}
 						</button>
 					</PopoverTrigger>
@@ -193,7 +195,10 @@ export function ResourceConsumption() {
 						showArrow={false}
 						className="md:hidden"
 					>
-						{formatMemory(normalizedSnapshot.totalMemory)}
+						<div className="flex flex-col gap-0.5 text-xs">
+							<span>CPU {formatCpu(normalizedSnapshot.totalCpu)}</span>
+							<span>Memory {formatMemory(normalizedSnapshot.totalMemory)}</span>
+						</div>
 					</TooltipContent>
 				)}
 			</Tooltip>
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/v2-workspace/$workspaceId/components/PaneViewer/PaneViewer.tsx b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/v2-workspace/$workspaceId/components/PaneViewer/PaneViewer.tsx
index ba1d4d82cca..caf19bfb4cb 100644
--- a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/v2-workspace/$workspaceId/components/PaneViewer/PaneViewer.tsx
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/v2-workspace/$workspaceId/components/PaneViewer/PaneViewer.tsx
@@ -10,10 +10,11 @@ import {
 } from "@superset/ui/dropdown-menu";
 import { useNavigate } from "@tanstack/react-router";
 import { FileCode2, Globe, MessageSquare, TerminalSquare } from "lucide-react";
-import { useCallback, useMemo } from "react";
+import { useCallback, useEffect, useMemo } from "react";
 import { BsTerminalPlus } from "react-icons/bs";
 import { TbMessageCirclePlus, TbWorld } from "react-icons/tb";
 import { HotkeyMenuShortcut } from "renderer/components/HotkeyMenuShortcut";
+import { addBrowserShortcutListener } from "renderer/lib/browser-shortcut-events";
 import { electronTrpc } from "renderer/lib/electron-trpc";
 import { WorkspaceChat } from "renderer/routes/_authenticated/_dashboard/v2-workspace/$workspaceId/components/WorkspaceChat";
 import { WorkspaceFilePreview } from "renderer/routes/_authenticated/_dashboard/v2-workspace/$workspaceId/components/WorkspaceFiles/components/WorkspaceFilePreview/WorkspaceFilePreview";
@@ -211,6 +212,7 @@ export function PaneViewer({
 					return (
 						<iframe
 							className="h-full w-full border-0 bg-background"
+							key={`${pane.id}:${data.reloadToken ?? "0"}`}
 							src={data.url}
 							title={pane.titleOverride ?? "Browser"}
 						/>
@@ -255,6 +257,26 @@ export function PaneViewer({
 	useAppHotkey("NEW_BROWSER", addBrowserRoot, undefined, [addBrowserRoot]);
 	useAppHotkey("QUICK_OPEN", handleQuickOpen, undefined, [handleQuickOpen]);
 
+	useEffect(() => {
+		return addBrowserShortcutListener(() => {
+			const activePane = store.getState().getActivePane();
+			if (!activePane || activePane.pane.kind !== "browser") {
+				return;
+			}
+
+			const data = activePane.pane.data as BrowserPaneData;
+
+			// v2 browser is iframe-based, so remounting is the safest reload path.
+			store.getState().setPaneData({
+				paneId: activePane.pane.id,
+				data: {
+					...data,
+					reloadToken: crypto.randomUUID(),
+				},
+			});
+		});
+	}, [store]);
+
 	return (
 		<>
 			<div
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/v2-workspace/$workspaceId/components/PaneViewer/pane-viewer.model.ts b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/v2-workspace/$workspaceId/components/PaneViewer/pane-viewer.model.ts
index b5584f900b2..d49fbcd8b63 100644
--- a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/v2-workspace/$workspaceId/components/PaneViewer/pane-viewer.model.ts
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/v2-workspace/$workspaceId/components/PaneViewer/pane-viewer.model.ts
@@ -21,6 +21,7 @@ export interface ChatPaneData {
 export interface BrowserPaneData {
 	url: string;
 	mode: "docs" | "preview" | "generic";
+	reloadToken?: string;
 }
 
 export interface DevtoolsPaneData {
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/workspace/$workspaceId/page.tsx b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/workspace/$workspaceId/page.tsx
index 1717f08819e..e000c2844cf 100644
--- a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/workspace/$workspaceId/page.tsx
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/workspace/$workspaceId/page.tsx
@@ -9,6 +9,7 @@ import {
 import { useCallback, useEffect, useMemo } from "react";
 import { useCopyToClipboard } from "renderer/hooks/useCopyToClipboard";
 import { useFileOpenMode } from "renderer/hooks/useFileOpenMode";
+import { addBrowserShortcutListener } from "renderer/lib/browser-shortcut-events";
 import { electronTrpc } from "renderer/lib/electron-trpc";
 import { getWorkspaceDisplayName } from "renderer/lib/getWorkspaceDisplayName";
 import { electronTrpcClient as trpcClient } from "renderer/lib/trpc-client";
@@ -38,12 +39,17 @@ import {
 } from "renderer/stores/editor-state/editorCoordinator";
 import { useEditorSessionsStore } from "renderer/stores/editor-state/useEditorSessionsStore";
 import { useAppHotkey } from "renderer/stores/hotkeys";
-import { SidebarMode, useSidebarStore } from "renderer/stores/sidebar-state";
+import {
+	RightSidebarTab,
+	SidebarMode,
+	useSidebarStore,
+} from "renderer/stores/sidebar-state";
 import { getPaneDimensions } from "renderer/stores/tabs/pane-refs";
 import { useTabsStore } from "renderer/stores/tabs/store";
 import type { Tab } from "renderer/stores/tabs/types";
 import { useTabsWithPresets } from "renderer/stores/tabs/useTabsWithPresets";
 import {
+	extractPaneIdsFromLayout,
 	findPanePath,
 	getFirstPaneId,
 	getNextPaneId,
@@ -187,6 +193,7 @@ export function WorkspacePage({
 	const setSidebarOpen = useSidebarStore((s) => s.setSidebarOpen);
 	const currentSidebarMode = useSidebarStore((s) => s.currentMode);
 	const setSidebarMode = useSidebarStore((s) => s.setMode);
+	const setRightSidebarTab = useSidebarStore((s) => s.setRightSidebarTab);
 
 	const tabs = useMemo(
 		() => allTabs.filter((tab) => tab.workspaceId === workspaceId),
@@ -469,6 +476,77 @@ export function WorkspacePage({
 	}, [commandPalette.toggle]);
 	useAppHotkey("QUICK_OPEN", handleQuickOpen, undefined, [handleQuickOpen]);
 
+	const handleBrowserShortcut = useCallback(
+		(action: "reload" | "hard-reload") => {
+			if (!isActive) return;
+
+			const state = useTabsStore.getState();
+			const workspaceTabs = state.tabs.filter(
+				(tab) => tab.workspaceId === workspaceId,
+			);
+			const resolvedActiveTabId = resolveActiveTabIdForWorkspace({
+				workspaceId,
+				tabs: workspaceTabs,
+				activeTabIds: state.activeTabIds,
+				tabHistoryStacks: state.tabHistoryStacks,
+			});
+
+			if (!resolvedActiveTabId) return;
+
+			const activeWorkspaceTab = workspaceTabs.find(
+				(tab) => tab.id === resolvedActiveTabId,
+			);
+			if (!activeWorkspaceTab) return;
+
+			const focusedWorkspacePaneId = state.focusedPaneIds[resolvedActiveTabId];
+			const focusedPane = focusedWorkspacePaneId
+				? state.panes[focusedWorkspacePaneId]
+				: null;
+
+			if (
+				focusedPane?.tabId === resolvedActiveTabId &&
+				focusedPane.type === "webview" &&
+				focusedPane.browser
+			) {
+				void trpcClient.browser.reload.mutate({
+					paneId: focusedPane.id,
+					hard: action === "hard-reload",
+				});
+				return;
+			}
+
+			const browserPanes = extractPaneIdsFromLayout(activeWorkspaceTab.layout)
+				.map((paneId) => state.panes[paneId])
+				.filter(
+					(pane): pane is NonNullable<typeof pane> =>
+						Boolean(pane) && pane.type === "webview" && Boolean(pane.browser),
+				);
+
+			if (browserPanes.length !== 1) return;
+
+			void trpcClient.browser.reload.mutate({
+				paneId: browserPanes[0].id,
+				hard: action === "hard-reload",
+			});
+		},
+		[isActive, workspaceId],
+	);
+
+	useEffect(() => {
+		return addBrowserShortcutListener(handleBrowserShortcut);
+	}, [handleBrowserShortcut]);
+
+	const handleSearchInFiles = useCallback(() => {
+		if (!isSidebarOpen) {
+			setSidebarOpen(true);
+		}
+		setSidebarMode(SidebarMode.Tabs);
+		setRightSidebarTab(RightSidebarTab.Search);
+	}, [isSidebarOpen, setRightSidebarTab, setSidebarMode, setSidebarOpen]);
+	useAppHotkey("SEARCH_IN_FILES", handleSearchInFiles, undefined, [
+		handleSearchInFiles,
+	]);
+
 	// Toggle changes sidebar (⌘L)
 	useAppHotkey("TOGGLE_SIDEBAR", () => toggleSidebar(), hotkeyOptions, [
 		toggleSidebar,
diff --git a/apps/desktop/src/renderer/routes/_authenticated/layout.tsx b/apps/desktop/src/renderer/routes/_authenticated/layout.tsx
index 8083d6b0dec..f2832cccfeb 100644
--- a/apps/desktop/src/renderer/routes/_authenticated/layout.tsx
+++ b/apps/desktop/src/renderer/routes/_authenticated/layout.tsx
@@ -18,9 +18,11 @@ import { useUpdateListener } from "renderer/components/UpdateToast";
 import { env } from "renderer/env.renderer";
 import { useOnlineStatus } from "renderer/hooks/useOnlineStatus";
 import { authClient, getAuthToken } from "renderer/lib/auth-client";
+import { dispatchBrowserShortcutEvent } from "renderer/lib/browser-shortcut-events";
 import { dragDropManager } from "renderer/lib/dnd";
 import { electronTrpc } from "renderer/lib/electron-trpc";
 import { showWorkspaceAutoNameWarningToast } from "renderer/lib/workspaces/showWorkspaceAutoNameWarningToast";
+import { LanguageServicesProvider } from "renderer/providers/LanguageServicesProvider";
 import { InitGitDialog } from "renderer/react-query/projects/InitGitDialog";
 import { DashboardNewWorkspaceModal } from "renderer/routes/_authenticated/components/DashboardNewWorkspaceModal";
 import { WorkspaceInitEffects } from "renderer/screens/main/components/WorkspaceInitEffects";
@@ -128,6 +130,8 @@ function AuthenticatedLayout() {
 				navigate({ to: `/settings/${section}` as "/settings/account" });
 			} else if (event.type === "open-workspace") {
 				navigate({ to: `/workspace/${event.data.workspaceId}` });
+			} else if (event.type === "browser-action") {
+				dispatchBrowserShortcutEvent(event.data.action);
 			}
 		},
 	});
@@ -175,6 +179,7 @@ function AuthenticatedLayout() {
 		<DndProvider manager={dragDropManager}>
 			<CollectionsProvider>
 				<HostServiceProvider>
+					<LanguageServicesProvider />
 					<AgentHooks />
 					<Outlet />
 					<WorkspaceInitEffects />
diff --git a/apps/desktop/src/renderer/routes/_authenticated/settings/behavior/components/BehaviorSettings/BehaviorSettings.tsx b/apps/desktop/src/renderer/routes/_authenticated/settings/behavior/components/BehaviorSettings/BehaviorSettings.tsx
index 7068eb9b069..4af8053357f 100644
--- a/apps/desktop/src/renderer/routes/_authenticated/settings/behavior/components/BehaviorSettings/BehaviorSettings.tsx
+++ b/apps/desktop/src/renderer/routes/_authenticated/settings/behavior/components/BehaviorSettings/BehaviorSettings.tsx
@@ -14,6 +14,7 @@ import {
 	SETTING_ITEM_ID,
 	type SettingItemId,
 } from "../../../utils/settings-search";
+import { DiagnosticsSettings } from "../DiagnosticsSettings";
 
 interface BehaviorSettingsProps {
 	visibleItems?: SettingItemId[] | null;
@@ -28,6 +29,10 @@ export function BehaviorSettings({ visibleItems }: BehaviorSettingsProps) {
 		SETTING_ITEM_ID.BEHAVIOR_TELEMETRY,
 		visibleItems,
 	);
+	const showPreventAgentSleep = isItemVisible(
+		SETTING_ITEM_ID.BEHAVIOR_PREVENT_AGENT_SLEEP,
+		visibleItems,
+	);
 	const showFileOpenMode = isItemVisible(
 		SETTING_ITEM_ID.BEHAVIOR_FILE_OPEN_MODE,
 		visibleItems,
@@ -40,6 +45,10 @@ export function BehaviorSettings({ visibleItems }: BehaviorSettingsProps) {
 		SETTING_ITEM_ID.BEHAVIOR_OPEN_LINKS_IN_APP,
 		visibleItems,
 	);
+	const showLanguageDiagnostics = isItemVisible(
+		SETTING_ITEM_ID.BEHAVIOR_LANGUAGE_DIAGNOSTICS,
+		visibleItems,
+	);
 
 	const utils = electronTrpc.useUtils();
 
@@ -66,6 +75,29 @@ export function BehaviorSettings({ visibleItems }: BehaviorSettingsProps) {
 		setConfirmOnQuit.mutate({ enabled });
 	};
 
+	const { data: preventAgentSleep, isLoading: isPreventAgentSleepLoading } =
+		electronTrpc.settings.getPreventAgentSleep.useQuery();
+	const setPreventAgentSleep =
+		electronTrpc.settings.setPreventAgentSleep.useMutation({
+			onMutate: async ({ enabled }) => {
+				await utils.settings.getPreventAgentSleep.cancel();
+				const previous = utils.settings.getPreventAgentSleep.getData();
+				utils.settings.getPreventAgentSleep.setData(undefined, enabled);
+				return { previous };
+			},
+			onError: (_err, _vars, context) => {
+				if (context?.previous !== undefined) {
+					utils.settings.getPreventAgentSleep.setData(
+						undefined,
+						context.previous,
+					);
+				}
+			},
+			onSettled: () => {
+				utils.settings.getPreventAgentSleep.invalidate();
+			},
+		});
+
 	// TODO: remove telemetry query/mutation/handler once telemetry procedures are removed
 	const { data: telemetryEnabled, isLoading: isTelemetryLoading } =
 		electronTrpc.settings.getTelemetryEnabled.useQuery();
@@ -188,6 +220,33 @@ export function BehaviorSettings({ visibleItems }: BehaviorSettingsProps) {
 					</div>
 				)}
 
+				{showPreventAgentSleep && (
+					<div className="flex items-center justify-between">
+						<div className="space-y-0.5">
+							<Label
+								htmlFor="prevent-agent-sleep"
+								className="text-sm font-medium"
+							>
+								Prevent Mac sleep during agent tasks
+							</Label>
+							<p className="text-xs text-muted-foreground">
+								Keep macOS awake while Claude, Codex, and other agents are
+								running in Superset terminals
+							</p>
+						</div>
+						<Switch
+							id="prevent-agent-sleep"
+							checked={preventAgentSleep ?? false}
+							onCheckedChange={(enabled) =>
+								setPreventAgentSleep.mutate({ enabled })
+							}
+							disabled={
+								isPreventAgentSleepLoading || setPreventAgentSleep.isPending
+							}
+						/>
+					</div>
+				)}
+
 				{showFileOpenMode && (
 					<div className="flex items-center justify-between">
 						<div className="space-y-0.5">
@@ -262,6 +321,8 @@ export function BehaviorSettings({ visibleItems }: BehaviorSettingsProps) {
 					</div>
 				)}
 
+				<DiagnosticsSettings visible={showLanguageDiagnostics} />
+
 				{false && showTelemetry && (
 					<div className="flex items-center justify-between">
 						<div className="space-y-0.5">
diff --git a/apps/desktop/src/renderer/routes/_authenticated/settings/behavior/components/DiagnosticsSettings/DiagnosticsSettings.tsx b/apps/desktop/src/renderer/routes/_authenticated/settings/behavior/components/DiagnosticsSettings/DiagnosticsSettings.tsx
new file mode 100644
index 00000000000..72a3216fd2b
--- /dev/null
+++ b/apps/desktop/src/renderer/routes/_authenticated/settings/behavior/components/DiagnosticsSettings/DiagnosticsSettings.tsx
@@ -0,0 +1,116 @@
+import { Label } from "@superset/ui/label";
+import { toast } from "@superset/ui/sonner";
+import { Switch } from "@superset/ui/switch";
+import { electronTrpc } from "renderer/lib/electron-trpc";
+import {
+	type LanguageServiceProviderId,
+	useLanguageServicePreferencesStore,
+} from "renderer/stores/language-service-preferences";
+
+interface DiagnosticsSettingsProps {
+	visible: boolean;
+}
+
+function isKnownProviderId(
+	providerId: string,
+): providerId is LanguageServiceProviderId {
+	return ["typescript", "json", "toml", "dart"].includes(providerId);
+}
+
+export function DiagnosticsSettings({ visible }: DiagnosticsSettingsProps) {
+	const utils = electronTrpc.useUtils();
+	const enabledProviders = useLanguageServicePreferencesStore(
+		(state) => state.enabledProviders,
+	);
+	const setProviderEnabledPreference = useLanguageServicePreferencesStore(
+		(state) => state.setProviderEnabled,
+	);
+	const { data: providers = [], isLoading } =
+		electronTrpc.languageServices.getProviders.useQuery();
+
+	const setProviderEnabled =
+		electronTrpc.languageServices.setProviderEnabled.useMutation({
+			onSuccess: async () => {
+				await utils.languageServices.getProviders.invalidate();
+			},
+		});
+
+	if (!visible) {
+		return null;
+	}
+
+	return (
+		<div className="space-y-4">
+			<div className="space-y-0.5">
+				<Label className="text-sm font-medium">Language diagnostics</Label>
+				<p className="text-xs text-muted-foreground">
+					Problems とエディタ下線に使う言語サービスを切り替えます。TSX と JSX は
+					TypeScript provider に含まれます。
+				</p>
+			</div>
+
+			<div className="space-y-3">
+				{providers.map((provider) => {
+					const providerId = provider.providerId;
+					const isKnownProvider = isKnownProviderId(providerId);
+					const checked = isKnownProvider
+						? enabledProviders[providerId]
+						: provider.enabled;
+					const isSwitchDisabled =
+						isLoading || setProviderEnabled.isPending || !isKnownProvider;
+
+					return (
+						<div
+							key={provider.providerId}
+							className="flex items-center justify-between gap-4"
+						>
+							<div className="space-y-0.5">
+								<Label
+									htmlFor={`language-service-${provider.providerId}`}
+									className="text-sm font-medium"
+								>
+									{provider.label}
+								</Label>
+								<p className="text-xs text-muted-foreground">
+									{provider.description}
+								</p>
+								{!isKnownProvider ? (
+									<p className="text-xs text-muted-foreground">
+										この provider は現在の設定 UI からは変更できません。
+									</p>
+								) : null}
+							</div>
+							<Switch
+								id={`language-service-${provider.providerId}`}
+								checked={checked}
+								disabled={isSwitchDisabled}
+								onCheckedChange={async (nextChecked) => {
+									if (!isKnownProvider) {
+										return;
+									}
+
+									const previous = enabledProviders[providerId];
+									try {
+										await setProviderEnabled.mutateAsync({
+											providerId,
+											enabled: nextChecked,
+										});
+										setProviderEnabledPreference(providerId, nextChecked);
+										await utils.languageServices.getWorkspaceDiagnostics.invalidate();
+									} catch (error) {
+										setProviderEnabledPreference(providerId, previous);
+										toast.error(
+											error instanceof Error
+												? error.message
+												: "Failed to update language diagnostics setting",
+										);
+									}
+								}}
+							/>
+						</div>
+					);
+				})}
+			</div>
+		</div>
+	);
+}
diff --git a/apps/desktop/src/renderer/routes/_authenticated/settings/behavior/components/DiagnosticsSettings/index.ts b/apps/desktop/src/renderer/routes/_authenticated/settings/behavior/components/DiagnosticsSettings/index.ts
new file mode 100644
index 00000000000..9a230201394
--- /dev/null
+++ b/apps/desktop/src/renderer/routes/_authenticated/settings/behavior/components/DiagnosticsSettings/index.ts
@@ -0,0 +1 @@
+export { DiagnosticsSettings } from "./DiagnosticsSettings";
diff --git a/apps/desktop/src/renderer/routes/_authenticated/settings/keyboard/page.tsx b/apps/desktop/src/renderer/routes/_authenticated/settings/keyboard/page.tsx
index aa00a30efd9..95ca3bf1a1c 100644
--- a/apps/desktop/src/renderer/routes/_authenticated/settings/keyboard/page.tsx
+++ b/apps/desktop/src/renderer/routes/_authenticated/settings/keyboard/page.tsx
@@ -32,6 +32,7 @@ import {
 } from "shared/hotkeys";
 
 const CATEGORY_ORDER: HotkeyCategory[] = [
+	"Browser",
 	"Workspace",
 	"Terminal",
 	"Layout",
diff --git a/apps/desktop/src/renderer/routes/_authenticated/settings/utils/settings-search/settings-search.ts b/apps/desktop/src/renderer/routes/_authenticated/settings/utils/settings-search/settings-search.ts
index 397e42d812c..9912ecdef3d 100644
--- a/apps/desktop/src/renderer/routes/_authenticated/settings/utils/settings-search/settings-search.ts
+++ b/apps/desktop/src/renderer/routes/_authenticated/settings/utils/settings-search/settings-search.ts
@@ -23,9 +23,11 @@ export const SETTING_ITEM_ID = {
 	KEYBOARD_SHORTCUTS: "keyboard-shortcuts",
 	BEHAVIOR_CONFIRM_QUIT: "behavior-confirm-quit",
 	BEHAVIOR_TELEMETRY: "behavior-telemetry",
+	BEHAVIOR_PREVENT_AGENT_SLEEP: "behavior-prevent-agent-sleep",
 	BEHAVIOR_FILE_OPEN_MODE: "behavior-file-open-mode",
 	BEHAVIOR_RESOURCE_MONITOR: "behavior-resource-monitor",
 	BEHAVIOR_OPEN_LINKS_IN_APP: "behavior-open-links-in-app",
+	BEHAVIOR_LANGUAGE_DIAGNOSTICS: "behavior-language-diagnostics",
 
 	GIT_BRANCH_PREFIX: "git-branch-prefix",
 	GIT_DELETE_LOCAL_BRANCH: "git-delete-local-branch",
@@ -417,6 +419,25 @@ export const SETTINGS_ITEMS: SettingsItem[] = [
 			"disable",
 		],
 	},
+	{
+		id: SETTING_ITEM_ID.BEHAVIOR_PREVENT_AGENT_SLEEP,
+		section: "behavior",
+		title: "Prevent Mac sleep during agent tasks",
+		description:
+			"Keep macOS awake while agents are running in Superset terminals",
+		keywords: [
+			"sleep",
+			"mac",
+			"macos",
+			"awake",
+			"caffeinate",
+			"agent",
+			"claude",
+			"codex",
+			"terminal",
+			"power",
+		],
+	},
 	{
 		id: SETTING_ITEM_ID.BEHAVIOR_FILE_OPEN_MODE,
 		section: "behavior",
@@ -489,6 +510,28 @@ export const SETTINGS_ITEMS: SettingsItem[] = [
 			"url",
 		],
 	},
+	{
+		id: SETTING_ITEM_ID.BEHAVIOR_LANGUAGE_DIAGNOSTICS,
+		section: "behavior",
+		title: "Language diagnostics",
+		description:
+			"Choose which language services report errors and warnings in Problems",
+		keywords: [
+			"diagnostics",
+			"problems",
+			"errors",
+			"warnings",
+			"typescript",
+			"tsx",
+			"json",
+			"toml",
+			"dart",
+			"flutter",
+			"language server",
+			"lint",
+			"validation",
+		],
+	},
 	{
 		id: SETTING_ITEM_ID.AGENTS_ENABLED,
 		section: "agents",
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/BrowserPane.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/BrowserPane.tsx
index 27854da53ca..e3b2bc8c32e 100644
--- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/BrowserPane.tsx
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/BrowserPane.tsx
@@ -5,8 +5,14 @@ import { LuMinus, LuPlus } from "react-icons/lu";
 import { TbDeviceDesktop } from "react-icons/tb";
 import type { MosaicBranch } from "react-mosaic-component";
 import { electronTrpc } from "renderer/lib/electron-trpc";
+import {
+	normalizeBookmarkUrl,
+	useBrowserBookmarksStore,
+} from "renderer/stores/browser-bookmarks";
 import { useTabsStore } from "renderer/stores/tabs/store";
+import type { SplitPaneOptions } from "renderer/stores/tabs/types";
 import { BasePaneWindow, PaneToolbarActions } from "../components";
+import { BookmarkBar } from "./components/BookmarkBar";
 import { BrowserErrorOverlay } from "./components/BrowserErrorOverlay";
 import { BrowserToolbar } from "./components/BrowserToolbar";
 import { BrowserOverflowMenu } from "./components/BrowserToolbar/components/BrowserOverflowMenu";
@@ -23,6 +29,7 @@ interface BrowserPaneProps {
 		sourcePaneId: string,
 		dimensions: { width: number; height: number },
 		path?: MosaicBranch[],
+		options?: SplitPaneOptions,
 	) => void;
 	removePane: (paneId: string) => void;
 	setFocusedPane: (tabId: string, paneId: string) => void;
@@ -43,9 +50,20 @@ export function BrowserPane({
 	const currentUrl = browserState?.currentUrl ?? DEFAULT_BROWSER_URL;
 	const pageTitle =
 		browserState?.history[browserState.historyIndex]?.title ?? "";
+	const currentFaviconUrl =
+		browserState?.history[browserState.historyIndex]?.faviconUrl;
 	const isLoading = browserState?.isLoading ?? false;
 	const loadError = browserState?.error ?? null;
 	const isBlankPage = currentUrl === "about:blank";
+	const currentBookmark = useBrowserBookmarksStore((state) =>
+		state.bookmarks.find(
+			(bookmark) =>
+				normalizeBookmarkUrl(bookmark.url) === normalizeBookmarkUrl(currentUrl),
+		),
+	);
+	const toggleBookmark = useBrowserBookmarksStore(
+		(state) => state.toggleBookmark,
+	);
 	const { mutate: openDevTools } =
 		electronTrpc.browser.openDevTools.useMutation();
 	const { mutate: setZoomLevel } =
@@ -61,7 +79,10 @@ export function BrowserPane({
 		canGoForward,
 	} = usePersistentWebview({
 		paneId,
+		tabId,
+		path,
 		initialUrl: currentUrl,
+		splitPaneAuto,
 	});
 
 	// -- Zoom (synced with Electron's built-in Cmd+/- zoom) -----------------
@@ -97,6 +118,14 @@ export function BrowserPane({
 	}, [openDevTools, paneId]);
 
 	const [isEditingUrl, setIsEditingUrl] = useState(false);
+	const handleToggleBookmark = useCallback(() => {
+		if (isBlankPage) return;
+		toggleBookmark({
+			url: currentUrl,
+			title: pageTitle || currentUrl,
+			faviconUrl: currentFaviconUrl,
+		});
+	}, [currentFaviconUrl, currentUrl, isBlankPage, pageTitle, toggleBookmark]);
 
 	return (
 		<BasePaneWindow
@@ -114,12 +143,15 @@ export function BrowserPane({
 						currentUrl={currentUrl}
 						pageTitle={pageTitle}
 						isLoading={isLoading}
+						hasPage={!isBlankPage}
+						isBookmarked={Boolean(currentBookmark)}
 						canGoBack={canGoBack}
 						canGoForward={canGoForward}
 						onGoBack={goBack}
 						onGoForward={goForward}
 						onReload={reload}
 						onNavigate={navigateTo}
+						onToggleBookmark={handleToggleBookmark}
 						onEditingChange={setIsEditingUrl}
 					/>
 					<div className="flex items-center shrink-0">
@@ -201,26 +233,33 @@ export function BrowserPane({
 				</div>
 			)}
 		>
-			<div className="relative flex flex-1 h-full">
-				<div ref={containerRef} className="w-full h-full" style={{ flex: 1 }} />
-				{loadError && !isLoading && (
-					<BrowserErrorOverlay error={loadError} onRetry={reload} />
-				)}
-				{isBlankPage && !isLoading && !loadError && (
-					<div className="absolute inset-0 flex flex-col items-center justify-center gap-3 bg-background pointer-events-none">
-						<GlobeIcon className="size-10 text-muted-foreground/30" />
-						<div className="text-center">
-							<p className="text-sm font-medium text-muted-foreground/50">
-								Browser
-							</p>
-							<p className="mt-1 text-xs text-muted-foreground/30">
-								Enter a URL above, or instruct an agent to navigate
-								<br />
-								and use the browser
-							</p>
+			<div className="flex h-full flex-1 flex-col">
+				<BookmarkBar currentUrl={currentUrl} onNavigate={navigateTo} />
+				<div className="relative flex flex-1 min-h-0">
+					<div
+						ref={containerRef}
+						className="h-full w-full"
+						style={{ flex: 1 }}
+					/>
+					{loadError && !isLoading && (
+						<BrowserErrorOverlay error={loadError} onRetry={reload} />
+					)}
+					{isBlankPage && !isLoading && !loadError && (
+						<div className="absolute inset-0 flex flex-col items-center justify-center gap-3 bg-background pointer-events-none">
+							<GlobeIcon className="size-10 text-muted-foreground/30" />
+							<div className="text-center">
+								<p className="text-sm font-medium text-muted-foreground/50">
+									Browser
+								</p>
+								<p className="mt-1 text-xs text-muted-foreground/30">
+									Enter a URL above, or instruct an agent to navigate
+									<br />
+									and use the browser
+								</p>
+							</div>
 						</div>
-					</div>
-				)}
+					)}
+				</div>
 			</div>
 		</BasePaneWindow>
 	);
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BookmarkBar/BookmarkBar.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BookmarkBar/BookmarkBar.tsx
new file mode 100644
index 00000000000..b6b6925b96e
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BookmarkBar/BookmarkBar.tsx
@@ -0,0 +1,82 @@
+import {
+	DndContext,
+	type DragEndEvent,
+	MouseSensor,
+	useSensor,
+	useSensors,
+} from "@dnd-kit/core";
+import {
+	horizontalListSortingStrategy,
+	SortableContext,
+} from "@dnd-kit/sortable";
+import { cn } from "@superset/ui/utils";
+import { useMemo } from "react";
+import {
+	normalizeBookmarkUrl,
+	useBrowserBookmarksStore,
+} from "renderer/stores/browser-bookmarks";
+import { BookmarkBarItem } from "./components/BookmarkBarItem";
+
+interface BookmarkBarProps {
+	currentUrl: string;
+	onNavigate: (url: string) => void;
+}
+
+export function BookmarkBar({ currentUrl, onNavigate }: BookmarkBarProps) {
+	const bookmarks = useBrowserBookmarksStore((state) => state.bookmarks);
+	const moveBookmark = useBrowserBookmarksStore((state) => state.moveBookmark);
+	const removeBookmark = useBrowserBookmarksStore(
+		(state) => state.removeBookmark,
+	);
+
+	const normalizedCurrentUrl = useMemo(
+		() => normalizeBookmarkUrl(currentUrl),
+		[currentUrl],
+	);
+
+	const sensors = useSensors(
+		useSensor(MouseSensor, {
+			activationConstraint: { distance: 8 },
+		}),
+	);
+
+	const handleDragEnd = ({ active, over }: DragEndEvent) => {
+		if (!over) return;
+		moveBookmark(String(active.id), String(over.id));
+	};
+
+	return (
+		<div className="flex h-9 shrink-0 items-center border-b border-border/70 bg-background/95 px-2">
+			{bookmarks.length > 0 ? (
+				<DndContext sensors={sensors} onDragEnd={handleDragEnd}>
+					<SortableContext
+						items={bookmarks.map((bookmark) => bookmark.id)}
+						strategy={horizontalListSortingStrategy}
+					>
+						<div className="flex min-w-0 flex-1 items-center gap-1 overflow-x-auto pb-0.5">
+							{bookmarks.map((bookmark) => (
+								<BookmarkBarItem
+									key={bookmark.id}
+									bookmark={bookmark}
+									isActive={
+										normalizeBookmarkUrl(bookmark.url) === normalizedCurrentUrl
+									}
+									onNavigate={onNavigate}
+									onRemove={removeBookmark}
+								/>
+							))}
+						</div>
+					</SortableContext>
+				</DndContext>
+			) : (
+				<div
+					className={cn(
+						"min-w-0 truncate px-2 text-[11px] text-muted-foreground/55",
+					)}
+				>
+					Click the star in the address bar to add bookmarks.
+				</div>
+			)}
+		</div>
+	);
+}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BookmarkBar/components/BookmarkBarItem/BookmarkBarItem.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BookmarkBar/components/BookmarkBarItem/BookmarkBarItem.tsx
new file mode 100644
index 00000000000..24cdca7d232
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BookmarkBar/components/BookmarkBarItem/BookmarkBarItem.tsx
@@ -0,0 +1,168 @@
+import { useSortable } from "@dnd-kit/sortable";
+import { CSS } from "@dnd-kit/utilities";
+import {
+	ContextMenu,
+	ContextMenuContent,
+	ContextMenuItem,
+	ContextMenuTrigger,
+} from "@superset/ui/context-menu";
+import { toast } from "@superset/ui/sonner";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@superset/ui/tooltip";
+import { cn } from "@superset/ui/utils";
+import { GlobeIcon } from "lucide-react";
+import { useEffect, useMemo, useRef, useState } from "react";
+import {
+	type BrowserBookmark,
+	useBrowserBookmarksStore,
+} from "renderer/stores/browser-bookmarks";
+import { EditBookmarkDialog } from "./components/EditBookmarkDialog";
+
+interface BookmarkBarItemProps {
+	bookmark: BrowserBookmark;
+	isActive: boolean;
+	onNavigate: (url: string) => void;
+	onRemove: (bookmarkId: string) => void;
+}
+
+export function BookmarkBarItem({
+	bookmark,
+	isActive,
+	onNavigate,
+	onRemove,
+}: BookmarkBarItemProps) {
+	const [faviconFailed, setFaviconFailed] = useState(false);
+	const [isEditOpen, setIsEditOpen] = useState(false);
+	const shouldOpenEditDialogRef = useRef(false);
+	const pendingOpenTimerRef = useRef<ReturnType<typeof setTimeout> | null>(
+		null,
+	);
+	const updateBookmark = useBrowserBookmarksStore(
+		(state) => state.updateBookmark,
+	);
+	const {
+		attributes,
+		listeners,
+		setNodeRef,
+		transform,
+		transition,
+		isDragging,
+	} = useSortable({
+		id: bookmark.id,
+	});
+
+	const style = useMemo(
+		() => ({
+			transform: CSS.Transform.toString(transform),
+			transition,
+		}),
+		[transform, transition],
+	);
+
+	const label = bookmark.title.trim() || bookmark.url;
+
+	useEffect(() => {
+		return () => {
+			if (pendingOpenTimerRef.current !== null) {
+				clearTimeout(pendingOpenTimerRef.current);
+			}
+		};
+	}, []);
+
+	const scheduleEditDialogOpen = () => {
+		if (pendingOpenTimerRef.current !== null) {
+			clearTimeout(pendingOpenTimerRef.current);
+		}
+		pendingOpenTimerRef.current = setTimeout(() => {
+			pendingOpenTimerRef.current = null;
+			setIsEditOpen(true);
+		}, 0);
+	};
+
+	return (
+		<>
+			<ContextMenu>
+				<ContextMenuTrigger asChild>
+					<div
+						ref={setNodeRef}
+						style={style}
+						className={cn("shrink-0", isDragging && "opacity-45")}
+					>
+						<Tooltip>
+							<TooltipTrigger asChild>
+								<button
+									type="button"
+									{...attributes}
+									{...listeners}
+									onClick={() => onNavigate(bookmark.url)}
+									className={cn(
+										"flex h-7 max-w-52 cursor-pointer items-center gap-2 rounded-md border px-2 text-xs transition-colors",
+										"border-transparent bg-transparent text-muted-foreground/75 hover:bg-accent/70 hover:text-foreground",
+										"active:cursor-grabbing",
+										isActive &&
+											"border-border bg-accent text-foreground shadow-sm",
+									)}
+								>
+									{bookmark.faviconUrl && !faviconFailed ? (
+										<img
+											src={bookmark.faviconUrl}
+											alt=""
+											className="size-3.5 shrink-0 rounded-sm"
+											onError={() => setFaviconFailed(true)}
+										/>
+									) : (
+										<GlobeIcon className="size-3.5 shrink-0 text-muted-foreground/60" />
+									)}
+									<span className="truncate">{label}</span>
+								</button>
+							</TooltipTrigger>
+							<TooltipContent side="bottom" showArrow={false}>
+								{bookmark.url}
+							</TooltipContent>
+						</Tooltip>
+					</div>
+				</ContextMenuTrigger>
+				<ContextMenuContent
+					className="w-44"
+					onCloseAutoFocus={(event) => {
+						if (!shouldOpenEditDialogRef.current) return;
+						shouldOpenEditDialogRef.current = false;
+						event.preventDefault();
+						scheduleEditDialogOpen();
+					}}
+				>
+					<ContextMenuItem onSelect={() => onNavigate(bookmark.url)}>
+						Open Bookmark
+					</ContextMenuItem>
+					<ContextMenuItem
+						onSelect={() => {
+							shouldOpenEditDialogRef.current = true;
+						}}
+					>
+						Edit Bookmark
+					</ContextMenuItem>
+					<ContextMenuItem onSelect={() => onRemove(bookmark.id)}>
+						Remove Bookmark
+					</ContextMenuItem>
+				</ContextMenuContent>
+			</ContextMenu>
+			<EditBookmarkDialog
+				bookmark={bookmark}
+				open={isEditOpen}
+				onOpenChange={setIsEditOpen}
+				onSave={({ title, url }) => {
+					const updatedBookmark = updateBookmark(bookmark.id, {
+						title,
+						url,
+						faviconUrl: bookmark.faviconUrl,
+					});
+					if (!updatedBookmark) {
+						toast.error("Failed to update bookmark");
+						return;
+					}
+					setIsEditOpen(false);
+					toast.success("Bookmark updated");
+				}}
+			/>
+		</>
+	);
+}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BookmarkBar/components/BookmarkBarItem/components/EditBookmarkDialog/EditBookmarkDialog.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BookmarkBar/components/BookmarkBarItem/components/EditBookmarkDialog/EditBookmarkDialog.tsx
new file mode 100644
index 00000000000..ff1a61cd54b
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BookmarkBar/components/BookmarkBarItem/components/EditBookmarkDialog/EditBookmarkDialog.tsx
@@ -0,0 +1,85 @@
+import { Button } from "@superset/ui/button";
+import {
+	Dialog,
+	DialogContent,
+	DialogFooter,
+	DialogHeader,
+	DialogTitle,
+} from "@superset/ui/dialog";
+import { Input } from "@superset/ui/input";
+import { Label } from "@superset/ui/label";
+import { useEffect, useState } from "react";
+import type { BrowserBookmark } from "renderer/stores/browser-bookmarks";
+
+interface EditBookmarkDialogProps {
+	bookmark: BrowserBookmark;
+	open: boolean;
+	onOpenChange: (open: boolean) => void;
+	onSave: (values: { title: string; url: string }) => void;
+}
+
+export function EditBookmarkDialog({
+	bookmark,
+	open,
+	onOpenChange,
+	onSave,
+}: EditBookmarkDialogProps) {
+	const [title, setTitle] = useState(bookmark.title);
+	const [url, setUrl] = useState(bookmark.url);
+
+	useEffect(() => {
+		if (!open) return;
+		setTitle(bookmark.title);
+		setUrl(bookmark.url);
+	}, [bookmark.title, bookmark.url, open]);
+
+	return (
+		<Dialog open={open} onOpenChange={onOpenChange}>
+			<DialogContent className="max-w-md">
+				<DialogHeader>
+					<DialogTitle>Edit Bookmark</DialogTitle>
+				</DialogHeader>
+				<form
+					className="space-y-4"
+					onSubmit={(event) => {
+						event.preventDefault();
+						onSave({ title, url });
+					}}
+				>
+					<div className="space-y-2">
+						<Label htmlFor={`bookmark-title-${bookmark.id}`}>Title</Label>
+						<Input
+							id={`bookmark-title-${bookmark.id}`}
+							value={title}
+							onChange={(event) => setTitle(event.target.value)}
+							placeholder="Bookmark title"
+							autoFocus
+						/>
+					</div>
+					<div className="space-y-2">
+						<Label htmlFor={`bookmark-url-${bookmark.id}`}>URL</Label>
+						<Input
+							id={`bookmark-url-${bookmark.id}`}
+							value={url}
+							onChange={(event) => setUrl(event.target.value)}
+							placeholder="https://example.com"
+							spellCheck={false}
+							autoCapitalize="off"
+							autoCorrect="off"
+						/>
+					</div>
+					<DialogFooter>
+						<Button
+							type="button"
+							variant="outline"
+							onClick={() => onOpenChange(false)}
+						>
+							Cancel
+						</Button>
+						<Button type="submit">Save</Button>
+					</DialogFooter>
+				</form>
+			</DialogContent>
+		</Dialog>
+	);
+}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BookmarkBar/components/BookmarkBarItem/components/EditBookmarkDialog/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BookmarkBar/components/BookmarkBarItem/components/EditBookmarkDialog/index.ts
new file mode 100644
index 00000000000..480b1d61c76
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BookmarkBar/components/BookmarkBarItem/components/EditBookmarkDialog/index.ts
@@ -0,0 +1 @@
+export { EditBookmarkDialog } from "./EditBookmarkDialog";
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BookmarkBar/components/BookmarkBarItem/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BookmarkBar/components/BookmarkBarItem/index.ts
new file mode 100644
index 00000000000..91c0510983d
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BookmarkBar/components/BookmarkBarItem/index.ts
@@ -0,0 +1 @@
+export { BookmarkBarItem } from "./BookmarkBarItem";
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BookmarkBar/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BookmarkBar/index.ts
new file mode 100644
index 00000000000..6de0d4c00b6
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BookmarkBar/index.ts
@@ -0,0 +1 @@
+export { BookmarkBar } from "./BookmarkBar";
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BrowserToolbar/BrowserToolbar.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BrowserToolbar/BrowserToolbar.tsx
index 7ce86fe3cdf..a068cb68338 100644
--- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BrowserToolbar/BrowserToolbar.tsx
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/components/BrowserToolbar/BrowserToolbar.tsx
@@ -7,6 +7,8 @@ import {
 	TbArrowRight,
 	TbLoader2,
 	TbRefresh,
+	TbStar,
+	TbStarFilled,
 } from "react-icons/tb";
 import { UrlSuggestions } from "./components/UrlSuggestions";
 import { useUrlAutocomplete } from "./hooks/useUrlAutocomplete";
@@ -21,12 +23,15 @@ interface BrowserToolbarProps {
 	currentUrl: string;
 	pageTitle: string;
 	isLoading: boolean;
+	hasPage: boolean;
+	isBookmarked: boolean;
 	canGoBack: boolean;
 	canGoForward: boolean;
 	onGoBack: () => void;
 	onGoForward: () => void;
 	onReload: () => void;
 	onNavigate: (url: string) => void;
+	onToggleBookmark: () => void;
 	onEditingChange?: (editing: boolean) => void;
 }
 
@@ -34,12 +39,15 @@ export function BrowserToolbar({
 	currentUrl,
 	pageTitle,
 	isLoading,
+	hasPage,
+	isBookmarked,
 	canGoBack,
 	canGoForward,
 	onGoBack,
 	onGoForward,
 	onReload,
 	onNavigate,
+	onToggleBookmark,
 	onEditingChange,
 }: BrowserToolbarProps) {
 	const [isEditing, setIsEditingRaw] = useState(false);
@@ -218,27 +226,6 @@ export function BrowserToolbar({
 								</>
 							)}
 						</button>
-						{!isBlank && (
-							<Tooltip>
-								<TooltipTrigger asChild>
-									<button
-										type="button"
-										onClick={() => {
-											navigator.clipboard.writeText(currentUrl).then(
-												() => toast.success("URL copied"),
-												() => toast.error("Failed to copy URL"),
-											);
-										}}
-										className="shrink-0 rounded p-0.5 text-muted-foreground/40 opacity-0 transition-all hover:text-muted-foreground group-hover:opacity-100"
-									>
-										<LuLink className="size-3" />
-									</button>
-								</TooltipTrigger>
-								<TooltipContent side="bottom" showArrow={false}>
-									Copy URL
-								</TooltipContent>
-							</Tooltip>
-						)}
 					</div>
 				)}
 				{isEditing && autocomplete.isOpen && (
@@ -249,6 +236,49 @@ export function BrowserToolbar({
 					/>
 				)}
 			</div>
+			<div className="ml-1 flex shrink-0 items-center gap-0.5">
+				{hasPage && (
+					<Tooltip>
+						<TooltipTrigger asChild>
+							<button
+								type="button"
+								onClick={onToggleBookmark}
+								className="rounded p-1 text-muted-foreground/50 transition-colors hover:text-foreground"
+							>
+								{isBookmarked ? (
+									<TbStarFilled className="size-3.5 text-amber-500" />
+								) : (
+									<TbStar className="size-3.5" />
+								)}
+							</button>
+						</TooltipTrigger>
+						<TooltipContent side="bottom" showArrow={false}>
+							{isBookmarked ? "Remove Bookmark" : "Add Bookmark"}
+						</TooltipContent>
+					</Tooltip>
+				)}
+				{!isBlank && (
+					<Tooltip>
+						<TooltipTrigger asChild>
+							<button
+								type="button"
+								onClick={() => {
+									navigator.clipboard.writeText(currentUrl).then(
+										() => toast.success("URL copied"),
+										() => toast.error("Failed to copy URL"),
+									);
+								}}
+								className="rounded p-1 text-muted-foreground/40 transition-colors hover:text-muted-foreground"
+							>
+								<LuLink className="size-3" />
+							</button>
+						</TooltipTrigger>
+						<TooltipContent side="bottom" showArrow={false}>
+							Copy URL
+						</TooltipContent>
+					</Tooltip>
+				)}
+			</div>
 		</div>
 	);
 }
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/hooks/usePersistentWebview/usePersistentWebview.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/hooks/usePersistentWebview/usePersistentWebview.ts
index 450f6ea3ad6..37e1447c6ed 100644
--- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/hooks/usePersistentWebview/usePersistentWebview.ts
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/BrowserPane/hooks/usePersistentWebview/usePersistentWebview.ts
@@ -1,6 +1,8 @@
 import { useCallback, useEffect, useRef } from "react";
+import type { MosaicBranch } from "react-mosaic-component";
 import { electronTrpc } from "renderer/lib/electron-trpc";
 import { useTabsStore } from "renderer/stores/tabs/store";
+import type { SplitPaneOptions } from "renderer/stores/tabs/types";
 import { PLATFORM } from "shared/constants";
 
 // ---------------------------------------------------------------------------
@@ -109,12 +111,24 @@ function sanitizeUrl(url: string): string {
 
 interface UsePersistentWebviewOptions {
 	paneId: string;
+	tabId: string;
+	path: MosaicBranch[];
 	initialUrl: string;
+	splitPaneAuto: (
+		tabId: string,
+		sourcePaneId: string,
+		dimensions: { width: number; height: number },
+		path?: MosaicBranch[],
+		options?: SplitPaneOptions,
+	) => void;
 }
 
 export function usePersistentWebview({
 	paneId,
+	tabId,
+	path,
 	initialUrl,
+	splitPaneAuto,
 }: UsePersistentWebviewOptions) {
 	const containerRef = useRef<HTMLDivElement | null>(null);
 	const isHistoryNavigation = useRef(false);
@@ -143,12 +157,13 @@ export function usePersistentWebview({
 		{
 			onData: ({ action, url }: { action: string; url: string }) => {
 				if (action === "open-in-split") {
-					const state = useTabsStore.getState();
-					const pane = state.panes[paneId];
-					if (!pane) return;
-					const tab = state.tabs.find((t) => t.id === pane.tabId);
-					if (!tab) return;
-					state.openInBrowserPane(tab.workspaceId, url);
+					const container = containerRef.current;
+					if (!container) return;
+					const { width, height } = container.getBoundingClientRect();
+					splitPaneAuto(tabId, paneId, { width, height }, path, {
+						paneType: "webview",
+						url,
+					});
 				}
 			},
 		},
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/DatabaseExplorerPane/DatabaseExplorerPane.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/DatabaseExplorerPane/DatabaseExplorerPane.tsx
new file mode 100644
index 00000000000..4615734b2db
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/DatabaseExplorerPane/DatabaseExplorerPane.tsx
@@ -0,0 +1,140 @@
+import { Badge } from "@superset/ui/badge";
+import { useEffect } from "react";
+import type { MosaicBranch } from "react-mosaic-component";
+import { DatabasesView } from "renderer/screens/main/components/WorkspaceView/RightSidebar/DatabasesView";
+import { useDatabaseSidebarStore } from "renderer/stores/database-sidebar";
+import { useTabsStore } from "renderer/stores/tabs/store";
+import type { SplitPaneOptions, Tab } from "renderer/stores/tabs/types";
+import { TabContentContextMenu } from "../../TabContentContextMenu";
+import { BasePaneWindow, PaneTitle, PaneToolbarActions } from "../components";
+
+interface DatabaseExplorerPaneProps {
+	paneId: string;
+	path: MosaicBranch[];
+	tabId: string;
+	workspaceId: string;
+	splitPaneAuto: (
+		tabId: string,
+		sourcePaneId: string,
+		dimensions: { width: number; height: number },
+		path?: MosaicBranch[],
+	) => void;
+	splitPaneHorizontal: (
+		tabId: string,
+		sourcePaneId: string,
+		path?: MosaicBranch[],
+		options?: SplitPaneOptions,
+	) => void;
+	splitPaneVertical: (
+		tabId: string,
+		sourcePaneId: string,
+		path?: MosaicBranch[],
+		options?: SplitPaneOptions,
+	) => void;
+	removePane: (paneId: string) => void;
+	setFocusedPane: (tabId: string, paneId: string) => void;
+	availableTabs: Tab[];
+	onMoveToTab: (targetTabId: string) => void;
+	onMoveToNewTab: () => void;
+	onPopOut?: () => void;
+}
+
+export function DatabaseExplorerPane({
+	paneId,
+	path,
+	tabId,
+	workspaceId,
+	splitPaneAuto,
+	splitPaneHorizontal,
+	splitPaneVertical,
+	removePane,
+	setFocusedPane,
+	availableTabs,
+	onMoveToTab,
+	onMoveToNewTab,
+	onPopOut,
+}: DatabaseExplorerPaneProps) {
+	const pane = useTabsStore((state) => state.panes[paneId]);
+	const setPaneName = useTabsStore((state) => state.setPaneName);
+	const setPaneAutoTitle = useTabsStore((state) => state.setPaneAutoTitle);
+	const equalizePaneSplits = useTabsStore((state) => state.equalizePaneSplits);
+	const setDatabaseExplorerConnection = useTabsStore(
+		(state) => state.setDatabaseExplorerConnection,
+	);
+	const connections = useDatabaseSidebarStore((state) => state.connections);
+
+	const connectionId = pane?.databaseExplorer?.connectionId ?? null;
+	const currentConnection =
+		connections.find((connection) => connection.id === connectionId) ?? null;
+
+	useEffect(() => {
+		if (!currentConnection) {
+			return;
+		}
+
+		setPaneAutoTitle(paneId, `DB: ${currentConnection.label}`);
+	}, [currentConnection, paneId, setPaneAutoTitle]);
+
+	return (
+		<BasePaneWindow
+			paneId={paneId}
+			path={path}
+			tabId={tabId}
+			splitPaneAuto={splitPaneAuto}
+			removePane={removePane}
+			setFocusedPane={setFocusedPane}
+			onPopOut={onPopOut}
+			renderToolbar={(handlers) => (
+				<div className="flex h-full w-full items-center justify-between px-3">
+					<div className="flex min-w-0 items-center gap-2">
+						<PaneTitle
+							name={pane?.name ?? "Database Explorer"}
+							fallback="Database Explorer"
+							onRename={(newName) => setPaneName(paneId, newName)}
+						/>
+						{currentConnection ? (
+							<Badge variant="outline" className="truncate">
+								{currentConnection.label}
+							</Badge>
+						) : null}
+					</div>
+					<PaneToolbarActions
+						splitOrientation={handlers.splitOrientation}
+						onSplitPane={handlers.onSplitPane}
+						onClosePane={handlers.onClosePane}
+						onPopOut={handlers.onPopOut}
+					/>
+				</div>
+			)}
+		>
+			<TabContentContextMenu
+				onSplitHorizontal={() => splitPaneHorizontal(tabId, paneId, path)}
+				onSplitVertical={() => splitPaneVertical(tabId, paneId, path)}
+				onSplitWithNewChat={() =>
+					splitPaneVertical(tabId, paneId, path, { paneType: "chat" })
+				}
+				onSplitWithNewBrowser={() =>
+					splitPaneVertical(tabId, paneId, path, { paneType: "webview" })
+				}
+				onEqualizePaneSplits={() => equalizePaneSplits(tabId)}
+				onClosePane={() => removePane(paneId)}
+				currentTabId={tabId}
+				availableTabs={availableTabs}
+				onMoveToTab={onMoveToTab}
+				onMoveToNewTab={onMoveToNewTab}
+				closeLabel="Close Database Explorer"
+			>
+				<div className="h-full w-full">
+					<DatabasesView
+						mode="pane"
+						selectedConnectionId={connectionId}
+						onSelectConnectionId={(nextConnectionId) =>
+							setDatabaseExplorerConnection(paneId, nextConnectionId)
+						}
+						workspaceId={workspaceId}
+					/>
+				</div>
+			</TabContentContextMenu>
+		</BasePaneWindow>
+	);
+}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/DatabaseExplorerPane/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/DatabaseExplorerPane/index.ts
new file mode 100644
index 00000000000..39807d644e0
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/DatabaseExplorerPane/index.ts
@@ -0,0 +1 @@
+export { DatabaseExplorerPane } from "./DatabaseExplorerPane";
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx
index 87acaddc7b6..f9e271e9b59 100644
--- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx
@@ -303,7 +303,6 @@ export function FileViewerPane({
 
 	useEffect(() => {
 		if (
-			viewMode === "diff" ||
 			viewMode === "conflict" ||
 			isLoadingRaw ||
 			!rawFileData?.ok ||
@@ -312,6 +311,10 @@ export function FileViewerPane({
 			return;
 		}
 
+		if (viewMode === "diff") {
+			return;
+		}
+
 		applyLoadedDocumentContent(
 			documentKey,
 			rawFileData.content,
@@ -327,6 +330,30 @@ export function FileViewerPane({
 		workingCopyRevision,
 	]);
 
+	useEffect(() => {
+		if (
+			viewMode !== "diff" ||
+			isDirty ||
+			!diffData ||
+			diffData.modified.length === 0
+		) {
+			return;
+		}
+
+		applyLoadedDocumentContent(
+			documentKey,
+			diffData.modified,
+			workingCopyRevision ?? rawRevision ?? null,
+		);
+	}, [
+		diffData,
+		documentKey,
+		isDirty,
+		rawRevision,
+		viewMode,
+		workingCopyRevision,
+	]);
+
 	const absoluteFilePath = useMemo(
 		() => toAbsoluteWorkspacePath(worktreePath, filePath),
 		[worktreePath, filePath],
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/components/CodeMirrorDiffViewer/CodeMirrorDiffViewer.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/components/CodeMirrorDiffViewer/CodeMirrorDiffViewer.tsx
index 8b2eefec472..98e21b41da4 100644
--- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/components/CodeMirrorDiffViewer/CodeMirrorDiffViewer.tsx
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/components/CodeMirrorDiffViewer/CodeMirrorDiffViewer.tsx
@@ -24,6 +24,7 @@ import { loadLanguageSupport } from "renderer/screens/main/components/WorkspaceV
 import { getCodeSyntaxHighlighting } from "renderer/screens/main/components/WorkspaceView/utils/code-theme";
 import { useResolvedTheme } from "renderer/stores/theme";
 import type { DiffViewMode } from "shared/changes-types";
+import { getEditorTheme } from "shared/themes";
 
 // Line decoration that suppresses inline cm-changedText highlights
 const suppressLineDeco = Decoration.line({ class: "cm-suppress-inline-diff" });
@@ -126,6 +127,74 @@ interface CodeMirrorDiffViewerProps {
 	onChange?: (value: string) => void;
 	onSave?: () => void;
 	blameEntries?: BlameEntry[];
+	diagnostics?: Array<{
+		line: number | null;
+		column: number | null;
+		endLine: number | null;
+		endColumn: number | null;
+		severity: "error" | "warning" | "info" | "hint";
+	}>;
+}
+
+function createDiagnosticsTheme(theme: ReturnType<typeof getEditorTheme>) {
+	return EditorView.theme({
+		".cm-problem-underline-error": {
+			textDecoration: `underline wavy ${theme.colors.deletion}`,
+			textUnderlineOffset: "3px",
+			textDecorationThickness: "1.5px",
+		},
+		".cm-problem-underline-warning": {
+			textDecoration: `underline wavy ${theme.colors.modified}`,
+			textUnderlineOffset: "3px",
+			textDecorationThickness: "1.5px",
+		},
+		".cm-problem-underline-info, .cm-problem-underline-hint": {
+			textDecoration: `underline dotted ${theme.colors.searchActive}`,
+			textUnderlineOffset: "3px",
+			textDecorationThickness: "1.5px",
+		},
+	});
+}
+
+function buildDiagnosticDecorations(
+	doc: EditorState["doc"],
+	diagnostics: NonNullable<CodeMirrorDiffViewerProps["diagnostics"]>,
+) {
+	const decorations = diagnostics
+		.filter((diagnostic) => diagnostic.line !== null)
+		.map((diagnostic) => {
+			const startLine = Math.max(1, Math.min(diagnostic.line ?? 1, doc.lines));
+			const startLineInfo = doc.line(startLine);
+			const startOffset = Math.max(0, (diagnostic.column ?? 1) - 1);
+			const from = Math.min(startLineInfo.from + startOffset, startLineInfo.to);
+
+			const endLineNumber = Math.max(
+				startLine,
+				Math.min(diagnostic.endLine ?? startLine, doc.lines),
+			);
+			const endLineInfo = doc.line(endLineNumber);
+			const endOffset = Math.max(
+				0,
+				(diagnostic.endColumn ??
+					(diagnostic.column !== null ? diagnostic.column + 1 : 2)) - 1,
+			);
+			let to = Math.min(endLineInfo.from + endOffset, endLineInfo.to);
+
+			if (to <= from) {
+				to = Math.min(from + 1, startLineInfo.to);
+			}
+
+			if (to <= from) {
+				return null;
+			}
+
+			return Decoration.mark({
+				class: `cm-problem-underline-${diagnostic.severity}`,
+			}).range(from, to);
+		})
+		.filter((decoration) => decoration !== null);
+
+	return Decoration.set(decorations, true);
 }
 
 export function CodeMirrorDiffViewer({
@@ -137,6 +206,7 @@ export function CodeMirrorDiffViewer({
 	onChange,
 	onSave,
 	blameEntries,
+	diagnostics = [],
 }: CodeMirrorDiffViewerProps) {
 	const containerRef = useRef<HTMLDivElement>(null);
 	const mergeViewRef = useRef<MergeView | null>(null);
@@ -145,6 +215,7 @@ export function CodeMirrorDiffViewer({
 	const themeCompartmentA = useRef(new Compartment()).current;
 	const themeCompartmentB = useRef(new Compartment()).current;
 	const blameCompartmentB = useRef(new Compartment()).current;
+	const diagnosticsCompartmentB = useRef(new Compartment()).current;
 	const onChangeRef = useRef(onChange);
 	const onSaveRef = useRef(onSave);
 	const activeTheme = useResolvedTheme();
@@ -154,6 +225,7 @@ export function CodeMirrorDiffViewer({
 	);
 	const editorFontFamily = fontSettings?.editorFontFamily ?? undefined;
 	const editorFontSize = fontSettings?.editorFontSize ?? undefined;
+	const editorTheme = getEditorTheme(activeTheme);
 
 	useEffect(() => {
 		onChangeRef.current = onChange;
@@ -234,6 +306,15 @@ export function CodeMirrorDiffViewer({
 					...editableExtensions,
 					themeCompartmentB.of(themeExts),
 					langCompartmentB.of([]),
+					diagnosticsCompartmentB.of([
+						createDiagnosticsTheme(editorTheme),
+						EditorView.decorations.of(
+							buildDiagnosticDecorations(
+								EditorState.create({ doc: modified }).doc,
+								diagnostics,
+							),
+						),
+					]),
 				],
 			},
 		});
@@ -276,6 +357,20 @@ export function CodeMirrorDiffViewer({
 		themeCompartmentB,
 	]);
 
+	useEffect(() => {
+		const mv = mergeViewRef.current;
+		if (!mv) return;
+
+		mv.b.dispatch({
+			effects: diagnosticsCompartmentB.reconfigure([
+				createDiagnosticsTheme(editorTheme),
+				EditorView.decorations.of(
+					buildDiagnosticDecorations(mv.b.state.doc, diagnostics),
+				),
+			]),
+		});
+	}, [diagnostics, diagnosticsCompartmentB, editorTheme]);
+
 	useEffect(() => {
 		const mv = mergeViewRef.current;
 		if (!mv) return;
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/components/FileViewerContent/FileViewerContent.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/components/FileViewerContent/FileViewerContent.tsx
index 749895e9a2a..d4f8148f272 100644
--- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/components/FileViewerContent/FileViewerContent.tsx
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/components/FileViewerContent/FileViewerContent.tsx
@@ -14,7 +14,7 @@ import { electronTrpc } from "renderer/lib/electron-trpc";
 import type { CodeEditorAdapter } from "renderer/screens/main/components/WorkspaceView/ContentView/components";
 import { CodeEditor } from "renderer/screens/main/components/WorkspaceView/components/CodeEditor";
 import type { Tab } from "renderer/stores/tabs/types";
-import { toAbsoluteWorkspacePath } from "shared/absolute-paths";
+import { pathsMatch, toAbsoluteWorkspacePath } from "shared/absolute-paths";
 import type { DiffViewMode } from "shared/changes-types";
 import { detectLanguage } from "shared/detect-language";
 import { isImageFile, isSpreadsheetFile } from "shared/file-types";
@@ -196,6 +196,42 @@ export function FileViewerContent({
 		[worktreePath, filePath],
 	);
 
+	const trpcUtils = electronTrpc.useUtils();
+	const { data: workspaceDiagnostics } =
+		electronTrpc.languageServices.getWorkspaceDiagnostics.useQuery(
+			{ workspaceId: workspaceId ?? "" },
+			{
+				enabled: Boolean(workspaceId),
+				staleTime: Infinity,
+			},
+		);
+
+	electronTrpc.languageServices.subscribeDiagnostics.useSubscription(
+		{ workspaceId: workspaceId ?? "" },
+		{
+			enabled: Boolean(workspaceId),
+			onData: () => {
+				if (!workspaceId) {
+					return;
+				}
+				void trpcUtils.languageServices.getWorkspaceDiagnostics.invalidate({
+					workspaceId,
+				});
+			},
+		},
+	);
+
+	const fileDiagnostics = useMemo(
+		() =>
+			(workspaceDiagnostics?.problems ?? []).filter(
+				(problem) =>
+					(problem.absolutePath && absoluteFilePath
+						? pathsMatch(problem.absolutePath, absoluteFilePath)
+						: false) || problem.relativePath === filePath,
+			),
+		[workspaceDiagnostics?.problems, absoluteFilePath, filePath],
+	);
+
 	const { data: blameData } = electronTrpc.changes.getGitBlame.useQuery(
 		{ worktreePath: worktreePath ?? "", absolutePath: absoluteFilePath },
 		{
@@ -406,6 +442,7 @@ export function FileViewerContent({
 							onChange={onContentChange}
 							onSave={onSaveFile}
 							blameEntries={blameData?.entries}
+							diagnostics={fileDiagnostics}
 						/>
 					</div>
 				</div>
@@ -540,6 +577,7 @@ export function FileViewerContent({
 					editorRef={editorRef}
 					fillHeight
 					blameEntries={blameData?.entries}
+					diagnostics={fileDiagnostics}
 				/>
 			</div>
 		</FileEditorContextMenu>
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/index.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/index.tsx
index bee60397568..bab84ee818a 100644
--- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/index.tsx
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/index.tsx
@@ -23,6 +23,7 @@ import { useTheme } from "renderer/stores/theme";
 import { BrowserPane } from "./BrowserPane";
 import { ChatPane } from "./ChatPane";
 import { MosaicSplitOverlay } from "./components";
+import { DatabaseExplorerPane } from "./DatabaseExplorerPane";
 import { DevToolsPane } from "./DevToolsPane";
 import { FileViewerPane } from "./FileViewerPane";
 import { GitGraphPane } from "./GitGraphPane";
@@ -345,6 +346,26 @@ export function TabView({ tab }: TabViewProps) {
 				);
 			}
 
+			if (paneInfo.type === "database-explorer") {
+				return (
+					<DatabaseExplorerPane
+						paneId={paneId}
+						path={path}
+						tabId={tab.id}
+						workspaceId={tab.workspaceId}
+						splitPaneAuto={splitPaneAuto}
+						splitPaneHorizontal={splitPaneHorizontal}
+						splitPaneVertical={splitPaneVertical}
+						removePane={removePane}
+						setFocusedPane={setFocusedPane}
+						availableTabs={workspaceTabs}
+						onMoveToTab={(targetTabId) => movePaneToTab(paneId, targetTabId)}
+						onMoveToNewTab={() => movePaneToNewTab(paneId)}
+						onPopOut={isTearoff ? undefined : () => handlePopOut(paneId)}
+					/>
+				);
+			}
+
 			// Default: terminal panes
 			return (
 				<TabPane
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/ChangesView/ChangesView.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/ChangesView/ChangesView.tsx
index 3ede1c9b575..73c5293c548 100644
--- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/ChangesView/ChangesView.tsx
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/ChangesView/ChangesView.tsx
@@ -32,6 +32,7 @@ import { CategorySection } from "./components/CategorySection";
 import { ChangesHeader } from "./components/ChangesHeader";
 import { CommitInput } from "./components/CommitInput";
 import { DiscardConfirmDialog } from "./components/DiscardConfirmDialog";
+import { RepositoryPanel } from "./components/RepositoryPanel";
 import { ReviewPanel } from "./components/ReviewPanel";
 import { VerticalResizablePanels } from "./components/VerticalResizablePanels";
 import { useOrderedSections } from "./hooks";
@@ -837,6 +838,7 @@ export function ChangesView({
 
 	return (
 		<div className="flex flex-col flex-1 min-h-0">
+			<RepositoryPanel isActive={isActive} />
 			<VerticalResizablePanels
 				topSizePercentage={diffsPanePercentage}
 				onTopSizePercentageChange={setDiffsPanePercentage}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/ChangesView/components/RepositoryPanel/RepositoryPanel.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/ChangesView/components/RepositoryPanel/RepositoryPanel.tsx
new file mode 100644
index 00000000000..95a7713095b
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/ChangesView/components/RepositoryPanel/RepositoryPanel.tsx
@@ -0,0 +1,1130 @@
+import { Avatar } from "@superset/ui/atoms/Avatar";
+import { Badge } from "@superset/ui/badge";
+import { Button } from "@superset/ui/button";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@superset/ui/collapsible";
+import {
+	Command,
+	CommandEmpty,
+	CommandGroup,
+	CommandInput,
+	CommandItem,
+	CommandList,
+} from "@superset/ui/command";
+import { Input } from "@superset/ui/input";
+import { Popover, PopoverContent, PopoverTrigger } from "@superset/ui/popover";
+import { Skeleton } from "@superset/ui/skeleton";
+import { toast } from "@superset/ui/sonner";
+import { Textarea } from "@superset/ui/textarea";
+import { cn } from "@superset/ui/utils";
+import type { ClipboardEvent } from "react";
+import { useEffect, useMemo, useState } from "react";
+import {
+	LuArrowUpRight,
+	LuCheck,
+	LuChevronDown,
+	LuFilePlus2,
+	LuGitPullRequest,
+	LuImage,
+	LuLoaderCircle,
+	LuPlay,
+	LuTag,
+	LuUserPlus,
+	LuWorkflow,
+	LuX,
+} from "react-icons/lu";
+import { electronTrpc } from "renderer/lib/electron-trpc";
+import { useWorkspaceId } from "renderer/screens/main/components/WorkspaceView/WorkspaceIdContext";
+import { useTabsStore } from "renderer/stores/tabs/store";
+
+function formatRepositoryTimestamp(value: string | null): string {
+	if (!value) {
+		return "";
+	}
+
+	const date = new Date(value);
+	if (Number.isNaN(date.getTime())) {
+		return "";
+	}
+
+	return new Intl.DateTimeFormat("ja-JP", {
+		month: "numeric",
+		day: "numeric",
+		hour: "2-digit",
+		minute: "2-digit",
+	}).format(date);
+}
+
+interface RepositoryPanelProps {
+	isActive?: boolean;
+}
+
+interface UploadedIssueAsset {
+	id: string;
+	name: string;
+	url: string;
+	markdown: string;
+}
+
+interface TrackedWorkflowRun {
+	workflowId: number;
+	workflowName: string;
+	ref: string;
+	dispatchedAt: string;
+}
+
+interface WorkflowRunSummary {
+	id: number;
+	status: string;
+	conclusion: string | null;
+	createdAt: string | null;
+	headBranch: string | null;
+	runStartedAt?: string | null;
+	runNumber?: number | null;
+	url?: string | null;
+}
+
+function buildSelectionSummary(items: string[], emptyLabel: string): string {
+	if (items.length === 0) {
+		return emptyLabel;
+	}
+
+	if (items.length <= 2) {
+		return items.join(", ");
+	}
+
+	return `${items.slice(0, 2).join(", ")} +${items.length - 2}`;
+}
+
+function readFileAsBase64(file: File): Promise<string> {
+	return new Promise((resolve, reject) => {
+		const reader = new FileReader();
+		reader.onload = () => {
+			const result = reader.result;
+			if (typeof result !== "string") {
+				reject(new Error("Failed to read image"));
+				return;
+			}
+			const commaIndex = result.indexOf(",");
+			resolve(commaIndex >= 0 ? result.slice(commaIndex + 1) : result);
+		};
+		reader.onerror = () =>
+			reject(reader.error ?? new Error("Failed to read image"));
+		reader.readAsDataURL(file);
+	});
+}
+
+function getWorkflowRunStatusLabel(
+	run?: {
+		status: string;
+		conclusion: string | null;
+	} | null,
+): string {
+	if (!run) {
+		return "Waiting";
+	}
+
+	if (run.status === "completed") {
+		switch (run.conclusion) {
+			case "success":
+				return "Succeeded";
+			case "failure":
+				return "Failed";
+			case "cancelled":
+				return "Cancelled";
+			case "skipped":
+				return "Skipped";
+			default:
+				return run.conclusion ?? "Completed";
+		}
+	}
+
+	if (run.status === "in_progress") {
+		return "Running";
+	}
+
+	if (run.status === "queued") {
+		return "Queued";
+	}
+
+	return run.status;
+}
+
+function getWorkflowRunStatusClassName(
+	run?: {
+		status: string;
+		conclusion: string | null;
+	} | null,
+): string {
+	if (!run) {
+		return "border-border/60 text-muted-foreground";
+	}
+
+	if (run.status !== "completed") {
+		return "border-blue-500/30 text-blue-600 dark:text-blue-300";
+	}
+
+	switch (run.conclusion) {
+		case "success":
+			return "border-emerald-500/30 text-emerald-600 dark:text-emerald-300";
+		case "failure":
+			return "border-red-500/30 text-red-600 dark:text-red-300";
+		case "cancelled":
+			return "border-amber-500/30 text-amber-600 dark:text-amber-300";
+		default:
+			return "border-border/60 text-muted-foreground";
+	}
+}
+
+function findTrackedWorkflowRun(
+	runs: WorkflowRunSummary[],
+	tracked: TrackedWorkflowRun,
+) {
+	const dispatchedAtMs = Date.parse(tracked.dispatchedAt);
+	return runs.find((run) => {
+		const createdAtMs = run.createdAt ? Date.parse(run.createdAt) : Number.NaN;
+		if (Number.isNaN(createdAtMs) || createdAtMs < dispatchedAtMs - 30_000) {
+			return false;
+		}
+
+		return !run.headBranch || run.headBranch === tracked.ref;
+	});
+}
+
+function WorkflowRunCard({
+	workspaceId,
+	tracked,
+	onOpenUrl,
+	onRemove,
+}: {
+	workspaceId: string;
+	tracked: TrackedWorkflowRun;
+	onOpenUrl: (url: string) => void;
+	onRemove: (workflowId: number) => void;
+}) {
+	const { data: runs = [], isFetching } =
+		electronTrpc.workspaces.getGitHubWorkflowRuns.useQuery(
+			{
+				workspaceId,
+				workflowId: tracked.workflowId,
+			},
+			{
+				refetchInterval: (query) => {
+					const matched = findTrackedWorkflowRun(
+						query.state.data ?? [],
+						tracked,
+					);
+					return matched?.status === "completed" ? false : 3_000;
+				},
+				refetchIntervalInBackground: true,
+				staleTime: 0,
+			},
+		);
+
+	const matchedRun = findTrackedWorkflowRun(runs, tracked);
+	const statusLabel = getWorkflowRunStatusLabel(matchedRun);
+	const statusClassName = getWorkflowRunStatusClassName(matchedRun);
+	const isPending =
+		!matchedRun ||
+		matchedRun.status === "queued" ||
+		matchedRun.status === "in_progress";
+	const timestampLabel = formatRepositoryTimestamp(
+		matchedRun?.runStartedAt ?? matchedRun?.createdAt ?? tracked.dispatchedAt,
+	);
+
+	return (
+		<div className="rounded-sm border border-border/60 bg-background px-2 py-2">
+			<div className="flex items-start justify-between gap-2">
+				<div className="min-w-0 flex-1">
+					<p className="truncate text-xs font-medium text-foreground">
+						{tracked.workflowName}
+					</p>
+					<p className="truncate text-[11px] text-muted-foreground">
+						{matchedRun?.runNumber ? `#${matchedRun.runNumber} · ` : ""}
+						{tracked.ref}
+					</p>
+				</div>
+				<div className="flex items-center gap-1">
+					<Badge variant="outline" className={statusClassName}>
+						{isPending ? (
+							<LuLoaderCircle className="mr-1 size-3 animate-spin" />
+						) : null}
+						{statusLabel}
+					</Badge>
+					<Button
+						type="button"
+						variant="ghost"
+						size="sm"
+						className="h-6 px-1.5 text-[10px]"
+						onClick={() => onRemove(tracked.workflowId)}
+					>
+						<LuX className="size-3" />
+					</Button>
+				</div>
+			</div>
+			<div className="mt-2 flex items-center justify-between gap-2">
+				<p className="truncate text-[11px] text-muted-foreground">
+					{matchedRun
+						? timestampLabel
+							? `${isPending ? "Updated" : "Finished"} ${timestampLabel}`
+							: statusLabel
+						: isFetching
+							? "Waiting for GitHub to create the run..."
+							: "Looking for the triggered run..."}
+				</p>
+				{matchedRun?.url ? (
+					<Button
+						type="button"
+						variant="ghost"
+						size="sm"
+						className="h-6 px-2 text-[10px]"
+						onClick={() => {
+							if (matchedRun.url) {
+								onOpenUrl(matchedRun.url);
+							}
+						}}
+					>
+						Open in GitHub
+					</Button>
+				) : null}
+			</div>
+		</div>
+	);
+}
+
+export function RepositoryPanel({ isActive = true }: RepositoryPanelProps) {
+	const workspaceId = useWorkspaceId();
+	const trpcUtils = electronTrpc.useUtils();
+	const addBrowserTab = useTabsStore((state) => state.addBrowserTab);
+	const [open, setOpen] = useState(false);
+	const [issueComposerOpen, setIssueComposerOpen] = useState(false);
+	const [issueTitle, setIssueTitle] = useState("");
+	const [issueBody, setIssueBody] = useState("");
+	const [issueAssignees, setIssueAssignees] = useState<string[]>([]);
+	const [issueLabels, setIssueLabels] = useState<string[]>([]);
+	const [issueAssigneeSearch, setIssueAssigneeSearch] = useState("");
+	const [issueLabelSearch, setIssueLabelSearch] = useState("");
+	const [openIssuePicker, setOpenIssuePicker] = useState<
+		"assignees" | "labels" | null
+	>(null);
+	const [uploadedAssets, setUploadedAssets] = useState<UploadedIssueAsset[]>(
+		[],
+	);
+	const [isUploadingAsset, setIsUploadingAsset] = useState(false);
+	const [workflowRef, setWorkflowRef] = useState("");
+	const [pendingWorkflowId, setPendingWorkflowId] = useState<number | null>(
+		null,
+	);
+	const [trackedWorkflowRuns, setTrackedWorkflowRuns] = useState<
+		TrackedWorkflowRun[]
+	>([]);
+	const {
+		data: repositoryOverview,
+		isLoading,
+		error,
+	} = electronTrpc.workspaces.getGitHubRepositoryOverview.useQuery(
+		{ workspaceId: workspaceId ?? "" },
+		{
+			enabled: !!workspaceId && isActive,
+			staleTime: 60_000,
+			refetchOnWindowFocus: isActive,
+		},
+	);
+	const createIssueMutation =
+		electronTrpc.workspaces.createGitHubIssue.useMutation();
+	const uploadIssueAssetMutation =
+		electronTrpc.workspaces.uploadGitHubIssueAsset.useMutation();
+	const dispatchWorkflowMutation =
+		electronTrpc.workspaces.dispatchGitHubWorkflow.useMutation();
+
+	const availableAssignees = repositoryOverview?.issueAssignees ?? [];
+	const availableAssigneesByLogin = useMemo(
+		() =>
+			new Map(
+				availableAssignees.map(
+					(assignee) => [assignee.login, assignee] as const,
+				),
+			),
+		[availableAssignees],
+	);
+	const availableLabels = repositoryOverview?.issueLabels ?? [];
+	const filteredAssignees = useMemo(() => {
+		const query = issueAssigneeSearch.trim().toLowerCase();
+		return availableAssignees.filter((candidate) => {
+			if (issueAssignees.includes(candidate.login)) {
+				return false;
+			}
+
+			return query ? candidate.login.toLowerCase().includes(query) : true;
+		});
+	}, [availableAssignees, issueAssigneeSearch, issueAssignees]);
+	const filteredLabels = useMemo(() => {
+		const query = issueLabelSearch.trim().toLowerCase();
+		return availableLabels.filter((candidate) => {
+			if (issueLabels.includes(candidate.name)) {
+				return false;
+			}
+
+			return query
+				? candidate.name.toLowerCase().includes(query) ||
+						candidate.description.toLowerCase().includes(query)
+				: true;
+		});
+	}, [availableLabels, issueLabelSearch, issueLabels]);
+
+	useEffect(() => {
+		if (!repositoryOverview) {
+			return;
+		}
+
+		setWorkflowRef((current) =>
+			current.trim()
+				? current
+				: repositoryOverview.branchExistsOnRemote
+					? repositoryOverview.currentBranch || repositoryOverview.defaultBranch
+					: repositoryOverview.defaultBranch,
+		);
+	}, [
+		repositoryOverview?.branchExistsOnRemote,
+		repositoryOverview?.currentBranch,
+		repositoryOverview?.defaultBranch,
+		repositoryOverview,
+	]);
+
+	useEffect(() => {
+		if (!issueComposerOpen) {
+			setOpenIssuePicker(null);
+			setIssueAssigneeSearch("");
+			setIssueLabelSearch("");
+		}
+	}, [issueComposerOpen]);
+
+	useEffect(() => {
+		if (workspaceId === undefined) {
+			setTrackedWorkflowRuns([]);
+			return;
+		}
+
+		setTrackedWorkflowRuns([]);
+	}, [workspaceId]);
+
+	const openUrl = (url: string) => {
+		if (!workspaceId) {
+			return;
+		}
+
+		addBrowserTab(workspaceId, url);
+	};
+
+	const invalidateOverview = async () => {
+		if (!workspaceId) {
+			return;
+		}
+
+		await trpcUtils.workspaces.getGitHubRepositoryOverview.invalidate({
+			workspaceId,
+		});
+	};
+
+	const handleCreateIssue = async () => {
+		if (!workspaceId || !issueTitle.trim()) {
+			return;
+		}
+
+		try {
+			const result = await createIssueMutation.mutateAsync({
+				workspaceId,
+				title: issueTitle.trim(),
+				body: issueBody.trim() || undefined,
+				assignees: issueAssignees,
+				labels: issueLabels,
+			});
+			setIssueTitle("");
+			setIssueBody("");
+			setIssueAssignees([]);
+			setIssueLabels([]);
+			setUploadedAssets([]);
+			setIssueComposerOpen(false);
+			toast.success("Issue created");
+			if (result.url) {
+				openUrl(result.url);
+			}
+			await invalidateOverview();
+		} catch (mutationError) {
+			const message =
+				mutationError instanceof Error
+					? mutationError.message
+					: "Unknown error";
+			toast.error(`Failed to create issue: ${message}`);
+		}
+	};
+
+	const handleTextareaPaste = async (
+		event: ClipboardEvent<HTMLTextAreaElement>,
+	) => {
+		const files = Array.from(event.clipboardData?.items ?? [])
+			.filter((item) => item.kind === "file")
+			.map((item) => item.getAsFile())
+			.filter((file): file is File => Boolean(file))
+			.filter((file) => file.type.startsWith("image/"));
+
+		if (files.length === 0 || !workspaceId) {
+			return;
+		}
+
+		event.preventDefault();
+		setIsUploadingAsset(true);
+		try {
+			const uploaded: UploadedIssueAsset[] = [];
+			for (const file of files) {
+				const contentBase64 = await readFileAsBase64(file);
+				const result = await uploadIssueAssetMutation.mutateAsync({
+					workspaceId,
+					filename: file.name || `pasted-image-${Date.now()}.png`,
+					contentBase64,
+					mimeType: file.type || undefined,
+				});
+				uploaded.push({
+					id: crypto.randomUUID(),
+					name: result.name,
+					url: result.url,
+					markdown: result.markdown,
+				});
+			}
+
+			setUploadedAssets((current) => [...current, ...uploaded]);
+			setIssueBody((current) => {
+				const prefix = current.trimEnd();
+				const markdown = uploaded.map((asset) => asset.markdown).join("\n");
+				return prefix ? `${prefix}\n\n${markdown}` : markdown;
+			});
+			toast.success(
+				uploaded.length === 1
+					? "Image attached to issue draft"
+					: `${uploaded.length} images attached to issue draft`,
+			);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			toast.error(`Failed to attach image: ${message}`);
+		} finally {
+			setIsUploadingAsset(false);
+		}
+	};
+
+	const removeUploadedAsset = (assetId: string) => {
+		const asset = uploadedAssets.find((item) => item.id === assetId);
+		if (!asset) {
+			return;
+		}
+
+		setUploadedAssets((current) =>
+			current.filter((item) => item.id !== assetId),
+		);
+		setIssueBody((current) => {
+			const next = current
+				.replace(asset.markdown, "")
+				.replace(/\n{3,}/g, "\n\n");
+			return next.trim();
+		});
+	};
+
+	const handleRunWorkflow = async (
+		workflowId: number,
+		workflowName: string,
+	) => {
+		if (!workspaceId) {
+			return;
+		}
+
+		setPendingWorkflowId(workflowId);
+		try {
+			const result = await dispatchWorkflowMutation.mutateAsync({
+				workspaceId,
+				workflowId,
+				ref: workflowRef.trim() || undefined,
+			});
+			setTrackedWorkflowRuns((current) =>
+				[
+					{
+						workflowId,
+						workflowName,
+						ref: result.ref,
+						dispatchedAt: result.dispatchedAt,
+					},
+					...current.filter((item) => item.workflowId !== workflowId),
+				].slice(0, 4),
+			);
+			toast.success(`Triggered ${workflowName} on ${result.ref}`);
+		} catch (mutationError) {
+			const message =
+				mutationError instanceof Error
+					? mutationError.message
+					: "Unknown error";
+			toast.error(`Failed to run workflow: ${message}`);
+		} finally {
+			setPendingWorkflowId((current) =>
+				current === workflowId ? null : current,
+			);
+		}
+	};
+
+	return (
+		<Collapsible open={open} onOpenChange={setOpen}>
+			<CollapsibleTrigger
+				className={cn(
+					"flex h-8 w-full items-center justify-between gap-2 border-b bg-background px-3 text-left text-xs font-medium text-foreground",
+					"transition-colors hover:bg-accent/30",
+				)}
+			>
+				<div className="flex min-w-0 items-center gap-2">
+					<LuChevronDown
+						className={cn(
+							"size-3 shrink-0 text-muted-foreground transition-transform duration-150",
+							!open && "-rotate-90",
+						)}
+					/>
+					<span>Repository</span>
+					{repositoryOverview?.repositoryNameWithOwner ? (
+						<span className="truncate text-[11px] font-normal text-muted-foreground">
+							{repositoryOverview.repositoryNameWithOwner}
+						</span>
+					) : null}
+				</div>
+				{isLoading ? (
+					<LuLoaderCircle className="size-3 animate-spin text-muted-foreground" />
+				) : null}
+			</CollapsibleTrigger>
+			<CollapsibleContent className="overflow-hidden border-b bg-background">
+				<div className="space-y-3 px-3 py-3">
+					{isLoading ? (
+						<div className="space-y-2">
+							<Skeleton className="h-4 w-40" />
+							<Skeleton className="h-8 w-full" />
+							<Skeleton className="h-16 w-full" />
+						</div>
+					) : error || !repositoryOverview ? (
+						<div className="rounded-sm border border-dashed border-border/70 px-3 py-2 text-xs text-muted-foreground">
+							GitHub repository is not available for this workspace.
+						</div>
+					) : (
+						<>
+							<div className="flex flex-wrap items-center gap-2">
+								<div className="min-w-0 flex-1">
+									<p className="truncate text-sm font-medium text-foreground">
+										{repositoryOverview.repositoryNameWithOwner}
+									</p>
+									<p className="truncate text-[11px] text-muted-foreground">
+										Branch {repositoryOverview.currentBranch}
+									</p>
+									{repositoryOverview.isFork ? (
+										<p className="truncate text-[11px] text-muted-foreground">
+											Upstream {repositoryOverview.upstreamNameWithOwner}
+										</p>
+									) : null}
+								</div>
+								{repositoryOverview.isFork ? (
+									<Badge variant="secondary">Fork</Badge>
+								) : null}
+								<Badge variant="outline">
+									Default {repositoryOverview.defaultBranch}
+								</Badge>
+							</div>
+
+							<div className="grid grid-cols-2 gap-2">
+								<Button
+									type="button"
+									variant="outline"
+									size="sm"
+									className="justify-start gap-1.5"
+									onClick={() => openUrl(repositoryOverview.repositoryUrl)}
+								>
+									<LuArrowUpRight className="size-3.5" />
+									Repo
+								</Button>
+								<Button
+									type="button"
+									variant="outline"
+									size="sm"
+									className="justify-start gap-1.5"
+									onClick={() => openUrl(repositoryOverview.pullsUrl)}
+								>
+									<LuGitPullRequest className="size-3.5" />
+									Pull Requests
+								</Button>
+								<Button
+									type="button"
+									variant="outline"
+									size="sm"
+									className="justify-start gap-1.5"
+									onClick={() => openUrl(repositoryOverview.issuesUrl)}
+								>
+									<LuFilePlus2 className="size-3.5" />
+									Issues
+								</Button>
+								<Button
+									type="button"
+									variant="outline"
+									size="sm"
+									className="justify-start gap-1.5"
+									onClick={() => openUrl(repositoryOverview.actionsUrl)}
+								>
+									<LuWorkflow className="size-3.5" />
+									Actions
+								</Button>
+							</div>
+
+							<div className="space-y-2 rounded-sm border border-border/60 bg-muted/10 p-2">
+								<div className="flex items-center justify-between gap-2">
+									<p className="text-xs font-medium text-foreground">
+										New Issue
+									</p>
+									<Button
+										type="button"
+										variant="ghost"
+										size="sm"
+										className="h-6 px-2 text-[11px]"
+										onClick={() => setIssueComposerOpen((current) => !current)}
+									>
+										{issueComposerOpen ? "Hide" : "Compose"}
+									</Button>
+								</div>
+								{issueComposerOpen ? (
+									<div className="space-y-2">
+										<Input
+											value={issueTitle}
+											onChange={(event) => setIssueTitle(event.target.value)}
+											placeholder="Issue title"
+										/>
+										<div className="grid grid-cols-2 gap-2">
+											<Popover
+												open={openIssuePicker === "assignees"}
+												onOpenChange={(nextOpen) => {
+													setOpenIssuePicker(nextOpen ? "assignees" : null);
+													if (!nextOpen) {
+														setIssueAssigneeSearch("");
+													}
+												}}
+											>
+												<PopoverTrigger asChild>
+													<button
+														type="button"
+														className="flex h-9 items-center gap-2 rounded-md border border-border/60 bg-background px-3 text-left text-xs transition-colors hover:bg-accent/30"
+													>
+														<LuUserPlus className="size-3.5 shrink-0 text-muted-foreground" />
+														<span className="truncate">
+															{buildSelectionSummary(
+																issueAssignees,
+																"Assignees",
+															)}
+														</span>
+														<LuChevronDown className="ml-auto size-3 shrink-0 text-muted-foreground" />
+													</button>
+												</PopoverTrigger>
+												<PopoverContent align="start" className="w-72 p-0">
+													<Command shouldFilter={false}>
+														<CommandInput
+															placeholder="Search assignees..."
+															value={issueAssigneeSearch}
+															onValueChange={setIssueAssigneeSearch}
+														/>
+														<CommandList className="max-h-64">
+															{issueAssignees.length > 0 ? (
+																<CommandGroup heading="Selected">
+																	{issueAssignees.map((assignee) => (
+																		<CommandItem
+																			key={`selected-assignee-${assignee}`}
+																			onSelect={() =>
+																				setIssueAssignees((current) =>
+																					current.filter(
+																						(item) => item !== assignee,
+																					),
+																				)
+																			}
+																		>
+																			<Avatar
+																				size="xs"
+																				fullName={assignee}
+																				image={
+																					availableAssigneesByLogin.get(
+																						assignee,
+																					)?.avatarUrl
+																				}
+																			/>
+																			<LuCheck className="size-3.5 text-primary" />
+																			<span className="flex-1 truncate">
+																				{assignee}
+																			</span>
+																			<LuX className="size-3.5 text-muted-foreground" />
+																		</CommandItem>
+																	))}
+																</CommandGroup>
+															) : null}
+															{filteredAssignees.length === 0 ? (
+																<CommandEmpty>No assignees found.</CommandEmpty>
+															) : (
+																<CommandGroup heading="Available">
+																	{filteredAssignees.map((assignee) => (
+																		<CommandItem
+																			key={assignee.login}
+																			onSelect={() =>
+																				setIssueAssignees((current) => [
+																					...current,
+																					assignee.login,
+																				])
+																			}
+																		>
+																			<Avatar
+																				size="xs"
+																				fullName={assignee.login}
+																				image={assignee.avatarUrl}
+																			/>
+																			<span className="truncate">
+																				{assignee.login}
+																			</span>
+																		</CommandItem>
+																	))}
+																</CommandGroup>
+															)}
+														</CommandList>
+													</Command>
+												</PopoverContent>
+											</Popover>
+											<Popover
+												open={openIssuePicker === "labels"}
+												onOpenChange={(nextOpen) => {
+													setOpenIssuePicker(nextOpen ? "labels" : null);
+													if (!nextOpen) {
+														setIssueLabelSearch("");
+													}
+												}}
+											>
+												<PopoverTrigger asChild>
+													<button
+														type="button"
+														className="flex h-9 items-center gap-2 rounded-md border border-border/60 bg-background px-3 text-left text-xs transition-colors hover:bg-accent/30"
+													>
+														<LuTag className="size-3.5 shrink-0 text-muted-foreground" />
+														<span className="truncate">
+															{buildSelectionSummary(issueLabels, "Labels")}
+														</span>
+														<LuChevronDown className="ml-auto size-3 shrink-0 text-muted-foreground" />
+													</button>
+												</PopoverTrigger>
+												<PopoverContent align="start" className="w-72 p-0">
+													<Command shouldFilter={false}>
+														<CommandInput
+															placeholder="Search labels..."
+															value={issueLabelSearch}
+															onValueChange={setIssueLabelSearch}
+														/>
+														<CommandList className="max-h-64">
+															{issueLabels.length > 0 ? (
+																<CommandGroup heading="Selected">
+																	{issueLabels.map((label) => (
+																		<CommandItem
+																			key={`selected-label-${label}`}
+																			onSelect={() =>
+																				setIssueLabels((current) =>
+																					current.filter(
+																						(item) => item !== label,
+																					),
+																				)
+																			}
+																		>
+																			<LuCheck className="size-3.5 text-primary" />
+																			<span className="flex-1 truncate">
+																				{label}
+																			</span>
+																			<LuX className="size-3.5 text-muted-foreground" />
+																		</CommandItem>
+																	))}
+																</CommandGroup>
+															) : null}
+															{filteredLabels.length === 0 ? (
+																<CommandEmpty>No labels found.</CommandEmpty>
+															) : (
+																<CommandGroup heading="Available">
+																	{filteredLabels.map((label) => (
+																		<CommandItem
+																			key={label.name}
+																			onSelect={() =>
+																				setIssueLabels((current) => [
+																					...current,
+																					label.name,
+																				])
+																			}
+																		>
+																			<span
+																				className="size-2.5 rounded-full"
+																				style={{
+																					backgroundColor: `#${label.color}`,
+																				}}
+																			/>
+																			<div className="flex min-w-0 flex-1 flex-col">
+																				<span className="truncate">
+																					{label.name}
+																				</span>
+																				{label.description ? (
+																					<span className="truncate text-[11px] text-muted-foreground">
+																						{label.description}
+																					</span>
+																				) : null}
+																			</div>
+																		</CommandItem>
+																	))}
+																</CommandGroup>
+															)}
+														</CommandList>
+													</Command>
+												</PopoverContent>
+											</Popover>
+										</div>
+										{issueAssignees.length > 0 || issueLabels.length > 0 ? (
+											<div className="flex flex-wrap gap-1">
+												{issueAssignees.map((assignee) => (
+													<Badge
+														key={`assignee-badge-${assignee}`}
+														variant="outline"
+														className="gap-1"
+													>
+														<Avatar
+															size="xs"
+															fullName={assignee}
+															image={
+																availableAssigneesByLogin.get(assignee)
+																	?.avatarUrl
+															}
+														/>
+														{assignee}
+													</Badge>
+												))}
+												{issueLabels.map((label) => (
+													<Badge
+														key={`label-badge-${label}`}
+														variant="secondary"
+														className="gap-1"
+													>
+														<LuTag className="size-3" />
+														{label}
+													</Badge>
+												))}
+											</div>
+										) : null}
+										<Textarea
+											value={issueBody}
+											onChange={(event) => setIssueBody(event.target.value)}
+											onPaste={(event) => {
+												void handleTextareaPaste(event);
+											}}
+											placeholder="Issue description. Paste images from clipboard to attach."
+											className="min-h-20 resize-y"
+										/>
+										{isUploadingAsset ? (
+											<div className="flex items-center gap-2 text-[11px] text-muted-foreground">
+												<LuLoaderCircle className="size-3 animate-spin" />
+												Uploading pasted image...
+											</div>
+										) : null}
+										{uploadedAssets.length > 0 ? (
+											<div className="space-y-1 rounded-sm border border-border/60 bg-background px-2 py-2">
+												<div className="flex items-center gap-2 text-[11px] font-medium text-foreground">
+													<LuImage className="size-3.5" />
+													Attached Images
+												</div>
+												<div className="space-y-1">
+													{uploadedAssets.map((asset) => (
+														<div
+															key={asset.id}
+															className="flex items-center justify-between gap-2 rounded-sm border border-border/50 px-2 py-1"
+														>
+															<button
+																type="button"
+																className="min-w-0 flex-1 truncate text-left text-[11px] text-foreground transition-colors hover:text-primary"
+																onClick={() => openUrl(asset.url)}
+															>
+																{asset.name}
+															</button>
+															<Button
+																type="button"
+																variant="ghost"
+																size="sm"
+																className="h-6 px-1.5 text-[10px]"
+																onClick={() => removeUploadedAsset(asset.id)}
+															>
+																<LuX className="size-3" />
+															</Button>
+														</div>
+													))}
+												</div>
+											</div>
+										) : null}
+										<div className="flex items-center justify-between gap-2">
+											<Button
+												type="button"
+												variant="ghost"
+												size="sm"
+												className="h-7 px-2 text-[11px]"
+												onClick={() => openUrl(repositoryOverview.newIssueUrl)}
+											>
+												Open in GitHub
+											</Button>
+											<Button
+												type="button"
+												size="sm"
+												className="h-7 px-2 text-[11px]"
+												onClick={() => {
+													void handleCreateIssue();
+												}}
+												disabled={
+													createIssueMutation.isPending ||
+													isUploadingAsset ||
+													!issueTitle.trim()
+												}
+											>
+												{createIssueMutation.isPending ? (
+													<LuLoaderCircle className="mr-1 size-3 animate-spin" />
+												) : null}
+												Create Issue
+											</Button>
+										</div>
+									</div>
+								) : null}
+							</div>
+
+							<div className="space-y-1.5">
+								<div className="flex items-center justify-between gap-2">
+									<p className="text-xs font-medium text-foreground">
+										Open Pull Requests
+									</p>
+									<span className="text-[11px] text-muted-foreground">
+										{repositoryOverview.pullRequests.length}
+									</span>
+								</div>
+								{repositoryOverview.pullRequests.length === 0 ? (
+									<p className="text-xs text-muted-foreground">
+										No open pull requests.
+									</p>
+								) : (
+									<div className="space-y-1">
+										{repositoryOverview.pullRequests.map((pullRequest) => (
+											<button
+												key={pullRequest.number}
+												type="button"
+												className="flex w-full items-start justify-between gap-2 rounded-sm border border-border/50 px-2 py-1.5 text-left transition-colors hover:bg-accent/40"
+												onClick={() => openUrl(pullRequest.url)}
+											>
+												<div className="min-w-0 flex-1">
+													<p className="truncate text-xs font-medium text-foreground">
+														#{pullRequest.number} {pullRequest.title}
+													</p>
+													<p className="truncate text-[11px] text-muted-foreground">
+														{pullRequest.headRefName}
+														{pullRequest.authorLogin
+															? ` by ${pullRequest.authorLogin}`
+															: ""}
+													</p>
+												</div>
+												<div className="shrink-0 text-right">
+													<p className="text-[10px] uppercase text-muted-foreground">
+														{pullRequest.state}
+													</p>
+													<p className="text-[10px] text-muted-foreground">
+														{formatRepositoryTimestamp(pullRequest.updatedAt)}
+													</p>
+												</div>
+											</button>
+										))}
+									</div>
+								)}
+							</div>
+
+							<div className="space-y-1.5">
+								<div className="flex items-center justify-between gap-2">
+									<p className="text-xs font-medium text-foreground">
+										Workflows
+									</p>
+									<span className="text-[11px] text-muted-foreground">
+										{repositoryOverview.workflows.length}
+									</span>
+								</div>
+								{workspaceId && trackedWorkflowRuns.length > 0 ? (
+									<div className="space-y-1">
+										<p className="text-[11px] font-medium text-muted-foreground">
+											Recent Runs
+										</p>
+										{trackedWorkflowRuns.map((tracked) => (
+											<WorkflowRunCard
+												key={`${tracked.workflowId}-${tracked.dispatchedAt}`}
+												workspaceId={workspaceId}
+												tracked={tracked}
+												onOpenUrl={openUrl}
+												onRemove={(workflowId) => {
+													setTrackedWorkflowRuns((current) =>
+														current.filter(
+															(item) => item.workflowId !== workflowId,
+														),
+													);
+												}}
+											/>
+										))}
+									</div>
+								) : null}
+								<Input
+									value={workflowRef}
+									onChange={(event) => setWorkflowRef(event.target.value)}
+									placeholder="Branch or ref to run"
+								/>
+								{repositoryOverview.workflows.length === 0 ? (
+									<p className="text-xs text-muted-foreground">
+										No workflows available.
+									</p>
+								) : (
+									<div className="space-y-1">
+										{repositoryOverview.workflows.map((workflow) => (
+											<div
+												key={workflow.id}
+												className="flex items-center justify-between gap-2 rounded-sm border border-border/50 px-2 py-1.5"
+											>
+												<div className="min-w-0 flex-1">
+													<p className="truncate text-xs font-medium text-foreground">
+														{workflow.name}
+													</p>
+													<p className="truncate text-[11px] text-muted-foreground">
+														{workflow.path || workflow.state}
+													</p>
+												</div>
+												<Button
+													type="button"
+													variant="outline"
+													size="sm"
+													className="h-7 shrink-0 px-2 text-[11px]"
+													onClick={() => {
+														void handleRunWorkflow(workflow.id, workflow.name);
+													}}
+													disabled={
+														pendingWorkflowId === workflow.id ||
+														!workflowRef.trim()
+													}
+												>
+													{pendingWorkflowId === workflow.id ? (
+														<LuLoaderCircle className="mr-1 size-3 animate-spin" />
+													) : (
+														<LuPlay className="mr-1 size-3" />
+													)}
+													Run
+												</Button>
+											</div>
+										))}
+									</div>
+								)}
+							</div>
+						</>
+					)}
+				</div>
+			</CollapsibleContent>
+		</Collapsible>
+	);
+}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/ChangesView/components/RepositoryPanel/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/ChangesView/components/RepositoryPanel/index.ts
new file mode 100644
index 00000000000..74ade422de9
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/ChangesView/components/RepositoryPanel/index.ts
@@ -0,0 +1 @@
+export { RepositoryPanel } from "./RepositoryPanel";
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/ChangesView/components/ReviewPanel/ReviewPanel.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/ChangesView/components/ReviewPanel/ReviewPanel.tsx
index 5668c30ff51..146922185bd 100644
--- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/ChangesView/components/ReviewPanel/ReviewPanel.tsx
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/ChangesView/components/ReviewPanel/ReviewPanel.tsx
@@ -1,4 +1,5 @@
 import type { GitHubStatus, PullRequestComment } from "@superset/local-db";
+import { Avatar as UserAvatar } from "@superset/ui/atoms/Avatar";
 import { Avatar, AvatarFallback, AvatarImage } from "@superset/ui/avatar";
 import { Button } from "@superset/ui/button";
 import {
@@ -25,6 +26,7 @@ import {
 	LuCode,
 	LuCopy,
 	LuLoaderCircle,
+	LuRefreshCw,
 	LuX,
 } from "react-icons/lu";
 import { VscChevronRight } from "react-icons/vsc";
@@ -175,9 +177,14 @@ export function ReviewPanel({
 		electronTrpc.workspaces.updatePullRequestReviewers.useMutation();
 	const updatePullRequestAssigneesMutation =
 		electronTrpc.workspaces.updatePullRequestAssignees.useMutation();
+	const rerunPullRequestChecksMutation =
+		electronTrpc.workspaces.rerunPullRequestChecks.useMutation();
 	const candidateKind =
 		identityPopoverOpen === "assignees" ? "assignee" : "reviewer";
 	const canEditPullRequest = pr?.state === "open" || pr?.state === "draft";
+	const [pendingRerunMode, setPendingRerunMode] = useState<
+		"all" | "failed" | null
+	>(null);
 	const {
 		data: identityCandidates = [],
 		isLoading: isIdentityCandidatesLoading,
@@ -495,6 +502,12 @@ export function ReviewPanel({
 	const checksStatus = relevantChecks.length > 0 ? pr.checksStatus : "none";
 	const checksStatusConfig = checkSummaryIconConfig[checksStatus];
 	const ChecksStatusIcon = checksStatusConfig.icon;
+	const actionChecks = relevantChecks.filter((check) =>
+		isActionsRunUrl(check.url),
+	);
+	const failedActionChecks = actionChecks.filter(
+		(check) => check.status === "failure",
+	);
 	const { active: activeComments, resolved: resolvedComments } =
 		splitPullRequestComments(comments);
 	const commentsCountLabel = isCommentsLoading ? "..." : comments.length;
@@ -509,6 +522,31 @@ export function ReviewPanel({
 		});
 	};
 
+	const handleRerunChecks = async (mode: "all" | "failed") => {
+		if (!resolvedWorkspaceId || pendingRerunMode) {
+			return;
+		}
+
+		setPendingRerunMode(mode);
+		try {
+			const result = await rerunPullRequestChecksMutation.mutateAsync({
+				workspaceId: resolvedWorkspaceId,
+				mode,
+			});
+			toast.success(
+				mode === "failed"
+					? `Re-ran failed jobs for ${result.rerunCount} workflow run${result.rerunCount === 1 ? "" : "s"}`
+					: `Re-ran ${result.rerunCount} workflow run${result.rerunCount === 1 ? "" : "s"}`,
+			);
+			await refreshReview("status");
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			toast.error(`Failed to rerun jobs: ${message}`);
+		} finally {
+			setPendingRerunMode((current) => (current === mode ? null : current));
+		}
+	};
+
 	const updateReviewers = async ({
 		add = [],
 		remove = [],
@@ -633,8 +671,13 @@ export function ReviewPanel({
 		void updateAssignees({ add: [candidate] });
 	};
 
-	const isActionsUrl = (url?: string) =>
-		url ? /\/actions\/runs\/\d+\/job\/\d+/.test(url) : false;
+	function isActionsJobUrl(url?: string) {
+		return url ? /\/actions\/runs\/\d+\/job\/\d+/.test(url) : false;
+	}
+
+	function isActionsRunUrl(url?: string) {
+		return url ? /\/actions\/runs\/\d+(?:\/|$)/.test(url) : false;
+	}
 
 	const renderIdentitySection = ({
 		label,
@@ -653,13 +696,20 @@ export function ReviewPanel({
 		const searchValue =
 			pendingGroup === "assignees" ? assigneeSearch : reviewerSearch;
 		const existingItems = new Set(items.map((item) => item.toLowerCase()));
+		const identityCandidatesByLogin = new Map(
+			identityCandidates.map(
+				(candidate) => [candidate.login.toLowerCase(), candidate] as const,
+			),
+		);
 		const query = searchValue.trim().toLowerCase();
 		const filteredCandidates = !isOpen
 			? []
 			: identityCandidates
-					.filter((candidate) => !existingItems.has(candidate.toLowerCase()))
+					.filter(
+						(candidate) => !existingItems.has(candidate.login.toLowerCase()),
+					)
 					.filter((candidate) =>
-						query ? candidate.toLowerCase().includes(query) : true,
+						query ? candidate.login.toLowerCase().includes(query) : true,
 					)
 					.slice(0, 8);
 
@@ -740,6 +790,14 @@ export function ReviewPanel({
 												className="flex items-center justify-between gap-2 text-xs"
 											>
 												<div className="flex min-w-0 items-center gap-2">
+													<UserAvatar
+														size="xs"
+														fullName={item}
+														image={
+															identityCandidatesByLogin.get(item.toLowerCase())
+																?.avatarUrl
+														}
+													/>
 													<LuCheck className="size-3.5 shrink-0 text-primary" />
 													<span className="truncate">{item}</span>
 												</div>
@@ -749,13 +807,22 @@ export function ReviewPanel({
 									: null}
 								{filteredCandidates.map((candidate) => (
 									<CommandItem
-										key={`${pendingGroup}-${candidate}`}
-										value={candidate}
+										key={`${pendingGroup}-${candidate.login}`}
+										value={candidate.login}
 										disabled={isPending}
-										onSelect={() => handleAddCandidate(pendingGroup, candidate)}
+										onSelect={() =>
+											handleAddCandidate(pendingGroup, candidate.login)
+										}
 										className="flex items-center justify-between gap-2 text-xs"
 									>
-										<span className="truncate">{candidate}</span>
+										<div className="flex min-w-0 items-center gap-2">
+											<UserAvatar
+												size="xs"
+												fullName={candidate.login}
+												image={candidate.avatarUrl}
+											/>
+											<span className="truncate">{candidate.login}</span>
+										</div>
 										<LuCheck className="size-3.5 shrink-0 opacity-0" />
 									</CommandItem>
 								))}
@@ -1017,6 +1084,46 @@ export function ReviewPanel({
 					</div>
 				</CollapsibleTrigger>
 				<CollapsibleContent className="px-0.5 pb-1 min-w-0 overflow-hidden">
+					{actionChecks.length > 0 ? (
+						<div className="flex flex-wrap items-center justify-end gap-1 px-1.5 py-1">
+							<Button
+								type="button"
+								variant="outline"
+								size="sm"
+								className="h-6 px-2 text-[10px]"
+								onClick={() => {
+									void handleRerunChecks("failed");
+								}}
+								disabled={
+									pendingRerunMode !== null || failedActionChecks.length === 0
+								}
+							>
+								{pendingRerunMode === "failed" ? (
+									<LuLoaderCircle className="mr-1 size-3 animate-spin" />
+								) : (
+									<LuRefreshCw className="mr-1 size-3" />
+								)}
+								Re-run failed jobs
+							</Button>
+							<Button
+								type="button"
+								variant="outline"
+								size="sm"
+								className="h-6 px-2 text-[10px]"
+								onClick={() => {
+									void handleRerunChecks("all");
+								}}
+								disabled={pendingRerunMode !== null}
+							>
+								{pendingRerunMode === "all" ? (
+									<LuLoaderCircle className="mr-1 size-3 animate-spin" />
+								) : (
+									<LuRefreshCw className="mr-1 size-3" />
+								)}
+								Re-run all jobs
+							</Button>
+						</div>
+					) : null}
 					{relevantChecks.length === 0 ? (
 						<div className="px-1.5 py-1 text-xs text-muted-foreground">
 							No checks reported.
@@ -1027,7 +1134,7 @@ export function ReviewPanel({
 								checkIconConfig[check.status];
 							const checkUrl = resolveCheckDestinationUrl(check, pr.url);
 							const isCheckExpanded = expandedChecks.has(check.name);
-							const canExpand = isActionsUrl(check.url);
+							const canExpand = isActionsJobUrl(check.url);
 
 							return (
 								<div key={check.name}>
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/DatabasesView/DatabasesView.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/DatabasesView/DatabasesView.tsx
new file mode 100644
index 00000000000..f2e6f08cb60
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/DatabasesView/DatabasesView.tsx
@@ -0,0 +1,3446 @@
+import { Alert, AlertDescription, AlertTitle } from "@superset/ui/alert";
+import { Badge } from "@superset/ui/badge";
+import { Button } from "@superset/ui/button";
+import { Checkbox } from "@superset/ui/checkbox";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@superset/ui/collapsible";
+import {
+	ContextMenu,
+	ContextMenuContent,
+	ContextMenuItem,
+	ContextMenuSeparator,
+	ContextMenuTrigger,
+} from "@superset/ui/context-menu";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogFooter,
+	DialogHeader,
+	DialogTitle,
+} from "@superset/ui/dialog";
+import {
+	Empty,
+	EmptyContent,
+	EmptyDescription,
+	EmptyHeader,
+	EmptyMedia,
+	EmptyTitle,
+} from "@superset/ui/empty";
+import { Input } from "@superset/ui/input";
+import { Label } from "@superset/ui/label";
+import { Popover, PopoverContent, PopoverTrigger } from "@superset/ui/popover";
+import {
+	ResizableHandle,
+	ResizablePanel,
+	ResizablePanelGroup,
+} from "@superset/ui/resizable";
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from "@superset/ui/select";
+import { toast } from "@superset/ui/sonner";
+import { Switch } from "@superset/ui/switch";
+import {
+	Table,
+	TableBody,
+	TableCell,
+	TableHead,
+	TableHeader,
+	TableRow,
+} from "@superset/ui/table";
+import { Textarea } from "@superset/ui/textarea";
+import { cn } from "@superset/ui/utils";
+import { defaultRangeExtractor, useVirtualizer } from "@tanstack/react-virtual";
+import {
+	memo,
+	startTransition,
+	useCallback,
+	useDeferredValue,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import {
+	LuArrowDown,
+	LuArrowUp,
+	LuArrowUpDown,
+	LuChevronDown,
+	LuChevronRight,
+	LuCopy,
+	LuDatabase,
+	LuEraser,
+	LuExternalLink,
+	LuEye,
+	LuEyeOff,
+	LuFilter,
+	LuPencil,
+	LuPlay,
+	LuPlus,
+	LuRefreshCw,
+	LuSearch,
+	LuTable2,
+	LuTrash2,
+	LuX,
+} from "react-icons/lu";
+import { MarkdownRenderer } from "renderer/components/MarkdownRenderer/MarkdownRenderer";
+import { useCopyToClipboard } from "renderer/hooks/useCopyToClipboard";
+import { electronTrpc } from "renderer/lib/electron-trpc";
+import { useWorkspaceId } from "renderer/screens/main/components/WorkspaceView/WorkspaceIdContext";
+import {
+	type SavedDatabaseConnection,
+	type SavedDatabaseQueryHistoryItem,
+	useDatabaseSidebarStore,
+} from "renderer/stores/database-sidebar";
+import { toAbsoluteWorkspacePath } from "shared/absolute-paths";
+
+const SQLITE_ROW_ID_COLUMN = "__superset_rowid";
+const SQLITE_PRIMARY_KEY_COLUMN = "__superset_primary_key";
+const POSTGRES_ROW_ID_COLUMN = "__superset_ctid";
+
+const SQLITE_DEFAULT_SQL = [
+	"SELECT name",
+	"FROM sqlite_master",
+	"WHERE type = 'table'",
+	"ORDER BY name;",
+].join("\n");
+
+const POSTGRES_DEFAULT_SQL = [
+	"SELECT table_schema, table_name",
+	"FROM information_schema.tables",
+	"WHERE table_schema NOT IN ('pg_catalog', 'information_schema')",
+	"ORDER BY table_schema, table_name",
+	"LIMIT 50;",
+].join("\n");
+
+const TABLE_PREVIEW_PAGE_SIZE = 15;
+const TABLE_PREVIEW_ROW_HEIGHT = 34;
+const TABLE_PREVIEW_OVERSCAN = 10;
+
+type ConnectionDialect = "sqlite" | "postgres";
+
+interface QueryResult {
+	columns: string[];
+	rows: Array<Record<string, unknown>>;
+	rowCount: number;
+	truncated: boolean;
+	elapsedMs: number;
+	command?: string;
+	lastInsertRowid?: string | number;
+}
+
+interface EditableCellState {
+	mode: "edit" | "insert" | "duplicate";
+	row: Record<string, unknown>;
+	column: string;
+	value: unknown;
+}
+
+interface RowDraftValue {
+	value: string;
+	isNull: boolean;
+}
+
+interface ContextCellState {
+	row: Record<string, unknown>;
+	column: string;
+	display: string;
+	title: string;
+}
+
+interface PendingEditRequest {
+	row: Record<string, unknown>;
+	column?: string;
+	mode?: EditableCellState["mode"];
+}
+
+interface TableSortState {
+	column: string;
+	direction: "asc" | "desc";
+}
+
+interface CellDetailState {
+	row: Record<string, unknown>;
+	column: string;
+	columnType: string;
+	value: unknown;
+	format: "text" | "json" | "markdown";
+	draft: string;
+}
+
+function isAbsoluteFilesystemPath(inputPath: string): boolean {
+	return inputPath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(inputPath);
+}
+
+function resolveSQLiteDatabasePath(
+	rawPath: string,
+	worktreePath?: string,
+): string | null {
+	const trimmedPath = rawPath.trim();
+	if (!trimmedPath) return null;
+	if (isAbsoluteFilesystemPath(trimmedPath)) return trimmedPath;
+	if (!worktreePath) return null;
+	return toAbsoluteWorkspacePath(worktreePath, trimmedPath);
+}
+
+function guessConnectionLabel(databasePath: string): string {
+	return databasePath.split(/[/\\]/).pop() ?? databasePath;
+}
+
+function guessPostgresLabel(connectionString: string): string {
+	try {
+		const url = new URL(connectionString);
+		const databaseName = url.pathname.replace(/^\//, "");
+		return databaseName ? `${url.hostname}/${databaseName}` : url.hostname;
+	} catch {
+		return "PostgreSQL";
+	}
+}
+
+function buildPostgresConnectionString(input: {
+	host: string;
+	port: string;
+	username: string;
+	password: string;
+	database?: string;
+	ssl: boolean;
+}): string {
+	const auth =
+		input.password.trim().length > 0
+			? `${encodeURIComponent(input.username)}:${encodeURIComponent(input.password)}`
+			: encodeURIComponent(input.username);
+	const query = input.ssl ? "?sslmode=require" : "";
+	const databaseName = input.database?.trim() || "postgres";
+
+	return `postgres://${auth}@${input.host}:${input.port}/${databaseName}${query}`;
+}
+
+function parsePostgresConnectionString(connectionString: string): {
+	host: string;
+	port: string;
+	username: string;
+	password: string;
+	database: string;
+	ssl: boolean;
+} | null {
+	try {
+		const url = new URL(connectionString);
+		return {
+			host: url.hostname,
+			port: url.port || "5432",
+			username: decodeURIComponent(url.username),
+			password: decodeURIComponent(url.password),
+			database: url.pathname.replace(/^\//, "") || "postgres",
+			ssl: url.searchParams.get("sslmode") === "require",
+		};
+	} catch {
+		return null;
+	}
+}
+
+function formatCellValue(value: unknown): string {
+	if (value === null) return "null";
+	if (value === undefined) return "";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") {
+		return String(value);
+	}
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}
+
+function quoteSqlIdentifier(identifier: string): string {
+	return `"${identifier.replaceAll('"', '""')}"`;
+}
+
+function toSqlLiteral(value: unknown, dialect: ConnectionDialect): string {
+	if (value === null || value === undefined) return "NULL";
+	if (typeof value === "number") {
+		return Number.isFinite(value) ? String(value) : `'${String(value)}'`;
+	}
+	if (typeof value === "bigint") return value.toString();
+	if (typeof value === "boolean") {
+		if (dialect === "sqlite") {
+			return value ? "1" : "0";
+		}
+		return value ? "TRUE" : "FALSE";
+	}
+	if (typeof value === "string") {
+		return `'${value.replaceAll("'", "''")}'`;
+	}
+	if (value instanceof Date) {
+		return `'${value.toISOString().replaceAll("'", "''")}'`;
+	}
+	return `'${JSON.stringify(value).replaceAll("'", "''")}'`;
+}
+
+function getRowIdentifier(
+	row: Record<string, unknown>,
+	dialect: ConnectionDialect,
+): string | null {
+	const identifier =
+		dialect === "sqlite"
+			? (row[SQLITE_PRIMARY_KEY_COLUMN] ?? row[SQLITE_ROW_ID_COLUMN])
+			: row[POSTGRES_ROW_ID_COLUMN];
+
+	if (identifier === undefined || identifier === null) {
+		return null;
+	}
+
+	return String(identifier);
+}
+
+function matchesSearchValue(value: unknown, query: string): boolean {
+	if (!query) return true;
+	return formatCellValue(value).toLowerCase().includes(query);
+}
+
+function comparePreviewValues(left: unknown, right: unknown): number {
+	if (left === right) return 0;
+	if (left === null || left === undefined) return 1;
+	if (right === null || right === undefined) return -1;
+	if (typeof left === "number" && typeof right === "number") {
+		return left - right;
+	}
+	if (typeof left === "boolean" && typeof right === "boolean") {
+		return Number(left) - Number(right);
+	}
+	if (left instanceof Date && right instanceof Date) {
+		return left.getTime() - right.getTime();
+	}
+
+	return formatCellValue(left).localeCompare(
+		formatCellValue(right),
+		undefined,
+		{
+			numeric: true,
+			sensitivity: "base",
+		},
+	);
+}
+
+function toCsvCell(value: unknown): string {
+	const stringValue = formatCellValue(value);
+	return `"${stringValue.replaceAll('"', '""')}"`;
+}
+
+function normalizeColumnType(type: string | null | undefined): string {
+	return (type ?? "").toLowerCase();
+}
+
+function supportsDetailViewer(columnType: string, value: unknown): boolean {
+	const normalizedType = normalizeColumnType(columnType);
+	if (
+		normalizedType.includes("json") ||
+		normalizedType.includes("text") ||
+		normalizedType.includes("char") ||
+		normalizedType.includes("citext") ||
+		normalizedType.includes("xml") ||
+		normalizedType.includes("array") ||
+		normalizedType.includes("bytea") ||
+		normalizedType.includes("blob") ||
+		normalizedType.includes("vector") ||
+		normalizedType.includes("hstore") ||
+		normalizedType.includes("geometry") ||
+		normalizedType.includes("geography") ||
+		normalizedType.includes("tsvector") ||
+		normalizedType.includes("tsquery")
+	) {
+		return true;
+	}
+
+	return typeof value === "string" && value.length > 80;
+}
+
+function canUseJsonDetailFormat(columnType: string, value: unknown): boolean {
+	const normalizedType = normalizeColumnType(columnType);
+	if (
+		normalizedType.includes("json") ||
+		normalizedType.includes("array") ||
+		Array.isArray(value) ||
+		(typeof value === "object" && value !== null)
+	) {
+		return true;
+	}
+
+	if (typeof value !== "string") {
+		return false;
+	}
+
+	try {
+		JSON.parse(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function canUseMarkdownDetailFormat(
+	columnType: string,
+	value: unknown,
+): boolean {
+	const normalizedType = normalizeColumnType(columnType);
+	if (
+		normalizedType.includes("json") ||
+		normalizedType.includes("array") ||
+		normalizedType.includes("bytea") ||
+		normalizedType.includes("blob")
+	) {
+		return false;
+	}
+
+	return typeof value === "string";
+}
+
+function formatCellDetailDraft(
+	value: unknown,
+	format: "text" | "json" | "markdown",
+): string {
+	if (format === "json") {
+		if (typeof value === "string") {
+			try {
+				return JSON.stringify(JSON.parse(value), null, 2);
+			} catch {
+				return value;
+			}
+		}
+		return JSON.stringify(value, null, 2);
+	}
+
+	return formatCellValue(value);
+}
+
+function buildSqliteRowSelector(row: Record<string, unknown>): string {
+	const primaryKeyPayload = row[SQLITE_PRIMARY_KEY_COLUMN];
+	if (typeof primaryKeyPayload === "string" && primaryKeyPayload.length > 0) {
+		try {
+			const parsed = JSON.parse(primaryKeyPayload) as Record<string, unknown>;
+			const clauses = Object.entries(parsed).map(([column, value]) =>
+				value === null
+					? `${quoteSqlIdentifier(column)} IS NULL`
+					: `${quoteSqlIdentifier(column)} = ${toSqlLiteral(value, "sqlite")}`,
+			);
+			if (clauses.length > 0) {
+				return clauses.join(" AND ");
+			}
+		} catch {
+			// Fall back to rowid below if the preview metadata is malformed.
+		}
+	}
+
+	const rowId = row[SQLITE_ROW_ID_COLUMN];
+	if (rowId === undefined) {
+		throw new Error("Missing SQLite row identifier.");
+	}
+	return `rowid = ${toSqlLiteral(rowId, "sqlite")}`;
+}
+
+function buildPostgresRowSelector(row: Record<string, unknown>): string {
+	const ctid = row[POSTGRES_ROW_ID_COLUMN];
+	if (ctid === undefined) {
+		throw new Error("Missing Postgres row identifier.");
+	}
+	return `ctid = ${toSqlLiteral(ctid, "postgres")}`;
+}
+
+function normalizeDraftValue(
+	value: string,
+	originalValue: unknown,
+): string | number | boolean | null {
+	if (originalValue === null || originalValue === undefined) {
+		return value;
+	}
+	if (typeof originalValue === "number") {
+		const parsed = Number(value);
+		return Number.isNaN(parsed) ? value : parsed;
+	}
+	if (typeof originalValue === "boolean") {
+		const normalized = value.trim().toLowerCase();
+		if (["true", "1", "t", "yes"].includes(normalized)) return true;
+		if (["false", "0", "f", "no"].includes(normalized)) return false;
+		return value;
+	}
+	return value;
+}
+
+const PreviewTableCellValue = memo(function PreviewTableCellValue({
+	row,
+	column,
+	onOpenContextMenu,
+	canOpenDetail,
+	onOpenDetail,
+}: {
+	row: Record<string, unknown>;
+	column: string;
+	onOpenContextMenu: (row: Record<string, unknown>, column: string) => void;
+	canOpenDetail: boolean;
+	onOpenDetail: (row: Record<string, unknown>, column: string) => void;
+}) {
+	const value = row[column];
+	const formattedValue = useMemo(() => formatCellValue(value), [value]);
+
+	return (
+		<div className="group flex items-center gap-1">
+			<button
+				type="button"
+				className="block min-w-0 flex-1 overflow-hidden text-ellipsis whitespace-nowrap text-left"
+				title={formattedValue}
+				onContextMenu={() => onOpenContextMenu(row, column)}
+			>
+				{formattedValue}
+			</button>
+			{canOpenDetail ? (
+				<button
+					type="button"
+					className="text-muted-foreground hover:text-foreground size-5 shrink-0 rounded opacity-0 transition-opacity group-hover:opacity-100"
+					onClick={(event) => {
+						event.stopPropagation();
+						onOpenDetail(row, column);
+					}}
+					aria-label={`Open full value for ${column}`}
+				>
+					<LuSearch className="size-3.5" />
+				</button>
+			) : null}
+		</div>
+	);
+});
+
+const PreviewTableRowView = memo(function PreviewTableRowView({
+	row,
+	rowId,
+	columns,
+	selected,
+	onToggleSelection,
+	onOpenContextMenu,
+	getCanOpenDetail,
+	onOpenDetail,
+	dataIndex,
+}: {
+	row: Record<string, unknown>;
+	rowId: string | null;
+	columns: string[];
+	selected: boolean;
+	onToggleSelection: (row: Record<string, unknown>, checked: boolean) => void;
+	onOpenContextMenu: (row: Record<string, unknown>, column: string) => void;
+	getCanOpenDetail: (column: string, value: unknown) => boolean;
+	onOpenDetail: (row: Record<string, unknown>, column: string) => void;
+	dataIndex?: number;
+}) {
+	return (
+		<TableRow data-index={dataIndex}>
+			<TableCell className="w-10 min-w-10">
+				<Checkbox
+					checked={selected}
+					onCheckedChange={(checked) =>
+						onToggleSelection(row, Boolean(checked))
+					}
+					aria-label="Select row"
+				/>
+			</TableCell>
+			{columns.map((column) => (
+				<TableCell
+					key={`${rowId ?? "row"}-${column}`}
+					className="max-w-[24rem] align-top font-mono text-[11px]"
+				>
+					<PreviewTableCellValue
+						row={row}
+						column={column}
+						onOpenContextMenu={onOpenContextMenu}
+						canOpenDetail={getCanOpenDetail(column, row[column])}
+						onOpenDetail={onOpenDetail}
+					/>
+				</TableCell>
+			))}
+		</TableRow>
+	);
+});
+
+function getConnectionSubtitle(connection: SavedDatabaseConnection): string {
+	return connection.dialect === "sqlite"
+		? (connection.databasePath ?? "")
+		: (connection.connectionString ?? "");
+}
+
+function getTableKey(table: { schema: string | null; name: string }): string {
+	return `${table.schema ?? "main"}.${table.name}`;
+}
+
+function getSchemaKey(table: { schema: string | null }): string {
+	return table.schema ?? "main";
+}
+
+function ConnectionItem({
+	connection,
+	isActive,
+	onOpen,
+	onEdit,
+	onSelect,
+	onRemove,
+}: {
+	connection: SavedDatabaseConnection;
+	isActive: boolean;
+	onOpen?: () => void;
+	onEdit?: () => void;
+	onSelect: () => void;
+	onRemove?: () => void;
+}) {
+	return (
+		<div
+			className={cn(
+				"group flex items-start gap-2 rounded-md border p-2 transition-colors",
+				isActive ? "border-primary bg-accent/40" : "hover:bg-muted/40",
+			)}
+		>
+			<button
+				type="button"
+				onClick={onSelect}
+				className="min-w-0 flex-1 text-left"
+			>
+				<div className="flex items-center gap-2">
+					<LuDatabase className="text-muted-foreground size-3.5 shrink-0" />
+					<span className="truncate text-sm font-medium">
+						{connection.label}
+					</span>
+					<Badge variant="outline">{connection.dialect}</Badge>
+					{connection.group ? (
+						<Badge variant="secondary">{connection.group}</Badge>
+					) : null}
+				</div>
+				<p className="text-muted-foreground mt-1 truncate font-mono text-[11px]">
+					{getConnectionSubtitle(connection)}
+				</p>
+			</button>
+			{onOpen ? (
+				<Button
+					variant="ghost"
+					size="icon"
+					type="button"
+					className="size-7 shrink-0 opacity-70 group-hover:opacity-100"
+					onClick={onOpen}
+				>
+					<LuExternalLink className="size-3.5" />
+				</Button>
+			) : null}
+			{onEdit ? (
+				<Button
+					variant="ghost"
+					size="icon"
+					type="button"
+					className="size-7 shrink-0 opacity-70 group-hover:opacity-100"
+					onClick={onEdit}
+				>
+					<LuPencil className="size-3.5" />
+				</Button>
+			) : null}
+			{onRemove ? (
+				<Button
+					variant="ghost"
+					size="icon"
+					type="button"
+					className="size-7 shrink-0 opacity-70 group-hover:opacity-100"
+					onClick={onRemove}
+				>
+					<LuTrash2 className="size-3.5" />
+				</Button>
+			) : null}
+		</div>
+	);
+}
+
+interface DatabasesViewProps {
+	mode?: "sidebar" | "pane";
+	onOpenExplorer?: (connectionId: string) => void;
+	selectedConnectionId?: string | null;
+	onSelectConnectionId?: (connectionId: string | null) => void;
+	workspaceId?: string;
+}
+
+export function DatabasesView({
+	mode = "sidebar",
+	onOpenExplorer,
+	selectedConnectionId,
+	onSelectConnectionId,
+	workspaceId: workspaceIdProp,
+}: DatabasesViewProps) {
+	const workspaceIdFromContext = useWorkspaceId();
+	const workspaceId = workspaceIdProp ?? workspaceIdFromContext;
+	const { data: workspace } = electronTrpc.workspaces.get.useQuery(
+		{ id: workspaceId ?? "" },
+		{ enabled: !!workspaceId },
+	);
+	const worktreePath = workspace?.worktreePath;
+	const isSidebarMode = mode === "sidebar";
+	const isPaneMode = mode === "pane";
+	const { copyToClipboard } = useCopyToClipboard();
+	const trpcUtils = electronTrpc.useUtils();
+
+	const connections = useDatabaseSidebarStore((state) => state.connections);
+	const sidebarSelectedConnectionId = useDatabaseSidebarStore(
+		(state) => state.activeConnectionId,
+	);
+	const addConnection = useDatabaseSidebarStore((state) => state.addConnection);
+	const updateConnection = useDatabaseSidebarStore(
+		(state) => state.updateConnection,
+	);
+	const removeConnection = useDatabaseSidebarStore(
+		(state) => state.removeConnection,
+	);
+	const queryHistory = useDatabaseSidebarStore((state) => state.queryHistory);
+	const addQueryHistoryItem = useDatabaseSidebarStore(
+		(state) => state.addQueryHistoryItem,
+	);
+	const removeQueryHistoryItem = useDatabaseSidebarStore(
+		(state) => state.removeQueryHistoryItem,
+	);
+	const clearQueryHistoryForConnection = useDatabaseSidebarStore(
+		(state) => state.clearQueryHistoryForConnection,
+	);
+	const setActiveConnectionId = useDatabaseSidebarStore(
+		(state) => state.setActiveConnectionId,
+	);
+	const resolvedSelectedConnectionId =
+		selectedConnectionId ?? sidebarSelectedConnectionId;
+	const handleSelectConnectionId =
+		onSelectConnectionId ?? setActiveConnectionId;
+
+	const activeConnection =
+		connections.find(
+			(connection) => connection.id === resolvedSelectedConnectionId,
+		) ?? null;
+
+	const [connectionType, setConnectionType] =
+		useState<ConnectionDialect>("postgres");
+	const [isAddConnectionOpen, setIsAddConnectionOpen] = useState(false);
+	const [editingConnectionId, setEditingConnectionId] = useState<string | null>(
+		null,
+	);
+	const [labelInput, setLabelInput] = useState("");
+	const [groupInput, setGroupInput] = useState("");
+	const [pathInput, setPathInput] = useState("");
+	const [useConnectionString, setUseConnectionString] = useState(false);
+	const [postgresHost, setPostgresHost] = useState("127.0.0.1");
+	const [postgresPort, setPostgresPort] = useState("5432");
+	const [postgresUsername, setPostgresUsername] = useState("postgres");
+	const [postgresPassword, setPostgresPassword] = useState("");
+	const [postgresDatabase, setPostgresDatabase] = useState("");
+	const [postgresSsl, setPostgresSsl] = useState(false);
+	const [showPassword, setShowPassword] = useState(false);
+	const [selectedTableKey, setSelectedTableKey] = useState<string | null>(null);
+	const [tablePreviewPage, setTablePreviewPage] = useState(0);
+	const [tableSearchInput, setTableSearchInput] = useState("");
+	const deferredTableSearchInput = useDeferredValue(tableSearchInput);
+	const [tableSort, setTableSort] = useState<TableSortState | null>(null);
+	const [columnFilters, setColumnFilters] = useState<Record<string, string>>(
+		{},
+	);
+	const [selectedRowIds, setSelectedRowIds] = useState<Record<string, boolean>>(
+		{},
+	);
+	const [expandedSchemaKeys, setExpandedSchemaKeys] = useState<
+		Record<string, boolean>
+	>({});
+	const [sql, setSql] = useState(POSTGRES_DEFAULT_SQL);
+	const [formError, setFormError] = useState<string | null>(null);
+	const [queryError, setQueryError] = useState<string | null>(null);
+	const [tableActionError, setTableActionError] = useState<string | null>(null);
+	const [queryResult, setQueryResult] = useState<QueryResult | null>(null);
+	const [isSqlDialogOpen, setIsSqlDialogOpen] = useState(false);
+	const [isEditDialogOpen, setIsEditDialogOpen] = useState(false);
+	const [isEditDialogLoading, setIsEditDialogLoading] = useState(false);
+	const [isCellDetailDialogOpen, setIsCellDetailDialogOpen] = useState(false);
+	const [isCellDetailLoading, setIsCellDetailLoading] = useState(false);
+	const [isCreatingRow, setIsCreatingRow] = useState(false);
+	const [tableExportFormat, setTableExportFormat] = useState<
+		"csv" | "json" | null
+	>(null);
+	const [isCellDetailCopying, setIsCellDetailCopying] = useState(false);
+	const [isCellDetailExporting, setIsCellDetailExporting] = useState(false);
+	const [isCellContextMenuOpen, setIsCellContextMenuOpen] = useState(false);
+	const [contextCell, setContextCell] = useState<ContextCellState | null>(null);
+	const [pendingEditRequest, setPendingEditRequest] =
+		useState<PendingEditRequest | null>(null);
+	const [editingCell, setEditingCell] = useState<EditableCellState | null>(
+		null,
+	);
+	const [rowDraft, setRowDraft] = useState<Record<string, RowDraftValue>>({});
+	const [cellDetail, setCellDetail] = useState<CellDetailState | null>(null);
+	const previewScrollRef = useRef<HTMLDivElement>(null);
+
+	const labelInputRef = useRef<HTMLInputElement>(null);
+	const groupInputRef = useRef<HTMLInputElement>(null);
+	const pathInputRef = useRef<HTMLInputElement>(null);
+	const postgresHostRef = useRef<HTMLInputElement>(null);
+	const postgresPortRef = useRef<HTMLInputElement>(null);
+	const postgresUsernameRef = useRef<HTMLInputElement>(null);
+	const postgresPasswordRef = useRef<HTMLInputElement>(null);
+	const postgresDatabaseRef = useRef<HTMLInputElement>(null);
+	const previousActiveConnectionIdRef = useRef<string | null>(null);
+
+	const resetConnectionForm = () => {
+		setEditingConnectionId(null);
+		setLabelInput("");
+		setGroupInput("");
+		setPathInput("");
+		setUseConnectionString(false);
+		setPostgresHost("127.0.0.1");
+		setPostgresPort("5432");
+		setPostgresUsername("postgres");
+		setPostgresPassword("");
+		setPostgresDatabase("");
+		setPostgresSsl(false);
+		setShowPassword(false);
+		setFormError(null);
+	};
+
+	const populateConnectionForm = (connection: SavedDatabaseConnection) => {
+		setEditingConnectionId(connection.id);
+		setConnectionType(connection.dialect);
+		setLabelInput(connection.label);
+		setGroupInput(connection.group ?? "");
+		setFormError(null);
+		setShowPassword(false);
+
+		if (connection.dialect === "sqlite") {
+			setPathInput(connection.databasePath ?? "");
+			setUseConnectionString(false);
+			setPostgresHost("127.0.0.1");
+			setPostgresPort("5432");
+			setPostgresUsername("postgres");
+			setPostgresPassword("");
+			setPostgresDatabase("");
+			setPostgresSsl(false);
+			return;
+		}
+
+		const parsed = parsePostgresConnectionString(
+			connection.connectionString ?? "",
+		);
+		if (parsed) {
+			setUseConnectionString(false);
+			setPathInput("");
+			setPostgresHost(parsed.host);
+			setPostgresPort(parsed.port);
+			setPostgresUsername(parsed.username);
+			setPostgresPassword(parsed.password);
+			setPostgresDatabase(parsed.database);
+			setPostgresSsl(parsed.ssl);
+			return;
+		}
+
+		setUseConnectionString(true);
+		setPathInput(connection.connectionString ?? "");
+		setPostgresHost("127.0.0.1");
+		setPostgresPort("5432");
+		setPostgresUsername("postgres");
+		setPostgresPassword("");
+		setPostgresDatabase("");
+		setPostgresSsl(false);
+	};
+
+	useEffect(() => {
+		if (!resolvedSelectedConnectionId && connections.length > 0) {
+			handleSelectConnectionId(connections[0]?.id ?? null);
+		}
+	}, [resolvedSelectedConnectionId, connections, handleSelectConnectionId]);
+
+	useEffect(() => {
+		if (
+			previousActiveConnectionIdRef.current === resolvedSelectedConnectionId
+		) {
+			return;
+		}
+
+		previousActiveConnectionIdRef.current = resolvedSelectedConnectionId;
+		setQueryError(null);
+		setTableActionError(null);
+		setQueryResult(null);
+		setSelectedTableKey(null);
+		setTablePreviewPage(0);
+		setTableSearchInput("");
+		setTableSort(null);
+		setColumnFilters({});
+		setSelectedRowIds({});
+	}, [resolvedSelectedConnectionId]);
+
+	useEffect(() => {
+		setSql(
+			connectionType === "sqlite" ? SQLITE_DEFAULT_SQL : POSTGRES_DEFAULT_SQL,
+		);
+	}, [connectionType]);
+
+	const discoverQuery = electronTrpc.databases.discoverSqliteFiles.useQuery(
+		{ worktreePath: worktreePath ?? "", limit: 25 },
+		{ enabled: Boolean(worktreePath) },
+	);
+
+	const inspectSqliteQuery = electronTrpc.databases.inspectSqlite.useQuery(
+		{ databasePath: activeConnection?.databasePath ?? "" },
+		{
+			enabled:
+				activeConnection?.dialect === "sqlite" &&
+				Boolean(activeConnection.databasePath),
+		},
+	);
+
+	const inspectPostgresQuery = electronTrpc.databases.inspectPostgres.useQuery(
+		{ connectionString: activeConnection?.connectionString ?? "" },
+		{
+			enabled:
+				activeConnection?.dialect === "postgres" &&
+				Boolean(activeConnection.connectionString),
+		},
+	);
+
+	const activeSchemaQuery =
+		activeConnection?.dialect === "postgres"
+			? inspectPostgresQuery
+			: inspectSqliteQuery;
+	const activeTables = activeSchemaQuery.data?.tables ?? [];
+	const selectedTable =
+		activeTables.find((table) => getTableKey(table) === selectedTableKey) ??
+		null;
+	const tablesBySchema = useMemo(() => {
+		const grouped = new Map<string, Array<(typeof activeTables)[number]>>();
+
+		for (const table of activeTables) {
+			const schemaKey = getSchemaKey(table);
+			const currentTables = grouped.get(schemaKey) ?? [];
+			currentTables.push(table);
+			grouped.set(schemaKey, currentTables);
+		}
+
+		return Array.from(grouped.entries()).map(([schemaKey, tables]) => ({
+			schemaKey,
+			label: schemaKey,
+			tables,
+		}));
+	}, [activeTables]);
+
+	useEffect(() => {
+		if (!activeTables.length) {
+			if (selectedTableKey !== null) {
+				setSelectedTableKey(null);
+				setTableActionError(null);
+				setTableSearchInput("");
+				setTableSort(null);
+				setColumnFilters({});
+				setSelectedRowIds({});
+			}
+			return;
+		}
+
+		if (
+			selectedTableKey &&
+			!activeTables.some((table) => getTableKey(table) === selectedTableKey)
+		) {
+			setSelectedTableKey(null);
+			setTableActionError(null);
+			setTableSearchInput("");
+			setTableSort(null);
+			setColumnFilters({});
+			setSelectedRowIds({});
+		}
+	}, [activeTables, selectedTableKey]);
+
+	useEffect(() => {
+		setExpandedSchemaKeys((current) => {
+			if (!tablesBySchema.length) {
+				return Object.keys(current).length === 0 ? current : {};
+			}
+
+			let changed = false;
+			const nextState = { ...current };
+			for (const group of tablesBySchema) {
+				if (nextState[group.schemaKey] === undefined) {
+					nextState[group.schemaKey] = false;
+					changed = true;
+				}
+			}
+
+			return changed ? nextState : current;
+		});
+	}, [tablesBySchema]);
+
+	const previewSqliteQuery = electronTrpc.databases.previewSqliteTable.useQuery(
+		{
+			databasePath: activeConnection?.databasePath ?? "",
+			tableName: selectedTable?.name ?? "",
+			limit: TABLE_PREVIEW_PAGE_SIZE,
+			offset: tablePreviewPage * TABLE_PREVIEW_PAGE_SIZE,
+		},
+		{
+			enabled:
+				activeConnection?.dialect === "sqlite" &&
+				Boolean(activeConnection.databasePath) &&
+				Boolean(selectedTable?.name),
+			placeholderData: (previousData) => previousData,
+		},
+	);
+
+	const previewPostgresQuery =
+		electronTrpc.databases.previewPostgresTable.useQuery(
+			{
+				connectionString: activeConnection?.connectionString ?? "",
+				schema: selectedTable?.schema ?? "public",
+				tableName: selectedTable?.name ?? "",
+				limit: TABLE_PREVIEW_PAGE_SIZE,
+				offset: tablePreviewPage * TABLE_PREVIEW_PAGE_SIZE,
+			},
+			{
+				enabled:
+					activeConnection?.dialect === "postgres" &&
+					Boolean(activeConnection.connectionString) &&
+					Boolean(selectedTable?.schema) &&
+					Boolean(selectedTable?.name),
+				placeholderData: (previousData) => previousData,
+			},
+		);
+
+	const executeSQLiteMutation =
+		electronTrpc.databases.executeSqlite.useMutation({
+			onSuccess: (result) => {
+				setQueryError(null);
+				setQueryResult(result);
+			},
+			onError: (error) => {
+				setQueryResult(null);
+				setQueryError(error.message);
+			},
+		});
+
+	const executePostgresMutation =
+		electronTrpc.databases.executePostgres.useMutation({
+			onSuccess: (result) => {
+				setQueryError(null);
+				setQueryResult(result);
+			},
+			onError: (error) => {
+				setQueryResult(null);
+				setQueryError(error.message);
+			},
+		});
+
+	const discoveredFiles = useMemo(() => {
+		const connectedPaths = new Set(
+			connections
+				.filter((connection) => connection.dialect === "sqlite")
+				.map((connection) => connection.databasePath)
+				.filter((value): value is string => Boolean(value)),
+		);
+
+		return (discoverQuery.data?.files ?? []).filter(
+			(file) => !connectedPaths.has(file.absolutePath),
+		);
+	}, [connections, discoverQuery.data?.files]);
+	const activePreviewQuery =
+		activeConnection?.dialect === "postgres"
+			? previewPostgresQuery
+			: previewSqliteQuery;
+	const isQueryRunning =
+		executeSQLiteMutation.isPending || executePostgresMutation.isPending;
+
+	const visiblePreviewColumns = activePreviewQuery.data?.columns ?? [];
+	const columnTypeByName = useMemo(
+		() =>
+			Object.fromEntries(
+				(selectedTable?.columns ?? []).map((column) => [
+					column.name,
+					column.type,
+				]),
+			) as Record<string, string>,
+		[selectedTable?.columns],
+	);
+	const selectedTableLabel = selectedTable
+		? selectedTable.schema
+			? `${selectedTable.schema}.${selectedTable.name}`
+			: selectedTable.name
+		: null;
+	const previewRows = activePreviewQuery.data?.rows ?? [];
+	const normalizedTableSearch = deferredTableSearchInput.trim().toLowerCase();
+	const normalizedColumnFilters = useMemo(
+		() =>
+			Object.fromEntries(
+				Object.entries(columnFilters)
+					.map(([column, value]) => [column, value.trim().toLowerCase()])
+					.filter(([, value]) => value.length > 0),
+			) as Record<string, string>,
+		[columnFilters],
+	);
+	const filteredPreviewRows = useMemo(() => {
+		const rows = [...previewRows];
+		const hasGlobalSearch = normalizedTableSearch.length > 0;
+		const filterEntries = Object.entries(normalizedColumnFilters);
+
+		const nextRows = rows.filter((row) => {
+			if (hasGlobalSearch) {
+				const matchesGlobal = visiblePreviewColumns.some((column) =>
+					matchesSearchValue(row[column], normalizedTableSearch),
+				);
+				if (!matchesGlobal) {
+					return false;
+				}
+			}
+
+			for (const [column, value] of filterEntries) {
+				if (!matchesSearchValue(row[column], value)) {
+					return false;
+				}
+			}
+
+			return true;
+		});
+
+		if (!tableSort) {
+			return nextRows;
+		}
+
+		return nextRows.sort((left, right) => {
+			const comparison = comparePreviewValues(
+				left[tableSort.column],
+				right[tableSort.column],
+			);
+			return tableSort.direction === "asc" ? comparison : -comparison;
+		});
+	}, [
+		previewRows,
+		normalizedTableSearch,
+		normalizedColumnFilters,
+		visiblePreviewColumns,
+		tableSort,
+	]);
+	const filteredPreviewRowIds = useMemo(
+		() =>
+			filteredPreviewRows
+				.map((row) =>
+					activeConnection
+						? getRowIdentifier(row, activeConnection.dialect)
+						: null,
+				)
+				.filter((value): value is string => Boolean(value)),
+		[filteredPreviewRows, activeConnection],
+	);
+	const selectedVisibleRowCount = useMemo(
+		() => filteredPreviewRowIds.filter((rowId) => selectedRowIds[rowId]).length,
+		[filteredPreviewRowIds, selectedRowIds],
+	);
+	const areAllVisibleRowsSelected =
+		filteredPreviewRowIds.length > 0 &&
+		selectedVisibleRowCount === filteredPreviewRowIds.length;
+	const isPartiallySelected =
+		selectedVisibleRowCount > 0 &&
+		selectedVisibleRowCount < filteredPreviewRowIds.length;
+	const queryHistoryForActiveConnection = useMemo(
+		() =>
+			activeConnection
+				? queryHistory.filter(
+						(item) => item.connectionId === activeConnection.id,
+					)
+				: [],
+		[activeConnection, queryHistory],
+	);
+	const getCanOpenDetail = useCallback(
+		(column: string, value: unknown) =>
+			supportsDetailViewer(columnTypeByName[column] ?? "", value),
+		[columnTypeByName],
+	);
+	const rowVirtualizer = useVirtualizer({
+		count: filteredPreviewRows.length,
+		getScrollElement: () => previewScrollRef.current,
+		estimateSize: () => TABLE_PREVIEW_ROW_HEIGHT,
+		overscan: TABLE_PREVIEW_OVERSCAN,
+		rangeExtractor: defaultRangeExtractor,
+	});
+	const virtualRows = rowVirtualizer.getVirtualItems();
+	const paddingTop = virtualRows.length > 0 ? (virtualRows[0]?.start ?? 0) : 0;
+	const paddingBottom =
+		virtualRows.length > 0
+			? rowVirtualizer.getTotalSize() -
+				(virtualRows[virtualRows.length - 1]?.end ?? 0)
+			: 0;
+
+	useEffect(() => {
+		if (!activeConnection) {
+			setSelectedRowIds((current) =>
+				Object.keys(current).length > 0 ? {} : current,
+			);
+			return;
+		}
+
+		const validRowIds = new Set(
+			previewRows
+				.map((row) => getRowIdentifier(row, activeConnection.dialect))
+				.filter((value): value is string => Boolean(value)),
+		);
+
+		setSelectedRowIds((current) => {
+			const nextEntries = Object.entries(current).filter(([rowId]) =>
+				validRowIds.has(rowId),
+			);
+			if (nextEntries.length === Object.keys(current).length) {
+				return current;
+			}
+			return Object.fromEntries(nextEntries);
+		});
+	}, [previewRows, activeConnection]);
+
+	useEffect(() => {
+		if (!selectedTableLabel) {
+			setContextCell(null);
+		}
+	}, [selectedTableLabel]);
+
+	const runSqlStatement = async (nextSql: string) => {
+		if (!activeConnection) {
+			throw new Error("Select a database connection first.");
+		}
+
+		if (
+			activeConnection.dialect === "sqlite" &&
+			activeConnection.databasePath
+		) {
+			return await executeSQLiteMutation.mutateAsync({
+				databasePath: activeConnection.databasePath,
+				sql: nextSql,
+				limit: 200,
+			});
+		}
+
+		if (
+			activeConnection.dialect === "postgres" &&
+			activeConnection.connectionString
+		) {
+			return await executePostgresMutation.mutateAsync({
+				connectionString: activeConnection.connectionString,
+				sql: nextSql,
+				limit: 200,
+			});
+		}
+
+		throw new Error(
+			"The selected connection is missing its connection details.",
+		);
+	};
+
+	const buildUpdateStatement = ({
+		row,
+		updates,
+	}: {
+		row: Record<string, unknown>;
+		updates: Record<string, unknown>;
+	}) => {
+		if (!selectedTable || !activeConnection) {
+			throw new Error("Select a table first.");
+		}
+
+		const assignments = Object.entries(updates).map(
+			([column, value]) =>
+				`${quoteSqlIdentifier(column)} = ${toSqlLiteral(
+					value,
+					activeConnection.dialect,
+				)}`,
+		);
+		if (!assignments.length) {
+			throw new Error("No changes to save.");
+		}
+
+		if (activeConnection.dialect === "sqlite") {
+			return `UPDATE ${quoteSqlIdentifier(selectedTable.name)} SET ${assignments.join(", ")} WHERE ${buildSqliteRowSelector(row)}`;
+		}
+
+		return `UPDATE ${quoteSqlIdentifier(selectedTable.schema ?? "public")}.${quoteSqlIdentifier(selectedTable.name)} SET ${assignments.join(", ")} WHERE ${buildPostgresRowSelector(row)}`;
+	};
+
+	const buildInsertStatement = (
+		values: Record<string, unknown>,
+		defaultSourceRow?: Record<string, unknown>,
+	) => {
+		if (!selectedTable || !activeConnection) {
+			throw new Error("Select a table first.");
+		}
+
+		const entries = Object.entries(values).filter(([column, value]) => {
+			if (value !== null && value !== undefined) {
+				return true;
+			}
+			return defaultSourceRow ? defaultSourceRow[column] !== undefined : false;
+		});
+
+		if (!entries.length) {
+			throw new Error("Enter at least one value to insert.");
+		}
+
+		const columns = entries.map(([column]) => quoteSqlIdentifier(column));
+		const sqlValues = entries.map(([, value]) =>
+			toSqlLiteral(value, activeConnection.dialect),
+		);
+		const tableReference =
+			activeConnection.dialect === "sqlite"
+				? quoteSqlIdentifier(selectedTable.name)
+				: `${quoteSqlIdentifier(selectedTable.schema ?? "public")}.${quoteSqlIdentifier(selectedTable.name)}`;
+
+		return `INSERT INTO ${tableReference} (${columns.join(", ")}) VALUES (${sqlValues.join(", ")})`;
+	};
+
+	const applyRowUpdate = async ({
+		row,
+		updates,
+	}: {
+		row: Record<string, unknown>;
+		updates: Record<string, unknown>;
+	}) => {
+		setTableActionError(null);
+		await runSqlStatement(buildUpdateStatement({ row, updates }));
+		await activePreviewQuery.refetch();
+	};
+
+	const exportRows = async (
+		rows: Array<Record<string, unknown>>,
+		format: "csv" | "json",
+	) => {
+		if (!selectedTableLabel) {
+			return;
+		}
+
+		const fileBaseName = selectedTableLabel.replaceAll(".", "_");
+		const content =
+			format === "json"
+				? JSON.stringify(
+						rows.map((row) =>
+							Object.fromEntries(
+								visiblePreviewColumns.map((column) => [column, row[column]]),
+							),
+						),
+						null,
+						2,
+					)
+				: [
+						visiblePreviewColumns.map((column) => toCsvCell(column)).join(","),
+						...rows.map((row) =>
+							visiblePreviewColumns
+								.map((column) => toCsvCell(row[column]))
+								.join(","),
+						),
+					].join("\n");
+
+		const blob = new Blob([content], {
+			type: format === "json" ? "application/json" : "text/csv;charset=utf-8",
+		});
+		try {
+			const objectUrl = URL.createObjectURL(blob);
+			const anchor = document.createElement("a");
+			anchor.href = objectUrl;
+			anchor.download = `${fileBaseName}.${format}`;
+			anchor.click();
+			URL.revokeObjectURL(objectUrl);
+		} catch (error) {
+			throw new Error(
+				error instanceof Error ? error.message : "Failed to export table rows.",
+			);
+		}
+	};
+
+	const handleAddConnection = () => {
+		setFormError(null);
+
+		const nextLabel = labelInputRef.current?.value ?? labelInput;
+		const nextGroup = groupInputRef.current?.value ?? groupInput;
+
+		if (connectionType === "sqlite") {
+			const nextPath = pathInputRef.current?.value ?? pathInput;
+			const resolvedPath = resolveSQLiteDatabasePath(nextPath, worktreePath);
+			if (!resolvedPath) {
+				setFormError(
+					worktreePath
+						? "Database path is required."
+						: "Use an absolute database path when no workspace is available.",
+				);
+				return;
+			}
+
+			const nextConnection = {
+				label: nextLabel.trim() || guessConnectionLabel(resolvedPath),
+				group: nextGroup.trim() || undefined,
+				dialect: "sqlite" as const,
+				databasePath: resolvedPath,
+			};
+
+			if (editingConnectionId) {
+				updateConnection({
+					id: editingConnectionId,
+					...nextConnection,
+				});
+			} else {
+				addConnection(nextConnection);
+			}
+		} else {
+			const nextPath = pathInputRef.current?.value ?? pathInput;
+			const nextHost = postgresHostRef.current?.value ?? postgresHost;
+			const nextPort = postgresPortRef.current?.value ?? postgresPort;
+			const nextUsername =
+				postgresUsernameRef.current?.value ?? postgresUsername;
+			const nextPassword =
+				postgresPasswordRef.current?.value ?? postgresPassword;
+			const nextDatabase =
+				postgresDatabaseRef.current?.value ?? postgresDatabase;
+
+			const connectionString = useConnectionString
+				? nextPath.trim()
+				: buildPostgresConnectionString({
+						host: nextHost.trim(),
+						port: nextPort.trim() || "5432",
+						username: nextUsername.trim(),
+						password: nextPassword,
+						database: nextDatabase.trim() || "postgres",
+						ssl: postgresSsl,
+					});
+
+			if (!connectionString) {
+				setFormError("Postgres connection string is required.");
+				return;
+			}
+
+			if (!useConnectionString && (!nextHost.trim() || !nextUsername.trim())) {
+				setFormError("Host and username are required.");
+				return;
+			}
+
+			const nextConnection = {
+				label: nextLabel.trim() || guessPostgresLabel(connectionString),
+				group: nextGroup.trim() || undefined,
+				dialect: "postgres" as const,
+				connectionString,
+			};
+
+			if (editingConnectionId) {
+				updateConnection({
+					id: editingConnectionId,
+					...nextConnection,
+				});
+			} else {
+				addConnection(nextConnection);
+			}
+		}
+
+		resetConnectionForm();
+		setIsAddConnectionOpen(false);
+	};
+
+	const handleAttachDiscoveredFile = (absolutePath: string) => {
+		addConnection({
+			label: guessConnectionLabel(absolutePath),
+			group: groupInput.trim() || undefined,
+			dialect: "sqlite",
+			databasePath: absolutePath,
+		});
+	};
+
+	const handleRunQuery = async () => {
+		try {
+			await runSqlStatement(sql);
+			if (activeConnection) {
+				addQueryHistoryItem({
+					connectionId: activeConnection.id,
+					sql,
+				});
+			}
+		} catch (error) {
+			setQueryResult(null);
+			setQueryError(
+				error instanceof Error ? error.message : "Failed to execute SQL.",
+			);
+		}
+	};
+
+	const handleCreateRow = async () => {
+		const blankRow = Object.fromEntries(
+			visiblePreviewColumns.map((column) => [column, null]),
+		) as Record<string, unknown>;
+		setIsCreatingRow(true);
+		try {
+			await handleOpenEditDialog(blankRow, visiblePreviewColumns[0], "insert");
+		} catch (error) {
+			const message =
+				error instanceof Error ? error.message : "Failed to open row editor.";
+			setTableActionError(message);
+			toast.error(message);
+		} finally {
+			setIsCreatingRow(false);
+		}
+	};
+
+	const fetchFullRow = useCallback(
+		async (row: Record<string, unknown>) => {
+			if (!activeConnection || !selectedTable) {
+				return row;
+			}
+
+			if (activeConnection.dialect === "sqlite") {
+				const detail = await trpcUtils.databases.getSqliteRowDetail.fetch({
+					databasePath: activeConnection.databasePath ?? "",
+					tableName: selectedTable.name,
+					rowId:
+						typeof row[SQLITE_ROW_ID_COLUMN] === "string" ||
+						typeof row[SQLITE_ROW_ID_COLUMN] === "number"
+							? (row[SQLITE_ROW_ID_COLUMN] as string | number)
+							: undefined,
+					primaryKey:
+						typeof row[SQLITE_PRIMARY_KEY_COLUMN] === "string"
+							? row[SQLITE_PRIMARY_KEY_COLUMN]
+							: undefined,
+				});
+				return {
+					...detail.row,
+					[SQLITE_ROW_ID_COLUMN]: row[SQLITE_ROW_ID_COLUMN],
+					[SQLITE_PRIMARY_KEY_COLUMN]: row[SQLITE_PRIMARY_KEY_COLUMN],
+				};
+			}
+
+			const detail = await trpcUtils.databases.getPostgresRowDetail.fetch({
+				connectionString: activeConnection.connectionString ?? "",
+				schema: selectedTable.schema ?? "public",
+				tableName: selectedTable.name,
+				ctid: String(row[POSTGRES_ROW_ID_COLUMN] ?? ""),
+			});
+			return {
+				...detail.row,
+				[POSTGRES_ROW_ID_COLUMN]: row[POSTGRES_ROW_ID_COLUMN],
+			};
+		},
+		[activeConnection, selectedTable, trpcUtils],
+	);
+
+	const handleOpenEditDialog = useCallback(
+		async (
+			row: Record<string, unknown>,
+			initialColumn?: string,
+			mode: EditableCellState["mode"] = "edit",
+		) => {
+			let sourceRow = row;
+			if (mode !== "insert" && activeConnection && selectedTable) {
+				setIsEditDialogLoading(true);
+				try {
+					sourceRow = await fetchFullRow(row);
+				} finally {
+					setIsEditDialogLoading(false);
+				}
+			}
+
+			const nextDraft = Object.fromEntries(
+				visiblePreviewColumns.map((column) => [
+					column,
+					{
+						value: formatCellValue(sourceRow[column]),
+						isNull: mode === "insert" ? true : sourceRow[column] === null,
+					},
+				]),
+			) as Record<string, RowDraftValue>;
+
+			if (initialColumn && nextDraft[initialColumn]) {
+				nextDraft[initialColumn] = {
+					value: formatCellValue(sourceRow[initialColumn]),
+					isNull: mode === "insert" ? false : sourceRow[initialColumn] === null,
+				};
+			}
+
+			setRowDraft(nextDraft);
+			setEditingCell({
+				mode,
+				row: sourceRow,
+				column: initialColumn ?? visiblePreviewColumns[0] ?? "",
+				value: initialColumn ? sourceRow[initialColumn] : null,
+			});
+			setIsEditDialogOpen(true);
+		},
+		[visiblePreviewColumns, activeConnection, selectedTable, fetchFullRow],
+	);
+
+	useEffect(() => {
+		if (!pendingEditRequest || isCellContextMenuOpen) {
+			return;
+		}
+
+		void handleOpenEditDialog(
+			pendingEditRequest.row,
+			pendingEditRequest.column,
+			pendingEditRequest.mode ?? "edit",
+		);
+		setPendingEditRequest(null);
+	}, [pendingEditRequest, isCellContextMenuOpen, handleOpenEditDialog]);
+
+	const handleSaveRowEdit = async () => {
+		if (!editingCell) {
+			return;
+		}
+
+		const nextValues = Object.fromEntries(
+			Object.entries(rowDraft).map(([column, draft]) => [
+				column,
+				draft.isNull
+					? null
+					: normalizeDraftValue(draft.value, editingCell.row[column]),
+			]),
+		);
+
+		try {
+			if (editingCell.mode === "edit") {
+				await applyRowUpdate({ row: editingCell.row, updates: nextValues });
+			} else {
+				setTableActionError(null);
+				await runSqlStatement(
+					buildInsertStatement(nextValues, editingCell.row),
+				);
+				await activePreviewQuery.refetch();
+			}
+			setIsEditDialogOpen(false);
+			setEditingCell(null);
+			setRowDraft({});
+		} catch (error) {
+			setTableActionError(
+				error instanceof Error ? error.message : "Failed to update row.",
+			);
+		}
+	};
+
+	const handleCopyRow = async (row: Record<string, unknown>) => {
+		const payload = Object.fromEntries(
+			visiblePreviewColumns.map((column) => [column, row[column]]),
+		);
+		await copyToClipboard(JSON.stringify(payload, null, 2));
+	};
+
+	const handleQuickCellUpdate = async ({
+		row,
+		column,
+		value,
+	}: {
+		row: Record<string, unknown>;
+		column: string;
+		value: unknown;
+	}) => {
+		try {
+			await applyRowUpdate({ row, updates: { [column]: value } });
+		} catch (error) {
+			setTableActionError(
+				error instanceof Error ? error.message : "Failed to update cell.",
+			);
+		}
+	};
+
+	const toggleTableSort = (column: string) => {
+		setTableSort((current) => {
+			if (!current || current.column !== column) {
+				return { column, direction: "asc" };
+			}
+			if (current.direction === "asc") {
+				return { column, direction: "desc" };
+			}
+			return null;
+		});
+	};
+
+	const setColumnFilterValue = (column: string, value: string) => {
+		setColumnFilters((current) => {
+			const next = { ...current };
+			if (value.trim().length === 0) {
+				delete next[column];
+			} else {
+				next[column] = value;
+			}
+			return next;
+		});
+	};
+
+	const toggleRowSelection = useCallback(
+		(row: Record<string, unknown>, checked: boolean) => {
+			if (!activeConnection) {
+				return;
+			}
+			const rowId = getRowIdentifier(row, activeConnection.dialect);
+			if (!rowId) {
+				return;
+			}
+			setSelectedRowIds((current) => {
+				if (checked) {
+					return {
+						...current,
+						[rowId]: true,
+					};
+				}
+				const next = { ...current };
+				delete next[rowId];
+				return next;
+			});
+		},
+		[activeConnection],
+	);
+
+	const handleOpenCellContextMenu = useCallback(
+		(row: Record<string, unknown>, column: string) => {
+			const formattedValue = formatCellValue(row[column]);
+			setContextCell({
+				row,
+				column,
+				display: formattedValue,
+				title: formattedValue,
+			});
+		},
+		[],
+	);
+
+	const handleOpenCellDetail = useCallback(
+		async (row: Record<string, unknown>, column: string) => {
+			setIsCellDetailLoading(true);
+			setIsCellDetailDialogOpen(true);
+			try {
+				const fullRow = await fetchFullRow(row);
+				const value = fullRow[column];
+				const columnType = columnTypeByName[column] ?? "";
+				const format = canUseJsonDetailFormat(columnType, value)
+					? "json"
+					: "text";
+				setCellDetail({
+					row: fullRow,
+					column,
+					columnType,
+					value,
+					format,
+					draft: formatCellDetailDraft(value, format),
+				});
+			} catch (error) {
+				setTableActionError(
+					error instanceof Error
+						? error.message
+						: "Failed to load full cell value.",
+				);
+				setIsCellDetailDialogOpen(false);
+			} finally {
+				setIsCellDetailLoading(false);
+			}
+		},
+		[columnTypeByName, fetchFullRow],
+	);
+
+	const handleCellDetailFormatChange = (
+		nextFormat: "text" | "json" | "markdown",
+	) => {
+		setCellDetail((current) =>
+			current
+				? {
+						...current,
+						format: nextFormat,
+						draft: formatCellDetailDraft(current.value, nextFormat),
+					}
+				: current,
+		);
+	};
+
+	const handleExportCellDetail = async () => {
+		if (!cellDetail || !selectedTableLabel) {
+			return;
+		}
+
+		setIsCellDetailExporting(true);
+		try {
+			const blob = new Blob([cellDetail.draft], {
+				type:
+					cellDetail.format === "json"
+						? "application/json"
+						: "text/plain;charset=utf-8",
+			});
+			const objectUrl = URL.createObjectURL(blob);
+			const anchor = document.createElement("a");
+			anchor.href = objectUrl;
+			anchor.download = `${selectedTableLabel.replaceAll(".", "_")}_${cellDetail.column}.${cellDetail.format === "json" ? "json" : cellDetail.format === "markdown" ? "md" : "txt"}`;
+			anchor.click();
+			URL.revokeObjectURL(objectUrl);
+			toast.success("セル内容をエクスポートしました。");
+		} catch (error) {
+			const message =
+				error instanceof Error
+					? error.message
+					: "Failed to export detailed cell value.";
+			setTableActionError(message);
+			toast.error(message);
+		} finally {
+			setIsCellDetailExporting(false);
+		}
+	};
+
+	const handleSaveCellDetail = async () => {
+		if (!cellDetail) {
+			return;
+		}
+
+		try {
+			const nextValue =
+				cellDetail.format === "json"
+					? JSON.parse(cellDetail.draft)
+					: cellDetail.draft;
+			await handleQuickCellUpdate({
+				row: cellDetail.row,
+				column: cellDetail.column,
+				value: nextValue,
+			});
+			setCellDetail((current) =>
+				current
+					? {
+							...current,
+							value: nextValue,
+						}
+					: current,
+			);
+			setIsCellDetailDialogOpen(false);
+		} catch (error) {
+			setTableActionError(
+				error instanceof Error
+					? error.message
+					: "Failed to save detailed cell value.",
+			);
+		}
+	};
+
+	const handleCopyCellDetail = async () => {
+		if (!cellDetail) {
+			return;
+		}
+
+		setIsCellDetailCopying(true);
+		try {
+			await copyToClipboard(cellDetail.draft);
+			toast.success("セル内容をコピーしました。");
+		} catch (error) {
+			const message =
+				error instanceof Error ? error.message : "Failed to copy cell value.";
+			setTableActionError(message);
+			toast.error(message);
+		} finally {
+			setIsCellDetailCopying(false);
+		}
+	};
+
+	const handleExportPreviewRows = async (format: "csv" | "json") => {
+		setTableExportFormat(format);
+		try {
+			await exportRows(filteredPreviewRows, format);
+			toast.success(
+				format === "csv"
+					? "CSV をエクスポートしました。"
+					: "JSON をエクスポートしました。",
+			);
+		} catch (error) {
+			const message =
+				error instanceof Error ? error.message : "Failed to export rows.";
+			setTableActionError(message);
+			toast.error(message);
+		} finally {
+			setTableExportFormat(null);
+		}
+	};
+
+	const toggleAllVisibleRows = (checked: boolean) => {
+		setSelectedRowIds((current) => {
+			if (checked) {
+				const next = { ...current };
+				for (const rowId of filteredPreviewRowIds) {
+					next[rowId] = true;
+				}
+				return next;
+			}
+			const next = { ...current };
+			for (const rowId of filteredPreviewRowIds) {
+				delete next[rowId];
+			}
+			return next;
+		});
+	};
+
+	const handleDeleteSelectedRows = async () => {
+		if (!selectedTable || !activeConnection || selectedVisibleRowCount === 0) {
+			return;
+		}
+
+		const rowsToDelete = filteredPreviewRows.filter((row) => {
+			const rowId = getRowIdentifier(row, activeConnection.dialect);
+			return rowId ? selectedRowIds[rowId] : false;
+		});
+
+		if (!rowsToDelete.length) {
+			return;
+		}
+
+		const confirmed = window.confirm(
+			`${rowsToDelete.length} 行を削除します。元に戻せません。続行しますか？`,
+		);
+		if (!confirmed) {
+			return;
+		}
+
+		try {
+			const deleteStatement =
+				activeConnection.dialect === "sqlite"
+					? `DELETE FROM ${quoteSqlIdentifier(selectedTable.name)} WHERE ${rowsToDelete
+							.map((row) => buildSqliteRowSelector(row))
+							.join(" OR ")}`
+					: `DELETE FROM ${quoteSqlIdentifier(selectedTable.schema ?? "public")}.${quoteSqlIdentifier(selectedTable.name)} WHERE ${rowsToDelete
+							.map((row) => buildPostgresRowSelector(row))
+							.join(" OR ")}`;
+
+			await runSqlStatement(deleteStatement);
+			setTableActionError(null);
+			setSelectedRowIds({});
+			await activePreviewQuery.refetch();
+		} catch (error) {
+			setTableActionError(
+				error instanceof Error ? error.message : "Failed to delete rows.",
+			);
+		}
+	};
+
+	const toggleSchemaGroup = (schemaKey: string) => {
+		setExpandedSchemaKeys((current) => ({
+			...current,
+			[schemaKey]: !current[schemaKey],
+		}));
+	};
+
+	return (
+		<div className="flex h-full min-h-0 flex-col">
+			<div className="shrink-0 border-b p-3">
+				<div className="mb-3 flex items-center justify-between">
+					<div>
+						<h2 className="text-sm font-semibold">
+							{isPaneMode ? "Database Explorer" : "Databases"}
+						</h2>
+						<p className="text-muted-foreground text-xs">
+							{isPaneMode
+								? "Browse schema, data, and queries in a full tab"
+								: "Manage SQLite and PostgreSQL connections"}
+						</p>
+					</div>
+					{isSidebarMode ? (
+						<Button
+							variant="outline"
+							size="sm"
+							type="button"
+							onClick={() => discoverQuery.refetch()}
+							disabled={!worktreePath || discoverQuery.isFetching}
+						>
+							<LuRefreshCw
+								className={cn(
+									"mr-1.5 size-3.5",
+									discoverQuery.isFetching && "animate-spin",
+								)}
+							/>
+							Refresh
+						</Button>
+					) : null}
+				</div>
+
+				{isSidebarMode ? (
+					<Collapsible
+						open={isAddConnectionOpen}
+						onOpenChange={setIsAddConnectionOpen}
+						className="rounded-lg border"
+					>
+						<div className="flex items-center justify-between p-3">
+							<div>
+								<p className="text-sm font-medium">
+									{editingConnectionId ? "接続を編集" : "新しい接続を追加"}
+								</p>
+								<p className="text-muted-foreground text-[11px]">
+									必要なときだけ開けます
+								</p>
+							</div>
+							<CollapsibleTrigger asChild>
+								<Button variant="outline" size="sm" type="button">
+									<LuPlus className="mr-1.5 size-3.5" />
+									{isAddConnectionOpen ? "閉じる" : "開く"}
+									<LuChevronDown
+										className={cn(
+											"ml-1.5 size-3.5 transition-transform",
+											isAddConnectionOpen && "rotate-180",
+										)}
+									/>
+								</Button>
+							</CollapsibleTrigger>
+						</div>
+
+						<CollapsibleContent className="border-t p-3">
+							<div className="space-y-3">
+								<div className="grid grid-cols-2 gap-2">
+									<Button
+										type="button"
+										variant={
+											connectionType === "sqlite" ? "default" : "outline"
+										}
+										size="sm"
+										onClick={() => setConnectionType("sqlite")}
+									>
+										SQLite
+									</Button>
+									<Button
+										type="button"
+										variant={
+											connectionType === "postgres" ? "default" : "outline"
+										}
+										size="sm"
+										onClick={() => setConnectionType("postgres")}
+									>
+										Postgres
+									</Button>
+								</div>
+
+								<div className="grid grid-cols-2 gap-3">
+									<div className="space-y-1">
+										<Label htmlFor="db-label">名前</Label>
+										<Input
+											id="db-label"
+											ref={labelInputRef}
+											value={labelInput}
+											onChange={(event) => {
+												setLabelInput(event.target.value);
+												setFormError(null);
+											}}
+											placeholder="Local Postgres"
+										/>
+									</div>
+									<div className="space-y-1">
+										<Label htmlFor="db-group">グループ</Label>
+										<Input
+											id="db-group"
+											ref={groupInputRef}
+											value={groupInput}
+											onChange={(event) => {
+												setGroupInput(event.target.value);
+												setFormError(null);
+											}}
+											placeholder="親/子"
+										/>
+									</div>
+								</div>
+
+								{connectionType === "sqlite" ? (
+									<div className="space-y-1">
+										<Label htmlFor="sqlite-path">SQLite ファイル</Label>
+										<Input
+											id="sqlite-path"
+											ref={pathInputRef}
+											value={pathInput}
+											onChange={(event) => {
+												setPathInput(event.target.value);
+												setFormError(null);
+											}}
+											placeholder={
+												worktreePath
+													? "SQLite file path (absolute or workspace-relative)"
+													: "Absolute SQLite file path"
+											}
+										/>
+									</div>
+								) : (
+									<div className="space-y-3">
+										<div className="flex items-center justify-between rounded-md border px-3 py-2">
+											<div>
+												<p className="text-sm font-medium">接続文字列を使用</p>
+												<p className="text-muted-foreground text-[11px]">
+													有効にすると PostgreSQL URL を直接入力します
+												</p>
+											</div>
+											<Switch
+												checked={useConnectionString}
+												onCheckedChange={setUseConnectionString}
+											/>
+										</div>
+
+										{useConnectionString ? (
+											<div className="space-y-1">
+												<Label htmlFor="postgres-url">接続文字列</Label>
+												<Input
+													id="postgres-url"
+													ref={pathInputRef}
+													value={pathInput}
+													onChange={(event) => {
+														setPathInput(event.target.value);
+														setFormError(null);
+													}}
+													placeholder="postgres://user:password@host:5432/database"
+												/>
+											</div>
+										) : (
+											<>
+												<div className="grid grid-cols-2 gap-3">
+													<div className="space-y-1">
+														<Label htmlFor="postgres-host">ホスト</Label>
+														<Input
+															id="postgres-host"
+															ref={postgresHostRef}
+															value={postgresHost}
+															onChange={(event) => {
+																setPostgresHost(event.target.value);
+																setFormError(null);
+															}}
+															placeholder="127.0.0.1"
+														/>
+													</div>
+													<div className="space-y-1">
+														<Label htmlFor="postgres-port">ポート</Label>
+														<Input
+															id="postgres-port"
+															ref={postgresPortRef}
+															value={postgresPort}
+															onChange={(event) => {
+																setPostgresPort(event.target.value);
+																setFormError(null);
+															}}
+															placeholder="5432"
+														/>
+													</div>
+												</div>
+
+												<div className="grid grid-cols-2 gap-3">
+													<div className="space-y-1">
+														<Label htmlFor="postgres-user">ユーザー名</Label>
+														<Input
+															id="postgres-user"
+															ref={postgresUsernameRef}
+															value={postgresUsername}
+															onChange={(event) => {
+																setPostgresUsername(event.target.value);
+																setFormError(null);
+															}}
+															placeholder="postgres"
+														/>
+													</div>
+													<div className="space-y-1">
+														<Label htmlFor="postgres-password">
+															パスワード
+														</Label>
+														<div className="relative">
+															<Input
+																id="postgres-password"
+																ref={postgresPasswordRef}
+																type={showPassword ? "text" : "password"}
+																value={postgresPassword}
+																onChange={(event) => {
+																	setPostgresPassword(event.target.value);
+																	setFormError(null);
+																}}
+																placeholder="password"
+																className="pr-10"
+															/>
+															<button
+																type="button"
+																aria-label={
+																	showPassword
+																		? "Hide password"
+																		: "Show password"
+																}
+																onClick={() =>
+																	setShowPassword((value) => !value)
+																}
+																className="text-muted-foreground hover:text-foreground absolute top-1/2 right-3 -translate-y-1/2"
+															>
+																{showPassword ? (
+																	<LuEyeOff className="size-4" />
+																) : (
+																	<LuEye className="size-4" />
+																)}
+															</button>
+														</div>
+													</div>
+												</div>
+
+												<div className="grid grid-cols-2 gap-3">
+													<div className="space-y-1">
+														<Label htmlFor="postgres-db">データベース</Label>
+														<Input
+															id="postgres-db"
+															ref={postgresDatabaseRef}
+															value={postgresDatabase}
+															onChange={(event) => {
+																setPostgresDatabase(event.target.value);
+																setFormError(null);
+															}}
+															placeholder="postgres (optional)"
+														/>
+														<p className="text-muted-foreground text-[11px]">
+															未入力なら `postgres` に接続します
+														</p>
+													</div>
+													<div className="flex items-end">
+														<div className="flex w-full items-center justify-between rounded-md border px-3 py-2">
+															<div>
+																<p className="text-sm font-medium">SSL</p>
+																<p className="text-muted-foreground text-[11px]">
+																	`sslmode=require`
+																</p>
+															</div>
+															<Switch
+																checked={postgresSsl}
+																onCheckedChange={setPostgresSsl}
+															/>
+														</div>
+													</div>
+												</div>
+											</>
+										)}
+									</div>
+								)}
+
+								<div className="flex items-center justify-between gap-2">
+									<p className="text-muted-foreground truncate text-[11px]">
+										{connectionType === "sqlite"
+											? worktreePath
+												? `Workspace root: ${worktreePath}`
+												: "No workspace root available"
+											: "Use a PostgreSQL connection string"}
+									</p>
+									<div className="flex items-center gap-2">
+										{editingConnectionId ? (
+											<Button
+												type="button"
+												size="sm"
+												variant="outline"
+												onClick={() => {
+													resetConnectionForm();
+													setIsAddConnectionOpen(false);
+												}}
+											>
+												キャンセル
+											</Button>
+										) : null}
+										<Button
+											type="button"
+											size="sm"
+											onClick={handleAddConnection}
+										>
+											<LuPlus className="mr-1.5 size-3.5" />
+											{editingConnectionId ? "更新" : "保存"}
+										</Button>
+									</div>
+								</div>
+
+								{formError ? (
+									<Alert variant="destructive">
+										<AlertTitle>Add connection failed</AlertTitle>
+										<AlertDescription>{formError}</AlertDescription>
+									</Alert>
+								) : null}
+							</div>
+						</CollapsibleContent>
+					</Collapsible>
+				) : null}
+			</div>
+
+			<div className="flex-1 min-h-0 overflow-hidden">
+				{isSidebarMode ? (
+					<div className="h-full overflow-y-auto">
+						<section className="border-b p-3">
+							<div className="mb-2 flex items-center justify-between">
+								<h3 className="text-sm font-medium">Saved connections</h3>
+								<Badge variant="outline">{connections.length}</Badge>
+							</div>
+							<div className="space-y-2">
+								{connections.length > 0 ? (
+									connections.map((connection) => (
+										<ConnectionItem
+											key={connection.id}
+											connection={connection}
+											isActive={connection.id === resolvedSelectedConnectionId}
+											onOpen={
+												onOpenExplorer
+													? () => {
+															handleSelectConnectionId(connection.id);
+															onOpenExplorer(connection.id);
+														}
+													: undefined
+											}
+											onEdit={() => {
+												populateConnectionForm(connection);
+												setIsAddConnectionOpen(true);
+											}}
+											onSelect={() => handleSelectConnectionId(connection.id)}
+											onRemove={() => removeConnection(connection.id)}
+										/>
+									))
+								) : (
+									<Empty className="min-h-0 border border-dashed p-4">
+										<EmptyHeader className="max-w-none">
+											<EmptyMedia variant="icon">
+												<LuDatabase />
+											</EmptyMedia>
+											<EmptyTitle>No database connections</EmptyTitle>
+											<EmptyDescription>
+												Add a database connection to inspect schema and run
+												queries.
+											</EmptyDescription>
+										</EmptyHeader>
+									</Empty>
+								)}
+							</div>
+						</section>
+
+						<section className="border-b p-3">
+							<div className="flex items-center justify-between gap-2">
+								<div>
+									<h3 className="text-sm font-medium">Explorer</h3>
+									<p className="text-muted-foreground text-[11px]">
+										スキーマやデータは専用タブで開きます
+									</p>
+								</div>
+								<Button
+									type="button"
+									size="sm"
+									onClick={() =>
+										activeConnection && onOpenExplorer?.(activeConnection.id)
+									}
+									disabled={!activeConnection}
+								>
+									<LuExternalLink className="mr-1.5 size-3.5" />
+									Open Explorer
+								</Button>
+							</div>
+						</section>
+
+						<section className="border-b p-3">
+							<div className="mb-2 flex items-center justify-between">
+								<h3 className="text-sm font-medium">
+									Detected workspace databases
+								</h3>
+								<Badge variant="outline">
+									{discoverQuery.data?.files.length ?? 0}
+								</Badge>
+							</div>
+							{discoveredFiles.length > 0 ? (
+								<div className="space-y-2">
+									{discoveredFiles.map((file) => (
+										<div
+											key={file.absolutePath}
+											className="flex items-center gap-2 rounded-md border p-2"
+										>
+											<div className="min-w-0 flex-1">
+												<p className="truncate text-sm font-medium">
+													{guessConnectionLabel(file.absolutePath)}
+												</p>
+												<p className="text-muted-foreground truncate font-mono text-[11px]">
+													{file.relativePath}
+												</p>
+											</div>
+											<Button
+												type="button"
+												size="sm"
+												variant="outline"
+												onClick={() =>
+													handleAttachDiscoveredFile(file.absolutePath)
+												}
+											>
+												<LuPlus className="mr-1.5 size-3.5" />
+												Attach
+											</Button>
+										</div>
+									))}
+								</div>
+							) : (
+								<p className="text-muted-foreground text-sm">
+									{worktreePath
+										? "No SQLite-like files detected in this workspace."
+										: "Open a workspace to auto-discover SQLite files."}
+								</p>
+							)}
+						</section>
+					</div>
+				) : (
+					<ResizablePanelGroup direction="horizontal" className="h-full">
+						<ResizablePanel defaultSize={24} minSize={18}>
+							<div className="h-full overflow-y-auto border-r">
+								<section className="border-b p-3">
+									<div className="mb-2 flex items-center justify-between">
+										<h3 className="text-sm font-medium">Connections</h3>
+										<Badge variant="outline">{connections.length}</Badge>
+									</div>
+									<div className="space-y-1">
+										{connections.map((connection) => (
+											<button
+												key={connection.id}
+												type="button"
+												className={cn(
+													"flex w-full items-center gap-2 rounded-md px-2 py-1.5 text-left text-sm transition-colors",
+													connection.id === resolvedSelectedConnectionId
+														? "bg-accent text-accent-foreground"
+														: "hover:bg-muted/50",
+												)}
+												onClick={() => handleSelectConnectionId(connection.id)}
+											>
+												<LuDatabase className="size-3.5 shrink-0 text-muted-foreground" />
+												<span className="truncate">{connection.label}</span>
+											</button>
+										))}
+									</div>
+								</section>
+
+								<section className="p-2">
+									<div className="mb-2 px-1">
+										<h3 className="text-sm font-medium">Schema</h3>
+									</div>
+									{!activeConnection ? (
+										<p className="text-muted-foreground px-2 text-sm">
+											接続を選択してください。
+										</p>
+									) : activeSchemaQuery.isLoading ? (
+										<p className="text-muted-foreground px-2 text-sm">
+											Loading schema...
+										</p>
+									) : activeSchemaQuery.error ? (
+										<Alert variant="destructive" className="mx-1">
+											<AlertTitle>Schema load failed</AlertTitle>
+											<AlertDescription>
+												{activeSchemaQuery.error.message}
+											</AlertDescription>
+										</Alert>
+									) : tablesBySchema.length ? (
+										<div className="space-y-1">
+											{tablesBySchema.map((group) => (
+												<div key={group.schemaKey} className="rounded-md">
+													<button
+														type="button"
+														className="hover:bg-muted/50 flex w-full items-center gap-1 rounded-md px-2 py-1.5 text-left text-sm"
+														onClick={() => toggleSchemaGroup(group.schemaKey)}
+													>
+														{expandedSchemaKeys[group.schemaKey] ? (
+															<LuChevronDown className="size-3.5 shrink-0 text-muted-foreground" />
+														) : (
+															<LuChevronRight className="size-3.5 shrink-0 text-muted-foreground" />
+														)}
+														<span className="truncate font-medium">
+															{group.label}
+														</span>
+														<Badge variant="outline" className="ml-auto">
+															{group.tables.length}
+														</Badge>
+													</button>
+													{expandedSchemaKeys[group.schemaKey] ? (
+														<div className="mt-1 space-y-0.5 pl-5">
+															{group.tables.map((table) => (
+																<button
+																	key={getTableKey(table)}
+																	type="button"
+																	className={cn(
+																		"flex w-full items-center gap-2 rounded-md px-2 py-1.5 text-left text-sm transition-colors",
+																		selectedTableKey === getTableKey(table)
+																			? "bg-accent text-accent-foreground"
+																			: "hover:bg-muted/50",
+																	)}
+																	onClick={() => {
+																		startTransition(() => {
+																			setSelectedTableKey(getTableKey(table));
+																			setTablePreviewPage(0);
+																			setTableActionError(null);
+																			setTableSearchInput("");
+																			setTableSort(null);
+																			setColumnFilters({});
+																			setSelectedRowIds({});
+																		});
+																		if (previewScrollRef.current) {
+																			previewScrollRef.current.scrollTop = 0;
+																		}
+																	}}
+																>
+																	<LuTable2 className="size-3.5 shrink-0 text-muted-foreground" />
+																	<span className="truncate">{table.name}</span>
+																</button>
+															))}
+														</div>
+													) : null}
+												</div>
+											))}
+										</div>
+									) : (
+										<p className="text-muted-foreground px-2 text-sm">
+											No user tables found in this database.
+										</p>
+									)}
+								</section>
+							</div>
+						</ResizablePanel>
+						<ResizableHandle withHandle />
+						<ResizablePanel defaultSize={76} minSize={45}>
+							<div className="h-full overflow-y-auto">
+								<section className="border-b p-3">
+									<div className="mb-2 flex items-center justify-between gap-2">
+										<div>
+											<h3 className="text-sm font-medium">Table data</h3>
+											<p className="text-muted-foreground text-[11px]">
+												左のツリーからテーブルを選ぶと先頭{" "}
+												{TABLE_PREVIEW_PAGE_SIZE} 件ずつ表示します
+											</p>
+										</div>
+										<div className="flex items-center gap-2">
+											{selectedTable ? (
+												<Badge variant="outline">{selectedTableLabel}</Badge>
+											) : null}
+											<Button
+												type="button"
+												size="sm"
+												variant="outline"
+												onClick={() => void handleCreateRow()}
+												disabled={!selectedTable || isCreatingRow}
+											>
+												{isCreatingRow ? (
+													<LuRefreshCw className="mr-1.5 size-3.5 animate-spin" />
+												) : (
+													<LuPlus className="mr-1.5 size-3.5" />
+												)}
+												{isCreatingRow ? "開いています..." : "行を追加"}
+											</Button>
+											<Button
+												type="button"
+												size="sm"
+												variant="outline"
+												onClick={() => activePreviewQuery.refetch()}
+												disabled={
+													!selectedTable || activePreviewQuery.isFetching
+												}
+											>
+												<LuRefreshCw
+													className={cn(
+														"mr-1.5 size-3.5",
+														activePreviewQuery.isFetching && "animate-spin",
+													)}
+												/>
+												更新
+											</Button>
+											<Button
+												type="button"
+												size="sm"
+												variant="outline"
+												onClick={() => void handleExportPreviewRows("csv")}
+												disabled={
+													!filteredPreviewRows.length ||
+													tableExportFormat !== null
+												}
+											>
+												<LuExternalLink
+													className={cn(
+														"mr-1.5 size-3.5",
+														tableExportFormat === "csv" && "animate-pulse",
+													)}
+												/>
+												{tableExportFormat === "csv" ? "書き出し中..." : "CSV"}
+											</Button>
+											<Button
+												type="button"
+												size="sm"
+												variant="outline"
+												onClick={() => void handleExportPreviewRows("json")}
+												disabled={
+													!filteredPreviewRows.length ||
+													tableExportFormat !== null
+												}
+											>
+												<LuExternalLink
+													className={cn(
+														"mr-1.5 size-3.5",
+														tableExportFormat === "json" && "animate-pulse",
+													)}
+												/>
+												{tableExportFormat === "json"
+													? "書き出し中..."
+													: "JSON"}
+											</Button>
+											<Button
+												type="button"
+												size="sm"
+												variant="outline"
+												onClick={() => setIsSqlDialogOpen(true)}
+												disabled={!activeConnection}
+											>
+												<LuPlay className="mr-1.5 size-3.5" />
+												SQL
+											</Button>
+										</div>
+									</div>
+
+									{!activeConnection ? (
+										<p className="text-muted-foreground text-sm">
+											Select a saved connection to browse table rows.
+										</p>
+									) : !selectedTable ? (
+										<p className="text-muted-foreground text-sm">
+											左のツリーからテーブルを選択してください。
+										</p>
+									) : activePreviewQuery.isLoading &&
+										!activePreviewQuery.data ? (
+										<p className="text-muted-foreground text-sm">
+											Loading table data...
+										</p>
+									) : activePreviewQuery.error ? (
+										<Alert variant="destructive">
+											<AlertTitle>Table preview failed</AlertTitle>
+											<AlertDescription>
+												{activePreviewQuery.error.message}
+											</AlertDescription>
+										</Alert>
+									) : activePreviewQuery.data ? (
+										<div className="space-y-3">
+											{tableActionError ? (
+												<Alert variant="destructive">
+													<AlertTitle>Action failed</AlertTitle>
+													<AlertDescription>
+														{tableActionError}
+													</AlertDescription>
+												</Alert>
+											) : null}
+											<div className="flex flex-wrap items-center gap-2">
+												<div className="relative min-w-[18rem] flex-1">
+													<LuSearch className="text-muted-foreground absolute top-1/2 left-3 size-4 -translate-y-1/2" />
+													<Input
+														value={tableSearchInput}
+														onChange={(event) =>
+															setTableSearchInput(event.target.value)
+														}
+														placeholder="検索結果"
+														className="pl-9"
+													/>
+													{tableSearchInput ? (
+														<button
+															type="button"
+															className="text-muted-foreground hover:text-foreground absolute top-1/2 right-3 -translate-y-1/2"
+															onClick={() => setTableSearchInput("")}
+														>
+															<LuX className="size-4" />
+														</button>
+													) : null}
+												</div>
+												<Button
+													type="button"
+													size="sm"
+													variant="outline"
+													onClick={() => void handleDeleteSelectedRows()}
+													disabled={
+														selectedVisibleRowCount === 0 || isQueryRunning
+													}
+												>
+													<LuTrash2 className="mr-1.5 size-3.5" />
+													削除
+													{selectedVisibleRowCount > 0
+														? ` (${selectedVisibleRowCount})`
+														: ""}
+												</Button>
+											</div>
+											<div className="flex items-center gap-2 text-xs">
+												<Badge variant="outline">
+													{filteredPreviewRows.length} rows shown
+												</Badge>
+												<Badge variant="outline">
+													{activePreviewQuery.data.elapsedMs} ms
+												</Badge>
+												<Badge variant="outline">
+													{filteredPreviewRows.length > 0
+														? `${activePreviewQuery.data.offset + 1}-${
+																activePreviewQuery.data.offset +
+																filteredPreviewRows.length
+															}`
+														: "0 rows"}
+												</Badge>
+												{selectedVisibleRowCount > 0 ? (
+													<Badge variant="secondary">
+														{selectedVisibleRowCount} selected
+													</Badge>
+												) : null}
+												{activePreviewQuery.data.hasMore ? (
+													<Badge variant="outline">more available</Badge>
+												) : null}
+												{activePreviewQuery.isFetching ? (
+													<Badge variant="secondary">
+														<LuRefreshCw className="mr-1 size-3 animate-spin" />
+														Updating...
+													</Badge>
+												) : null}
+											</div>
+											<ContextMenu onOpenChange={setIsCellContextMenuOpen}>
+												<ContextMenuTrigger asChild>
+													<div className="overflow-hidden rounded-md border">
+														<div
+															ref={previewScrollRef}
+															className="max-h-[42rem] overflow-auto"
+														>
+															<Table className="min-w-max">
+																<TableHeader>
+																	<TableRow>
+																		<TableHead className="w-10 min-w-10">
+																			<Checkbox
+																				checked={
+																					areAllVisibleRowsSelected
+																						? true
+																						: isPartiallySelected
+																							? "indeterminate"
+																							: false
+																				}
+																				onCheckedChange={(checked) =>
+																					toggleAllVisibleRows(Boolean(checked))
+																				}
+																				aria-label="Select all visible rows"
+																			/>
+																		</TableHead>
+																		{activePreviewQuery.data.columns.map(
+																			(column) => (
+																				<TableHead
+																					key={column}
+																					className="whitespace-nowrap"
+																				>
+																					<div className="flex items-center gap-1">
+																						<button
+																							type="button"
+																							className="hover:text-foreground flex items-center gap-1 font-medium"
+																							onClick={() =>
+																								toggleTableSort(column)
+																							}
+																						>
+																							<span>{column}</span>
+																							{tableSort?.column === column ? (
+																								tableSort.direction ===
+																								"asc" ? (
+																									<LuArrowUp className="size-3.5" />
+																								) : (
+																									<LuArrowDown className="size-3.5" />
+																								)
+																							) : (
+																								<LuArrowUpDown className="text-muted-foreground size-3.5" />
+																							)}
+																						</button>
+																						<Popover>
+																							<PopoverTrigger asChild>
+																								<Button
+																									type="button"
+																									size="icon"
+																									variant="ghost"
+																									className={cn(
+																										"size-6",
+																										columnFilters[column] &&
+																											"text-primary",
+																									)}
+																								>
+																									<LuFilter className="size-3.5" />
+																								</Button>
+																							</PopoverTrigger>
+																							<PopoverContent
+																								align="start"
+																								className="w-72 space-y-3"
+																							>
+																								<div className="space-y-1">
+																									<p className="text-sm font-medium">
+																										フィルター条件 "{column}"
+																									</p>
+																									<Input
+																										value={
+																											columnFilters[column] ??
+																											""
+																										}
+																										onChange={(event) =>
+																											setColumnFilterValue(
+																												column,
+																												event.target.value,
+																											)
+																										}
+																										placeholder="部分一致で絞り込み"
+																									/>
+																								</div>
+																								<div className="flex items-center justify-end gap-2">
+																									<Button
+																										type="button"
+																										size="sm"
+																										variant="outline"
+																										onClick={() =>
+																											setColumnFilterValue(
+																												column,
+																												"",
+																											)
+																										}
+																									>
+																										Clear
+																									</Button>
+																								</div>
+																							</PopoverContent>
+																						</Popover>
+																					</div>
+																				</TableHead>
+																			),
+																		)}
+																	</TableRow>
+																</TableHeader>
+																<TableBody>
+																	{paddingTop > 0 ? (
+																		<TableRow>
+																			<TableCell
+																				colSpan={Math.max(
+																					activePreviewQuery.data.columns
+																						.length + 1,
+																					1,
+																				)}
+																				style={{ height: paddingTop }}
+																				className="p-0"
+																			/>
+																		</TableRow>
+																	) : null}
+																	{filteredPreviewRows.length > 0 ? (
+																		virtualRows.map((virtualRow) => {
+																			const row =
+																				filteredPreviewRows[virtualRow.index];
+																			const rowId = activeConnection
+																				? getRowIdentifier(
+																						row,
+																						activeConnection.dialect,
+																					)
+																				: null;
+																			return (
+																				<PreviewTableRowView
+																					key={
+																						rowId ??
+																						`${virtualRow.index}-${activePreviewQuery.data.columns.join("-")}`
+																					}
+																					row={row}
+																					rowId={rowId}
+																					columns={
+																						activePreviewQuery.data.columns
+																					}
+																					selected={Boolean(
+																						rowId && selectedRowIds[rowId],
+																					)}
+																					onToggleSelection={toggleRowSelection}
+																					onOpenContextMenu={
+																						handleOpenCellContextMenu
+																					}
+																					getCanOpenDetail={getCanOpenDetail}
+																					onOpenDetail={handleOpenCellDetail}
+																					dataIndex={virtualRow.index}
+																				/>
+																			);
+																		})
+																	) : (
+																		<TableRow>
+																			<TableCell
+																				colSpan={Math.max(
+																					activePreviewQuery.data.columns
+																						.length + 1,
+																					1,
+																				)}
+																				className="text-muted-foreground text-center text-sm"
+																			>
+																				{previewRows.length > 0
+																					? "現在の検索条件に一致する行はありません。"
+																					: "No rows found in this table."}
+																			</TableCell>
+																		</TableRow>
+																	)}
+																	{paddingBottom > 0 ? (
+																		<TableRow>
+																			<TableCell
+																				colSpan={Math.max(
+																					activePreviewQuery.data.columns
+																						.length + 1,
+																					1,
+																				)}
+																				style={{ height: paddingBottom }}
+																				className="p-0"
+																			/>
+																		</TableRow>
+																	) : null}
+																</TableBody>
+															</Table>
+														</div>
+													</div>
+												</ContextMenuTrigger>
+												<ContextMenuContent>
+													<ContextMenuItem
+														disabled={!contextCell}
+														onSelect={() =>
+															contextCell
+																? copyToClipboard(contextCell.display)
+																: undefined
+														}
+													>
+														<LuCopy className="mr-2 size-4" />
+														コピー
+													</ContextMenuItem>
+													<ContextMenuItem
+														disabled={!contextCell}
+														onSelect={() => {
+															if (!contextCell) {
+																return;
+															}
+															setPendingEditRequest({
+																row: contextCell.row,
+																column: contextCell.column,
+															});
+															setIsCellContextMenuOpen(false);
+														}}
+													>
+														<LuPencil className="mr-2 size-4" />
+														編集
+													</ContextMenuItem>
+													<ContextMenuItem
+														disabled={!contextCell}
+														onSelect={() =>
+															contextCell
+																? handleCopyRow(contextCell.row)
+																: undefined
+														}
+													>
+														<LuCopy className="mr-2 size-4" />
+														行をコピー
+													</ContextMenuItem>
+													<ContextMenuItem
+														disabled={!contextCell}
+														onSelect={() =>
+															contextCell
+																? (() => {
+																		setPendingEditRequest({
+																			row: contextCell.row,
+																			mode: "duplicate",
+																		});
+																		setIsCellContextMenuOpen(false);
+																	})()
+																: undefined
+														}
+													>
+														<LuPlus className="mr-2 size-4" />
+														行を複製
+													</ContextMenuItem>
+													<ContextMenuSeparator />
+													<ContextMenuItem
+														disabled={!contextCell}
+														onSelect={() =>
+															contextCell
+																? handleQuickCellUpdate({
+																		row: contextCell.row,
+																		column: contextCell.column,
+																		value: null,
+																	})
+																: undefined
+														}
+													>
+														<LuEraser className="mr-2 size-4" />
+														NULLに設定
+													</ContextMenuItem>
+													<ContextMenuItem
+														disabled={!contextCell}
+														onSelect={() =>
+															contextCell
+																? handleQuickCellUpdate({
+																		row: contextCell.row,
+																		column: contextCell.column,
+																		value: "",
+																	})
+																: undefined
+														}
+													>
+														<LuEraser className="mr-2 size-4" />
+														空の文字列に設定
+													</ContextMenuItem>
+												</ContextMenuContent>
+											</ContextMenu>
+											<div className="flex items-center justify-end gap-2">
+												<Button
+													type="button"
+													size="sm"
+													variant="outline"
+													onClick={() => {
+														setTablePreviewPage((page) =>
+															Math.max(page - 1, 0),
+														);
+														if (previewScrollRef.current) {
+															previewScrollRef.current.scrollTop = 0;
+														}
+													}}
+													disabled={tablePreviewPage === 0}
+												>
+													前へ
+												</Button>
+												<Button
+													type="button"
+													size="sm"
+													variant="outline"
+													onClick={() => {
+														setTablePreviewPage((page) => page + 1);
+														if (previewScrollRef.current) {
+															previewScrollRef.current.scrollTop = 0;
+														}
+													}}
+													disabled={!activePreviewQuery.data.hasMore}
+												>
+													次へ
+												</Button>
+											</div>
+										</div>
+									) : (
+										<p className="text-muted-foreground text-sm">
+											Select a table to preview its rows.
+										</p>
+									)}
+								</section>
+							</div>
+						</ResizablePanel>
+					</ResizablePanelGroup>
+				)}
+			</div>
+			<Dialog open={isSqlDialogOpen} onOpenChange={setIsSqlDialogOpen}>
+				<DialogContent className="flex max-h-[85vh] !max-w-[72rem] flex-col overflow-hidden">
+					<DialogHeader>
+						<DialogTitle>
+							SQL Runner
+							{selectedTableLabel ? ` · ${selectedTableLabel}` : ""}
+						</DialogTitle>
+						<DialogDescription>
+							選択中のデータベース接続に対して SQL を実行します。
+						</DialogDescription>
+					</DialogHeader>
+					<div className="grid min-h-0 flex-1 grid-cols-[16rem_minmax(0,1fr)] gap-3">
+						<div className="min-h-0 overflow-hidden rounded-md border">
+							<div className="flex items-center justify-between border-b px-3 py-2">
+								<div>
+									<p className="text-sm font-medium">Query history</p>
+									<p className="text-muted-foreground text-[11px]">
+										接続ごとに最近の実行 SQL を保存します
+									</p>
+								</div>
+								<Button
+									type="button"
+									size="sm"
+									variant="ghost"
+									onClick={() =>
+										activeConnection
+											? clearQueryHistoryForConnection(activeConnection.id)
+											: undefined
+									}
+									disabled={
+										!activeConnection || !queryHistoryForActiveConnection.length
+									}
+								>
+									Clear
+								</Button>
+							</div>
+							<div className="max-h-[34rem] overflow-y-auto p-2">
+								{queryHistoryForActiveConnection.length ? (
+									<div className="space-y-1">
+										{queryHistoryForActiveConnection.map(
+											(item: SavedDatabaseQueryHistoryItem) => (
+												<div
+													key={item.id}
+													className="hover:bg-muted/50 rounded-md border p-2"
+												>
+													<button
+														type="button"
+														className="w-full text-left"
+														onClick={() => setSql(item.sql)}
+													>
+														<p className="truncate font-mono text-[11px]">
+															{item.sql.replaceAll(/\s+/g, " ").trim()}
+														</p>
+														<p className="text-muted-foreground mt-1 text-[10px]">
+															{new Date(item.executedAt).toLocaleString()}
+														</p>
+													</button>
+													<div className="mt-2 flex items-center justify-end gap-2">
+														<Button
+															type="button"
+															size="sm"
+															variant="ghost"
+															onClick={() => setSql(item.sql)}
+														>
+															Load
+														</Button>
+														<Button
+															type="button"
+															size="sm"
+															variant="ghost"
+															onClick={() => removeQueryHistoryItem(item.id)}
+														>
+															<LuTrash2 className="size-3.5" />
+														</Button>
+													</div>
+												</div>
+											),
+										)}
+									</div>
+								) : (
+									<p className="text-muted-foreground text-sm">
+										まだ履歴はありません。
+									</p>
+								)}
+							</div>
+						</div>
+						<div className="flex min-h-0 flex-col gap-3">
+							<Textarea
+								value={sql}
+								onChange={(event) => setSql(event.target.value)}
+								className="min-h-40 font-mono text-[12px]"
+							/>
+							{queryError ? (
+								<Alert variant="destructive">
+									<AlertTitle>Query failed</AlertTitle>
+									<AlertDescription>{queryError}</AlertDescription>
+								</Alert>
+							) : null}
+							<div className="min-h-0 flex-1 overflow-hidden rounded-md border">
+								<div className="h-full max-h-[26rem] overflow-auto p-3">
+									{isQueryRunning ? (
+										<p className="text-muted-foreground text-sm">
+											Running query...
+										</p>
+									) : queryResult ? (
+										<div className="space-y-3">
+											<div className="flex items-center gap-2 text-xs">
+												<Badge variant="outline">
+													{queryResult.rowCount} rows
+												</Badge>
+												<Badge variant="outline">
+													{queryResult.elapsedMs} ms
+												</Badge>
+												{queryResult.command ? (
+													<Badge variant="outline">{queryResult.command}</Badge>
+												) : null}
+												{queryResult.truncated ? (
+													<Badge variant="outline">Truncated to 200 rows</Badge>
+												) : null}
+												{queryResult.lastInsertRowid ? (
+													<Badge variant="outline">
+														last id {String(queryResult.lastInsertRowid)}
+													</Badge>
+												) : null}
+											</div>
+											<div className="overflow-hidden rounded-md border">
+												<div className="max-h-80 overflow-auto">
+													<Table className="min-w-max">
+														<TableHeader>
+															<TableRow>
+																{queryResult.columns.map((column) => (
+																	<TableHead
+																		key={column}
+																		className="whitespace-nowrap"
+																	>
+																		{column}
+																	</TableHead>
+																))}
+															</TableRow>
+														</TableHeader>
+														<TableBody>
+															{queryResult.rows.length > 0 ? (
+																queryResult.rows.map((row, index) => (
+																	<TableRow
+																		key={`${index}-${queryResult.columns.join("-")}`}
+																	>
+																		{queryResult.columns.map((column) => (
+																			<TableCell
+																				key={`${index}-${column}`}
+																				className="max-w-[24rem] align-top font-mono text-[11px]"
+																			>
+																				<div className="overflow-hidden text-ellipsis whitespace-nowrap">
+																					{formatCellValue(row[column])}
+																				</div>
+																			</TableCell>
+																		))}
+																	</TableRow>
+																))
+															) : (
+																<TableRow>
+																	<TableCell
+																		colSpan={Math.max(
+																			queryResult.columns.length,
+																			1,
+																		)}
+																		className="text-muted-foreground text-center text-sm"
+																	>
+																		Query completed with no result rows.
+																	</TableCell>
+																</TableRow>
+															)}
+														</TableBody>
+													</Table>
+												</div>
+											</div>
+										</div>
+									) : (
+										<Empty className="min-h-0 border-0 p-0">
+											<EmptyContent className="max-w-none">
+												<EmptyHeader className="max-w-none">
+													<EmptyMedia variant="icon">
+														<LuPlay />
+													</EmptyMedia>
+													<EmptyTitle>No query results yet</EmptyTitle>
+													<EmptyDescription>
+														Run a query against the selected database
+														connection.
+													</EmptyDescription>
+												</EmptyHeader>
+											</EmptyContent>
+										</Empty>
+									)}
+								</div>
+							</div>
+						</div>
+					</div>
+					<DialogFooter>
+						<Button
+							type="button"
+							variant="outline"
+							onClick={() => setIsSqlDialogOpen(false)}
+						>
+							閉じる
+						</Button>
+						<Button
+							type="button"
+							onClick={() => void handleRunQuery()}
+							disabled={!activeConnection || isQueryRunning}
+						>
+							<LuPlay className="mr-1.5 size-3.5" />
+							Run
+						</Button>
+					</DialogFooter>
+				</DialogContent>
+			</Dialog>
+			<Dialog
+				open={isEditDialogOpen}
+				onOpenChange={(open) => {
+					if (!open) {
+						return;
+					}
+				}}
+			>
+				<DialogContent className="flex max-h-[85vh] !max-w-[72rem] flex-col overflow-hidden">
+					<DialogHeader>
+						<DialogTitle>
+							{editingCell?.mode === "insert"
+								? "Insert Row"
+								: editingCell?.mode === "duplicate"
+									? "Duplicate Row"
+									: "Edit Row"}{" "}
+							{selectedTableLabel ? `for "${selectedTableLabel}"` : ""}
+						</DialogTitle>
+						<DialogDescription>
+							{editingCell?.mode === "edit"
+								? "選択した行の各カラム値を編集します。"
+								: "値を確認して新しい行を保存します。"}
+						</DialogDescription>
+					</DialogHeader>
+					<div className="grid max-h-[60vh] grid-cols-2 gap-4 overflow-y-auto pr-1">
+						{isEditDialogLoading ? (
+							<p className="text-muted-foreground col-span-2 text-sm">
+								Loading full row data...
+							</p>
+						) : editingCell ? (
+							visiblePreviewColumns.map((column) => {
+								const draft = rowDraft[column] ?? {
+									value: "",
+									isNull: false,
+								};
+								return (
+									<div key={column} className="space-y-1">
+										<div className="flex items-center justify-between gap-2">
+											<Label htmlFor={`edit-row-${column}`}>{column}</Label>
+											<Button
+												type="button"
+												size="sm"
+												variant="ghost"
+												onClick={() =>
+													setRowDraft((current) => ({
+														...current,
+														[column]: { value: "", isNull: true },
+													}))
+												}
+											>
+												NULL
+											</Button>
+										</div>
+										<Input
+											id={`edit-row-${column}`}
+											value={draft.isNull ? "" : draft.value}
+											onChange={(event) =>
+												setRowDraft((current) => ({
+													...current,
+													[column]: {
+														value: event.target.value,
+														isNull: false,
+													},
+												}))
+											}
+											placeholder={draft.isNull ? "NULL" : column}
+										/>
+									</div>
+								);
+							})
+						) : null}
+					</div>
+					<DialogFooter>
+						<Button
+							type="button"
+							variant="outline"
+							onClick={() => {
+								setIsEditDialogOpen(false);
+								setEditingCell(null);
+								setRowDraft({});
+							}}
+						>
+							キャンセル
+						</Button>
+						<Button
+							type="button"
+							onClick={() => void handleSaveRowEdit()}
+							disabled={isEditDialogLoading}
+						>
+							{editingCell?.mode === "edit" ? "更新" : "保存"}
+						</Button>
+					</DialogFooter>
+				</DialogContent>
+			</Dialog>
+			<Dialog
+				open={isCellDetailDialogOpen}
+				onOpenChange={(open) => {
+					if (!open) {
+						setIsCellDetailDialogOpen(false);
+						setCellDetail(null);
+					}
+				}}
+			>
+				<DialogContent className="flex max-h-[85vh] !max-w-[72rem] flex-col overflow-hidden">
+					<DialogHeader>
+						<DialogTitle>データを編集</DialogTitle>
+						<DialogDescription>
+							{cellDetail?.column
+								? `${cellDetail.column} の詳細値を表示・編集します。`
+								: "セルの詳細値を表示します。"}
+						</DialogDescription>
+					</DialogHeader>
+					<div className="flex min-h-0 flex-1 flex-col gap-3 overflow-hidden">
+						<div className="flex items-center gap-2">
+							<Select
+								value={cellDetail?.format === "json" ? "json" : "text"}
+								onValueChange={(value) =>
+									handleCellDetailFormatChange(value as "text" | "json")
+								}
+								disabled={!cellDetail}
+							>
+								<SelectTrigger className="w-32">
+									<SelectValue />
+								</SelectTrigger>
+								<SelectContent>
+									<SelectItem value="text">Text</SelectItem>
+									{cellDetail &&
+									canUseJsonDetailFormat(
+										cellDetail.columnType,
+										cellDetail.value,
+									) ? (
+										<SelectItem value="json">JSON</SelectItem>
+									) : null}
+								</SelectContent>
+							</Select>
+							{cellDetail &&
+							canUseMarkdownDetailFormat(
+								cellDetail.columnType,
+								cellDetail.value,
+							) ? (
+								<Button
+									type="button"
+									size="sm"
+									variant={
+										cellDetail.format === "markdown" ? "default" : "outline"
+									}
+									onClick={() =>
+										handleCellDetailFormatChange(
+											cellDetail.format === "markdown" ? "text" : "markdown",
+										)
+									}
+								>
+									<LuEye className="mr-1.5 size-3.5" />
+									{cellDetail.format === "markdown"
+										? "テキスト編集に戻る"
+										: "Markdownとして見る"}
+								</Button>
+							) : null}
+							<Button
+								type="button"
+								size="sm"
+								variant="outline"
+								onClick={() => void handleCopyCellDetail()}
+								disabled={!cellDetail || isCellDetailCopying}
+							>
+								<LuCopy className="mr-1.5 size-3.5" />
+								{isCellDetailCopying ? "コピー中..." : "コピー"}
+							</Button>
+							<Button
+								type="button"
+								size="sm"
+								variant="outline"
+								onClick={() => void handleExportCellDetail()}
+								disabled={!cellDetail || isCellDetailExporting}
+							>
+								<LuExternalLink className="mr-1.5 size-3.5" />
+								{isCellDetailExporting ? "書き出し中..." : "Export"}
+							</Button>
+						</div>
+						<div className="min-h-0 flex-1 overflow-hidden rounded-md border">
+							{isCellDetailLoading ? (
+								<div className="flex h-full items-center justify-center">
+									<p className="text-muted-foreground text-sm">
+										Loading full cell value...
+									</p>
+								</div>
+							) : cellDetail?.format === "markdown" ? (
+								<div className="h-[31rem] min-h-[31rem] max-h-[78vh] overflow-y-auto p-3">
+									<div className="min-h-full">
+										<MarkdownRenderer
+											content={cellDetail.draft}
+											scrollable={false}
+											className="!h-auto overflow-visible"
+										/>
+									</div>
+								</div>
+							) : (
+								<textarea
+									value={cellDetail?.draft ?? ""}
+									onChange={(event) =>
+										setCellDetail((current) =>
+											current
+												? { ...current, draft: event.target.value }
+												: current,
+										)
+									}
+									className="text-foreground placeholder:text-muted-foreground h-[31rem] min-h-[31rem] w-full resize-none overflow-auto border-0 bg-transparent px-3 py-2 font-mono text-[12px] outline-none"
+								/>
+							)}
+						</div>
+					</div>
+					<DialogFooter>
+						<Button
+							type="button"
+							variant="outline"
+							onClick={() => {
+								setIsCellDetailDialogOpen(false);
+								setCellDetail(null);
+							}}
+						>
+							閉じる
+						</Button>
+						<Button
+							type="button"
+							onClick={() => void handleSaveCellDetail()}
+							disabled={!cellDetail || isCellDetailLoading}
+						>
+							保存
+						</Button>
+					</DialogFooter>
+				</DialogContent>
+			</Dialog>
+		</div>
+	);
+}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/DatabasesView/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/DatabasesView/index.ts
new file mode 100644
index 00000000000..d59923a8c7a
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/DatabasesView/index.ts
@@ -0,0 +1 @@
+export { DatabasesView } from "./DatabasesView";
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/ProblemsView/ProblemsView.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/ProblemsView/ProblemsView.tsx
new file mode 100644
index 00000000000..1426066e4c9
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/ProblemsView/ProblemsView.tsx
@@ -0,0 +1,575 @@
+import { Badge } from "@superset/ui/badge";
+import { Button } from "@superset/ui/button";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@superset/ui/collapsible";
+import {
+	ContextMenu,
+	ContextMenuContent,
+	ContextMenuItem,
+	ContextMenuTrigger,
+} from "@superset/ui/context-menu";
+import {
+	Empty,
+	EmptyContent,
+	EmptyDescription,
+	EmptyHeader,
+	EmptyMedia,
+	EmptyTitle,
+} from "@superset/ui/empty";
+import { ScrollArea } from "@superset/ui/scroll-area";
+import { toast } from "@superset/ui/sonner";
+import { ToggleGroup, ToggleGroupItem } from "@superset/ui/toggle-group";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@superset/ui/tooltip";
+import { cn } from "@superset/ui/utils";
+import { useMemo, useState } from "react";
+import {
+	LuChevronDown,
+	LuChevronRight,
+	LuCircleAlert,
+	LuClipboard,
+	LuCopy,
+	LuInfo,
+	LuRefreshCw,
+	LuTriangleAlert,
+} from "react-icons/lu";
+import { electronTrpc } from "renderer/lib/electron-trpc";
+import { useWorkspaceId } from "renderer/screens/main/components/WorkspaceView/WorkspaceIdContext";
+
+type ProblemItem = {
+	providerId: string;
+	absolutePath: string | null;
+	relativePath: string | null;
+	line: number | null;
+	column: number | null;
+	endLine: number | null;
+	endColumn: number | null;
+	message: string;
+	code: string | number | null;
+	severity: "error" | "warning" | "info" | "hint";
+	source: string;
+	relatedInformation?: Array<{
+		absolutePath: string | null;
+		relativePath: string | null;
+		line: number | null;
+		column: number | null;
+		endLine: number | null;
+		endColumn: number | null;
+		message: string;
+	}>;
+};
+
+const SEVERITY_FILTERS = [
+	{
+		value: "error",
+		label: "Error",
+		shortLabel: "Error",
+	},
+	{
+		value: "warning",
+		label: "Warning",
+		shortLabel: "Warn",
+	},
+	{
+		value: "info",
+		label: "Info",
+		shortLabel: "Info",
+	},
+	{
+		value: "hint",
+		label: "Hint",
+		shortLabel: "Hint",
+	},
+] as const satisfies ReadonlyArray<{
+	value: ProblemItem["severity"];
+	label: string;
+	shortLabel: string;
+}>;
+
+function severityLabel(severity: ProblemItem["severity"]): string {
+	switch (severity) {
+		case "error":
+			return "Error";
+		case "warning":
+			return "Warning";
+		case "info":
+			return "Info";
+		default:
+			return "Hint";
+	}
+}
+
+function severityIcon(severity: ProblemItem["severity"]) {
+	switch (severity) {
+		case "error":
+			return <LuCircleAlert className="size-3.5 shrink-0 text-red-500" />;
+		case "warning":
+			return <LuTriangleAlert className="size-3.5 shrink-0 text-amber-500" />;
+		default:
+			return <LuInfo className="size-3.5 shrink-0 text-blue-500" />;
+	}
+}
+
+function severityToMarkerSeverity(severity: ProblemItem["severity"]): number {
+	switch (severity) {
+		case "error":
+			return 8;
+		case "warning":
+			return 4;
+		case "info":
+			return 2;
+		default:
+			return 1;
+	}
+}
+
+function normalizeSource(source: string): string {
+	return source === "typescript" ? "ts" : source;
+}
+
+function getSummaryCount(
+	summary:
+		| {
+				errorCount: number;
+				warningCount: number;
+				infoCount: number;
+				hintCount: number;
+		  }
+		| null
+		| undefined,
+	severity: ProblemItem["severity"],
+): number {
+	switch (severity) {
+		case "error":
+			return summary?.errorCount ?? 0;
+		case "warning":
+			return summary?.warningCount ?? 0;
+		case "info":
+			return summary?.infoCount ?? 0;
+		default:
+			return summary?.hintCount ?? 0;
+	}
+}
+
+function buildClipboardPayload(problem: ProblemItem) {
+	return [
+		{
+			resource: problem.absolutePath ?? problem.relativePath ?? "",
+			owner: problem.providerId,
+			code: problem.code !== null ? String(problem.code) : "",
+			severity: severityToMarkerSeverity(problem.severity),
+			message: problem.message,
+			source: normalizeSource(problem.source),
+			startLineNumber: problem.line ?? 1,
+			startColumn: problem.column ?? 1,
+			endLineNumber: problem.endLine ?? problem.line ?? 1,
+			endColumn: problem.endColumn ?? problem.column ?? 1,
+			relatedInformation:
+				problem.relatedInformation?.map((item) => ({
+					startLineNumber: item.line ?? 1,
+					startColumn: item.column ?? 1,
+					endLineNumber: item.endLine ?? item.line ?? 1,
+					endColumn: item.endColumn ?? item.column ?? 1,
+					message: item.message,
+					resource: item.absolutePath ?? item.relativePath ?? "",
+				})) ?? [],
+			origin: "extHost1",
+		},
+	];
+}
+
+async function copyToClipboard(text: string, successMessage: string) {
+	await navigator.clipboard.writeText(text);
+	toast.success(successMessage);
+}
+
+function TruncatedWithTooltip({
+	children,
+	tooltip,
+	className,
+}: {
+	children: string;
+	tooltip?: string;
+	className?: string;
+}) {
+	return (
+		<Tooltip delayDuration={400}>
+			<TooltipTrigger asChild>
+				<div
+					className={cn(
+						"min-w-0 max-w-full overflow-hidden text-ellipsis whitespace-nowrap",
+						className,
+					)}
+				>
+					{children}
+				</div>
+			</TooltipTrigger>
+			<TooltipContent
+				side="top"
+				align="start"
+				className="max-w-[420px] text-xs"
+			>
+				<p className="whitespace-pre-wrap break-words">{tooltip ?? children}</p>
+			</TooltipContent>
+		</Tooltip>
+	);
+}
+
+export function ProblemsView({
+	isActive,
+	onOpenFileAtLine,
+}: {
+	isActive: boolean;
+	onOpenFileAtLine: (path: string, line?: number) => void;
+}) {
+	const workspaceId = useWorkspaceId();
+	const trpcUtils = electronTrpc.useUtils();
+	const [openGroups, setOpenGroups] = useState<Record<string, boolean>>({});
+	const [severityFilters, setSeverityFilters] = useState<
+		ProblemItem["severity"][]
+	>(SEVERITY_FILTERS.map((filter) => filter.value));
+
+	const { data, isLoading, isFetching, refetch } =
+		electronTrpc.languageServices.getWorkspaceDiagnostics.useQuery(
+			{ workspaceId: workspaceId ?? "" },
+			{
+				enabled: isActive && Boolean(workspaceId),
+				staleTime: Infinity,
+			},
+		);
+
+	const refreshDiagnostics =
+		electronTrpc.languageServices.refreshWorkspace.useMutation({
+			onSuccess: async (_data, variables) => {
+				await trpcUtils.languageServices.getWorkspaceDiagnostics.invalidate({
+					workspaceId: variables.workspaceId,
+				});
+			},
+		});
+
+	electronTrpc.languageServices.subscribeDiagnostics.useSubscription(
+		{ workspaceId: workspaceId ?? "" },
+		{
+			enabled: Boolean(workspaceId),
+			onData: () => {
+				if (!workspaceId) {
+					return;
+				}
+				void trpcUtils.languageServices.getWorkspaceDiagnostics.invalidate({
+					workspaceId,
+				});
+			},
+		},
+	);
+
+	const visibleProblems = useMemo(() => {
+		const activeSeverities = new Set(severityFilters);
+		return (data?.problems ?? []).filter((problem) =>
+			activeSeverities.has(problem.severity),
+		);
+	}, [data?.problems, severityFilters]);
+
+	const groupedProblems = useMemo(() => {
+		const groups = new Map<string, ProblemItem[]>();
+		for (const problem of visibleProblems) {
+			const groupKey = problem.relativePath ?? "Workspace";
+			const existing = groups.get(groupKey);
+			if (existing) {
+				existing.push(problem);
+			} else {
+				groups.set(groupKey, [problem]);
+			}
+		}
+
+		return Array.from(groups.entries()).map(([groupKey, problems]) => ({
+			groupKey,
+			problems,
+		}));
+	}, [visibleProblems]);
+
+	return (
+		<div className="flex h-full min-h-0 flex-col overflow-hidden">
+			<div className="overflow-hidden border-b px-3 py-2">
+				<div className="flex min-w-0 items-center justify-between gap-2 overflow-hidden">
+					<div className="flex min-w-0 items-center gap-2">
+						<Badge variant="destructive">{data?.summary.errorCount ?? 0}</Badge>
+						<Badge variant="secondary">{data?.summary.warningCount ?? 0}</Badge>
+						<Badge variant="outline">
+							{visibleProblems.length}
+							{visibleProblems.length !== (data?.totalCount ?? 0)
+								? ` / ${data?.totalCount ?? 0}`
+								: ""}{" "}
+							total
+						</Badge>
+					</div>
+					<Button
+						type="button"
+						variant="ghost"
+						size="icon"
+						className="size-7 shrink-0"
+						onClick={() => {
+							if (!workspaceId) {
+								return;
+							}
+							void refreshDiagnostics.mutateAsync({ workspaceId });
+							void refetch();
+						}}
+						disabled={isFetching || refreshDiagnostics.isPending}
+					>
+						<LuRefreshCw
+							className={cn(
+								"size-3.5",
+								(isFetching || refreshDiagnostics.isPending) && "animate-spin",
+							)}
+						/>
+					</Button>
+				</div>
+				<div className="mt-2 flex min-w-0 flex-wrap items-start gap-2 overflow-hidden">
+					<ToggleGroup
+						type="multiple"
+						value={severityFilters}
+						onValueChange={(nextValue) => {
+							setSeverityFilters(
+								nextValue.filter((value): value is ProblemItem["severity"] =>
+									SEVERITY_FILTERS.some((filter) => filter.value === value),
+								),
+							);
+						}}
+						size="sm"
+						variant="outline"
+						className="min-w-0 max-w-full flex-wrap overflow-hidden gap-1"
+						spacing={1}
+					>
+						{SEVERITY_FILTERS.map((filter) => {
+							const count = getSummaryCount(data?.summary, filter.value);
+							return (
+								<ToggleGroupItem
+									key={filter.value}
+									value={filter.value}
+									aria-label={`Show ${filter.label} problems`}
+									className="h-6 gap-1 px-2 text-[11px] text-muted-foreground data-[state=on]:text-foreground"
+								>
+									{severityIcon(filter.value)}
+									<span>{filter.shortLabel}</span>
+									<span className="text-[10px] opacity-70">{count}</span>
+								</ToggleGroupItem>
+							);
+						})}
+					</ToggleGroup>
+					{groupedProblems.length > 0 ? (
+						<div className="flex min-w-0 shrink-0 items-center gap-1">
+							<Button
+								type="button"
+								variant="ghost"
+								size="sm"
+								className="h-6 max-w-[92px] px-2 text-[11px] text-muted-foreground"
+								onClick={() => {
+									setOpenGroups(
+										Object.fromEntries(
+											groupedProblems.map(({ groupKey }) => [groupKey, true]),
+										),
+									);
+								}}
+							>
+								<span className="block truncate">Expand all</span>
+							</Button>
+							<Button
+								type="button"
+								variant="ghost"
+								size="sm"
+								className="h-6 max-w-[96px] px-2 text-[11px] text-muted-foreground"
+								onClick={() => {
+									setOpenGroups(
+										Object.fromEntries(
+											groupedProblems.map(({ groupKey }) => [groupKey, false]),
+										),
+									);
+								}}
+							>
+								<span className="block truncate">Collapse all</span>
+							</Button>
+						</div>
+					) : null}
+				</div>
+			</div>
+
+			<ScrollArea className="min-h-0 flex-1">
+				{isLoading ? (
+					<div className="text-muted-foreground px-3 py-4 text-sm">
+						Collecting diagnostics...
+					</div>
+				) : (data?.problems.length ?? 0) === 0 ? (
+					<Empty className="h-full min-h-[220px]">
+						<EmptyHeader>
+							<EmptyMedia variant="icon">
+								<LuTriangleAlert className="size-5" />
+							</EmptyMedia>
+							<EmptyTitle>No Problems</EmptyTitle>
+							<EmptyDescription>
+								No diagnostics were found in the currently open supported files.
+							</EmptyDescription>
+						</EmptyHeader>
+						<EmptyContent />
+					</Empty>
+				) : visibleProblems.length === 0 ? (
+					<Empty className="h-full min-h-[220px]">
+						<EmptyHeader>
+							<EmptyMedia variant="icon">
+								<LuInfo className="size-5" />
+							</EmptyMedia>
+							<EmptyTitle>No Matching Problems</EmptyTitle>
+							<EmptyDescription>
+								現在の severity フィルタに一致する問題はありません。
+							</EmptyDescription>
+						</EmptyHeader>
+						<EmptyContent />
+					</Empty>
+				) : (
+					<div className="divide-y">
+						{groupedProblems.map(({ groupKey, problems }) => (
+							<Collapsible
+								key={groupKey}
+								open={openGroups[groupKey] ?? true}
+								onOpenChange={(open) => {
+									setOpenGroups((current) => ({
+										...current,
+										[groupKey]: open,
+									}));
+								}}
+								className="px-3 py-2"
+							>
+								<div className="mb-1 flex min-w-0 items-center justify-between gap-2">
+									<CollapsibleTrigger className="flex min-w-0 flex-1 items-center gap-1.5 overflow-hidden text-left">
+										{(openGroups[groupKey] ?? true) ? (
+											<LuChevronDown className="text-muted-foreground size-3.5 shrink-0" />
+										) : (
+											<LuChevronRight className="text-muted-foreground size-3.5 shrink-0" />
+										)}
+										<TruncatedWithTooltip
+											className="text-xs font-medium"
+											tooltip={groupKey}
+										>
+											{groupKey}
+										</TruncatedWithTooltip>
+									</CollapsibleTrigger>
+									<span className="text-muted-foreground shrink-0 text-[11px]">
+										{problems.length}
+									</span>
+								</div>
+								<CollapsibleContent className="space-y-0.5">
+									{problems.map((problem, index) => {
+										const canOpen = Boolean(problem.relativePath);
+										return (
+											<ContextMenu
+												key={`${groupKey}:${problem.code ?? "no-code"}:${problem.line ?? 0}:${index}`}
+											>
+												<ContextMenuTrigger asChild>
+													<button
+														type="button"
+														disabled={!canOpen}
+														onClick={() => {
+															if (problem.relativePath) {
+																onOpenFileAtLine(
+																	problem.relativePath,
+																	problem.line ?? undefined,
+																);
+															}
+														}}
+														className={cn(
+															"group block w-full max-w-full overflow-hidden rounded-sm px-1.5 py-1 text-left transition-colors",
+															canOpen
+																? "hover:bg-muted/60"
+																: "cursor-default opacity-90",
+														)}
+													>
+														<div className="grid w-full min-w-0 max-w-full grid-cols-[14px_minmax(0,1fr)] gap-2 overflow-hidden">
+															<div className="pt-0.5">
+																{severityIcon(problem.severity)}
+															</div>
+															<div className="min-w-0 overflow-hidden">
+																<TruncatedWithTooltip
+																	className="w-full text-xs leading-5"
+																	tooltip={problem.message}
+																>
+																	{problem.message}
+																</TruncatedWithTooltip>
+																<div className="text-muted-foreground mt-0.5 grid w-full min-w-0 max-w-full grid-cols-[minmax(0,1fr)_auto] items-center gap-2 overflow-hidden text-[11px] leading-4">
+																	<div className="flex min-w-0 items-center gap-2 overflow-hidden">
+																		<span className="max-w-[56px] shrink-0 truncate">
+																			{severityLabel(problem.severity)}
+																		</span>
+																		<TruncatedWithTooltip
+																			className="min-w-0 flex-1"
+																			tooltip={
+																				problem.code !== null
+																					? `${normalizeSource(problem.source)}(${problem.code})`
+																					: normalizeSource(problem.source)
+																			}
+																		>
+																			{problem.code !== null
+																				? `${normalizeSource(problem.source)}(${problem.code})`
+																				: normalizeSource(problem.source)}
+																		</TruncatedWithTooltip>
+																	</div>
+																	{problem.line !== null ? (
+																		<div className="shrink-0 whitespace-nowrap text-right tabular-nums">
+																			[Ln {problem.line}
+																			{problem.column !== null
+																				? `, Col ${problem.column}`
+																				: ""}
+																			]
+																		</div>
+																	) : null}
+																</div>
+															</div>
+														</div>
+													</button>
+												</ContextMenuTrigger>
+												<ContextMenuContent>
+													<ContextMenuItem
+														onSelect={() => {
+															void copyToClipboard(
+																problem.message,
+																"Problem message copied",
+															);
+														}}
+													>
+														<LuClipboard className="mr-2 size-4" />
+														メッセージをコピー
+													</ContextMenuItem>
+													<ContextMenuItem
+														onSelect={() => {
+															void copyToClipboard(
+																JSON.stringify(
+																	buildClipboardPayload(problem),
+																	null,
+																	"\t",
+																),
+																"Problem copied",
+															);
+														}}
+													>
+														<LuCopy className="mr-2 size-4" />
+														コピー
+													</ContextMenuItem>
+												</ContextMenuContent>
+											</ContextMenu>
+										);
+									})}
+								</CollapsibleContent>
+							</Collapsible>
+						))}
+						{data?.truncated ? (
+							<div className="text-muted-foreground px-3 py-3 text-xs">
+								Showing the first {data.problems.length} problems out of{" "}
+								{data.totalCount}.
+							</div>
+						) : null}
+					</div>
+				)}
+			</ScrollArea>
+		</div>
+	);
+}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/ProblemsView/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/ProblemsView/index.ts
new file mode 100644
index 00000000000..b054e35255c
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/ProblemsView/index.ts
@@ -0,0 +1 @@
+export { ProblemsView } from "./ProblemsView";
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/SearchView.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/SearchView.tsx
new file mode 100644
index 00000000000..5c236c8b8b0
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/SearchView.tsx
@@ -0,0 +1,328 @@
+import { Badge } from "@superset/ui/badge";
+import { Button } from "@superset/ui/button";
+import { ScrollArea } from "@superset/ui/scroll-area";
+import { toast } from "@superset/ui/sonner";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { LuRefreshCw } from "react-icons/lu";
+import { electronTrpc } from "renderer/lib/electron-trpc";
+import { useWorkspaceFileEvents } from "renderer/screens/main/components/WorkspaceView/hooks/useWorkspaceFileEvents";
+import { useWorkspaceId } from "renderer/screens/main/components/WorkspaceView/WorkspaceIdContext";
+import { useSearchDialogStore } from "renderer/stores/search-dialog-state";
+import { SearchFileGroup } from "./components/SearchFileGroup";
+import { SearchToolbar } from "./components/SearchToolbar";
+import { useContentSearch } from "./hooks/useContentSearch";
+import type { SearchContentResult, SearchResultGroup } from "./types";
+
+function groupSearchResults(
+	results: SearchContentResult[],
+): SearchResultGroup[] {
+	const groups = new Map<string, SearchResultGroup>();
+
+	for (const result of results) {
+		const existing = groups.get(result.absolutePath);
+		if (existing) {
+			existing.matches.push(result);
+			continue;
+		}
+
+		groups.set(result.absolutePath, {
+			absolutePath: result.absolutePath,
+			relativePath: result.relativePath,
+			name: result.name,
+			matches: [result],
+		});
+	}
+
+	return Array.from(groups.values())
+		.map((group) => ({
+			...group,
+			matches: [...group.matches].sort((left, right) => {
+				if (left.line !== right.line) {
+					return left.line - right.line;
+				}
+				return left.column - right.column;
+			}),
+		}))
+		.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+
+function buildReplaceSummary(input: {
+	replacements: number;
+	filesUpdated: number;
+	conflictCount: number;
+	failedCount: number;
+}): string {
+	const parts = [
+		`Replaced ${input.replacements} match${input.replacements === 1 ? "" : "es"} in ${input.filesUpdated} file${input.filesUpdated === 1 ? "" : "s"}.`,
+	];
+
+	if (input.conflictCount > 0) {
+		parts.push(
+			`${input.conflictCount} file${input.conflictCount === 1 ? "" : "s"} changed on disk and were skipped.`,
+		);
+	}
+
+	if (input.failedCount > 0) {
+		parts.push(
+			`${input.failedCount} file${input.failedCount === 1 ? "" : "s"} failed to update.`,
+		);
+	}
+
+	return parts.join(" ");
+}
+
+export function SearchView({
+	isActive,
+	onOpenFileAtLine,
+}: {
+	isActive: boolean;
+	onOpenFileAtLine: (path: string, line?: number, column?: number) => void;
+}) {
+	const workspaceId = useWorkspaceId();
+	const utils = electronTrpc.useUtils();
+	const searchInputRef = useRef<HTMLInputElement>(null);
+	const [query, setQuery] = useState("");
+	const [replacement, setReplacement] = useState("");
+	const [replaceOpen, setReplaceOpen] = useState(false);
+	const [isRegex, setIsRegex] = useState(false);
+	const [caseSensitive, setCaseSensitive] = useState(false);
+	const [openGroups, setOpenGroups] = useState<Record<string, boolean>>({});
+	const includePattern = useSearchDialogStore(
+		(state) => state.byMode.keywordSearch.includePattern,
+	);
+	const excludePattern = useSearchDialogStore(
+		(state) => state.byMode.keywordSearch.excludePattern,
+	);
+	const setIncludePatternByMode = useSearchDialogStore(
+		(state) => state.setIncludePattern,
+	);
+	const setExcludePatternByMode = useSearchDialogStore(
+		(state) => state.setExcludePattern,
+	);
+	const replaceMutation = electronTrpc.filesystem.replaceContent.useMutation();
+
+	const { searchResults, isFetching, hasQuery, validationError } =
+		useContentSearch({
+			workspaceId,
+			query,
+			includePattern,
+			excludePattern,
+			isRegex,
+			caseSensitive,
+			enabled: isActive,
+		});
+
+	const groupedResults = useMemo(
+		() => groupSearchResults(searchResults),
+		[searchResults],
+	);
+
+	useEffect(() => {
+		if (!isActive) {
+			return;
+		}
+
+		searchInputRef.current?.focus();
+		searchInputRef.current?.select();
+	}, [isActive]);
+
+	useEffect(() => {
+		if (groupedResults.length === 0) {
+			return;
+		}
+
+		setOpenGroups((current) => {
+			let changed = false;
+			const nextGroups = { ...current };
+			for (const group of groupedResults) {
+				if (nextGroups[group.absolutePath] === undefined) {
+					nextGroups[group.absolutePath] = true;
+					changed = true;
+				}
+			}
+			return changed ? nextGroups : current;
+		});
+	}, [groupedResults]);
+
+	useWorkspaceFileEvents(
+		workspaceId ?? "",
+		() => {
+			if (!query.trim()) {
+				return;
+			}
+			void utils.filesystem.searchContent.invalidate();
+		},
+		Boolean(workspaceId && query.trim().length > 0),
+	);
+
+	const totalMatches = searchResults.length;
+	const totalFiles = groupedResults.length;
+	const canReplace =
+		replaceOpen &&
+		hasQuery &&
+		validationError === null &&
+		!replaceMutation.isPending;
+
+	const runReplace = useCallback(
+		async (paths?: string[]) => {
+			if (!workspaceId || !query.trim() || validationError) {
+				return;
+			}
+
+			try {
+				const result = await replaceMutation.mutateAsync({
+					workspaceId,
+					query,
+					replacement,
+					includeHidden: false,
+					includePattern,
+					excludePattern,
+					isRegex,
+					caseSensitive,
+					paths,
+				});
+
+				const summary = buildReplaceSummary({
+					replacements: result.replacements,
+					filesUpdated: result.filesUpdated,
+					conflictCount: result.conflicts.length,
+					failedCount: result.failed.length,
+				});
+
+				if (result.filesUpdated > 0) {
+					if (result.conflicts.length > 0 || result.failed.length > 0) {
+						toast.warning(summary);
+					} else {
+						toast.success(summary);
+					}
+				} else if (result.conflicts.length > 0 || result.failed.length > 0) {
+					toast.error(summary);
+				} else {
+					toast.warning("No matches were replaced.");
+				}
+
+				void utils.filesystem.searchContent.invalidate();
+			} catch (error) {
+				toast.error(
+					error instanceof Error ? error.message : "Failed to replace matches.",
+				);
+			}
+		},
+		[
+			caseSensitive,
+			excludePattern,
+			includePattern,
+			isRegex,
+			query,
+			replacement,
+			replaceMutation,
+			utils.filesystem.searchContent,
+			validationError,
+			workspaceId,
+		],
+	);
+
+	const handleOpenGroupChange = useCallback(
+		(absolutePath: string, nextOpen: boolean) => {
+			setOpenGroups((current) => ({
+				...current,
+				[absolutePath]: nextOpen,
+			}));
+		},
+		[],
+	);
+
+	return (
+		<div className="flex h-full min-h-0 flex-col overflow-hidden">
+			<SearchToolbar
+				searchInputRef={searchInputRef}
+				query={query}
+				replacement={replacement}
+				replaceOpen={replaceOpen}
+				includePattern={includePattern}
+				excludePattern={excludePattern}
+				isRegex={isRegex}
+				caseSensitive={caseSensitive}
+				canReplaceAll={canReplace && totalMatches > 0}
+				isReplacing={replaceMutation.isPending}
+				onQueryChange={setQuery}
+				onReplacementChange={setReplacement}
+				onIncludePatternChange={(value) =>
+					setIncludePatternByMode("keywordSearch", value)
+				}
+				onExcludePatternChange={(value) =>
+					setExcludePatternByMode("keywordSearch", value)
+				}
+				onToggleReplace={() => setReplaceOpen((current) => !current)}
+				onToggleRegex={() => setIsRegex((current) => !current)}
+				onToggleCaseSensitive={() => setCaseSensitive((current) => !current)}
+				onReplaceAll={() => {
+					void runReplace();
+				}}
+			/>
+
+			<div className="flex shrink-0 items-center justify-between border-b px-3 py-2">
+				<div className="flex min-w-0 items-center gap-2">
+					<Badge variant="outline">{totalFiles} files</Badge>
+					<Badge variant="secondary">{totalMatches} results</Badge>
+				</div>
+				<Button
+					type="button"
+					variant="ghost"
+					size="icon"
+					className="size-7 shrink-0"
+					disabled={!hasQuery || validationError !== null || isFetching}
+					onClick={() => {
+						void utils.filesystem.searchContent.invalidate();
+					}}
+				>
+					<LuRefreshCw className="size-3.5" />
+				</Button>
+			</div>
+
+			{validationError ? (
+				<div className="shrink-0 border-b border-destructive/40 bg-destructive/5 px-3 py-2 text-xs text-destructive">
+					Invalid regular expression: {validationError}
+				</div>
+			) : null}
+
+			<ScrollArea className="flex-1 min-h-0">
+				<div className="space-y-2 p-2">
+					{!hasQuery ? (
+						<div className="rounded-md border border-dashed px-3 py-6 text-center text-sm text-muted-foreground">
+							Enter a search query to find matches across the workspace.
+						</div>
+					) : null}
+
+					{hasQuery &&
+					validationError === null &&
+					groupedResults.length === 0 ? (
+						<div className="rounded-md border border-dashed px-3 py-6 text-center text-sm text-muted-foreground">
+							{isFetching ? "Searching workspace..." : "No results found."}
+						</div>
+					) : null}
+
+					{groupedResults.map((group) => (
+						<SearchFileGroup
+							key={group.absolutePath}
+							group={group}
+							isOpen={openGroups[group.absolutePath] ?? true}
+							query={query}
+							isRegex={isRegex}
+							caseSensitive={caseSensitive}
+							isReplacing={replaceMutation.isPending}
+							showReplaceAction={canReplace}
+							onOpenChange={(nextOpen) =>
+								handleOpenGroupChange(group.absolutePath, nextOpen)
+							}
+							onOpenMatch={onOpenFileAtLine}
+							onReplaceInFile={(absolutePath) => {
+								void runReplace([absolutePath]);
+							}}
+						/>
+					))}
+				</div>
+			</ScrollArea>
+		</div>
+	);
+}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/components/SearchFileGroup/SearchFileGroup.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/components/SearchFileGroup/SearchFileGroup.tsx
new file mode 100644
index 00000000000..0d5ac1db8d0
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/components/SearchFileGroup/SearchFileGroup.tsx
@@ -0,0 +1,116 @@
+import { Badge } from "@superset/ui/badge";
+import { Button } from "@superset/ui/button";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@superset/ui/collapsible";
+import { cn } from "@superset/ui/utils";
+import { LuChevronDown, LuChevronRight, LuReplace } from "react-icons/lu";
+import { FileIcon } from "renderer/screens/main/components/WorkspaceView/RightSidebar/FilesView/utils";
+import type { SearchResultGroup } from "../../types";
+import { SearchMatchItem } from "../SearchMatchItem";
+
+interface SearchFileGroupProps {
+	group: SearchResultGroup;
+	isOpen: boolean;
+	query: string;
+	isRegex: boolean;
+	caseSensitive: boolean;
+	isReplacing: boolean;
+	showReplaceAction: boolean;
+	onOpenChange: (open: boolean) => void;
+	onOpenMatch: (absolutePath: string, line: number, column: number) => void;
+	onReplaceInFile: (absolutePath: string) => void;
+}
+
+function getParentPath(relativePath: string): string {
+	const segments = relativePath.split(/[\\/]/);
+	if (segments.length <= 1) {
+		return ".";
+	}
+	return segments.slice(0, -1).join("/");
+}
+
+export function SearchFileGroup({
+	group,
+	isOpen,
+	query,
+	isRegex,
+	caseSensitive,
+	isReplacing,
+	showReplaceAction,
+	onOpenChange,
+	onOpenMatch,
+	onReplaceInFile,
+}: SearchFileGroupProps) {
+	const parentPath = getParentPath(group.relativePath);
+
+	return (
+		<Collapsible open={isOpen} onOpenChange={onOpenChange}>
+			<div className="rounded-md border border-border/60 bg-background/60">
+				<div className="flex items-start gap-1 px-1.5 py-1.5">
+					<CollapsibleTrigger asChild>
+						<button
+							type="button"
+							className="flex min-w-0 flex-1 items-start gap-2 rounded-md px-1 py-1 text-left transition-colors hover:bg-accent/40"
+						>
+							<span className="mt-0.5 shrink-0 text-muted-foreground">
+								{isOpen ? (
+									<LuChevronDown className="size-3.5" />
+								) : (
+									<LuChevronRight className="size-3.5" />
+								)}
+							</span>
+							<FileIcon
+								fileName={group.name}
+								className="mt-0.5 size-4 shrink-0"
+							/>
+							<div className="min-w-0 flex-1">
+								<div className="truncate text-sm font-medium text-foreground">
+									{group.name}
+								</div>
+								<div className="truncate text-xs text-muted-foreground">
+									{parentPath}
+								</div>
+							</div>
+						</button>
+					</CollapsibleTrigger>
+					<Badge variant="outline" className="mt-1 shrink-0">
+						{group.matches.length}
+					</Badge>
+					{showReplaceAction ? (
+						<Button
+							type="button"
+							variant="ghost"
+							size="sm"
+							className={cn(
+								"h-7 shrink-0 gap-1 px-2 text-xs",
+								isReplacing && "pointer-events-none",
+							)}
+							disabled={isReplacing}
+							onClick={() => onReplaceInFile(group.absolutePath)}
+						>
+							<LuReplace className="size-3.5" />
+							Replace
+						</Button>
+					) : null}
+				</div>
+				<CollapsibleContent className="border-t border-border/50 px-1.5 py-1">
+					<div className="space-y-1">
+						{group.matches.map((match) => (
+							<SearchMatchItem
+								key={match.id}
+								match={match}
+								query={query}
+								isRegex={isRegex}
+								caseSensitive={caseSensitive}
+								onOpen={onOpenMatch}
+							/>
+						))}
+					</div>
+				</CollapsibleContent>
+			</div>
+		</Collapsible>
+	);
+}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/components/SearchFileGroup/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/components/SearchFileGroup/index.ts
new file mode 100644
index 00000000000..50b1fdea06c
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/components/SearchFileGroup/index.ts
@@ -0,0 +1 @@
+export { SearchFileGroup } from "./SearchFileGroup";
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/components/SearchMatchItem/SearchMatchItem.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/components/SearchMatchItem/SearchMatchItem.tsx
new file mode 100644
index 00000000000..d0b87288581
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/components/SearchMatchItem/SearchMatchItem.tsx
@@ -0,0 +1,39 @@
+import type { SearchContentResult } from "../../types";
+import { highlightSearchText } from "../../utils/searchPattern/searchPattern";
+
+interface SearchMatchItemProps {
+	match: SearchContentResult;
+	query: string;
+	isRegex: boolean;
+	caseSensitive: boolean;
+	onOpen: (absolutePath: string, line: number, column: number) => void;
+}
+
+export function SearchMatchItem({
+	match,
+	query,
+	isRegex,
+	caseSensitive,
+	onOpen,
+}: SearchMatchItemProps) {
+	return (
+		<button
+			type="button"
+			className="flex w-full items-start gap-2 rounded-md px-2 py-2 text-left transition-colors hover:bg-accent/50"
+			onClick={() => onOpen(match.absolutePath, match.line, match.column)}
+		>
+			<span className="mt-0.5 shrink-0 rounded bg-muted px-1.5 py-0.5 font-mono text-[10px] text-muted-foreground">
+				{match.line}:{match.column}
+			</span>
+			<div className="min-w-0 flex-1 text-xs leading-5 text-foreground">
+				<div className="break-words">
+					{highlightSearchText(match.preview, {
+						query,
+						isRegex,
+						caseSensitive,
+					})}
+				</div>
+			</div>
+		</button>
+	);
+}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/components/SearchMatchItem/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/components/SearchMatchItem/index.ts
new file mode 100644
index 00000000000..0a8b2159f79
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/components/SearchMatchItem/index.ts
@@ -0,0 +1 @@
+export { SearchMatchItem } from "./SearchMatchItem";
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/components/SearchToolbar/SearchToolbar.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/components/SearchToolbar/SearchToolbar.tsx
new file mode 100644
index 00000000000..9384ec2e1e4
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/components/SearchToolbar/SearchToolbar.tsx
@@ -0,0 +1,165 @@
+import { Button } from "@superset/ui/button";
+import { Input } from "@superset/ui/input";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@superset/ui/tooltip";
+import { cn } from "@superset/ui/utils";
+import type { ReactNode, RefObject } from "react";
+import { LuReplace, LuSearch, LuX } from "react-icons/lu";
+import { PiTextAa } from "react-icons/pi";
+import { TbRegex } from "react-icons/tb";
+
+interface SearchToolbarProps {
+	searchInputRef: RefObject<HTMLInputElement | null>;
+	query: string;
+	replacement: string;
+	replaceOpen: boolean;
+	includePattern: string;
+	excludePattern: string;
+	isRegex: boolean;
+	caseSensitive: boolean;
+	canReplaceAll: boolean;
+	isReplacing: boolean;
+	onQueryChange: (value: string) => void;
+	onReplacementChange: (value: string) => void;
+	onIncludePatternChange: (value: string) => void;
+	onExcludePatternChange: (value: string) => void;
+	onToggleReplace: () => void;
+	onToggleRegex: () => void;
+	onToggleCaseSensitive: () => void;
+	onReplaceAll: () => void;
+}
+
+function ToggleIconButton({
+	label,
+	isActive,
+	onClick,
+	children,
+}: {
+	label: string;
+	isActive: boolean;
+	onClick: () => void;
+	children: ReactNode;
+}) {
+	return (
+		<Tooltip>
+			<TooltipTrigger asChild>
+				<Button
+					type="button"
+					variant="ghost"
+					size="icon"
+					className={cn(
+						"size-8 shrink-0 text-muted-foreground",
+						isActive && "bg-accent text-accent-foreground",
+					)}
+					aria-pressed={isActive}
+					onClick={onClick}
+				>
+					{children}
+				</Button>
+			</TooltipTrigger>
+			<TooltipContent side="bottom">{label}</TooltipContent>
+		</Tooltip>
+	);
+}
+
+export function SearchToolbar({
+	searchInputRef,
+	query,
+	replacement,
+	replaceOpen,
+	includePattern,
+	excludePattern,
+	isRegex,
+	caseSensitive,
+	canReplaceAll,
+	isReplacing,
+	onQueryChange,
+	onReplacementChange,
+	onIncludePatternChange,
+	onExcludePatternChange,
+	onToggleReplace,
+	onToggleRegex,
+	onToggleCaseSensitive,
+	onReplaceAll,
+}: SearchToolbarProps) {
+	return (
+		<div className="shrink-0 border-b px-2 py-2">
+			<div className="flex items-center gap-1">
+				<div className="relative min-w-0 flex-1">
+					<LuSearch className="pointer-events-none absolute left-2 top-1/2 size-4 -translate-y-1/2 text-muted-foreground" />
+					<Input
+						ref={searchInputRef}
+						value={query}
+						onChange={(event) => onQueryChange(event.target.value)}
+						placeholder="Search in files"
+						className="h-8 pl-8 pr-8 text-sm"
+					/>
+					{query.length > 0 ? (
+						<button
+							type="button"
+							className="absolute right-2 top-1/2 -translate-y-1/2 rounded p-0.5 text-muted-foreground transition-colors hover:bg-accent hover:text-foreground"
+							onClick={() => onQueryChange("")}
+						>
+							<LuX className="size-3.5" />
+						</button>
+					) : null}
+				</div>
+				<ToggleIconButton
+					label={replaceOpen ? "Hide replace" : "Show replace"}
+					isActive={replaceOpen}
+					onClick={onToggleReplace}
+				>
+					<LuReplace className="size-4" />
+				</ToggleIconButton>
+				<ToggleIconButton
+					label="Match case"
+					isActive={caseSensitive}
+					onClick={onToggleCaseSensitive}
+				>
+					<PiTextAa className="size-4" />
+				</ToggleIconButton>
+				<ToggleIconButton
+					label="Use regular expression"
+					isActive={isRegex}
+					onClick={onToggleRegex}
+				>
+					<TbRegex className="size-4" />
+				</ToggleIconButton>
+			</div>
+
+			{replaceOpen ? (
+				<div className="mt-2 flex items-center gap-2">
+					<Input
+						value={replacement}
+						onChange={(event) => onReplacementChange(event.target.value)}
+						placeholder="Replace"
+						className="h-8 min-w-0 flex-1 text-sm"
+					/>
+					<Button
+						type="button"
+						size="sm"
+						className="h-8 shrink-0"
+						disabled={!canReplaceAll || isReplacing}
+						onClick={onReplaceAll}
+					>
+						Replace All
+					</Button>
+				</div>
+			) : null}
+
+			<div className="mt-2 grid gap-1">
+				<Input
+					value={includePattern}
+					onChange={(event) => onIncludePatternChange(event.target.value)}
+					placeholder="files to include (glob)"
+					className="h-7 text-xs"
+				/>
+				<Input
+					value={excludePattern}
+					onChange={(event) => onExcludePatternChange(event.target.value)}
+					placeholder="files to exclude (glob)"
+					className="h-7 text-xs"
+				/>
+			</div>
+		</div>
+	);
+}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/components/SearchToolbar/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/components/SearchToolbar/index.ts
new file mode 100644
index 00000000000..5f705ca2727
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/components/SearchToolbar/index.ts
@@ -0,0 +1 @@
+export { SearchToolbar } from "./SearchToolbar";
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/hooks/useContentSearch/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/hooks/useContentSearch/index.ts
new file mode 100644
index 00000000000..91aded42ce3
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/hooks/useContentSearch/index.ts
@@ -0,0 +1 @@
+export { useContentSearch } from "./useContentSearch";
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/hooks/useContentSearch/useContentSearch.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/hooks/useContentSearch/useContentSearch.ts
new file mode 100644
index 00000000000..febaa78b3a0
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/hooks/useContentSearch/useContentSearch.ts
@@ -0,0 +1,80 @@
+import { useMemo } from "react";
+import { useDebouncedValue } from "renderer/hooks/useDebouncedValue";
+import { electronTrpc } from "renderer/lib/electron-trpc";
+import type { SearchContentResult } from "../../types";
+import { getSearchValidationError } from "../../utils/searchPattern/searchPattern";
+
+const DEFAULT_SEARCH_LIMIT = 500;
+
+interface UseContentSearchParams {
+	workspaceId: string | undefined;
+	query: string;
+	includePattern: string;
+	excludePattern: string;
+	isRegex: boolean;
+	caseSensitive: boolean;
+	enabled?: boolean;
+	limit?: number;
+}
+
+export function useContentSearch({
+	workspaceId,
+	query,
+	includePattern,
+	excludePattern,
+	isRegex,
+	caseSensitive,
+	enabled = true,
+	limit = DEFAULT_SEARCH_LIMIT,
+}: UseContentSearchParams) {
+	const trimmedQuery = query.trim();
+	const validationError = useMemo(
+		() => getSearchValidationError(trimmedQuery, isRegex),
+		[trimmedQuery, isRegex],
+	);
+	const debouncedQuery = useDebouncedValue(trimmedQuery, 150);
+	const isDebouncing =
+		trimmedQuery.length > 0 && trimmedQuery !== debouncedQuery;
+
+	const { data, isFetching } = electronTrpc.filesystem.searchContent.useQuery(
+		{
+			workspaceId: workspaceId ?? "",
+			query: debouncedQuery,
+			includeHidden: false,
+			includePattern,
+			excludePattern,
+			limit,
+			isRegex,
+			caseSensitive,
+		},
+		{
+			enabled:
+				Boolean(workspaceId) &&
+				enabled &&
+				debouncedQuery.length > 0 &&
+				validationError === null,
+			staleTime: 1000,
+			placeholderData: (previous) => previous ?? { matches: [] },
+		},
+	);
+
+	const searchResults: SearchContentResult[] =
+		validationError === null
+			? (data?.matches.map((match) => ({
+					id: `${match.absolutePath}:${match.line}:${match.column}`,
+					absolutePath: match.absolutePath,
+					relativePath: match.relativePath,
+					name: match.absolutePath.split(/[/\\]/).pop() ?? match.absolutePath,
+					line: match.line,
+					column: match.column,
+					preview: match.preview,
+				})) ?? [])
+			: [];
+
+	return {
+		searchResults,
+		isFetching: validationError === null && (isFetching || isDebouncing),
+		hasQuery: trimmedQuery.length > 0,
+		validationError,
+	};
+}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/index.ts
new file mode 100644
index 00000000000..3da19d829b8
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/index.ts
@@ -0,0 +1 @@
+export { SearchView } from "./SearchView";
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/types.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/types.ts
new file mode 100644
index 00000000000..afdcf8f4c1a
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/types.ts
@@ -0,0 +1,16 @@
+export interface SearchContentResult {
+	id: string;
+	absolutePath: string;
+	relativePath: string;
+	name: string;
+	line: number;
+	column: number;
+	preview: string;
+}
+
+export interface SearchResultGroup {
+	absolutePath: string;
+	relativePath: string;
+	name: string;
+	matches: SearchContentResult[];
+}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/utils/searchPattern/searchPattern.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/utils/searchPattern/searchPattern.tsx
new file mode 100644
index 00000000000..8502c62a3b2
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/SearchView/utils/searchPattern/searchPattern.tsx
@@ -0,0 +1,110 @@
+import type { ReactNode } from "react";
+
+function escapeRegExp(input: string): string {
+	return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function createSearchRegExp({
+	query,
+	isRegex,
+	caseSensitive,
+}: {
+	query: string;
+	isRegex: boolean;
+	caseSensitive: boolean;
+}): RegExp | null {
+	const trimmedQuery = query.trim();
+	if (!trimmedQuery) {
+		return null;
+	}
+
+	try {
+		return new RegExp(
+			isRegex ? trimmedQuery : escapeRegExp(trimmedQuery),
+			caseSensitive ? "gu" : "giu",
+		);
+	} catch {
+		return null;
+	}
+}
+
+export function getSearchValidationError(
+	query: string,
+	isRegex: boolean,
+): string | null {
+	if (!isRegex || query.trim().length === 0) {
+		return null;
+	}
+
+	try {
+		new RegExp(query, "u");
+		return null;
+	} catch (error) {
+		return error instanceof Error
+			? error.message
+			: "Invalid regular expression";
+	}
+}
+
+export function highlightSearchText(
+	text: string,
+	{
+		query,
+		isRegex,
+		caseSensitive,
+	}: {
+		query: string;
+		isRegex: boolean;
+		caseSensitive: boolean;
+	},
+): ReactNode {
+	const regex = createSearchRegExp({
+		query,
+		isRegex,
+		caseSensitive,
+	});
+	if (!regex) {
+		return text;
+	}
+
+	const nodes: ReactNode[] = [];
+	let cursor = 0;
+	let match = regex.exec(text);
+
+	while (match) {
+		const matchText = match[0] ?? "";
+		const matchLength = matchText.length > 0 ? matchText.length : 1;
+		const endIndex = match.index + matchLength;
+
+		if (match.index > cursor) {
+			nodes.push(
+				<span key={`text-${cursor}`}>{text.slice(cursor, match.index)}</span>,
+			);
+		}
+
+		nodes.push(
+			<mark
+				key={`mark-${match.index}-${endIndex}`}
+				className="rounded bg-[var(--highlight-match)] px-0.5 text-foreground"
+			>
+				{text.slice(match.index, endIndex)}
+			</mark>,
+		);
+
+		cursor = endIndex;
+		if (matchText.length === 0) {
+			regex.lastIndex += 1;
+		}
+		match = regex.exec(text);
+	}
+
+	if (nodes.length === 0) {
+		return text;
+	}
+
+	if (cursor < text.length) {
+		nodes.push(<span key={`text-${cursor}`}>{text.slice(cursor)}</span>);
+	}
+
+	return nodes;
+}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/index.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/index.tsx
index 8c716053286..ec06f49c352 100644
--- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/index.tsx
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/RightSidebar/index.tsx
@@ -2,9 +2,12 @@ import { Button } from "@superset/ui/button";
 import { Tooltip, TooltipContent, TooltipTrigger } from "@superset/ui/tooltip";
 import { useCallback } from "react";
 import {
+	LuCircleAlert,
+	LuDatabase,
 	LuExpand,
 	LuFile,
 	LuGitCompareArrows,
+	LuSearch,
 	LuShrink,
 	LuX,
 } from "react-icons/lu";
@@ -21,8 +24,11 @@ import { toAbsoluteWorkspacePath } from "shared/absolute-paths";
 import type { ChangeCategory, ChangedFile } from "shared/changes-types";
 import { useScrollContext } from "../ChangesContent";
 import { ChangesView } from "./ChangesView";
+import { DatabasesView } from "./DatabasesView";
 import { FilesView } from "./FilesView";
 import { getSidebarHeaderTabButtonClassName } from "./headerTabStyles";
+import { ProblemsView } from "./ProblemsView";
+import { SearchView } from "./SearchView";
 
 function TabButton({
 	isActive,
@@ -30,12 +36,14 @@ function TabButton({
 	icon,
 	label,
 	compact,
+	hasAlert,
 }: {
 	isActive: boolean;
 	onClick: () => void;
 	icon: React.ReactNode;
 	label: string;
 	compact?: boolean;
+	hasAlert?: boolean;
 }) {
 	if (compact) {
 		return (
@@ -49,7 +57,12 @@ function TabButton({
 							compact: true,
 						})}
 					>
-						{icon}
+						<span className="relative inline-flex">
+							{icon}
+							{hasAlert ? (
+								<span className="absolute -right-1 -top-1 size-2 rounded-full bg-red-500" />
+							) : null}
+						</span>
 					</button>
 				</TooltipTrigger>
 				<TooltipContent side="bottom" showArrow={false}>
@@ -65,7 +78,12 @@ function TabButton({
 			onClick={onClick}
 			className={getSidebarHeaderTabButtonClassName({ isActive })}
 		>
-			{icon}
+			<span className="relative inline-flex">
+				{icon}
+				{hasAlert ? (
+					<span className="absolute -right-1 -top-1 size-2 rounded-full bg-red-500" />
+				) : null}
+			</span>
 			{label}
 		</button>
 	);
@@ -87,13 +105,38 @@ export function RightSidebar() {
 	const isExpanded = currentMode === SidebarMode.Changes;
 	const compactTabs = sidebarWidth < 250;
 	const showChangesTab = !!worktreePath;
+	const trpcUtils = electronTrpc.useUtils();
+	const { data: workspaceDiagnostics } =
+		electronTrpc.languageServices.getWorkspaceDiagnostics.useQuery(
+			{ workspaceId: workspaceId ?? "" },
+			{
+				enabled: Boolean(workspaceId),
+				staleTime: Infinity,
+			},
+		);
+	const hasProblemErrors = (workspaceDiagnostics?.summary.errorCount ?? 0) > 0;
+
+	electronTrpc.languageServices.subscribeDiagnostics.useSubscription(
+		{ workspaceId: workspaceId ?? "" },
+		{
+			enabled: Boolean(workspaceId),
+			onData: () => {
+				if (!workspaceId) {
+					return;
+				}
+				void trpcUtils.languageServices.getWorkspaceDiagnostics.invalidate({
+					workspaceId,
+				});
+			},
+		},
+	);
 
 	const handleExpandToggle = () => {
 		setMode(isExpanded ? SidebarMode.Tabs : SidebarMode.Changes);
 	};
 
 	const addFileViewerPane = useTabsStore((s) => s.addFileViewerPane);
-	const trpcUtils = electronTrpc.useUtils();
+	const addDatabaseExplorerTab = useTabsStore((s) => s.addDatabaseExplorerTab);
 	const { scrollToFile } = useScrollContext();
 
 	const invalidateFileContent = useCallback(
@@ -152,13 +195,14 @@ export function RightSidebar() {
 	);
 
 	const handleOpenFileAtLine = useCallback(
-		(path: string, line?: number) => {
+		(path: string, line?: number, column?: number) => {
 			if (!workspaceId || !worktreePath) return;
 			const absolutePath = toAbsoluteWorkspacePath(worktreePath, path);
 			addFileViewerPane(workspaceId, {
 				filePath: absolutePath,
 				viewMode: "raw",
 				line,
+				column,
 			});
 		},
 		[workspaceId, worktreePath, addFileViewerPane],
@@ -170,6 +214,16 @@ export function RightSidebar() {
 				? handleFileScrollTo
 				: handleFileOpenPane
 			: undefined;
+	const handleOpenDatabaseExplorer = useCallback(
+		(connectionId: string) => {
+			if (!workspaceId) {
+				return;
+			}
+
+			addDatabaseExplorerTab(workspaceId, connectionId);
+		},
+		[workspaceId, addDatabaseExplorerTab],
+	);
 
 	return (
 		<aside className="h-full flex flex-col overflow-hidden">
@@ -180,7 +234,7 @@ export function RightSidebar() {
 							isActive={rightSidebarTab === RightSidebarTab.Changes}
 							onClick={() => setRightSidebarTab(RightSidebarTab.Changes)}
 							icon={<LuGitCompareArrows className="size-3.5" />}
-							label="Changes"
+							label="Git"
 							compact={compactTabs}
 						/>
 					)}
@@ -191,6 +245,28 @@ export function RightSidebar() {
 						label="Files"
 						compact={compactTabs}
 					/>
+					<TabButton
+						isActive={rightSidebarTab === RightSidebarTab.Search}
+						onClick={() => setRightSidebarTab(RightSidebarTab.Search)}
+						icon={<LuSearch className="size-3.5" />}
+						label="Search"
+						compact={compactTabs}
+					/>
+					<TabButton
+						isActive={rightSidebarTab === RightSidebarTab.Problems}
+						onClick={() => setRightSidebarTab(RightSidebarTab.Problems)}
+						icon={<LuCircleAlert className="size-3.5" />}
+						label="Problems"
+						compact={compactTabs}
+						hasAlert={hasProblemErrors}
+					/>
+					<TabButton
+						isActive={rightSidebarTab === RightSidebarTab.Databases}
+						onClick={() => setRightSidebarTab(RightSidebarTab.Databases)}
+						icon={<LuDatabase className="size-3.5" />}
+						label="Databases"
+						compact={compactTabs}
+					/>
 				</div>
 				<div className="flex-1" />
 				<div className="flex items-center h-10 pr-2 gap-0.5">
@@ -254,13 +330,46 @@ export function RightSidebar() {
 			)}
 			<div
 				className={
-					rightSidebarTab === RightSidebarTab.Changes && showChangesTab
-						? "hidden"
-						: "flex-1 min-h-0 flex flex-col overflow-hidden"
+					rightSidebarTab === RightSidebarTab.Files
+						? "flex-1 min-h-0 flex flex-col overflow-hidden"
+						: "hidden"
 				}
 			>
 				<FilesView />
 			</div>
+			<div
+				className={
+					rightSidebarTab === RightSidebarTab.Search
+						? "flex-1 min-h-0 flex flex-col overflow-hidden"
+						: "hidden"
+				}
+			>
+				<SearchView
+					isActive={rightSidebarTab === RightSidebarTab.Search}
+					onOpenFileAtLine={handleOpenFileAtLine}
+				/>
+			</div>
+			<div
+				className={
+					rightSidebarTab === RightSidebarTab.Problems
+						? "flex-1 min-h-0 flex flex-col overflow-hidden"
+						: "hidden"
+				}
+			>
+				<ProblemsView
+					isActive={rightSidebarTab === RightSidebarTab.Problems}
+					onOpenFileAtLine={handleOpenFileAtLine}
+				/>
+			</div>
+			<div
+				className={
+					rightSidebarTab === RightSidebarTab.Databases
+						? "flex-1 min-h-0 flex flex-col overflow-hidden"
+						: "hidden"
+				}
+			>
+				<DatabasesView onOpenExplorer={handleOpenDatabaseExplorer} />
+			</div>
 		</aside>
 	);
 }
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/components/CodeEditor/CodeEditor.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/components/CodeEditor/CodeEditor.tsx
index ad16e085501..77748d0f6d1 100644
--- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/components/CodeEditor/CodeEditor.tsx
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/components/CodeEditor/CodeEditor.tsx
@@ -13,6 +13,7 @@ import {
 } from "@codemirror/search";
 import { Compartment, EditorSelection, EditorState } from "@codemirror/state";
 import {
+	Decoration,
 	drawSelection,
 	dropCursor,
 	EditorView,
@@ -44,6 +45,13 @@ interface CodeEditorProps {
 	onChange?: (value: string) => void;
 	onSave?: () => void;
 	blameEntries?: BlameEntry[];
+	diagnostics?: Array<{
+		line: number | null;
+		column: number | null;
+		endLine: number | null;
+		endColumn: number | null;
+		severity: "error" | "warning" | "info" | "hint";
+	}>;
 }
 
 const HIGHLIGHT_CLEAR_DELAY_MS = 1800;
@@ -51,6 +59,67 @@ const HIGHLIGHT_RETRY_DELAY_MS = 80;
 const HIGHLIGHT_MAX_RETRIES = 8;
 const SCROLL_STABILIZE_DELAY_MS = 120;
 
+function createDiagnosticsTheme(theme: ReturnType<typeof getEditorTheme>) {
+	return EditorView.theme({
+		".cm-problem-underline-error": {
+			textDecoration: `underline wavy ${theme.colors.deletion}`,
+			textUnderlineOffset: "3px",
+			textDecorationThickness: "1.5px",
+		},
+		".cm-problem-underline-warning": {
+			textDecoration: `underline wavy ${theme.colors.modified}`,
+			textUnderlineOffset: "3px",
+			textDecorationThickness: "1.5px",
+		},
+		".cm-problem-underline-info, .cm-problem-underline-hint": {
+			textDecoration: `underline dotted ${theme.colors.searchActive}`,
+			textUnderlineOffset: "3px",
+			textDecorationThickness: "1.5px",
+		},
+	});
+}
+
+function buildDiagnosticDecorations(
+	doc: EditorState["doc"],
+	diagnostics: NonNullable<CodeEditorProps["diagnostics"]>,
+) {
+	const decorations = diagnostics
+		.filter((diagnostic) => diagnostic.line !== null)
+		.map((diagnostic) => {
+			const startLine = Math.max(1, Math.min(diagnostic.line ?? 1, doc.lines));
+			const startLineInfo = doc.line(startLine);
+			const startOffset = Math.max(0, (diagnostic.column ?? 1) - 1);
+			const from = Math.min(startLineInfo.from + startOffset, startLineInfo.to);
+
+			const endLineNumber = Math.max(
+				startLine,
+				Math.min(diagnostic.endLine ?? startLine, doc.lines),
+			);
+			const endLineInfo = doc.line(endLineNumber);
+			const endOffset = Math.max(
+				0,
+				(diagnostic.endColumn ??
+					(diagnostic.column !== null ? diagnostic.column + 1 : 2)) - 1,
+			);
+			let to = Math.min(endLineInfo.from + endOffset, endLineInfo.to);
+
+			if (to <= from) {
+				to = Math.min(from + 1, startLineInfo.to);
+			}
+
+			if (to <= from) {
+				return null;
+			}
+
+			return Decoration.mark({
+				class: `cm-problem-underline-${diagnostic.severity}`,
+			}).range(from, to);
+		})
+		.filter((decoration) => decoration !== null);
+
+	return Decoration.set(decorations, true);
+}
+
 function createCodeMirrorAdapter(
 	view: EditorView,
 	jumpHighlightStyle: {
@@ -356,6 +425,7 @@ export function CodeEditor({
 	onChange,
 	onSave,
 	blameEntries,
+	diagnostics = [],
 }: CodeEditorProps) {
 	const containerRef = useRef<HTMLDivElement | null>(null);
 	const viewRef = useRef<EditorView | null>(null);
@@ -363,6 +433,7 @@ export function CodeEditor({
 	const themeCompartment = useRef(new Compartment()).current;
 	const editableCompartment = useRef(new Compartment()).current;
 	const blameCompartment = useRef(new Compartment()).current;
+	const diagnosticsCompartment = useRef(new Compartment()).current;
 	const onChangeRef = useRef(onChange);
 	const onSaveRef = useRef(onSave);
 	// Guards against re-entrant onChange calls triggered by the value-sync effect's own dispatch.
@@ -444,6 +515,15 @@ export function CodeEditor({
 				]),
 				languageCompartment.of([]),
 				blameCompartment.of([]),
+				diagnosticsCompartment.of([
+					createDiagnosticsTheme(editorTheme),
+					EditorView.decorations.of(
+						buildDiagnosticDecorations(
+							EditorState.create({ doc: value }).doc,
+							diagnostics,
+						),
+					),
+				]),
 				updateListener,
 			],
 		});
@@ -518,6 +598,20 @@ export function CodeEditor({
 		themeCompartment,
 	]);
 
+	useEffect(() => {
+		const view = viewRef.current;
+		if (!view) return;
+
+		view.dispatch({
+			effects: diagnosticsCompartment.reconfigure([
+				createDiagnosticsTheme(editorTheme),
+				EditorView.decorations.of(
+					buildDiagnosticDecorations(view.state.doc, diagnostics),
+				),
+			]),
+		});
+	}, [diagnostics, diagnosticsCompartment, editorTheme]);
+
 	useEffect(() => {
 		const view = viewRef.current;
 		if (!view) return;
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/components/CodeEditor/loadLanguageSupport.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/components/CodeEditor/loadLanguageSupport.ts
index 876ca792f05..a4bba6a22d2 100644
--- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/components/CodeEditor/loadLanguageSupport.ts
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/components/CodeEditor/loadLanguageSupport.ts
@@ -29,6 +29,10 @@ export async function loadLanguageSupport(
 			const { json } = await import("@codemirror/lang-json");
 			return json();
 		}
+		case "jsonc": {
+			const { json } = await import("@codemirror/lang-json");
+			return json();
+		}
 		case "html": {
 			const { html } = await import("@codemirror/lang-html");
 			return html();
@@ -101,6 +105,11 @@ export async function loadLanguageSupport(
 				() => import("@codemirror/legacy-modes/mode/toml"),
 				"toml",
 			);
+		case "dart":
+			return loadLegacyLanguage(
+				() => import("@codemirror/legacy-modes/mode/clike"),
+				"dart",
+			);
 		case "ruby":
 			return loadLegacyLanguage(
 				() => import("@codemirror/legacy-modes/mode/ruby"),
diff --git a/apps/desktop/src/renderer/stores/browser-bookmarks.ts b/apps/desktop/src/renderer/stores/browser-bookmarks.ts
new file mode 100644
index 00000000000..974ab301c75
--- /dev/null
+++ b/apps/desktop/src/renderer/stores/browser-bookmarks.ts
@@ -0,0 +1,193 @@
+import { create } from "zustand";
+import { devtools, persist } from "zustand/middleware";
+
+export interface BrowserBookmark {
+	id: string;
+	url: string;
+	title: string;
+	faviconUrl?: string;
+	createdAt: number;
+}
+
+interface BrowserBookmarkInput {
+	url: string;
+	title: string;
+	faviconUrl?: string;
+}
+
+interface BrowserBookmarksState {
+	bookmarks: BrowserBookmark[];
+	addBookmark: (bookmark: BrowserBookmarkInput) => BrowserBookmark | null;
+	updateBookmark: (
+		bookmarkId: string,
+		bookmark: BrowserBookmarkInput,
+	) => BrowserBookmark | null;
+	removeBookmark: (bookmarkId: string) => void;
+	moveBookmark: (activeId: string, overId: string) => void;
+	toggleBookmark: (bookmark: BrowserBookmarkInput) => boolean;
+}
+
+export function normalizeBookmarkUrl(url: string): string {
+	const trimmed = url.trim();
+	if (!trimmed || trimmed === "about:blank") return trimmed;
+
+	try {
+		const parsed = new URL(trimmed);
+		if (parsed.pathname === "/" && !parsed.search && !parsed.hash) {
+			return parsed.origin;
+		}
+		return parsed.toString();
+	} catch {
+		return trimmed.replace(/\/+$/, "");
+	}
+}
+
+function findBookmarkIndex(bookmarks: BrowserBookmark[], url: string): number {
+	const normalizedUrl = normalizeBookmarkUrl(url);
+	return bookmarks.findIndex(
+		(bookmark) => normalizeBookmarkUrl(bookmark.url) === normalizedUrl,
+	);
+}
+
+function moveItem<T>(items: T[], fromIndex: number, toIndex: number): T[] {
+	if (fromIndex === toIndex) return items;
+	const nextItems = [...items];
+	const [movedItem] = nextItems.splice(fromIndex, 1);
+	if (!movedItem) return items;
+	nextItems.splice(toIndex, 0, movedItem);
+	return nextItems;
+}
+
+export const useBrowserBookmarksStore = create<BrowserBookmarksState>()(
+	devtools(
+		persist(
+			(set, get) => ({
+				bookmarks: [],
+
+				addBookmark: (bookmark) => {
+					const normalizedUrl = normalizeBookmarkUrl(bookmark.url);
+					if (!normalizedUrl || normalizedUrl === "about:blank") {
+						return null;
+					}
+
+					const title = bookmark.title.trim() || normalizedUrl;
+					const existingIndex = findBookmarkIndex(
+						get().bookmarks,
+						normalizedUrl,
+					);
+					if (existingIndex >= 0) {
+						const existingBookmark = get().bookmarks[existingIndex];
+						if (!existingBookmark) return null;
+						const updatedBookmark = {
+							...existingBookmark,
+							url: normalizedUrl,
+							title,
+							faviconUrl: bookmark.faviconUrl ?? existingBookmark.faviconUrl,
+						};
+						set((state) => ({
+							bookmarks: state.bookmarks.map((entry, index) =>
+								index === existingIndex ? updatedBookmark : entry,
+							),
+						}));
+						return updatedBookmark;
+					}
+
+					const nextBookmark: BrowserBookmark = {
+						id: crypto.randomUUID(),
+						url: normalizedUrl,
+						title,
+						faviconUrl: bookmark.faviconUrl,
+						createdAt: Date.now(),
+					};
+
+					set((state) => ({
+						bookmarks: [...state.bookmarks, nextBookmark],
+					}));
+
+					return nextBookmark;
+				},
+
+				updateBookmark: (bookmarkId, bookmark) => {
+					const normalizedUrl = normalizeBookmarkUrl(bookmark.url);
+					if (!normalizedUrl || normalizedUrl === "about:blank") {
+						return null;
+					}
+
+					const targetBookmark = get().bookmarks.find(
+						(entry) => entry.id === bookmarkId,
+					);
+					if (!targetBookmark) return null;
+
+					const duplicateBookmark = get().bookmarks.find(
+						(entry) =>
+							entry.id !== bookmarkId &&
+							normalizeBookmarkUrl(entry.url) === normalizedUrl,
+					);
+					if (duplicateBookmark) {
+						return null;
+					}
+
+					const updatedBookmark: BrowserBookmark = {
+						...targetBookmark,
+						url: normalizedUrl,
+						title: bookmark.title.trim() || normalizedUrl,
+						faviconUrl: bookmark.faviconUrl ?? targetBookmark.faviconUrl,
+					};
+
+					set((state) => ({
+						bookmarks: state.bookmarks.map((entry) =>
+							entry.id === bookmarkId ? updatedBookmark : entry,
+						),
+					}));
+
+					return updatedBookmark;
+				},
+
+				removeBookmark: (bookmarkId) => {
+					set((state) => ({
+						bookmarks: state.bookmarks.filter(
+							(bookmark) => bookmark.id !== bookmarkId,
+						),
+					}));
+				},
+
+				moveBookmark: (activeId, overId) => {
+					if (activeId === overId) return;
+					set((state) => {
+						const fromIndex = state.bookmarks.findIndex(
+							(bookmark) => bookmark.id === activeId,
+						);
+						const toIndex = state.bookmarks.findIndex(
+							(bookmark) => bookmark.id === overId,
+						);
+						if (fromIndex < 0 || toIndex < 0) return state;
+						return {
+							bookmarks: moveItem(state.bookmarks, fromIndex, toIndex),
+						};
+					});
+				},
+
+				toggleBookmark: (bookmark) => {
+					const existingIndex = findBookmarkIndex(
+						get().bookmarks,
+						bookmark.url,
+					);
+					if (existingIndex >= 0) {
+						const existingBookmark = get().bookmarks[existingIndex];
+						if (existingBookmark) {
+							get().removeBookmark(existingBookmark.id);
+						}
+						return false;
+					}
+
+					return get().addBookmark(bookmark) !== null;
+				},
+			}),
+			{
+				name: "browser-bookmarks-store",
+				version: 1,
+			},
+		),
+		{ name: "BrowserBookmarksStore" },
+	),
+);
diff --git a/apps/desktop/src/renderer/stores/database-sidebar.ts b/apps/desktop/src/renderer/stores/database-sidebar.ts
new file mode 100644
index 00000000000..4e7697251bf
--- /dev/null
+++ b/apps/desktop/src/renderer/stores/database-sidebar.ts
@@ -0,0 +1,234 @@
+import { create } from "zustand";
+import { devtools, persist } from "zustand/middleware";
+
+export interface SavedDatabaseConnection {
+	id: string;
+	label: string;
+	group?: string;
+	dialect: "sqlite" | "postgres";
+	databasePath?: string;
+	connectionString?: string;
+	createdAt: number;
+}
+
+export interface SavedDatabaseQueryHistoryItem {
+	id: string;
+	connectionId: string;
+	sql: string;
+	executedAt: number;
+}
+
+interface DatabaseSidebarState {
+	connections: SavedDatabaseConnection[];
+	queryHistory: SavedDatabaseQueryHistoryItem[];
+	activeConnectionId: string | null;
+	addConnection: (
+		input:
+			| {
+					label: string;
+					group?: string;
+					dialect: "sqlite";
+					databasePath: string;
+			  }
+			| {
+					label: string;
+					group?: string;
+					dialect: "postgres";
+					connectionString: string;
+			  },
+	) => SavedDatabaseConnection;
+	updateConnection: (
+		input:
+			| {
+					id: string;
+					label: string;
+					group?: string;
+					dialect: "sqlite";
+					databasePath: string;
+			  }
+			| {
+					id: string;
+					label: string;
+					group?: string;
+					dialect: "postgres";
+					connectionString: string;
+			  },
+	) => SavedDatabaseConnection | null;
+	removeConnection: (id: string) => void;
+	setActiveConnectionId: (id: string | null) => void;
+	addQueryHistoryItem: (input: {
+		connectionId: string;
+		sql: string;
+	}) => SavedDatabaseQueryHistoryItem;
+	removeQueryHistoryItem: (id: string) => void;
+	clearQueryHistoryForConnection: (connectionId: string) => void;
+}
+
+export const useDatabaseSidebarStore = create<DatabaseSidebarState>()(
+	devtools(
+		persist(
+			(set, get) => ({
+				connections: [],
+				queryHistory: [],
+				activeConnectionId: null,
+
+				addConnection: (input) => {
+					const existingConnection = get().connections.find((connection) => {
+						if (connection.dialect !== input.dialect) {
+							return false;
+						}
+
+						if (input.dialect === "sqlite") {
+							return connection.databasePath === input.databasePath;
+						}
+
+						return connection.connectionString === input.connectionString;
+					});
+					if (existingConnection) {
+						set({ activeConnectionId: existingConnection.id });
+						return existingConnection;
+					}
+
+					const connection: SavedDatabaseConnection = {
+						id: crypto.randomUUID(),
+						label: input.label,
+						group: input.group,
+						dialect: input.dialect,
+						databasePath:
+							input.dialect === "sqlite" ? input.databasePath : undefined,
+						connectionString:
+							input.dialect === "postgres" ? input.connectionString : undefined,
+						createdAt: Date.now(),
+					};
+
+					set((state) => ({
+						connections: [connection, ...state.connections],
+						activeConnectionId: connection.id,
+					}));
+
+					return connection;
+				},
+
+				updateConnection: (input) => {
+					const currentConnection = get().connections.find(
+						(connection) => connection.id === input.id,
+					);
+					if (!currentConnection) {
+						return null;
+					}
+
+					const updatedConnection: SavedDatabaseConnection = {
+						...currentConnection,
+						label: input.label,
+						group: input.group,
+						dialect: input.dialect,
+						databasePath:
+							input.dialect === "sqlite" ? input.databasePath : undefined,
+						connectionString:
+							input.dialect === "postgres" ? input.connectionString : undefined,
+					};
+
+					set((state) => ({
+						connections: state.connections.map((connection) =>
+							connection.id === input.id ? updatedConnection : connection,
+						),
+						activeConnectionId: input.id,
+					}));
+
+					return updatedConnection;
+				},
+
+				removeConnection: (id) => {
+					set((state) => {
+						const nextConnections = state.connections.filter(
+							(connection) => connection.id !== id,
+						);
+						return {
+							connections: nextConnections,
+							queryHistory: state.queryHistory.filter(
+								(item) => item.connectionId !== id,
+							),
+							activeConnectionId:
+								state.activeConnectionId === id
+									? (nextConnections[0]?.id ?? null)
+									: state.activeConnectionId,
+						};
+					});
+				},
+
+				setActiveConnectionId: (id) => {
+					set({ activeConnectionId: id });
+				},
+
+				addQueryHistoryItem: ({ connectionId, sql }) => {
+					const normalizedSql = sql.trim();
+					const item: SavedDatabaseQueryHistoryItem = {
+						id: crypto.randomUUID(),
+						connectionId,
+						sql: normalizedSql,
+						executedAt: Date.now(),
+					};
+
+					set((state) => {
+						const deduped = state.queryHistory.filter(
+							(entry) =>
+								!(
+									entry.connectionId === connectionId &&
+									entry.sql.trim() === normalizedSql
+								),
+						);
+						const nextHistory = [item, ...deduped].slice(0, 100);
+						return {
+							queryHistory: nextHistory,
+						};
+					});
+
+					return item;
+				},
+
+				removeQueryHistoryItem: (id) => {
+					set((state) => ({
+						queryHistory: state.queryHistory.filter((item) => item.id !== id),
+					}));
+				},
+
+				clearQueryHistoryForConnection: (connectionId) => {
+					set((state) => ({
+						queryHistory: state.queryHistory.filter(
+							(item) => item.connectionId !== connectionId,
+						),
+					}));
+				},
+			}),
+			{
+				name: "database-sidebar-store",
+				version: 3,
+				migrate: (persistedState) => {
+					const state = persistedState as {
+						connections?: Array<{
+							id: string;
+							label: string;
+							group?: string;
+							databasePath?: string;
+							dialect?: "sqlite" | "postgres";
+							connectionString?: string;
+							createdAt: number;
+						}>;
+						queryHistory?: SavedDatabaseQueryHistoryItem[];
+						activeConnectionId?: string | null;
+					};
+
+					return {
+						connections: (state.connections ?? []).map((connection) => ({
+							...connection,
+							dialect: connection.dialect ?? "sqlite",
+						})),
+						queryHistory: state.queryHistory ?? [],
+						activeConnectionId: state.activeConnectionId ?? null,
+					} as DatabaseSidebarState;
+				},
+			},
+		),
+		{ name: "DatabaseSidebarStore" },
+	),
+);
diff --git a/apps/desktop/src/renderer/stores/hotkeys/store.ts b/apps/desktop/src/renderer/stores/hotkeys/store.ts
index 0a6f010872d..02c5fe60c5d 100644
--- a/apps/desktop/src/renderer/stores/hotkeys/store.ts
+++ b/apps/desktop/src/renderer/stores/hotkeys/store.ts
@@ -232,6 +232,7 @@ export function useHotkeysByCategory(options?: {
 			Array<HotkeyDefinition & { id: HotkeyId }>
 		> = {
 			Navigation: [],
+			Browser: [],
 			Workspace: [],
 			Layout: [],
 			Terminal: [],
diff --git a/apps/desktop/src/renderer/stores/language-service-preferences.ts b/apps/desktop/src/renderer/stores/language-service-preferences.ts
new file mode 100644
index 00000000000..5ca99a7a72c
--- /dev/null
+++ b/apps/desktop/src/renderer/stores/language-service-preferences.ts
@@ -0,0 +1,51 @@
+import { create } from "zustand";
+import { devtools, persist } from "zustand/middleware";
+
+export type LanguageServiceProviderId = "typescript" | "json" | "toml" | "dart";
+
+type LanguageServicePreferencesState = {
+	enabledProviders: Record<LanguageServiceProviderId, boolean>;
+	hasHydrated: boolean;
+	setProviderEnabled: (
+		providerId: LanguageServiceProviderId,
+		enabled: boolean,
+	) => void;
+	setHasHydrated: (hasHydrated: boolean) => void;
+};
+
+const DEFAULT_ENABLED_PROVIDERS: Record<LanguageServiceProviderId, boolean> = {
+	typescript: true,
+	json: true,
+	toml: true,
+	dart: true,
+};
+
+export const useLanguageServicePreferencesStore =
+	create<LanguageServicePreferencesState>()(
+		devtools(
+			persist(
+				(set) => ({
+					enabledProviders: DEFAULT_ENABLED_PROVIDERS,
+					hasHydrated: false,
+					setProviderEnabled: (providerId, enabled) =>
+						set((state) => ({
+							enabledProviders: {
+								...state.enabledProviders,
+								[providerId]: enabled,
+							},
+						})),
+					setHasHydrated: (hasHydrated) => set({ hasHydrated }),
+				}),
+				{
+					name: "language-service-preferences",
+					partialize: (state) => ({
+						enabledProviders: state.enabledProviders,
+					}),
+					onRehydrateStorage: () => (state) => {
+						state?.setHasHydrated(true);
+					},
+				},
+			),
+			{ name: "LanguageServicePreferencesStore" },
+		),
+	);
diff --git a/apps/desktop/src/renderer/stores/sidebar-state.ts b/apps/desktop/src/renderer/stores/sidebar-state.ts
index 4d2be3411fd..6fbc0e09a9a 100644
--- a/apps/desktop/src/renderer/stores/sidebar-state.ts
+++ b/apps/desktop/src/renderer/stores/sidebar-state.ts
@@ -9,6 +9,9 @@ export enum SidebarMode {
 export enum RightSidebarTab {
 	Changes = "changes",
 	Files = "files",
+	Search = "search",
+	Problems = "problems",
+	Databases = "databases",
 }
 
 export const DEFAULT_SIDEBAR_WIDTH = 250;
diff --git a/apps/desktop/src/renderer/stores/tabs/store.ts b/apps/desktop/src/renderer/stores/tabs/store.ts
index 9aa739369c1..3eca6eb0746 100644
--- a/apps/desktop/src/renderer/stores/tabs/store.ts
+++ b/apps/desktop/src/renderer/stores/tabs/store.ts
@@ -35,6 +35,7 @@ import {
 	createBrowserTabWithPane,
 	createChatPane,
 	createChatTabWithPane,
+	createDatabaseExplorerTabWithPane,
 	createDevToolsPane,
 	createFileViewerPane,
 	createGitGraphTabWithPane,
@@ -1434,7 +1435,10 @@ export const useTabsStore = create<TabsStore>()(
 						paneType === "chat"
 							? createChatPane(tabId)
 							: paneType === "webview"
-								? createBrowserPane(tabId)
+								? createBrowserPane(
+										tabId,
+										options?.url ? { url: options.url } : undefined,
+									)
 								: createPane(tabId, "terminal", options);
 					const panelType =
 						paneType === "chat"
@@ -1503,7 +1507,10 @@ export const useTabsStore = create<TabsStore>()(
 						paneType === "chat"
 							? createChatPane(tabId)
 							: paneType === "webview"
-								? createBrowserPane(tabId)
+								? createBrowserPane(
+										tabId,
+										options?.url ? { url: options.url } : undefined,
+									)
 								: createPane(tabId, "terminal", options);
 					const panelType =
 						paneType === "chat"
@@ -1663,6 +1670,52 @@ export const useTabsStore = create<TabsStore>()(
 					return { tabId: tab.id, paneId: pane.id };
 				},
 
+				addDatabaseExplorerTab: (
+					workspaceId: string,
+					connectionId?: string | null,
+				) => {
+					const state = get();
+
+					const { tab, pane } = createDatabaseExplorerTabWithPane(
+						workspaceId,
+						connectionId,
+					);
+
+					const currentActiveId = state.activeTabIds[workspaceId];
+					const historyStack = state.tabHistoryStacks[workspaceId] || [];
+					const newHistoryStack = currentActiveId
+						? [
+								currentActiveId,
+								...historyStack.filter((id) => id !== currentActiveId),
+							]
+						: historyStack;
+
+					set({
+						tabs: [...state.tabs, tab],
+						panes: { ...state.panes, [pane.id]: pane },
+						activeTabIds: {
+							...state.activeTabIds,
+							[workspaceId]: tab.id,
+						},
+						focusedPaneIds: {
+							...state.focusedPaneIds,
+							[tab.id]: pane.id,
+						},
+						tabHistoryStacks: {
+							...state.tabHistoryStacks,
+							[workspaceId]: newHistoryStack,
+						},
+					});
+
+					posthog.capture("panel_opened", {
+						panel_type: "database-explorer",
+						workspace_id: workspaceId,
+						pane_id: pane.id,
+					});
+
+					return { tabId: tab.id, paneId: pane.id };
+				},
+
 				addGitGraphTab: (workspaceId: string, worktreePath: string) => {
 					const state = get();
 
@@ -1818,6 +1871,31 @@ export const useTabsStore = create<TabsStore>()(
 					}
 				},
 
+				setDatabaseExplorerConnection: (paneId, connectionId) => {
+					set((state) => {
+						const pane = state.panes[paneId];
+						if (!pane || pane.type !== "database-explorer") {
+							return state;
+						}
+
+						if (pane.databaseExplorer?.connectionId === connectionId) {
+							return state;
+						}
+
+						return {
+							panes: {
+								...state.panes,
+								[paneId]: {
+									...pane,
+									databaseExplorer: {
+										connectionId,
+									},
+								},
+							},
+						};
+					});
+				},
+
 				updateBrowserUrl: (
 					paneId: string,
 					url: string,
diff --git a/apps/desktop/src/renderer/stores/tabs/types.ts b/apps/desktop/src/renderer/stores/tabs/types.ts
index f88d9ada275..3247247194f 100644
--- a/apps/desktop/src/renderer/stores/tabs/types.ts
+++ b/apps/desktop/src/renderer/stores/tabs/types.ts
@@ -51,6 +51,7 @@ export interface AddTabOptions {
 export interface SplitPaneOptions {
 	initialCwd?: string;
 	paneType?: "terminal" | "chat" | "webview";
+	url?: string;
 }
 
 export interface AddChatTabOptions {
@@ -203,11 +204,19 @@ export interface TabsStore extends TabsState {
 		workspaceId: string,
 		url?: string,
 	) => { tabId: string; paneId: string };
+	addDatabaseExplorerTab: (
+		workspaceId: string,
+		connectionId?: string | null,
+	) => { tabId: string; paneId: string };
 	addGitGraphTab: (
 		workspaceId: string,
 		worktreePath: string,
 	) => { tabId: string; paneId: string };
 	openInBrowserPane: (workspaceId: string, url: string) => void;
+	setDatabaseExplorerConnection: (
+		paneId: string,
+		connectionId: string | null,
+	) => void;
 	updateBrowserUrl: (
 		paneId: string,
 		url: string,
diff --git a/apps/desktop/src/renderer/stores/tabs/utils.ts b/apps/desktop/src/renderer/stores/tabs/utils.ts
index d878fe5e119..2ae3ed1ebe9 100644
--- a/apps/desktop/src/renderer/stores/tabs/utils.ts
+++ b/apps/desktop/src/renderer/stores/tabs/utils.ts
@@ -13,6 +13,7 @@ import { hasRenderedPreview, isImageFile } from "shared/file-types";
 import {
 	acknowledgedStatus,
 	type BrowserPaneState,
+	type DatabaseExplorerPaneState,
 	type DevToolsPaneState,
 	type DiffLayout,
 	type FileViewerMode,
@@ -382,6 +383,42 @@ export const createGitGraphTabWithPane = (
 	return { tab, pane };
 };
 
+export const createDatabaseExplorerPane = (
+	tabId: string,
+	connectionId?: string | null,
+): Pane => {
+	const id = generateId("pane");
+	const databaseExplorer: DatabaseExplorerPaneState = {
+		connectionId: connectionId ?? null,
+	};
+
+	return {
+		id,
+		tabId,
+		type: "database-explorer",
+		name: "Database Explorer",
+		databaseExplorer,
+	};
+};
+
+export const createDatabaseExplorerTabWithPane = (
+	workspaceId: string,
+	connectionId?: string | null,
+): { tab: Tab; pane: Pane } => {
+	const tabId = generateId("tab");
+	const pane = createDatabaseExplorerPane(tabId, connectionId);
+
+	const tab: Tab = {
+		id: tabId,
+		name: "Database Explorer",
+		workspaceId,
+		layout: pane.id,
+		createdAt: Date.now(),
+	};
+
+	return { tab, pane };
+};
+
 export const createChatTabWithPane = (
 	workspaceId: string,
 	options?: AddChatTabOptions,
diff --git a/apps/desktop/src/shared/browser-shortcuts.ts b/apps/desktop/src/shared/browser-shortcuts.ts
new file mode 100644
index 00000000000..0b67190ad8d
--- /dev/null
+++ b/apps/desktop/src/shared/browser-shortcuts.ts
@@ -0,0 +1 @@
+export type BrowserShortcutAction = "reload" | "hard-reload";
diff --git a/apps/desktop/src/shared/constants.ts b/apps/desktop/src/shared/constants.ts
index c19264f803c..b8e6ef06486 100644
--- a/apps/desktop/src/shared/constants.ts
+++ b/apps/desktop/src/shared/constants.ts
@@ -50,6 +50,7 @@ export const DEFAULT_USE_COMPACT_TERMINAL_ADD_BUTTON = true;
 export const DEFAULT_TELEMETRY_ENABLED = true;
 export const DEFAULT_SHOW_RESOURCE_MONITOR = true;
 export const DEFAULT_OPEN_LINKS_IN_APP = false;
+export const DEFAULT_PREVENT_AGENT_SLEEP = false;
 
 // External links (documentation, help resources, etc.)
 export const EXTERNAL_LINKS = {
diff --git a/apps/desktop/src/shared/detect-language.ts b/apps/desktop/src/shared/detect-language.ts
index d4f42df7647..2645ddae080 100644
--- a/apps/desktop/src/shared/detect-language.ts
+++ b/apps/desktop/src/shared/detect-language.ts
@@ -20,6 +20,7 @@ export function detectLanguage(filePath: string): string {
 
 		// Data formats
 		json: "json",
+		jsonc: "json",
 		yaml: "yaml",
 		yml: "yaml",
 		xml: "xml",
@@ -41,6 +42,7 @@ export function detectLanguage(filePath: string): string {
 
 		// Other languages
 		py: "python",
+		dart: "dart",
 		rb: "ruby",
 		go: "go",
 		rs: "rust",
diff --git a/apps/desktop/src/shared/hotkeys.ts b/apps/desktop/src/shared/hotkeys.ts
index 5e1af31e630..ba461f9b31b 100644
--- a/apps/desktop/src/shared/hotkeys.ts
+++ b/apps/desktop/src/shared/hotkeys.ts
@@ -9,6 +9,7 @@ export type HotkeyPlatform = "darwin" | "win32" | "linux";
 
 export type HotkeyCategory =
 	| "Navigation"
+	| "Browser"
 	| "Workspace"
 	| "Layout"
 	| "Terminal"
@@ -403,6 +404,20 @@ export const HOTKEYS = {
 		description: "Go forward to the next page in history",
 	}),
 
+	// Browser
+	BROWSER_RELOAD: defineHotkey({
+		keys: null,
+		label: "Reload Browser",
+		category: "Browser",
+		description: "Reload the active browser pane",
+	}),
+	BROWSER_HARD_RELOAD: defineHotkey({
+		keys: null,
+		label: "Hard Reload Browser",
+		category: "Browser",
+		description: "Force reload the active browser pane",
+	}),
+
 	// Workspace - switch with ⌘+1-9
 	JUMP_TO_WORKSPACE_1: defineHotkey({
 		keys: "meta+1",
@@ -788,6 +803,12 @@ export const HOTKEYS = {
 		category: "Navigation",
 		description: "Search and open files in the current workspace",
 	}),
+	SEARCH_IN_FILES: defineHotkey({
+		keys: "meta+shift+f",
+		label: "Search in Files",
+		category: "Navigation",
+		description: "Search and replace across files in the current workspace",
+	}),
 
 	// Chat
 	FIND_IN_CHAT: defineHotkey({
@@ -849,6 +870,7 @@ export function getHotkeysByCategory(options?: {
 }): Record<HotkeyCategory, HotkeyWithId[]> {
 	const grouped: Record<HotkeyCategory, HotkeyWithId[]> = {
 		Navigation: [],
+		Browser: [],
 		Workspace: [],
 		Layout: [],
 		Terminal: [],
diff --git a/apps/desktop/src/shared/tabs-types.ts b/apps/desktop/src/shared/tabs-types.ts
index a91b37e2007..d959d3a4ffd 100644
--- a/apps/desktop/src/shared/tabs-types.ts
+++ b/apps/desktop/src/shared/tabs-types.ts
@@ -14,7 +14,8 @@ export type PaneType =
 	| "file-viewer"
 	| "chat"
 	| "devtools"
-	| "git-graph";
+	| "git-graph"
+	| "database-explorer";
 
 /**
  * Pane status for agent lifecycle indicators
@@ -144,6 +145,7 @@ export interface Pane {
 	browser?: BrowserPaneState; // For browser (webview) panes
 	devtools?: DevToolsPaneState; // For devtools panes
 	gitGraph?: GitGraphPaneState; // For git-graph panes
+	databaseExplorer?: DatabaseExplorerPaneState; // For database explorer panes
 	workspaceRun?: {
 		workspaceId: string;
 		state: "running" | "stopped-by-user" | "stopped-by-exit";
@@ -225,6 +227,13 @@ export interface GitGraphPaneState {
 	worktreePath: string;
 }
 
+/**
+ * Database Explorer pane-specific properties
+ */
+export interface DatabaseExplorerPaneState {
+	connectionId: string | null;
+}
+
 /**
  * Base Tab interface - shared fields without layout
  */
diff --git a/bun.lock b/bun.lock
index 08d7a47f85a..c04a0957c7b 100644
--- a/bun.lock
+++ b/bun.lock
@@ -176,6 +176,7 @@
         "@tanstack/react-router": "^1.147.3",
         "@tanstack/react-table": "^8.21.3",
         "@tanstack/react-virtual": "^3.13.18",
+        "@taplo/lib": "^0.5.0",
         "@tiptap/core": "^3.17.1",
         "@tiptap/extension-blockquote": "^3.17.1",
         "@tiptap/extension-bold": "^3.17.1",
@@ -264,6 +265,7 @@
         "node-addon-api": "^7.1.0",
         "node-pty": "1.1.0",
         "os-locale": "^6.0.2",
+        "pg": "8.20.0",
         "pidtree": "^0.6.0",
         "pidusage": "^4.0.1",
         "posthog-js": "1.310.1",
@@ -299,6 +301,8 @@
         "use-resize-observer": "^9.1.0",
         "utf-8-validate": "^6.0.6",
         "uuid": "^13.0.0",
+        "vscode-json-languageservice": "^5.7.2",
+        "vscode-languageserver-textdocument": "^1.0.12",
         "zod": "^4.3.5",
         "zustand": "^5.0.8",
       },
@@ -315,6 +319,7 @@
         "@types/http-proxy": "^1.17.17",
         "@types/lodash": "^4.17.20",
         "@types/node": "^24.9.1",
+        "@types/pg": "8.15.6",
         "@types/react": "~19.2.2",
         "@types/react-dom": "^19.2.3",
         "@types/react-syntax-highlighter": "^15.5.13",
@@ -941,6 +946,7 @@
   },
   "overrides": {
     "axios": "1.14.0",
+    "fstream>mkdirp": "^0.5.6",
   },
   "packages": {
     "7zip-bin": ["7zip-bin@5.2.0", "", {}, "sha512-ukTPVhqG4jNzMro2qA9HSCSSVJN3aN7tlb+hfqYCt3ER0yWroeA2VR38MNrOHLQ/cVj+DaIMad0kFCtWWowh/A=="],
@@ -2449,6 +2455,10 @@
 
     "@tanstack/virtual-file-routes": ["@tanstack/virtual-file-routes@1.161.7", "", { "bin": { "intent": "bin/intent.js" } }, "sha512-olW33+Cn+bsCsZKPwEGhlkqS6w3M2slFv11JIobdnCFKMLG97oAI2kWKdx5/zsywTL8flpnoIgaZZPlQTFYhdQ=="],
 
+    "@taplo/core": ["@taplo/core@0.2.0", "", {}, "sha512-r8bl54Zj1In3QLkiW/ex694bVzpPJ9EhwqT9xkcUVODnVUGirdB1JTsmiIv0o1uwqZiwhi8xNnTOQBRQCpizrQ=="],
+
+    "@taplo/lib": ["@taplo/lib@0.5.0", "", { "dependencies": { "@taplo/core": "^0.2.0" } }, "sha512-+xIqpQXJco3T+VGaTTwmhxLa51qpkQxCjRwezjFZgr+l21ExlywJFcDfTrNmL6lG6tqb0h8GyJKO3UPGPtSCWg=="],
+
     "@tavily/core": ["@tavily/core@0.7.2", "", { "dependencies": { "axios": "^1.7.7", "https-proxy-agent": "^7.0.6", "js-tiktoken": "^1.0.14" } }, "sha512-N9xfw9miPD1jyVKYTMWV1hQvWPNjATT9Hffr6tv7VMHzwOPOeBwfX/R25ZE2F7meTyq6xSeGxclWnLVH2xHqFA=="],
 
     "@tiptap/core": ["@tiptap/core@3.21.0", "", { "peerDependencies": { "@tiptap/pm": "^3.21.0" } }, "sha512-IfnQiuEeabDSPr1C/zHFTbnvlTf5z0DE/d/xz4C6bkL4ZBDJ3rr99h2qsaV0l8F+kbNswZMlQdM8rxNlMy95fQ=="],
@@ -2703,7 +2713,7 @@
 
     "@types/offscreencanvas": ["@types/offscreencanvas@2019.7.3", "", {}, "sha512-ieXiYmgSRXUDeOntE1InxjWyvEelZGP63M+cGuquuRLuIKKT1osnkXjxev9B7d1nXSug5vpunx+gNlbVxMlC9A=="],
 
-    "@types/pg": ["@types/pg@8.20.0", "", { "dependencies": { "@types/node": "*", "pg-protocol": "*", "pg-types": "^2.2.0" } }, "sha512-bEPFOaMAHTEP1EzpvHTbmwR8UsFyHSKsRisLIHVMXnpNefSbGA1bD6CVy+qKjGSqmZqNqBDV2azOBo8TgkcVow=="],
+    "@types/pg": ["@types/pg@8.15.6", "", { "dependencies": { "@types/node": "*", "pg-protocol": "*", "pg-types": "^2.2.0" } }, "sha512-NoaMtzhxOrubeL/7UZuNTrejB4MPAJ0RpxZqXQf2qXuVlTPuG6Y8p4u9dKRaue4yjmC7ZhzVO2/Yyyn25znrPQ=="],
 
     "@types/pg-pool": ["@types/pg-pool@2.0.7", "", { "dependencies": { "@types/pg": "*" } }, "sha512-U4CwmGVQcbEuqpyju8/ptOKg6gEC+Tqsvj2xS9o1g71bUh8twxnC6ZL5rZKCsGN0iyH0CwgUyc9VR5owNQF9Ng=="],
 
@@ -2799,6 +2809,8 @@
 
     "@vitejs/plugin-react": ["@vitejs/plugin-react@5.2.0", "", { "dependencies": { "@babel/core": "^7.29.0", "@babel/plugin-transform-react-jsx-self": "^7.27.1", "@babel/plugin-transform-react-jsx-source": "^7.27.1", "@rolldown/pluginutils": "1.0.0-rc.3", "@types/babel__core": "^7.20.5", "react-refresh": "^0.18.0" }, "peerDependencies": { "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-YmKkfhOAi3wsB1PhJq5Scj3GXMn3WvtQ/JC0xoopuHoXSdmtdStOpFrYaT1kie2YgFBcIe64ROzMYRjCrYOdYw=="],
 
+    "@vscode/l10n": ["@vscode/l10n@0.0.18", "", {}, "sha512-KYSIHVmslkaCDyw013pphY+d7x1qV8IZupYfeIfzNA+nsaWHbn5uPuQRvdRFsa9zFzGeudPuoGoZ1Op4jrJXIQ=="],
+
     "@vue/compiler-core": ["@vue/compiler-core@3.5.31", "", { "dependencies": { "@babel/parser": "^7.29.2", "@vue/shared": "3.5.31", "entities": "^7.0.1", "estree-walker": "^2.0.2", "source-map-js": "^1.2.1" } }, "sha512-k/ueL14aNIEy5Onf0OVzR8kiqF/WThgLdFhxwa4e/KF/0qe38IwIdofoSWBTvvxQOesaz6riAFAUaYjoF9fLLQ=="],
 
     "@vue/compiler-dom": ["@vue/compiler-dom@3.5.31", "", { "dependencies": { "@vue/compiler-core": "3.5.31", "@vue/shared": "3.5.31" } }, "sha512-BMY/ozS/xxjYqRFL+tKdRpATJYDTTgWSo0+AJvJNg4ig+Hgb0dOsHPXvloHQ5hmlivUqw1Yt2pPIqp4e0v1GUw=="],
@@ -4103,6 +4115,8 @@
 
     "json5": ["json5@2.2.3", "", { "bin": { "json5": "lib/cli.js" } }, "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg=="],
 
+    "jsonc-parser": ["jsonc-parser@3.3.1", "", {}, "sha512-HUgH65KyejrUFPvHFPbqOY0rsFip3Bo5wb4ngvdi1EpCYWUQDC5V+Y7mZws+DLkr4M//zQJoanu1SP+87Dv1oQ=="],
+
     "jsonfile": ["jsonfile@6.2.0", "", { "dependencies": { "universalify": "^2.0.0" }, "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg=="],
 
     "jszip": ["jszip@3.10.1", "", { "dependencies": { "lie": "~3.3.0", "pako": "~1.0.2", "readable-stream": "~2.3.6", "setimmediate": "^1.0.5" } }, "sha512-xXDvecyTpGLrqFrvkrUSoxxfJI5AH7U8zxxtVclpsUtMCq4JQ290LY8AW5c7Ggnr/Y/oK+bQMbqK2qmtk3pN4g=="],
@@ -5547,6 +5561,8 @@
 
     "vlq": ["vlq@1.0.1", "", {}, "sha512-gQpnTgkubC6hQgdIcRdYGDSDc+SaujOdyesZQMv6JlfQee/9Mp0Qhnys6WxDWvQnL5WZdT7o2Ul187aSt0Rq+w=="],
 
+    "vscode-json-languageservice": ["vscode-json-languageservice@5.7.2", "", { "dependencies": { "@vscode/l10n": "^0.0.18", "jsonc-parser": "^3.3.1", "vscode-languageserver-textdocument": "^1.0.12", "vscode-languageserver-types": "^3.17.5", "vscode-uri": "^3.1.0" } }, "sha512-WtKRDtJfFEmLrgtu+ODexOHm/6/krRF0k6t+uvkKIKW1Jh9ZIyxZQwJJwB3qhrEgvAxa37zbUg+vn+UyUK/U2w=="],
+
     "vscode-jsonrpc": ["vscode-jsonrpc@8.2.1", "", {}, "sha512-kdjOSJ2lLIn7r1rtrMbbNCHjyMPfRnowdKjBQ+mGq6NAW5QY2bEZC/khaC5OR8svbbjvLEaIXkOq45e2X9BIbQ=="],
 
     "vscode-languageserver": ["vscode-languageserver@9.0.1", "", { "dependencies": { "vscode-languageserver-protocol": "3.17.5" }, "bin": { "installServerIntoExtension": "bin/installServerIntoExtension" } }, "sha512-woByF3PDpkHFUreUa7Hos7+pUWdeWMXRd26+ZX2A8cFx6v/JPTtd4/uN0/jB6XQHYaOlHbio03NTHCqrgG5n7g=="],
@@ -5827,14 +5843,14 @@
 
     "@neondatabase/serverless/@types/node": ["@types/node@22.19.15", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-F0R/h2+dsy5wJAUe3tAU6oqa2qbWY5TpNfL/RGmo1y38hiyO1w3x2jPtt76wmuaJI4DQnOBu21cNXQ2STIUUWg=="],
 
+    "@neondatabase/serverless/@types/pg": ["@types/pg@8.20.0", "", { "dependencies": { "@types/node": "*", "pg-protocol": "*", "pg-types": "^2.2.0" } }, "sha512-bEPFOaMAHTEP1EzpvHTbmwR8UsFyHSKsRisLIHVMXnpNefSbGA1bD6CVy+qKjGSqmZqNqBDV2azOBo8TgkcVow=="],
+
     "@npmcli/agent/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="],
 
     "@opentelemetry/instrumentation/import-in-the-middle": ["import-in-the-middle@3.0.0", "", { "dependencies": { "acorn": "^8.15.0", "acorn-import-attributes": "^1.9.5", "cjs-module-lexer": "^2.2.0", "module-details-from-path": "^1.0.4" } }, "sha512-OnGy+eYT7wVejH2XWgLRgbmzujhhVIATQH0ztIeRilwHBjTeG3pD+XnH3PKX0r9gJ0BuJmJ68q/oh9qgXnNDQg=="],
 
     "@opentelemetry/instrumentation-http/@opentelemetry/core": ["@opentelemetry/core@2.6.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-HLM1v2cbZ4TgYN6KEOj+Bbj8rAKriOdkF9Ed3tG25FoprSiQl7kYc+RRT6fUZGOvx0oMi5U67GoFdT+XUn8zEg=="],
 
-    "@opentelemetry/instrumentation-pg/@types/pg": ["@types/pg@8.15.6", "", { "dependencies": { "@types/node": "*", "pg-protocol": "*", "pg-types": "^2.2.0" } }, "sha512-NoaMtzhxOrubeL/7UZuNTrejB4MPAJ0RpxZqXQf2qXuVlTPuG6Y8p4u9dKRaue4yjmC7ZhzVO2/Yyyn25znrPQ=="],
-
     "@pierre/diffs/diff": ["diff@8.0.3", "", {}, "sha512-qejHi7bcSD4hQAZE0tNAawRK1ZtafHDmMTMkrrIGgSLl7hTnQHmKCeB45xAcbfTqK2zowkM3j3bHt/4b/ARbYQ=="],
 
     "@poppinss/colors/kleur": ["kleur@4.1.5", "", {}, "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ=="],
@@ -5979,6 +5995,8 @@
 
     "@tanstack/router-utils/diff": ["diff@8.0.3", "", {}, "sha512-qejHi7bcSD4hQAZE0tNAawRK1ZtafHDmMTMkrrIGgSLl7hTnQHmKCeB45xAcbfTqK2zowkM3j3bHt/4b/ARbYQ=="],
 
+    "@types/pg-pool/@types/pg": ["@types/pg@8.20.0", "", { "dependencies": { "@types/node": "*", "pg-protocol": "*", "pg-types": "^2.2.0" } }, "sha512-bEPFOaMAHTEP1EzpvHTbmwR8UsFyHSKsRisLIHVMXnpNefSbGA1bD6CVy+qKjGSqmZqNqBDV2azOBo8TgkcVow=="],
+
     "@types/plist/xmlbuilder": ["xmlbuilder@15.1.1", "", {}, "sha512-yMqGBqtXyeN1e3TGYvgNgDVZ3j84W4cwkOXQswghol6APgZWaff9lnbvN7MHYJOiXsvGPXtjTYJEiC9J2wv9Eg=="],
 
     "@types/three/fflate": ["fflate@0.8.2", "", {}, "sha512-cPJU47OaAoCbg0pBvzsgpTPhmhqI5eJjh/JIu8tPj5q+T7iLvW/JAYUqmE7KOB4R1ZyEhzBaIQpQpardBF5z8A=="],
@@ -6651,6 +6669,8 @@
 
     "@neondatabase/serverless/@types/node/undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],
 
+    "@neondatabase/serverless/@types/pg/@types/node": ["@types/node@24.12.0", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-GYDxsZi3ChgmckRT9HPU0WEhKLP08ev/Yfcq2AstjrDASOYCSXeyjDsHg4v5t4jOj7cyDX3vmprafKlWIG9MXQ=="],
+
     "@opentelemetry/instrumentation/import-in-the-middle/cjs-module-lexer": ["cjs-module-lexer@2.2.0", "", {}, "sha512-4bHTS2YuzUvtoLjdy+98ykbNB5jS0+07EvFNXerqZQJ89F7DI6ET7OQo/HJuW6K0aVsKA9hj9/RVb2kQVOrPDQ=="],
 
     "@prisma/instrumentation/@opentelemetry/instrumentation/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.207.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-lAb0jQRVyleQQGiuuvCOTDVspc14nx6XJjP4FspJ1sNARo3Regq4ZZbrc3rN4b1TYSuUCvgH+UXUPug4SLOqEQ=="],
@@ -7375,8 +7395,6 @@
 
     "@sentry/electron/@sentry/node/@opentelemetry/instrumentation-http/@opentelemetry/core": ["@opentelemetry/core@2.5.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-ka4H8OM6+DlUhSAZpONu0cPBtPPTQKxbxVzC4CzVx5+K4JnroJVBtDzLAMx4/3CDTJXRvVFhpFjtl4SaiTNoyQ=="],
 
-    "@sentry/electron/@sentry/node/@opentelemetry/instrumentation-pg/@types/pg": ["@types/pg@8.15.6", "", { "dependencies": { "@types/node": "*", "pg-protocol": "*", "pg-types": "^2.2.0" } }, "sha512-NoaMtzhxOrubeL/7UZuNTrejB4MPAJ0RpxZqXQf2qXuVlTPuG6Y8p4u9dKRaue4yjmC7ZhzVO2/Yyyn25znrPQ=="],
-
     "@sentry/electron/@sentry/node/@prisma/instrumentation/@opentelemetry/instrumentation": ["@opentelemetry/instrumentation@0.207.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.207.0", "import-in-the-middle": "^2.0.0", "require-in-the-middle": "^8.0.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-y6eeli9+TLKnznrR8AZlQMSJT7wILpXH+6EYq5Vf/4Ao+huI7EedxQHwRgVUOMLFbe7VFDvHJrX9/f4lcwnJsA=="],
 
     "@sentry/electron/@sentry/node/import-in-the-middle/cjs-module-lexer": ["cjs-module-lexer@2.2.0", "", {}, "sha512-4bHTS2YuzUvtoLjdy+98ykbNB5jS0+07EvFNXerqZQJ89F7DI6ET7OQo/HJuW6K0aVsKA9hj9/RVb2kQVOrPDQ=="],
diff --git a/bunfig.toml b/bunfig.toml
index ddc0bf73739..01c48e4b3d9 100644
--- a/bunfig.toml
+++ b/bunfig.toml
@@ -1,3 +1,3 @@
 [install]
-minimumReleaseAge = 604800
+#minimumReleaseAge = 604800
 linker = "isolated" # Prevent hoisting from resolving `path-scurry@2` to `lru-cache@6` (missing `LRUCache`), which breaks the `@superset/desktop` postinstall native rebuild.
diff --git a/packages/host-service/src/trpc/router/filesystem/filesystem.ts b/packages/host-service/src/trpc/router/filesystem/filesystem.ts
index 04e42246c1d..b3c1a92a2b2 100644
--- a/packages/host-service/src/trpc/router/filesystem/filesystem.ts
+++ b/packages/host-service/src/trpc/router/filesystem/filesystem.ts
@@ -28,6 +28,29 @@ const writeFileContentSchema = z.union([
 	}),
 ]);
 
+const searchContentInputSchema = z.object({
+	workspaceId: z.string(),
+	query: z.string(),
+	includeHidden: z.boolean().optional(),
+	includePattern: z.string().optional(),
+	excludePattern: z.string().optional(),
+	limit: z.number().optional(),
+	isRegex: z.boolean().optional(),
+	caseSensitive: z.boolean().optional(),
+});
+
+const replaceContentInputSchema = z.object({
+	workspaceId: z.string(),
+	query: z.string(),
+	replacement: z.string(),
+	includeHidden: z.boolean().optional(),
+	includePattern: z.string().optional(),
+	excludePattern: z.string().optional(),
+	isRegex: z.boolean().optional(),
+	caseSensitive: z.boolean().optional(),
+	paths: z.array(z.string()).optional(),
+});
+
 export const filesystemRouter = router({
 	listDirectory: protectedProcedure
 		.input(
@@ -196,16 +219,7 @@ export const filesystemRouter = router({
 		}),
 
 	searchContent: protectedProcedure
-		.input(
-			z.object({
-				workspaceId: z.string(),
-				query: z.string(),
-				includeHidden: z.boolean().optional(),
-				includePattern: z.string().optional(),
-				excludePattern: z.string().optional(),
-				limit: z.number().optional(),
-			}),
-		)
+		.input(searchContentInputSchema)
 		.query(async ({ ctx, input }) => {
 			const trimmedQuery = input.query.trim();
 			if (!trimmedQuery) {
@@ -219,4 +233,26 @@ export const filesystemRouter = router({
 				query: trimmedQuery,
 			});
 		}),
+
+	replaceContent: protectedProcedure
+		.input(replaceContentInputSchema)
+		.mutation(async ({ ctx, input }) => {
+			const trimmedQuery = input.query.trim();
+			if (!trimmedQuery) {
+				return {
+					replacements: 0,
+					filesUpdated: 0,
+					updated: [],
+					conflicts: [],
+					failed: [],
+				};
+			}
+
+			const { workspaceId, ...serviceInput } = input;
+			const service = getFilesystemService(ctx, workspaceId);
+			return await service.replaceContent({
+				...serviceInput,
+				query: trimmedQuery,
+			});
+		}),
 });
diff --git a/packages/local-db/drizzle/0038_groovy_sister_grimm.sql b/packages/local-db/drizzle/0038_groovy_sister_grimm.sql
new file mode 100644
index 00000000000..df3c4ad4e7e
--- /dev/null
+++ b/packages/local-db/drizzle/0038_groovy_sister_grimm.sql
@@ -0,0 +1 @@
+ALTER TABLE `settings` ADD `prevent_agent_sleep` integer;
\ No newline at end of file
diff --git a/packages/local-db/drizzle/meta/0038_snapshot.json b/packages/local-db/drizzle/meta/0038_snapshot.json
new file mode 100644
index 00000000000..f39b62eeff4
--- /dev/null
+++ b/packages/local-db/drizzle/meta/0038_snapshot.json
@@ -0,0 +1,1397 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "f5a46ce1-7feb-41e5-ac95-e413720a1534",
+  "prevId": "c4874a39-c07e-4a7f-9f98-44e3c578dee0",
+  "tables": {
+    "browser_history": {
+      "name": "browser_history",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "url": {
+          "name": "url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "favicon_url": {
+          "name": "favicon_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_visited_at": {
+          "name": "last_visited_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "visit_count": {
+          "name": "visit_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        }
+      },
+      "indexes": {
+        "browser_history_url_unique": {
+          "name": "browser_history_url_unique",
+          "columns": [
+            "url"
+          ],
+          "isUnique": true
+        },
+        "browser_history_url_idx": {
+          "name": "browser_history_url_idx",
+          "columns": [
+            "url"
+          ],
+          "isUnique": false
+        },
+        "browser_history_last_visited_at_idx": {
+          "name": "browser_history_last_visited_at_idx",
+          "columns": [
+            "last_visited_at"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "organization_members": {
+      "name": "organization_members",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "organization_id": {
+          "name": "organization_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "organization_members_organization_id_idx": {
+          "name": "organization_members_organization_id_idx",
+          "columns": [
+            "organization_id"
+          ],
+          "isUnique": false
+        },
+        "organization_members_user_id_idx": {
+          "name": "organization_members_user_id_idx",
+          "columns": [
+            "user_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "organization_members_organization_id_organizations_id_fk": {
+          "name": "organization_members_organization_id_organizations_id_fk",
+          "tableFrom": "organization_members",
+          "tableTo": "organizations",
+          "columnsFrom": [
+            "organization_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "organization_members_user_id_users_id_fk": {
+          "name": "organization_members_user_id_users_id_fk",
+          "tableFrom": "organization_members",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "organizations": {
+      "name": "organizations",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "clerk_org_id": {
+          "name": "clerk_org_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "github_org": {
+          "name": "github_org",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "avatar_url": {
+          "name": "avatar_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "organizations_clerk_org_id_unique": {
+          "name": "organizations_clerk_org_id_unique",
+          "columns": [
+            "clerk_org_id"
+          ],
+          "isUnique": true
+        },
+        "organizations_slug_unique": {
+          "name": "organizations_slug_unique",
+          "columns": [
+            "slug"
+          ],
+          "isUnique": true
+        },
+        "organizations_slug_idx": {
+          "name": "organizations_slug_idx",
+          "columns": [
+            "slug"
+          ],
+          "isUnique": false
+        },
+        "organizations_clerk_org_id_idx": {
+          "name": "organizations_clerk_org_id_idx",
+          "columns": [
+            "clerk_org_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "projects": {
+      "name": "projects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "main_repo_path": {
+          "name": "main_repo_path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "color": {
+          "name": "color",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "tab_order": {
+          "name": "tab_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_opened_at": {
+          "name": "last_opened_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "config_toast_dismissed": {
+          "name": "config_toast_dismissed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "default_branch": {
+          "name": "default_branch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "workspace_base_branch": {
+          "name": "workspace_base_branch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "github_owner": {
+          "name": "github_owner",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "branch_prefix_mode": {
+          "name": "branch_prefix_mode",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "branch_prefix_custom": {
+          "name": "branch_prefix_custom",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "worktree_base_dir": {
+          "name": "worktree_base_dir",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "hide_image": {
+          "name": "hide_image",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "icon_url": {
+          "name": "icon_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "neon_project_id": {
+          "name": "neon_project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "default_app": {
+          "name": "default_app",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "projects_main_repo_path_idx": {
+          "name": "projects_main_repo_path_idx",
+          "columns": [
+            "main_repo_path"
+          ],
+          "isUnique": false
+        },
+        "projects_last_opened_at_idx": {
+          "name": "projects_last_opened_at_idx",
+          "columns": [
+            "last_opened_at"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "settings": {
+      "name": "settings",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "last_active_workspace_id": {
+          "name": "last_active_workspace_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "terminal_presets": {
+          "name": "terminal_presets",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "terminal_presets_initialized": {
+          "name": "terminal_presets_initialized",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "agent_preset_overrides": {
+          "name": "agent_preset_overrides",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "agent_custom_definitions": {
+          "name": "agent_custom_definitions",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "selected_ringtone_id": {
+          "name": "selected_ringtone_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "active_organization_id": {
+          "name": "active_organization_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "confirm_on_quit": {
+          "name": "confirm_on_quit",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "terminal_link_behavior": {
+          "name": "terminal_link_behavior",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "persist_terminal": {
+          "name": "persist_terminal",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false,
+          "default": true
+        },
+        "auto_apply_default_preset": {
+          "name": "auto_apply_default_preset",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "branch_prefix_mode": {
+          "name": "branch_prefix_mode",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "branch_prefix_custom": {
+          "name": "branch_prefix_custom",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "notification_sounds_muted": {
+          "name": "notification_sounds_muted",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "prevent_agent_sleep": {
+          "name": "prevent_agent_sleep",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "delete_local_branch": {
+          "name": "delete_local_branch",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "file_open_mode": {
+          "name": "file_open_mode",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "show_presets_bar": {
+          "name": "show_presets_bar",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "use_compact_terminal_add_button": {
+          "name": "use_compact_terminal_add_button",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "terminal_font_family": {
+          "name": "terminal_font_family",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "terminal_font_size": {
+          "name": "terminal_font_size",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "editor_font_family": {
+          "name": "editor_font_family",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "editor_font_size": {
+          "name": "editor_font_size",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "show_resource_monitor": {
+          "name": "show_resource_monitor",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "worktree_base_dir": {
+          "name": "worktree_base_dir",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "open_links_in_app": {
+          "name": "open_links_in_app",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "default_editor": {
+          "name": "default_editor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "tasks": {
+      "name": "tasks",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status_color": {
+          "name": "status_color",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status_type": {
+          "name": "status_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status_position": {
+          "name": "status_position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "priority": {
+          "name": "priority",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "organization_id": {
+          "name": "organization_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "repository_id": {
+          "name": "repository_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "assignee_id": {
+          "name": "assignee_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "creator_id": {
+          "name": "creator_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "estimate": {
+          "name": "estimate",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "due_date": {
+          "name": "due_date",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "labels": {
+          "name": "labels",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "branch": {
+          "name": "branch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "pr_url": {
+          "name": "pr_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "external_provider": {
+          "name": "external_provider",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "external_id": {
+          "name": "external_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "external_key": {
+          "name": "external_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "external_url": {
+          "name": "external_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_synced_at": {
+          "name": "last_synced_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sync_error": {
+          "name": "sync_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "tasks_slug_unique": {
+          "name": "tasks_slug_unique",
+          "columns": [
+            "slug"
+          ],
+          "isUnique": true
+        },
+        "tasks_slug_idx": {
+          "name": "tasks_slug_idx",
+          "columns": [
+            "slug"
+          ],
+          "isUnique": false
+        },
+        "tasks_organization_id_idx": {
+          "name": "tasks_organization_id_idx",
+          "columns": [
+            "organization_id"
+          ],
+          "isUnique": false
+        },
+        "tasks_assignee_id_idx": {
+          "name": "tasks_assignee_id_idx",
+          "columns": [
+            "assignee_id"
+          ],
+          "isUnique": false
+        },
+        "tasks_status_idx": {
+          "name": "tasks_status_idx",
+          "columns": [
+            "status"
+          ],
+          "isUnique": false
+        },
+        "tasks_created_at_idx": {
+          "name": "tasks_created_at_idx",
+          "columns": [
+            "created_at"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "tasks_organization_id_organizations_id_fk": {
+          "name": "tasks_organization_id_organizations_id_fk",
+          "tableFrom": "tasks",
+          "tableTo": "organizations",
+          "columnsFrom": [
+            "organization_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "tasks_assignee_id_users_id_fk": {
+          "name": "tasks_assignee_id_users_id_fk",
+          "tableFrom": "tasks",
+          "tableTo": "users",
+          "columnsFrom": [
+            "assignee_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "tasks_creator_id_users_id_fk": {
+          "name": "tasks_creator_id_users_id_fk",
+          "tableFrom": "tasks",
+          "tableTo": "users",
+          "columnsFrom": [
+            "creator_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "users": {
+      "name": "users",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "clerk_id": {
+          "name": "clerk_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "avatar_url": {
+          "name": "avatar_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "users_clerk_id_unique": {
+          "name": "users_clerk_id_unique",
+          "columns": [
+            "clerk_id"
+          ],
+          "isUnique": true
+        },
+        "users_email_unique": {
+          "name": "users_email_unique",
+          "columns": [
+            "email"
+          ],
+          "isUnique": true
+        },
+        "users_email_idx": {
+          "name": "users_email_idx",
+          "columns": [
+            "email"
+          ],
+          "isUnique": false
+        },
+        "users_clerk_id_idx": {
+          "name": "users_clerk_id_idx",
+          "columns": [
+            "clerk_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "workspace_sections": {
+      "name": "workspace_sections",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "tab_order": {
+          "name": "tab_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "is_collapsed": {
+          "name": "is_collapsed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false,
+          "default": false
+        },
+        "color": {
+          "name": "color",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "workspace_sections_project_id_idx": {
+          "name": "workspace_sections_project_id_idx",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "workspace_sections_project_id_projects_id_fk": {
+          "name": "workspace_sections_project_id_projects_id_fk",
+          "tableFrom": "workspace_sections",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "workspaces": {
+      "name": "workspaces",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "worktree_id": {
+          "name": "worktree_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "branch": {
+          "name": "branch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "tab_order": {
+          "name": "tab_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_opened_at": {
+          "name": "last_opened_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "is_unread": {
+          "name": "is_unread",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false,
+          "default": false
+        },
+        "is_unnamed": {
+          "name": "is_unnamed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false,
+          "default": false
+        },
+        "deleting_at": {
+          "name": "deleting_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "port_base": {
+          "name": "port_base",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "section_id": {
+          "name": "section_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "workspaces_project_id_idx": {
+          "name": "workspaces_project_id_idx",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": false
+        },
+        "workspaces_worktree_id_idx": {
+          "name": "workspaces_worktree_id_idx",
+          "columns": [
+            "worktree_id"
+          ],
+          "isUnique": false
+        },
+        "workspaces_last_opened_at_idx": {
+          "name": "workspaces_last_opened_at_idx",
+          "columns": [
+            "last_opened_at"
+          ],
+          "isUnique": false
+        },
+        "workspaces_section_id_idx": {
+          "name": "workspaces_section_id_idx",
+          "columns": [
+            "section_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "workspaces_project_id_projects_id_fk": {
+          "name": "workspaces_project_id_projects_id_fk",
+          "tableFrom": "workspaces",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "workspaces_worktree_id_worktrees_id_fk": {
+          "name": "workspaces_worktree_id_worktrees_id_fk",
+          "tableFrom": "workspaces",
+          "tableTo": "worktrees",
+          "columnsFrom": [
+            "worktree_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "workspaces_section_id_workspace_sections_id_fk": {
+          "name": "workspaces_section_id_workspace_sections_id_fk",
+          "tableFrom": "workspaces",
+          "tableTo": "workspace_sections",
+          "columnsFrom": [
+            "section_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "worktrees": {
+      "name": "worktrees",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "path": {
+          "name": "path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "branch": {
+          "name": "branch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "base_branch": {
+          "name": "base_branch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "git_status": {
+          "name": "git_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "github_status": {
+          "name": "github_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_by_superset": {
+          "name": "created_by_superset",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        }
+      },
+      "indexes": {
+        "worktrees_project_id_idx": {
+          "name": "worktrees_project_id_idx",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": false
+        },
+        "worktrees_branch_idx": {
+          "name": "worktrees_branch_idx",
+          "columns": [
+            "branch"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "worktrees_project_id_projects_id_fk": {
+          "name": "worktrees_project_id_projects_id_fk",
+          "tableFrom": "worktrees",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}
\ No newline at end of file
diff --git a/packages/local-db/drizzle/meta/_journal.json b/packages/local-db/drizzle/meta/_journal.json
index a1ce94a6fa4..ea13fbc416e 100644
--- a/packages/local-db/drizzle/meta/_journal.json
+++ b/packages/local-db/drizzle/meta/_journal.json
@@ -267,6 +267,13 @@
       "when": 1773824260645,
       "tag": "0037_add_created_by_superset_to_worktrees",
       "breakpoints": true
+    },
+    {
+      "idx": 38,
+      "version": "6",
+      "when": 1775066139568,
+      "tag": "0038_groovy_sister_grimm",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file
diff --git a/packages/local-db/src/schema/schema.ts b/packages/local-db/src/schema/schema.ts
index 522482bbb1d..f84d5a1780e 100644
--- a/packages/local-db/src/schema/schema.ts
+++ b/packages/local-db/src/schema/schema.ts
@@ -207,6 +207,7 @@ export const settings = sqliteTable("settings", {
 	notificationSoundsMuted: integer("notification_sounds_muted", {
 		mode: "boolean",
 	}),
+	preventAgentSleep: integer("prevent_agent_sleep", { mode: "boolean" }),
 	deleteLocalBranch: integer("delete_local_branch", { mode: "boolean" }),
 	fileOpenMode: text("file_open_mode").$type<FileOpenMode>(),
 	showPresetsBar: integer("show_presets_bar", { mode: "boolean" }),
diff --git a/packages/workspace-fs/src/client/index.ts b/packages/workspace-fs/src/client/index.ts
index 4305f130647..95b5355e404 100644
--- a/packages/workspace-fs/src/client/index.ts
+++ b/packages/workspace-fs/src/client/index.ts
@@ -53,6 +53,9 @@ export function createFsClient(transport: FsClientTransport): FsService {
 		async searchContent(input) {
 			return await transport.request("searchContent", input);
 		},
+		async replaceContent(input) {
+			return await transport.request("replaceContent", input);
+		},
 		watchPath(input) {
 			return transport.subscribe("watchPath", input);
 		},
diff --git a/packages/workspace-fs/src/core/service.ts b/packages/workspace-fs/src/core/service.ts
index 787f9948d22..f0cd6c87f08 100644
--- a/packages/workspace-fs/src/core/service.ts
+++ b/packages/workspace-fs/src/core/service.ts
@@ -3,6 +3,7 @@ import type {
 	FsEntry,
 	FsMetadata,
 	FsReadResult,
+	FsReplaceContentResult,
 	FsSearchMatch,
 	FsWatchEvent,
 	FsWriteResult,
@@ -64,8 +65,21 @@ export interface FsService {
 		includePattern?: string;
 		excludePattern?: string;
 		limit?: number;
+		isRegex?: boolean;
+		caseSensitive?: boolean;
 	}): Promise<{ matches: FsContentMatch[] }>;
 
+	replaceContent(input: {
+		query: string;
+		replacement: string;
+		includeHidden?: boolean;
+		includePattern?: string;
+		excludePattern?: string;
+		isRegex?: boolean;
+		caseSensitive?: boolean;
+		paths?: string[];
+	}): Promise<FsReplaceContentResult>;
+
 	watchPath(input: {
 		absolutePath: string;
 		recursive?: boolean;
@@ -139,9 +153,24 @@ export interface FsRequestMap {
 			includePattern?: string;
 			excludePattern?: string;
 			limit?: number;
+			isRegex?: boolean;
+			caseSensitive?: boolean;
 		};
 		output: { matches: FsContentMatch[] };
 	};
+	replaceContent: {
+		input: {
+			query: string;
+			replacement: string;
+			includeHidden?: boolean;
+			includePattern?: string;
+			excludePattern?: string;
+			isRegex?: boolean;
+			caseSensitive?: boolean;
+			paths?: string[];
+		};
+		output: FsReplaceContentResult;
+	};
 }
 
 export interface FsSubscriptionMap {
diff --git a/packages/workspace-fs/src/host/service.ts b/packages/workspace-fs/src/host/service.ts
index 973be99bc72..951133336d0 100644
--- a/packages/workspace-fs/src/host/service.ts
+++ b/packages/workspace-fs/src/host/service.ts
@@ -10,7 +10,7 @@ import {
 	writeFile,
 } from "../fs";
 import type { SearchContentOptions } from "../search";
-import { searchContent, searchFiles } from "../search";
+import { replaceContent, searchContent, searchFiles } from "../search";
 import type { FsWatchEvent } from "../types";
 import type { FsWatcherManager, WatchPathOptions } from "../watch";
 
@@ -225,11 +225,27 @@ export function createFsHostService(
 				includePattern: input.includePattern,
 				excludePattern: input.excludePattern,
 				limit: input.limit,
+				isRegex: input.isRegex,
+				caseSensitive: input.caseSensitive,
 				runRipgrep: options.runRipgrep,
 			});
 			return { matches };
 		},
 
+		async replaceContent(input) {
+			return await replaceContent({
+				rootPath,
+				query: input.query,
+				replacement: input.replacement,
+				includeHidden: input.includeHidden,
+				includePattern: input.includePattern,
+				excludePattern: input.excludePattern,
+				isRegex: input.isRegex,
+				caseSensitive: input.caseSensitive,
+				paths: input.paths,
+			});
+		},
+
 		watchPath(
 			input: WatchPathOptions,
 		): AsyncIterable<{ events: FsWatchEvent[] }> {
diff --git a/packages/workspace-fs/src/search.ts b/packages/workspace-fs/src/search.ts
index 7defe3a5be4..e08230ff88d 100644
--- a/packages/workspace-fs/src/search.ts
+++ b/packages/workspace-fs/src/search.ts
@@ -4,8 +4,17 @@ import path from "node:path";
 import { promisify } from "node:util";
 import fg from "fast-glob";
 import Fuse from "fuse.js";
-import { normalizeAbsolutePath, toRelativePath } from "./paths";
-import type { FsContentMatch, FsSearchMatch } from "./types";
+import { readFile as readFsFile, writeFile as writeFsFile } from "./fs";
+import {
+	isPathWithinRoot,
+	normalizeAbsolutePath,
+	toRelativePath,
+} from "./paths";
+import type {
+	FsContentMatch,
+	FsReplaceContentResult,
+	FsSearchMatch,
+} from "./types";
 
 const execFileAsync = promisify(execFile);
 
@@ -100,12 +109,37 @@ export interface SearchContentOptions {
 	includePattern?: string;
 	excludePattern?: string;
 	limit?: number;
+	isRegex?: boolean;
+	caseSensitive?: boolean;
 	runRipgrep?: (
 		args: string[],
 		options: RunRipgrepOptions,
 	) => Promise<{ stdout: string }>;
 }
 
+export interface ReplaceContentOptions {
+	rootPath: string;
+	query: string;
+	replacement: string;
+	includeHidden?: boolean;
+	includePattern?: string;
+	excludePattern?: string;
+	isRegex?: boolean;
+	caseSensitive?: boolean;
+	paths?: string[];
+}
+
+interface CompiledSearchPattern {
+	isRegex: boolean;
+	caseSensitive: boolean;
+	regex: RegExp;
+}
+
+interface LineSearchMatch {
+	index: number;
+	length: number;
+}
+
 const searchIndexCache = new Map<string, FileSearchCacheEntry>();
 const searchIndexBuilds = new Map<string, Promise<FileSearchIndex>>();
 const searchIndexVersions = new Map<string, number>();
@@ -297,6 +331,104 @@ function globToRegExp(pattern: string): RegExp {
 	return new RegExp(regex);
 }
 
+function escapeRegExp(input: string): string {
+	return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function resolveCaseSensitive(
+	query: string,
+	caseSensitive: boolean | undefined,
+	isRegex: boolean,
+): boolean {
+	if (caseSensitive !== undefined) {
+		return caseSensitive;
+	}
+
+	if (isRegex) {
+		return true;
+	}
+
+	return /[A-Z]/.test(query);
+}
+
+function compileSearchPattern({
+	query,
+	isRegex = false,
+	caseSensitive,
+}: Pick<
+	SearchContentOptions,
+	"query" | "isRegex" | "caseSensitive"
+>): CompiledSearchPattern {
+	const resolvedCaseSensitive = resolveCaseSensitive(
+		query,
+		caseSensitive,
+		isRegex,
+	);
+	const flags = resolvedCaseSensitive ? "gu" : "giu";
+	const source = isRegex ? query : escapeRegExp(query);
+
+	return {
+		isRegex,
+		caseSensitive: resolvedCaseSensitive,
+		regex: new RegExp(source, flags),
+	};
+}
+
+function collectLineSearchMatches(
+	line: string,
+	pattern: CompiledSearchPattern,
+): LineSearchMatch[] {
+	const matches: LineSearchMatch[] = [];
+	const regex = new RegExp(pattern.regex.source, pattern.regex.flags);
+	let result = regex.exec(line);
+
+	while (result) {
+		const matchText = result[0] ?? "";
+		const matchLength = matchText.length > 0 ? matchText.length : 1;
+		matches.push({
+			index: result.index,
+			length: matchLength,
+		});
+
+		if (matchText.length === 0) {
+			regex.lastIndex += 1;
+		}
+
+		result = regex.exec(line);
+	}
+
+	return matches;
+}
+
+function countMatchesInText(
+	text: string,
+	pattern: CompiledSearchPattern,
+): number {
+	let count = 0;
+	const regex = new RegExp(pattern.regex.source, pattern.regex.flags);
+	let result = regex.exec(text);
+
+	while (result) {
+		count += 1;
+		const matchText = result[0] ?? "";
+		if (matchText.length === 0) {
+			regex.lastIndex += 1;
+		}
+		result = regex.exec(text);
+	}
+
+	return count;
+}
+
+function replaceTextContent(
+	text: string,
+	pattern: CompiledSearchPattern,
+	replacement: string,
+): string {
+	const regex = new RegExp(pattern.regex.source, pattern.regex.flags);
+	return text.replace(regex, replacement);
+}
+
 const defaultIgnoreMatchers = DEFAULT_IGNORE_PATTERNS.map(globToRegExp);
 
 function createPathFilterMatcher({
@@ -518,12 +650,17 @@ function rankContentMatches(
 	matches: InternalContentMatch[],
 	query: string,
 	limit: number,
+	isRegex = false,
 ): InternalContentMatch[] {
 	if (matches.length === 0) {
 		return [];
 	}
 
 	const safeLimit = safeSearchLimit(limit);
+	if (isRegex) {
+		return matches.slice(0, safeLimit);
+	}
+
 	const fuse = new Fuse(matches, {
 		keys: [
 			{ name: "preview", weight: 2 },
@@ -562,8 +699,12 @@ async function searchContentWithRipgrep({
 	includePattern,
 	excludePattern,
 	limit,
+	isRegex,
+	caseSensitive,
+	useSmartCase,
 	runRipgrep,
 }: Required<Omit<SearchContentOptions, "runRipgrep">> & {
+	useSmartCase: boolean;
 	runRipgrep: NonNullable<SearchContentOptions["runRipgrep"]>;
 }): Promise<InternalContentMatch[]> {
 	const safeLimit = safeSearchLimit(limit);
@@ -572,8 +713,6 @@ async function searchContentWithRipgrep({
 		"--json",
 		"--line-number",
 		"--column",
-		"--fixed-strings",
-		"--smart-case",
 		"--no-messages",
 		"--max-filesize",
 		`${Math.floor(MAX_KEYWORD_FILE_SIZE_BYTES / 1024)}K`,
@@ -581,6 +720,23 @@ async function searchContentWithRipgrep({
 		String(KEYWORD_SEARCH_MAX_COUNT_PER_FILE),
 	];
 
+	if (isRegex) {
+		if (caseSensitive) {
+			args.push("--case-sensitive");
+		} else {
+			args.push("--ignore-case");
+		}
+	} else {
+		if (caseSensitive) {
+			args.push("--case-sensitive");
+		} else if (useSmartCase) {
+			args.push("--smart-case");
+		} else {
+			args.push("--ignore-case");
+		}
+		args.push("--fixed-strings");
+	}
+
 	if (includeHidden) {
 		args.push("--hidden", "--no-ignore");
 	}
@@ -696,7 +852,7 @@ async function searchContentWithRipgrep({
 			});
 		}
 
-		return rankContentMatches(matches, query, safeLimit);
+		return rankContentMatches(matches, query, safeLimit, isRegex);
 	} catch (error) {
 		const err = error as NodeJS.ErrnoException & {
 			code?: string | number | null;
@@ -717,17 +873,18 @@ async function searchContentWithRipgrep({
 async function searchContentWithScan({
 	index,
 	query,
+	pattern,
 	pathMatcher,
 	limit,
 }: {
 	index: FileSearchIndex;
 	query: string;
+	pattern: CompiledSearchPattern;
 	pathMatcher: PathFilterMatcher;
 	limit: number;
 }): Promise<InternalContentMatch[]> {
 	const safeLimit = safeSearchLimit(limit);
 	const maxCandidates = safeLimit * KEYWORD_SEARCH_CANDIDATE_MULTIPLIER;
-	const lowerNeedle = query.toLowerCase();
 	const matches: InternalContentMatch[] = [];
 
 	for (const item of index.items) {
@@ -760,31 +917,24 @@ async function searchContentWithScan({
 				}
 
 				const line = lines[lineIndex] ?? "";
-				const lowerLine = line.toLowerCase();
-				let fromIndex = 0;
-
-				while (matches.length < maxCandidates) {
-					const matchIndex = lowerLine.indexOf(lowerNeedle, fromIndex);
-					if (matchIndex === -1) {
+				for (const match of collectLineSearchMatches(line, pattern)) {
+					if (matches.length >= maxCandidates) {
 						break;
 					}
-
 					matches.push({
 						absolutePath: item.absolutePath,
 						relativePath: item.relativePath,
 						name: item.name,
 						line: lineIndex + 1,
-						column: matchIndex + 1,
+						column: match.index + 1,
 						preview: formatPreviewLine(line),
 					});
-
-					fromIndex = matchIndex + lowerNeedle.length;
 				}
 			}
 		} catch {}
 	}
 
-	return rankContentMatches(matches, query, safeLimit);
+	return rankContentMatches(matches, query, safeLimit, pattern.isRegex);
 }
 
 function isHiddenRelativePath(relativePath: string): boolean {
@@ -999,6 +1149,8 @@ export async function searchContent({
 	includePattern = "",
 	excludePattern = "",
 	limit = 20,
+	isRegex = false,
+	caseSensitive,
 	runRipgrep = defaultRunRipgrep,
 }: SearchContentOptions): Promise<FsContentMatch[]> {
 	const trimmedQuery = query.trim();
@@ -1006,6 +1158,12 @@ export async function searchContent({
 		return [];
 	}
 
+	const pattern = compileSearchPattern({
+		query: trimmedQuery,
+		isRegex,
+		caseSensitive,
+	});
+
 	const index = await getSearchIndex({
 		rootPath,
 		includeHidden,
@@ -1024,12 +1182,16 @@ export async function searchContent({
 			includePattern,
 			excludePattern,
 			limit,
+			isRegex,
+			caseSensitive: pattern.caseSensitive,
+			useSmartCase: !isRegex && caseSensitive === undefined,
 			runRipgrep,
 		});
 	} catch {
 		internalMatches = await searchContentWithScan({
 			index,
 			query: trimmedQuery,
+			pattern,
 			pathMatcher,
 			limit,
 		});
@@ -1045,3 +1207,143 @@ export async function searchContent({
 		}),
 	);
 }
+
+export async function replaceContent({
+	rootPath,
+	query,
+	replacement,
+	includeHidden = true,
+	includePattern = "",
+	excludePattern = "",
+	isRegex = false,
+	caseSensitive,
+	paths,
+}: ReplaceContentOptions): Promise<FsReplaceContentResult> {
+	const trimmedQuery = query.trim();
+	if (!trimmedQuery) {
+		return {
+			replacements: 0,
+			filesUpdated: 0,
+			updated: [],
+			conflicts: [],
+			failed: [],
+		};
+	}
+
+	const normalizedRootPath = normalizeAbsolutePath(rootPath);
+	const pattern = compileSearchPattern({
+		query: trimmedQuery,
+		isRegex,
+		caseSensitive,
+	});
+	const index = await getSearchIndex({
+		rootPath: normalizedRootPath,
+		includeHidden,
+	});
+	const pathMatcher = createPathFilterMatcher({
+		includePattern,
+		excludePattern,
+	});
+	const allowedPaths =
+		paths && paths.length > 0
+			? new Set(
+					paths
+						.map((item) => normalizeAbsolutePath(item))
+						.filter((item) => isPathWithinRoot(normalizedRootPath, item)),
+				)
+			: null;
+	const candidates = index.items.filter((item) => {
+		if (!matchesPathFilters(item.relativePath, pathMatcher)) {
+			return false;
+		}
+		if (allowedPaths) {
+			return allowedPaths.has(item.absolutePath);
+		}
+		return true;
+	});
+
+	const updated: FsReplaceContentResult["updated"] = [];
+	const conflicts: FsReplaceContentResult["conflicts"] = [];
+	const failed: FsReplaceContentResult["failed"] = [];
+	let replacementCount = 0;
+
+	for (const candidate of candidates) {
+		try {
+			const readResult = await readFsFile({
+				rootPath: normalizedRootPath,
+				absolutePath: candidate.absolutePath,
+				maxBytes: MAX_KEYWORD_FILE_SIZE_BYTES,
+			});
+			if (readResult.kind !== "bytes" || readResult.exceededLimit) {
+				continue;
+			}
+
+			const buffer = Buffer.from(readResult.content);
+			if (isBinaryContent(buffer)) {
+				continue;
+			}
+
+			const content = buffer.toString("utf8");
+			const matchesInFile = countMatchesInText(content, pattern);
+			if (matchesInFile === 0) {
+				continue;
+			}
+
+			const nextContent = replaceTextContent(content, pattern, replacement);
+			if (nextContent === content) {
+				continue;
+			}
+
+			const writeResult = await writeFsFile({
+				rootPath: normalizedRootPath,
+				absolutePath: candidate.absolutePath,
+				content: nextContent,
+				encoding: "utf-8",
+				precondition: { ifMatch: readResult.revision },
+			});
+
+			if (!writeResult.ok) {
+				if (writeResult.reason === "conflict") {
+					conflicts.push({
+						absolutePath: candidate.absolutePath,
+						relativePath: candidate.relativePath,
+						currentRevision: writeResult.currentRevision,
+					});
+					continue;
+				}
+
+				failed.push({
+					absolutePath: candidate.absolutePath,
+					relativePath: candidate.relativePath,
+					message: `Replace failed: ${writeResult.reason}`,
+				});
+				continue;
+			}
+
+			replacementCount += matchesInFile;
+			updated.push({
+				absolutePath: candidate.absolutePath,
+				relativePath: candidate.relativePath,
+				replacements: matchesInFile,
+				revision: writeResult.revision,
+			});
+		} catch (error) {
+			failed.push({
+				absolutePath: candidate.absolutePath,
+				relativePath: candidate.relativePath,
+				message:
+					error instanceof Error
+						? error.message
+						: "Replace failed unexpectedly",
+			});
+		}
+	}
+
+	return {
+		replacements: replacementCount,
+		filesUpdated: updated.length,
+		updated,
+		conflicts,
+		failed,
+	};
+}
diff --git a/packages/workspace-fs/src/types.ts b/packages/workspace-fs/src/types.ts
index 657763bfb62..8b585772b2c 100644
--- a/packages/workspace-fs/src/types.ts
+++ b/packages/workspace-fs/src/types.ts
@@ -59,6 +59,33 @@ export interface FsContentMatch {
 	preview: string;
 }
 
+export interface FsReplaceContentUpdatedFile {
+	absolutePath: string;
+	relativePath: string;
+	replacements: number;
+	revision: string;
+}
+
+export interface FsReplaceContentConflictFile {
+	absolutePath: string;
+	relativePath: string;
+	currentRevision: string;
+}
+
+export interface FsReplaceContentFailedFile {
+	absolutePath: string;
+	relativePath: string;
+	message: string;
+}
+
+export interface FsReplaceContentResult {
+	replacements: number;
+	filesUpdated: number;
+	updated: FsReplaceContentUpdatedFile[];
+	conflicts: FsReplaceContentConflictFile[];
+	failed: FsReplaceContentFailedFile[];
+}
+
 export type FsWatchEvent = {
 	kind: "create" | "update" | "delete" | "rename" | "overflow";
 	absolutePath: string;