diff --git a/.env.example b/.env.example
index 464107ea1a4..51ea90178ea 100644
--- a/.env.example
+++ b/.env.example
@@ -27,6 +27,12 @@ NEXT_PUBLIC_ADMIN_URL=http://localhost:3003
 NEXT_PUBLIC_MARKETING_URL=http://localhost:3002
 NEXT_PUBLIC_DOCS_URL=http://localhost:3004
 
+# -----------------------------------------------------------------------------
+# Streams Server (AI Chat)
+# -----------------------------------------------------------------------------
+NEXT_PUBLIC_STREAMS_URL=http://localhost:8080
+EXPO_PUBLIC_STREAMS_URL=http://localhost:8080
+
 # -----------------------------------------------------------------------------
 # Better Auth
 # -----------------------------------------------------------------------------
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 00000000000..041817dbb43
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,2 @@
+# Git LFS tracking for large binaries (darwin-arm64 only for now)
+apps/desktop/resources/bin/darwin-arm64/claude filter=lfs diff=lfs merge=lfs -text
diff --git a/.gitignore b/.gitignore
index da7b0a9ec27..22247fb67cb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -67,3 +67,13 @@ next-env.d.ts
 
 # Reference material downloaded for agents
 examples
+
+# Streams data
+apps/streams/data/
+
+# Claude binaries - only darwin-arm64 tracked with Git LFS, others downloaded at build time
+apps/desktop/resources/bin/VERSION
+apps/desktop/resources/bin/darwin-x64/
+apps/desktop/resources/bin/linux-arm64/
+apps/desktop/resources/bin/linux-x64/
+apps/desktop/resources/bin/win32-x64/
diff --git a/apps/desktop/electron-builder.ts b/apps/desktop/electron-builder.ts
index 9fb84f56634..1c422b379b4 100644
--- a/apps/desktop/electron-builder.ts
+++ b/apps/desktop/electron-builder.ts
@@ -56,6 +56,12 @@ const config: Configuration = {
 			to: "resources/migrations",
 			filter: ["**/*"],
 		},
+		// Claude Code binary - bundled for AI chat functionality
+		{
+			from: "resources/bin/${platform}-${arch}",
+			to: "bin",
+			filter: ["**/*"],
+		},
 	],
 
 	files: [
diff --git a/apps/desktop/electron.vite.config.ts b/apps/desktop/electron.vite.config.ts
index 912e8a51f34..9e3557b0513 100644
--- a/apps/desktop/electron.vite.config.ts
+++ b/apps/desktop/electron.vite.config.ts
@@ -144,6 +144,10 @@ export default defineConfig({
 				process.env.NEXT_PUBLIC_DOCS_URL,
 				"https://docs.superset.sh",
 			),
+			"process.env.NEXT_PUBLIC_STREAMS_URL": defineEnv(
+				process.env.NEXT_PUBLIC_STREAMS_URL,
+				"http://localhost:8080",
+			),
 			"import.meta.env.DEV_SERVER_PORT": defineEnv(String(DEV_SERVER_PORT)),
 			"import.meta.env.NEXT_PUBLIC_POSTHOG_KEY": defineEnv(
 				process.env.NEXT_PUBLIC_POSTHOG_KEY,
diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index 81cd2133661..0c04c4fb24a 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -20,9 +20,11 @@
 		"dev": "cross-env NODE_ENV=development 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",
-		"prebuild": "bun run clean:dev && bun run compile:app && bun run copy:native-modules",
+		"download:claude": "bun run scripts/download-claude-binary.ts",
+		"upgrade:claude": "bun run scripts/upgrade-claude-binary.ts",
+		"prebuild": "bun run clean:dev && bun run compile:app && bun run copy:native-modules && bun run download:claude",
 		"build": "cross-env CSC_IDENTITY_AUTO_DISCOVERY=false electron-builder --publish never",
-		"prepackage": "bun run copy:native-modules",
+		"prepackage": "bun run copy:native-modules && bun run download:claude",
 		"package": "electron-builder --config electron-builder.ts",
 		"install:deps": "electron-builder install-app-deps",
 		"release": "electron-builder --publish always",
@@ -33,10 +35,12 @@
 		"test": "bun test"
 	},
 	"dependencies": {
+		"@anthropic-ai/claude-agent-sdk": "^0.2.19",
 		"@better-auth/stripe": "1.4.17",
 		"@dnd-kit/core": "^6.3.1",
 		"@dnd-kit/sortable": "^10.0.0",
 		"@dnd-kit/utilities": "^3.2.2",
+		"@durable-streams/client": "^0.2.0",
 		"@electric-sql/client": "https://pkg.pr.new/@electric-sql/client@3724",
 		"@headless-tree/core": "^1.6.3",
 		"@headless-tree/react": "^1.6.3",
@@ -45,6 +49,7 @@
 		"@radix-ui/react-dialog": "^1.1.15",
 		"@radix-ui/react-label": "^2.1.8",
 		"@sentry/electron": "^7.7.0",
+		"@superset/ai-chat": "workspace:*",
 		"@superset/auth": "workspace:*",
 		"@superset/db": "workspace:*",
 		"@superset/local-db": "workspace:*",
@@ -52,9 +57,9 @@
 		"@superset/trpc": "workspace:*",
 		"@superset/ui": "workspace:*",
 		"@t3-oss/env-core": "^0.13.8",
-		"@tanstack/db": "0.5.22",
-		"@tanstack/electric-db-collection": "0.2.27",
-		"@tanstack/react-db": "0.1.66",
+		"@tanstack/db": "^0.5.24",
+		"@tanstack/electric-db-collection": "0.2.30",
+		"@tanstack/react-db": "^0.1.68",
 		"@tanstack/react-query": "^5.90.19",
 		"@tanstack/react-router": "^1.147.3",
 		"@tanstack/react-table": "^8.21.3",
diff --git a/apps/desktop/resources/bin/darwin-arm64/claude b/apps/desktop/resources/bin/darwin-arm64/claude
new file mode 100755
index 00000000000..a23bea278ab
--- /dev/null
+++ b/apps/desktop/resources/bin/darwin-arm64/claude
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ae572cf525b2eec2da17a9100355413c4d59a43c124733e5cf1356dc50a576a
+size 180472304
diff --git a/apps/desktop/scripts/download-claude-binary.ts b/apps/desktop/scripts/download-claude-binary.ts
new file mode 100644
index 00000000000..af7eec695b2
--- /dev/null
+++ b/apps/desktop/scripts/download-claude-binary.ts
@@ -0,0 +1,366 @@
+/**
+ * Download Claude Code binary for bundling with the desktop app.
+ *
+ * This script downloads the Claude Code CLI binary from the official distribution
+ * and places it in the resources/bin directory for electron-builder to package.
+ *
+ * Usage:
+ *   bun run scripts/download-claude-binary.ts
+ *   bun run scripts/download-claude-binary.ts --all     # Download all platforms
+ *   bun run scripts/download-claude-binary.ts --version=2.1.17  # Specific version
+ *
+ * The binary is downloaded based on the current platform and architecture.
+ */
+
+import { createHash } from "node:crypto";
+import {
+	chmodSync,
+	createReadStream,
+	createWriteStream,
+	existsSync,
+	mkdirSync,
+	rmSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs";
+import https from "node:https";
+import { dirname, join } from "node:path";
+
+// Claude Code distribution base URL (same as 1code uses)
+const DIST_BASE =
+	"https://storage.googleapis.com/claude-code-dist-86c565f3-f756-42ad-8dfa-d59b1c096819/claude-code-releases";
+
+// Platform mappings
+const PLATFORMS: Record<string, { dir: string; binary: string }> = {
+	"darwin-arm64": { dir: "darwin-arm64", binary: "claude" },
+	"darwin-x64": { dir: "darwin-x64", binary: "claude" },
+	"linux-arm64": { dir: "linux-arm64", binary: "claude" },
+	"linux-x64": { dir: "linux-x64", binary: "claude" },
+	"win32-x64": { dir: "win32-x64", binary: "claude.exe" },
+};
+
+interface PlatformManifest {
+	checksum: string;
+	size: number;
+}
+
+interface Manifest {
+	version: string;
+	platforms: Record<string, PlatformManifest>;
+}
+
+function getPlatformKey(): string {
+	return `${process.platform}-${process.arch}`;
+}
+
+/**
+ * Fetch JSON from URL
+ */
+function fetchJson<T>(url: string): Promise<T> {
+	return new Promise((resolve, reject) => {
+		const request = (requestUrl: string) => {
+			https
+				.get(requestUrl, (res) => {
+					if (res.statusCode === 301 || res.statusCode === 302) {
+						const location = res.headers.location;
+						if (location) {
+							return request(location);
+						}
+						return reject(new Error("Redirect without location"));
+					}
+					if (res.statusCode !== 200) {
+						return reject(new Error(`HTTP ${res.statusCode}`));
+					}
+					let data = "";
+					res.on("data", (chunk) => {
+						data += chunk;
+					});
+					res.on("end", () => resolve(JSON.parse(data) as T));
+					res.on("error", reject);
+				})
+				.on("error", reject);
+		};
+		request(url);
+	});
+}
+
+/**
+ * Fetch text from URL
+ */
+function fetchText(url: string): Promise<string> {
+	return new Promise((resolve, reject) => {
+		const request = (requestUrl: string) => {
+			https
+				.get(requestUrl, (res) => {
+					if (res.statusCode === 301 || res.statusCode === 302) {
+						const location = res.headers.location;
+						if (location) {
+							return request(location);
+						}
+						return reject(new Error("Redirect without location"));
+					}
+					if (res.statusCode !== 200) {
+						return reject(new Error(`HTTP ${res.statusCode}`));
+					}
+					let data = "";
+					res.on("data", (chunk) => {
+						data += chunk;
+					});
+					res.on("end", () => resolve(data));
+					res.on("error", reject);
+				})
+				.on("error", reject);
+		};
+		request(url);
+	});
+}
+
+/**
+ * Download file with progress
+ */
+function downloadFile(url: string, destPath: string): Promise<void> {
+	return new Promise((resolve, reject) => {
+		// Ensure parent directory exists
+		const parentDir = dirname(destPath);
+		if (!existsSync(parentDir)) {
+			mkdirSync(parentDir, { recursive: true });
+		}
+
+		const file = createWriteStream(destPath);
+
+		const request = (requestUrl: string) => {
+			https
+				.get(requestUrl, (res) => {
+					if (res.statusCode === 301 || res.statusCode === 302) {
+						file.close();
+						if (existsSync(destPath)) unlinkSync(destPath);
+						const location = res.headers.location;
+						if (location) {
+							return request(location);
+						}
+						return reject(new Error("Redirect without location"));
+					}
+
+					if (res.statusCode !== 200) {
+						file.close();
+						if (existsSync(destPath)) unlinkSync(destPath);
+						return reject(new Error(`HTTP ${res.statusCode}`));
+					}
+
+					const totalSize = Number.parseInt(
+						res.headers["content-length"] || "0",
+						10,
+					);
+					let downloaded = 0;
+					let lastPercent = 0;
+
+					res.on("data", (chunk: Buffer) => {
+						downloaded += chunk.length;
+						if (totalSize > 0) {
+							const percent = Math.floor((downloaded / totalSize) * 100);
+							if (percent !== lastPercent && percent % 10 === 0) {
+								process.stdout.write(`\r  Progress: ${percent}%`);
+								lastPercent = percent;
+							}
+						}
+					});
+
+					res.pipe(file);
+
+					file.on("finish", () => {
+						file.close();
+						process.stdout.write("\r  Progress: 100%\n");
+						resolve();
+					});
+
+					res.on("error", (err) => {
+						file.close();
+						if (existsSync(destPath)) unlinkSync(destPath);
+						reject(err);
+					});
+				})
+				.on("error", (err) => {
+					file.close();
+					if (existsSync(destPath)) unlinkSync(destPath);
+					reject(err);
+				});
+		};
+
+		request(url);
+	});
+}
+
+/**
+ * Calculate SHA256 hash of file
+ */
+function calculateSha256(filePath: string): Promise<string> {
+	return new Promise((resolve, reject) => {
+		const hash = createHash("sha256");
+		const stream = createReadStream(filePath);
+		stream.on("data", (chunk) => hash.update(chunk));
+		stream.on("end", () => resolve(hash.digest("hex")));
+		stream.on("error", reject);
+	});
+}
+
+/**
+ * Get latest version from GCS bucket
+ */
+async function getLatestVersion(): Promise<string> {
+	console.log("Fetching latest Claude Code version...");
+
+	try {
+		const version = await fetchText(`${DIST_BASE}/latest`);
+		return version.trim();
+	} catch (error) {
+		console.warn(
+			`Failed to fetch latest version: ${error instanceof Error ? error.message : error}`,
+		);
+	}
+
+	// Fallback to known version
+	return "2.1.17";
+}
+
+/**
+ * Download binary for a specific platform
+ */
+async function downloadPlatform(
+	version: string,
+	platformKey: string,
+	manifest: Manifest,
+): Promise<boolean> {
+	const platform = PLATFORMS[platformKey];
+	if (!platform) {
+		console.error(`Unknown platform: ${platformKey}`);
+		return false;
+	}
+
+	const resourcesDir = join(dirname(import.meta.dirname), "resources");
+	const targetDir = join(resourcesDir, "bin", platformKey);
+	const targetPath = join(targetDir, platform.binary);
+
+	// Create directory
+	mkdirSync(targetDir, { recursive: true });
+
+	// Get expected hash from manifest
+	const platformManifest = manifest.platforms[platform.dir];
+	if (!platformManifest) {
+		console.error(`No manifest entry for ${platform.dir}`);
+		return false;
+	}
+
+	const expectedHash = platformManifest.checksum;
+	const downloadUrl = `${DIST_BASE}/${version}/${platform.dir}/${platform.binary}`;
+
+	console.log(`\nDownloading Claude Code for ${platformKey}...`);
+	console.log(`  URL: ${downloadUrl}`);
+	console.log(`  Size: ${(platformManifest.size / 1024 / 1024).toFixed(1)} MB`);
+
+	// Check if already downloaded with correct hash
+	if (existsSync(targetPath)) {
+		const existingHash = await calculateSha256(targetPath);
+		if (existingHash === expectedHash) {
+			console.log("  Already downloaded and verified");
+			return true;
+		}
+		console.log("  Existing file has wrong hash, re-downloading...");
+	}
+
+	// Download
+	await downloadFile(downloadUrl, targetPath);
+
+	// Verify hash
+	const actualHash = await calculateSha256(targetPath);
+	if (actualHash !== expectedHash) {
+		console.error("  Hash mismatch!");
+		console.error(`    Expected: ${expectedHash}`);
+		console.error(`    Actual:   ${actualHash}`);
+		rmSync(targetPath);
+		return false;
+	}
+	console.log(`  Verified SHA256: ${actualHash.substring(0, 16)}...`);
+
+	// Make executable (Unix)
+	if (process.platform !== "win32") {
+		chmodSync(targetPath, 0o755);
+	}
+
+	console.log(`  Saved to: ${targetPath}`);
+	return true;
+}
+
+async function main() {
+	const args = process.argv.slice(2);
+	const downloadAll = args.includes("--all");
+	const versionArg = args.find((a) => a.startsWith("--version="));
+	const specifiedVersion = versionArg?.split("=")[1];
+
+	console.log("Claude Code Binary Downloader");
+	console.log("=============================\n");
+
+	// Get version
+	const version = specifiedVersion || (await getLatestVersion());
+	console.log(`Version: ${version}`);
+
+	// Fetch manifest
+	const manifestUrl = `${DIST_BASE}/${version}/manifest.json`;
+	console.log(`Fetching manifest: ${manifestUrl}`);
+
+	let manifest: Manifest;
+	try {
+		manifest = await fetchJson<Manifest>(manifestUrl);
+	} catch (error) {
+		console.error(
+			`Failed to fetch manifest: ${error instanceof Error ? error.message : error}`,
+		);
+		process.exit(1);
+	}
+
+	// Determine which platforms to download
+	let platformsToDownload: string[];
+	if (downloadAll) {
+		platformsToDownload = Object.keys(PLATFORMS);
+	} else {
+		// Current platform only
+		const currentPlatform = getPlatformKey();
+		if (!PLATFORMS[currentPlatform]) {
+			console.error(`Unsupported platform: ${currentPlatform}`);
+			console.log(`Supported platforms: ${Object.keys(PLATFORMS).join(", ")}`);
+			process.exit(1);
+		}
+		platformsToDownload = [currentPlatform];
+	}
+
+	console.log(`\nPlatforms to download: ${platformsToDownload.join(", ")}`);
+
+	// Create bin directory
+	const resourcesDir = join(dirname(import.meta.dirname), "resources");
+	const binDir = join(resourcesDir, "bin");
+	mkdirSync(binDir, { recursive: true });
+
+	// Write version file
+	writeFileSync(
+		join(binDir, "VERSION"),
+		`${version}\n${new Date().toISOString()}\n`,
+	);
+
+	// Download each platform
+	let success = true;
+	for (const platform of platformsToDownload) {
+		const result = await downloadPlatform(version, platform, manifest);
+		if (!result) success = false;
+	}
+
+	if (success) {
+		console.log("\n✓ All downloads completed successfully!");
+	} else {
+		console.error("\n✗ Some downloads failed");
+		process.exit(1);
+	}
+}
+
+main().catch((error) => {
+	console.error("Fatal error:", error);
+	process.exit(1);
+});
diff --git a/apps/desktop/scripts/upgrade-claude-binary.ts b/apps/desktop/scripts/upgrade-claude-binary.ts
new file mode 100644
index 00000000000..cfc75b6f4d6
--- /dev/null
+++ b/apps/desktop/scripts/upgrade-claude-binary.ts
@@ -0,0 +1,82 @@
+#!/usr/bin/env bun
+/**
+ * Upgrade Claude Code binary to the latest version.
+ *
+ * This script:
+ * 1. Downloads the latest Claude Code binary for darwin-arm64
+ * 2. Stages the updated binary in git
+ *
+ * Usage:
+ *   bun run scripts/upgrade-claude-binary.ts
+ *   bun run scripts/upgrade-claude-binary.ts --version=2.1.31  # Specific version
+ *
+ * After running, commit the changes:
+ *   git commit -m "chore: upgrade claude binary to vX.X.X"
+ */
+
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+const SCRIPT_DIR = import.meta.dirname;
+const DESKTOP_DIR = dirname(SCRIPT_DIR);
+const BIN_DIR = join(DESKTOP_DIR, "resources", "bin");
+
+function run(cmd: string, opts?: { cwd?: string }): string {
+	console.log(`$ ${cmd}`);
+	return execSync(cmd, {
+		encoding: "utf-8",
+		cwd: opts?.cwd ?? DESKTOP_DIR,
+		stdio: ["inherit", "pipe", "inherit"],
+	}).trim();
+}
+
+async function main() {
+	const args = process.argv.slice(2);
+	const versionArg = args.find((a) => a.startsWith("--version="));
+	const versionFlag = versionArg ? ` ${versionArg}` : "";
+
+	console.log("Claude Code Binary Upgrader");
+	console.log("===========================\n");
+
+	// Get current version if exists
+	const versionFile = join(BIN_DIR, "VERSION");
+	if (existsSync(versionFile)) {
+		const currentVersion = readFileSync(versionFile, "utf-8")
+			.split("\n")[0]
+			.trim();
+		console.log(`Current version: ${currentVersion}`);
+	} else {
+		console.log("No existing binaries found");
+	}
+
+	// Download darwin-arm64 only (tracked with Git LFS)
+	// Other platforms are downloaded at build time
+	console.log("\nDownloading binary for darwin-arm64...\n");
+	run(`bun run scripts/download-claude-binary.ts${versionFlag}`);
+
+	// Get new version
+	const newVersion = readFileSync(versionFile, "utf-8").split("\n")[0].trim();
+	console.log(`\nNew version: ${newVersion}`);
+
+	// Stage the binary
+	console.log("\nStaging binary in git...");
+	run("git add resources/bin/darwin-arm64/claude");
+
+	// Show status
+	console.log("\nGit status:");
+	const status = run("git status --short resources/bin/darwin-arm64/");
+	console.log(status || "  (no changes)");
+
+	console.log("\n✓ Upgrade complete!");
+	console.log("\nNext steps:");
+	console.log(
+		`  git commit -m "chore: upgrade claude binary to v${newVersion}"`,
+	);
+	console.log("  git push");
+}
+
+main().catch((error) => {
+	console.error("Fatal error:", error);
+	process.exit(1);
+});
diff --git a/apps/desktop/src/lib/trpc/routers/ai-chat/index.ts b/apps/desktop/src/lib/trpc/routers/ai-chat/index.ts
new file mode 100644
index 00000000000..7e356a40018
--- /dev/null
+++ b/apps/desktop/src/lib/trpc/routers/ai-chat/index.ts
@@ -0,0 +1,100 @@
+/**
+ * AI Chat tRPC Router
+ *
+ * Provides local control of Claude sessions via tRPC.
+ * Uses observable pattern for streaming (required by trpc-electron).
+ */
+
+import { observable } from "@trpc/server/observable";
+import { z } from "zod";
+import { publicProcedure, router } from "../..";
+import {
+	type ClaudeStreamEvent,
+	claudeSessionManager,
+} from "./utils/session-manager";
+
+export const createAiChatRouter = () => {
+	return router({
+		/**
+		 * Start a Claude session.
+		 */
+		startSession: publicProcedure
+			.input(
+				z.object({
+					sessionId: z.string(),
+					cwd: z.string(),
+					claudeSessionId: z.string().optional(),
+				}),
+			)
+			.mutation(async ({ input }) => {
+				await claudeSessionManager.startSession({
+					sessionId: input.sessionId,
+					cwd: input.cwd,
+					claudeSessionId: input.claudeSessionId,
+				});
+				return { success: true };
+			}),
+
+		/**
+		 * Interrupt an active Claude session (SIGINT).
+		 */
+		interrupt: publicProcedure
+			.input(z.object({ sessionId: z.string() }))
+			.mutation(async ({ input }) => {
+				await claudeSessionManager.interrupt({ sessionId: input.sessionId });
+				return { success: true };
+			}),
+
+		/**
+		 * Stop a Claude session completely.
+		 */
+		stopSession: publicProcedure
+			.input(z.object({ sessionId: z.string() }))
+			.mutation(async ({ input }) => {
+				await claudeSessionManager.stopSession({ sessionId: input.sessionId });
+				return { success: true };
+			}),
+
+		/**
+		 * Check if a session is active.
+		 */
+		isSessionActive: publicProcedure
+			.input(z.object({ sessionId: z.string() }))
+			.query(({ input }) => {
+				return claudeSessionManager.isSessionActive(input.sessionId);
+			}),
+
+		/**
+		 * Get all active session IDs.
+		 */
+		getActiveSessions: publicProcedure.query(() => {
+			return claudeSessionManager.getActiveSessions();
+		}),
+
+		/**
+		 * Subscribe to stream events from Claude sessions.
+		 *
+		 * This uses the observable pattern required by trpc-electron.
+		 * Events are filtered by sessionId if provided.
+		 */
+		streamEvents: publicProcedure
+			.input(z.object({ sessionId: z.string().optional() }))
+			.subscription(({ input }) => {
+				return observable<ClaudeStreamEvent>((emit) => {
+					const onEvent = (event: ClaudeStreamEvent) => {
+						// Filter by sessionId if specified
+						if (input.sessionId && event.sessionId !== input.sessionId) {
+							return;
+						}
+						emit.next(event);
+					};
+
+					claudeSessionManager.on("event", onEvent);
+
+					return () => {
+						claudeSessionManager.off("event", onEvent);
+					};
+				});
+			}),
+	});
+};
diff --git a/apps/desktop/src/lib/trpc/routers/ai-chat/utils/auth/auth.ts b/apps/desktop/src/lib/trpc/routers/ai-chat/utils/auth/auth.ts
new file mode 100644
index 00000000000..d624cea69a4
--- /dev/null
+++ b/apps/desktop/src/lib/trpc/routers/ai-chat/utils/auth/auth.ts
@@ -0,0 +1,245 @@
+/**
+ * Claude Code authentication resolution.
+ *
+ * Reads Claude credentials from various sources:
+ * 1. Environment variable (ANTHROPIC_API_KEY)
+ * 2. Claude config file (~/.claude.json or ~/.config/claude/credentials.json)
+ * 3. macOS Keychain (via security command)
+ */
+
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+
+interface ClaudeCredentials {
+	apiKey: string;
+	source: "env" | "config" | "keychain";
+}
+
+interface ClaudeConfigFile {
+	apiKey?: string;
+	api_key?: string;
+	oauthAccessToken?: string;
+	oauth_access_token?: string;
+	// Claude Code CLI format
+	claudeAiOauth?: {
+		accessToken?: string;
+		refreshToken?: string;
+		expiresAt?: number;
+	};
+}
+
+/**
+ * Get Claude credentials from environment variable.
+ */
+function getCredentialsFromEnv(): ClaudeCredentials | null {
+	const apiKey = process.env.ANTHROPIC_API_KEY;
+	if (apiKey) {
+		return { apiKey, source: "env" };
+	}
+	return null;
+}
+
+/**
+ * Get Claude credentials from config file.
+ */
+function getCredentialsFromConfig(): ClaudeCredentials | null {
+	const home = homedir();
+	// Check Claude Code CLI credentials first (most common case)
+	const configPaths = [
+		join(home, ".claude", ".credentials.json"), // Claude Code CLI
+		join(home, ".claude.json"),
+		join(home, ".config", "claude", "credentials.json"),
+		join(home, ".config", "claude", "config.json"),
+	];
+
+	for (const configPath of configPaths) {
+		if (existsSync(configPath)) {
+			try {
+				const content = readFileSync(configPath, "utf-8");
+				const config: ClaudeConfigFile = JSON.parse(content);
+
+				// Check for Claude Code CLI OAuth format first
+				if (config.claudeAiOauth?.accessToken) {
+					console.log(
+						`[claude/auth] Found OAuth credentials in: ${configPath}`,
+					);
+					return { apiKey: config.claudeAiOauth.accessToken, source: "config" };
+				}
+
+				// Fall back to other formats
+				const apiKey =
+					config.apiKey ||
+					config.api_key ||
+					config.oauthAccessToken ||
+					config.oauth_access_token;
+
+				if (apiKey) {
+					console.log(`[claude/auth] Found credentials in: ${configPath}`);
+					return { apiKey, source: "config" };
+				}
+			} catch (error) {
+				console.warn(
+					`[claude/auth] Failed to parse config at ${configPath}:`,
+					error,
+				);
+			}
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Get Claude credentials from macOS Keychain.
+ */
+function getCredentialsFromKeychain(): ClaudeCredentials | null {
+	if (platform() !== "darwin") {
+		return null;
+	}
+
+	try {
+		// Claude CLI stores credentials in the keychain with this service/account
+		const result = execSync(
+			'security find-generic-password -s "claude-cli" -a "api-key" -w 2>/dev/null',
+			{ encoding: "utf-8" },
+		).trim();
+
+		if (result) {
+			console.log("[claude/auth] Found credentials in macOS Keychain");
+			return { apiKey: result, source: "keychain" };
+		}
+	} catch {
+		// Not found in keychain, this is fine
+	}
+
+	// Try alternate keychain entry format
+	try {
+		const result = execSync(
+			'security find-generic-password -s "anthropic-api-key" -w 2>/dev/null',
+			{ encoding: "utf-8" },
+		).trim();
+
+		if (result) {
+			console.log(
+				"[claude/auth] Found credentials in macOS Keychain (anthropic-api-key)",
+			);
+			return { apiKey: result, source: "keychain" };
+		}
+	} catch {
+		// Not found in keychain, this is fine
+	}
+
+	return null;
+}
+
+/**
+ * Get existing Claude credentials from any available source.
+ *
+ * Priority:
+ * 1. Environment variable (ANTHROPIC_API_KEY)
+ * 2. Config file (~/.claude.json, ~/.config/claude/credentials.json)
+ * 3. macOS Keychain
+ */
+export function getExistingClaudeCredentials(): ClaudeCredentials | null {
+	// 1. Check environment variable
+	const envCredentials = getCredentialsFromEnv();
+	if (envCredentials) {
+		console.log("[claude/auth] Using credentials from environment variable");
+		return envCredentials;
+	}
+
+	// 2. Check config file
+	const configCredentials = getCredentialsFromConfig();
+	if (configCredentials) {
+		return configCredentials;
+	}
+
+	// 3. Check macOS Keychain
+	const keychainCredentials = getCredentialsFromKeychain();
+	if (keychainCredentials) {
+		return keychainCredentials;
+	}
+
+	console.warn("[claude/auth] No Claude credentials found");
+	return null;
+}
+
+/**
+ * Build environment variables for running Claude CLI.
+ *
+ * IMPORTANT: We do NOT set ANTHROPIC_API_KEY when using OAuth credentials.
+ * The Claude binary handles its own OAuth authentication from ~/.claude/.credentials.json.
+ * Setting ANTHROPIC_API_KEY to an OAuth token causes authentication failure.
+ *
+ * We only set ANTHROPIC_API_KEY if:
+ * 1. It's already in the environment (user explicitly set it)
+ * 2. We found a raw API key (not OAuth) in config
+ */
+export function buildClaudeEnv(): Record<string, string> {
+	const env: Record<string, string> = {
+		...process.env,
+	} as Record<string, string>;
+
+	// Check if user has OAuth credentials - if so, let the binary handle auth
+	const hasOAuth = hasClaudeOAuthCredentials();
+	if (hasOAuth) {
+		console.log(
+			"[claude/auth] OAuth credentials found - letting binary handle authentication",
+		);
+		// Don't set ANTHROPIC_API_KEY, let the binary use its own OAuth flow
+	} else {
+		// Only set ANTHROPIC_API_KEY if we have a raw API key (not OAuth)
+		const credentials = getExistingClaudeCredentials();
+		if (credentials && credentials.source !== "config") {
+			// Only use env or keychain credentials (not OAuth from config)
+			env.ANTHROPIC_API_KEY = credentials.apiKey;
+			console.log(`[claude/auth] Using API key from ${credentials.source}`);
+		}
+	}
+
+	// Ensure PATH includes common binary locations
+	const pathAdditions = ["/usr/local/bin", "/opt/homebrew/bin", "/usr/bin"];
+	const currentPath = env.PATH || "";
+	const pathParts = currentPath.split(":");
+
+	for (const addition of pathAdditions) {
+		if (!pathParts.includes(addition)) {
+			pathParts.push(addition);
+		}
+	}
+
+	env.PATH = pathParts.join(":");
+
+	// Mark as SDK entry (like 1code does)
+	env.CLAUDE_CODE_ENTRYPOINT = "sdk-ts";
+
+	return env;
+}
+
+/**
+ * Check if Claude OAuth credentials are available.
+ */
+function hasClaudeOAuthCredentials(): boolean {
+	const home = homedir();
+	const credentialsPath = join(home, ".claude", ".credentials.json");
+
+	if (existsSync(credentialsPath)) {
+		try {
+			const content = readFileSync(credentialsPath, "utf-8");
+			const config: ClaudeConfigFile = JSON.parse(content);
+			return !!config.claudeAiOauth?.accessToken;
+		} catch {
+			return false;
+		}
+	}
+	return false;
+}
+
+/**
+ * Check if Claude credentials are available.
+ */
+export function hasClaudeCredentials(): boolean {
+	return getExistingClaudeCredentials() !== null;
+}
diff --git a/apps/desktop/src/lib/trpc/routers/ai-chat/utils/auth/index.ts b/apps/desktop/src/lib/trpc/routers/ai-chat/utils/auth/index.ts
new file mode 100644
index 00000000000..d24d7a75562
--- /dev/null
+++ b/apps/desktop/src/lib/trpc/routers/ai-chat/utils/auth/index.ts
@@ -0,0 +1 @@
+export { buildClaudeEnv } from "./auth";
diff --git a/apps/desktop/src/lib/trpc/routers/ai-chat/utils/session-manager/index.ts b/apps/desktop/src/lib/trpc/routers/ai-chat/utils/session-manager/index.ts
new file mode 100644
index 00000000000..36e6f2e4017
--- /dev/null
+++ b/apps/desktop/src/lib/trpc/routers/ai-chat/utils/session-manager/index.ts
@@ -0,0 +1,7 @@
+export type {
+	ClaudeStreamEvent,
+	ErrorEvent,
+	SessionEndEvent,
+	SessionStartEvent,
+} from "./session-manager";
+export { claudeSessionManager } from "./session-manager";
diff --git a/apps/desktop/src/lib/trpc/routers/ai-chat/utils/session-manager/session-manager.ts b/apps/desktop/src/lib/trpc/routers/ai-chat/utils/session-manager/session-manager.ts
new file mode 100644
index 00000000000..9289cf991c7
--- /dev/null
+++ b/apps/desktop/src/lib/trpc/routers/ai-chat/utils/session-manager/session-manager.ts
@@ -0,0 +1,500 @@
+/**
+ * Claude Code Session Manager
+ *
+ * Manages Claude SDK sessions using V1 query() API with streaming.
+ * Persists ALL raw SDKMessage objects to the durable stream.
+ *
+ * Architecture:
+ * - All clients POST user messages to the durable stream
+ * - This manager watches the stream for new user messages
+ * - When a user message appears, it calls query() with resume for multi-turn
+ * - includePartialMessages: true enables stream_event messages for live streaming
+ * - ALL SDK messages are persisted as raw JSON chunks
+ * - Client-side materialize() reconstructs UI state from chunks
+ */
+
+import { EventEmitter } from "node:events";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { DurableStream, IdempotentProducer } from "@durable-streams/client";
+import { app } from "electron";
+import { buildClaudeEnv } from "../auth";
+
+const DURABLE_STREAM_URL =
+	process.env.DURABLE_STREAM_URL || "http://localhost:8080";
+
+// ============================================================================
+// Events (simplified — only for local IPC subscribers)
+// ============================================================================
+
+export interface SessionStartEvent {
+	type: "session_start";
+	sessionId: string;
+}
+
+export interface SessionEndEvent {
+	type: "session_end";
+	sessionId: string;
+	exitCode: number | null;
+}
+
+export interface ErrorEvent {
+	type: "error";
+	sessionId: string;
+	error: string;
+}
+
+export type ClaudeStreamEvent =
+	| SessionStartEvent
+	| SessionEndEvent
+	| ErrorEvent;
+
+// ============================================================================
+// Active Session State
+// ============================================================================
+
+interface ActiveSession {
+	sessionId: string;
+	cwd: string;
+	claudeSessionId?: string;
+	abortController?: AbortController;
+	activeQuery?: { interrupt(): Promise<void>; close(): void };
+	streamWatcher?: StreamWatcher;
+	processingMessageIds: Set<string>;
+}
+
+// ============================================================================
+// Durable Stream Producers (per-session)
+// ============================================================================
+
+const sessionProducers = new Map<string, IdempotentProducer>();
+
+async function createProducer(sessionId: string): Promise<IdempotentProducer> {
+	const streamOpts = {
+		url: `${DURABLE_STREAM_URL}/streams/${sessionId}`,
+		contentType: "application/json",
+	};
+
+	let stream: DurableStream;
+	try {
+		stream = await DurableStream.create(streamOpts);
+	} catch {
+		// Stream may already exist — connect to it
+		stream = await DurableStream.connect(streamOpts);
+	}
+
+	const producer = new IdempotentProducer(stream, "session-manager", {
+		autoClaim: true,
+		onError: (err: Error) =>
+			console.error(`[durable-stream] Batch failed for ${sessionId}:`, err),
+	});
+
+	sessionProducers.set(sessionId, producer);
+	return producer;
+}
+
+async function closeProducer(sessionId: string): Promise<void> {
+	const producer = sessionProducers.get(sessionId);
+	if (!producer) return;
+	await producer.flush();
+	await producer.close();
+	sessionProducers.delete(sessionId);
+}
+
+// ============================================================================
+// Stream Watcher
+// ============================================================================
+
+class StreamWatcher {
+	private intervalId: ReturnType<typeof setInterval> | null = null;
+	private seenMessageIds: Set<string> = new Set();
+	private isPolling = false;
+	private isStopped = false;
+	private onNewUserMessage: (messageId: string, content: string) => void;
+	private sessionId = "";
+
+	constructor(onNewUserMessage: (messageId: string, content: string) => void) {
+		this.onNewUserMessage = onNewUserMessage;
+	}
+
+	/**
+	 * Fetch the current stream and seed seenMessageIds with all existing
+	 * user_input keys, then start polling for new messages.
+	 * This prevents reprocessing historical messages after a restart.
+	 */
+	async start(sessionId: string): Promise<void> {
+		this.sessionId = sessionId;
+		this.seenMessageIds.clear();
+		this.isStopped = false;
+
+		// Seed with existing messages before polling
+		await this.seedExistingMessages();
+
+		this.intervalId = setInterval(() => this.poll(), 500);
+		console.log(
+			`[stream-watcher] Started polling for ${sessionId} (${this.seenMessageIds.size} existing messages seeded)`,
+		);
+	}
+
+	/**
+	 * Fetch all existing events from the stream and record their keys
+	 * so they are not treated as new messages.
+	 */
+	private async seedExistingMessages(): Promise<void> {
+		try {
+			const response = await fetch(
+				`${DURABLE_STREAM_URL}/streams/${this.sessionId}`,
+				{ headers: { Accept: "application/json" } },
+			);
+
+			if (!response.ok) return;
+
+			const events = (await response.json()) as Array<Record<string, unknown>>;
+
+			for (const event of events) {
+				if (event.type !== "chunk") continue;
+
+				const value = event.value as Record<string, unknown> | undefined;
+				if (!value || value.type !== "user_input") continue;
+
+				const key = event.key as string;
+				if (key) {
+					this.seenMessageIds.add(key);
+				}
+			}
+		} catch (error) {
+			console.warn(
+				`[stream-watcher] Failed to seed existing messages for ${this.sessionId}:`,
+				error,
+			);
+		}
+	}
+
+	private async poll(): Promise<void> {
+		if (this.isStopped) return;
+		if (this.isPolling) return;
+		this.isPolling = true;
+
+		try {
+			const response = await fetch(
+				`${DURABLE_STREAM_URL}/streams/${this.sessionId}`,
+				{ headers: { Accept: "application/json" } },
+			);
+
+			if (!response.ok) return;
+
+			const events = (await response.json()) as Array<Record<string, unknown>>;
+
+			for (const event of events) {
+				if (event.type !== "chunk") continue;
+
+				const value = event.value as Record<string, unknown> | undefined;
+				if (!value) continue;
+
+				// Detect user input messages (new format: { type: "user_input", content, ... })
+				if (value.type !== "user_input") continue;
+
+				const key = event.key as string;
+				if (!key || this.seenMessageIds.has(key)) continue;
+
+				this.seenMessageIds.add(key);
+
+				const content = value.content as string | undefined;
+				if (content && !this.isStopped) {
+					console.log(`[stream-watcher] New user message: ${key}`);
+					this.onNewUserMessage(key, content);
+				}
+			}
+		} catch {
+			// Ignore poll errors
+		} finally {
+			this.isPolling = false;
+		}
+	}
+
+	stop(): void {
+		this.isStopped = true;
+		if (this.intervalId) {
+			clearInterval(this.intervalId);
+			this.intervalId = null;
+		}
+		this.seenMessageIds.clear();
+	}
+}
+
+// ============================================================================
+// Session Manager
+// ============================================================================
+
+// Cache V1 SDK query function
+let cachedQuery:
+	| typeof import("@anthropic-ai/claude-agent-sdk").query
+	| null = null;
+
+const getSDK = async () => {
+	if (cachedQuery) return { query: cachedQuery };
+	const sdk = await import("@anthropic-ai/claude-agent-sdk");
+	cachedQuery = sdk.query;
+	return { query: cachedQuery };
+};
+
+class ClaudeSessionManager extends EventEmitter {
+	private sessions: Map<string, ActiveSession> = new Map();
+
+	async startSession({
+		sessionId,
+		cwd,
+		claudeSessionId,
+		enableDurableStream = true,
+	}: {
+		sessionId: string;
+		cwd: string;
+		claudeSessionId?: string;
+		enableDurableStream?: boolean;
+	}): Promise<void> {
+		if (this.sessions.has(sessionId)) {
+			console.warn(`[claude/session] Session ${sessionId} already running`);
+			return;
+		}
+
+		console.log(`[claude/session] Initializing session ${sessionId} in ${cwd}`);
+
+		if (enableDurableStream) {
+			try {
+				await createProducer(sessionId);
+				console.log(`[claude/session] Durable stream created for ${sessionId}`);
+			} catch (error) {
+				console.error(`[claude/session] Failed to create stream:`, error);
+			}
+		}
+
+		const session: ActiveSession = {
+			sessionId,
+			cwd,
+			claudeSessionId,
+			processingMessageIds: new Set(),
+		};
+
+		this.sessions.set(sessionId, session);
+
+		if (sessionProducers.has(sessionId)) {
+			const watcher = new StreamWatcher((messageId, content) => {
+				if (session.processingMessageIds.has(messageId)) {
+					return;
+				}
+				session.processingMessageIds.add(messageId);
+
+				this.processUserMessage({ sessionId, content }).finally(() => {
+					session.processingMessageIds.delete(messageId);
+				});
+			});
+
+			session.streamWatcher = watcher;
+			await watcher.start(sessionId);
+		}
+
+		this.emit("event", {
+			type: "session_start",
+			sessionId,
+		} satisfies SessionStartEvent);
+	}
+
+	/**
+	 * Process a user message through Claude using V1 query() API.
+	 * Uses includePartialMessages for real-time streaming events.
+	 * Persists ALL raw SDKMessage objects to the durable stream.
+	 */
+	private async processUserMessage({
+		sessionId,
+		content,
+	}: {
+		sessionId: string;
+		content: string;
+	}): Promise<void> {
+		console.log(
+			`[claude/session] processUserMessage for ${sessionId}: "${content.slice(0, 50)}..."`,
+		);
+
+		const session = this.sessions.get(sessionId);
+		if (!session) {
+			console.error(`[claude/session] Session ${sessionId} not found`);
+			this.emit("event", {
+				type: "error",
+				sessionId,
+				error: "Session not found",
+			} satisfies ErrorEvent);
+			return;
+		}
+
+		// Abort any previous in-flight query
+		if (session.activeQuery) {
+			session.activeQuery.close();
+			session.activeQuery = undefined;
+		}
+
+		const abortController = new AbortController();
+		session.abortController = abortController;
+
+		const binaryName = process.platform === "win32" ? "claude.exe" : "claude";
+		const binaryPath = app.isPackaged
+			? join(process.resourcesPath, "bin", binaryName)
+			: join(
+					app.getAppPath(),
+					"resources",
+					"bin",
+					`${process.platform}-${process.arch}`,
+					binaryName,
+				);
+		if (!existsSync(binaryPath)) {
+			this.emit("event", {
+				type: "error",
+				sessionId,
+				error: "Claude binary not found",
+			} satisfies ErrorEvent);
+			return;
+		}
+
+		const env = buildClaudeEnv();
+
+		try {
+			const { query } = await getSDK();
+
+			const options = {
+				includePartialMessages: true,
+				cwd: session.cwd,
+				resume: session.claudeSessionId,
+				model: process.env.CLAUDE_MODEL || "claude-sonnet-4-5-20250929",
+				pathToClaudeCodeExecutable: binaryPath,
+				env,
+				permissionMode: "bypassPermissions" as const,
+				abortController,
+			};
+
+			console.log(
+				`[claude/session] Starting V1 query in ${session.cwd} (resume=${session.claudeSessionId || "none"})`,
+			);
+
+			const q = query({ prompt: content, options });
+			session.activeQuery = q;
+
+			// Stream and persist ALL SDK messages as raw passthrough.
+			// includePartialMessages: true gives us stream_event messages for live streaming.
+			// Turn detection happens client-side in materialize().
+			let totalChunks = 0;
+			let seq = 0;
+
+			for await (const msg of q) {
+				if (abortController.signal.aborted) {
+					console.log(`[claude/session] Stream aborted`);
+					break;
+				}
+
+				const msgAny = msg as Record<string, unknown>;
+				const msgType = msgAny.type as string;
+				console.log(
+					`[claude/session] SDK message #${seq}: type=${msgType}${msgType === "stream_event" ? ` event=${(msgAny.event as Record<string, unknown>)?.type}` : ""}`,
+				);
+
+				// Extract session ID from init message
+				if (msgType === "system" && msgAny.subtype === "init") {
+					const sdkSessionId = msgAny.session_id as string | undefined;
+					if (sdkSessionId) {
+						session.claudeSessionId = sdkSessionId;
+						console.log(
+							`[claude/session] Got Claude session ID: ${sdkSessionId}`,
+						);
+					}
+				}
+
+				// Persist raw SDK message with ordering metadata
+				const producer = sessionProducers.get(sessionId);
+				if (producer) {
+					const uuid = (msgAny.uuid as string) || crypto.randomUUID();
+					producer.append(
+						JSON.stringify({
+							type: "chunk",
+							key: uuid,
+							value: {
+								...(msg as Record<string, unknown>),
+								createdAt: new Date().toISOString(),
+								_seq: seq++,
+							},
+							headers: { operation: "upsert" },
+						}),
+					);
+					// Flush immediately so chunks are visible to clients as they arrive
+					await producer.flush();
+				}
+
+				totalChunks++;
+			}
+
+			q.close();
+			session.activeQuery = undefined;
+
+			// Flush pending events
+			const flushProducer = sessionProducers.get(sessionId);
+			if (flushProducer) {
+				await flushProducer.flush();
+			}
+
+			console.log(
+				`[claude/session] Message processing complete, ${totalChunks} chunks persisted`,
+			);
+		} catch (error) {
+			session.activeQuery = undefined;
+			const errorMessage =
+				error instanceof Error ? error.message : String(error);
+			console.error(`[claude/session] SDK error: ${errorMessage}`);
+			if (error instanceof Error && error.stack) {
+				console.error(`[claude/session] Stack:`, error.stack);
+			}
+			this.emit("event", {
+				type: "error",
+				sessionId,
+				error: errorMessage,
+			} satisfies ErrorEvent);
+		}
+	}
+
+	async interrupt({ sessionId }: { sessionId: string }): Promise<void> {
+		const session = this.sessions.get(sessionId);
+		if (!session) {
+			console.warn(
+				`[claude/session] Session ${sessionId} not found for interrupt`,
+			);
+			return;
+		}
+
+		console.log(`[claude/session] Interrupting session ${sessionId}`);
+		if (session.activeQuery) {
+			await session.activeQuery.interrupt();
+		}
+		session.abortController?.abort();
+	}
+
+	async stopSession({ sessionId }: { sessionId: string }): Promise<void> {
+		const session = this.sessions.get(sessionId);
+		if (!session) {
+			return;
+		}
+
+		console.log(`[claude/session] Stopping session ${sessionId}`);
+		session.activeQuery?.close();
+		session.activeQuery = undefined;
+		session.abortController?.abort();
+		session.streamWatcher?.stop();
+		this.sessions.delete(sessionId);
+		await closeProducer(sessionId);
+	}
+
+	isSessionActive(sessionId: string): boolean {
+		return this.sessions.has(sessionId);
+	}
+
+	getActiveSessions(): string[] {
+		return Array.from(this.sessions.keys());
+	}
+}
+
+export const claudeSessionManager = new ClaudeSessionManager();
diff --git a/apps/desktop/src/lib/trpc/routers/index.ts b/apps/desktop/src/lib/trpc/routers/index.ts
index ca340bddd4a..6020f7480cc 100644
--- a/apps/desktop/src/lib/trpc/routers/index.ts
+++ b/apps/desktop/src/lib/trpc/routers/index.ts
@@ -1,5 +1,6 @@
 import type { BrowserWindow } from "electron";
 import { router } from "..";
+import { createAiChatRouter } from "./ai-chat";
 import { createAnalyticsRouter } from "./analytics";
 import { createAuthRouter } from "./auth";
 import { createAutoUpdateRouter } from "./auto-update";
@@ -22,6 +23,7 @@ import { createWorkspacesRouter } from "./workspaces";
 
 export const createAppRouter = (getWindow: () => BrowserWindow | null) => {
 	return router({
+		aiChat: createAiChatRouter(),
 		analytics: createAnalyticsRouter(),
 		auth: createAuthRouter(),
 		autoUpdate: createAutoUpdateRouter(),
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 e9f19043286..17b97abbdd6 100644
--- a/apps/desktop/src/lib/trpc/routers/ui-state/index.ts
+++ b/apps/desktop/src/lib/trpc/routers/ui-state/index.ts
@@ -33,7 +33,7 @@ const fileViewerStateSchema = z.object({
 const paneSchema = z.object({
 	id: z.string(),
 	tabId: z.string(),
-	type: z.enum(["terminal", "webview", "file-viewer"]),
+	type: z.enum(["terminal", "webview", "file-viewer", "chat"]),
 	name: z.string(),
 	isNew: z.boolean().optional(),
 	status: z.enum(["idle", "working", "permission", "review"]).optional(),
@@ -43,6 +43,7 @@ const paneSchema = z.object({
 	cwd: z.string().nullable().optional(),
 	cwdConfirmed: z.boolean().optional(),
 	fileViewer: fileViewerStateSchema.optional(),
+	chat: z.object({ sessionId: z.string() }).optional(),
 });
 
 /**
diff --git a/apps/desktop/src/renderer/env.renderer.ts b/apps/desktop/src/renderer/env.renderer.ts
index 0e41dea4a6e..0103fab71e0 100644
--- a/apps/desktop/src/renderer/env.renderer.ts
+++ b/apps/desktop/src/renderer/env.renderer.ts
@@ -17,6 +17,7 @@ const envSchema = z.object({
 		.default("development"),
 	NEXT_PUBLIC_API_URL: z.url().default("https://api.superset.sh"),
 	NEXT_PUBLIC_WEB_URL: z.url().default("https://app.superset.sh"),
+	NEXT_PUBLIC_STREAMS_URL: z.url().default("http://localhost:8080"),
 	NEXT_PUBLIC_POSTHOG_KEY: z.string().optional(),
 	NEXT_PUBLIC_POSTHOG_HOST: z.string().default("https://us.i.posthog.com"),
 	SENTRY_DSN_DESKTOP: z.string().optional(),
@@ -33,6 +34,7 @@ const rawEnv = {
 	NODE_ENV: process.env.NODE_ENV,
 	NEXT_PUBLIC_API_URL: process.env.NEXT_PUBLIC_API_URL,
 	NEXT_PUBLIC_WEB_URL: process.env.NEXT_PUBLIC_WEB_URL,
+	NEXT_PUBLIC_STREAMS_URL: process.env.NEXT_PUBLIC_STREAMS_URL,
 	NEXT_PUBLIC_POSTHOG_KEY: import.meta.env.NEXT_PUBLIC_POSTHOG_KEY as
 		| string
 		| undefined,
diff --git a/apps/desktop/src/renderer/index.html b/apps/desktop/src/renderer/index.html
index 5340b8f15b5..84ef48def0a 100644
--- a/apps/desktop/src/renderer/index.html
+++ b/apps/desktop/src/renderer/index.html
@@ -11,11 +11,11 @@
       - default-src 'self': Only allow resources from same origin
       - script-src 'self' 'wasm-unsafe-eval' https://*.posthog.com: Allow scripts from same origin + WebAssembly (for xterm ImageAddon) + PostHog
       - style-src 'self' 'unsafe-inline': Allow styles from same origin + inline (needed for CSS-in-JS)
-      - connect-src 'self' ws: wss: %NEXT_PUBLIC_API_URL% https://*.posthog.com https://*.sentry.io sentry-ipc:: Allow WebSocket + API (includes Electric proxy) + PostHog + Sentry
+      - connect-src 'self' ws: wss: http://localhost:* %NEXT_PUBLIC_API_URL% https://*.posthog.com https://*.sentry.io sentry-ipc:: Allow WebSocket + API (includes Electric proxy) + PostHog + Sentry + localhost for stream server
       - img-src 'self' data: %NEXT_PUBLIC_API_URL% https://*.public.blob.vercel-storage.com https://github.com https://avatars.githubusercontent.com: Allow images from same origin + data URIs + API (Linear image proxy) + Vercel blob storage + GitHub avatars
       - font-src 'self': Allow fonts from same origin
     -->
-    <meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'self' 'wasm-unsafe-eval' https://*.posthog.com; style-src 'self' 'unsafe-inline'; connect-src 'self' ws: wss: %NEXT_PUBLIC_API_URL% https://*.posthog.com https://*.sentry.io sentry-ipc:; img-src 'self' data: %NEXT_PUBLIC_API_URL% https://*.public.blob.vercel-storage.com https://github.com https://avatars.githubusercontent.com; font-src 'self';" />
+    <meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'self' 'wasm-unsafe-eval' https://*.posthog.com; style-src 'self' 'unsafe-inline'; connect-src 'self' ws: wss: http://localhost:* %NEXT_PUBLIC_API_URL% https://*.posthog.com https://*.sentry.io sentry-ipc:; img-src 'self' data: %NEXT_PUBLIC_API_URL% https://*.public.blob.vercel-storage.com https://github.com https://avatars.githubusercontent.com; font-src 'self';" />
   </head>
 
   <body>
diff --git a/apps/desktop/src/renderer/lib/workspace-utils.ts b/apps/desktop/src/renderer/lib/workspace-utils.ts
new file mode 100644
index 00000000000..d23982acfe5
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/workspace-utils.ts
@@ -0,0 +1,19 @@
+/**
+ * Get the most recently opened workspace path from grouped workspaces.
+ */
+export function getMostRecentWorkspacePath(
+	groups: Array<{
+		workspaces: Array<{
+			worktreePath: string;
+			lastOpenedAt: number;
+		}>;
+	}>,
+): string | null {
+	const allWorkspaces = groups.flatMap((g) => g.workspaces);
+	if (allWorkspaces.length === 0) return null;
+
+	const sorted = [...allWorkspaces].sort(
+		(a, b) => b.lastOpenedAt - a.lastOpenedAt,
+	);
+	return sorted[0].worktreePath || null;
+}
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/$chatId/page.tsx b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/$chatId/page.tsx
new file mode 100644
index 00000000000..158b7a27544
--- /dev/null
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/$chatId/page.tsx
@@ -0,0 +1,96 @@
+import { createStream } from "@superset/ai-chat/stream";
+import { Button } from "@superset/ui/button";
+import { ScrollArea } from "@superset/ui/scroll-area";
+import { cn } from "@superset/ui/utils";
+import { createFileRoute, useNavigate } from "@tanstack/react-router";
+import { useCallback, useEffect } from "react";
+import { env } from "renderer/env.renderer";
+import { ChatView } from "../components/ChatView";
+import { useChatStore } from "../stores/chatStore";
+
+export const Route = createFileRoute(
+	"/_authenticated/_dashboard/chats/$chatId/",
+)({
+	component: ChatDetailPage,
+});
+
+function ChatDetailPage() {
+	const { chatId } = Route.useParams();
+	const navigate = useNavigate();
+	const { sessions, createSession } = useChatStore();
+
+	// Ensure stream exists when page loads
+	useEffect(() => {
+		createStream(env.NEXT_PUBLIC_STREAMS_URL, chatId).catch((err) => {
+			console.error("[chats] Failed to ensure stream exists on load:", err);
+		});
+	}, [chatId]);
+
+	const handleCreateChat = useCallback(async () => {
+		const session = createSession();
+		try {
+			await createStream(env.NEXT_PUBLIC_STREAMS_URL, session.id);
+		} catch (err) {
+			console.error("[chats] Failed to create stream:", err);
+		}
+		navigate({ to: "/chats/$chatId", params: { chatId: session.id } });
+	}, [navigate, createSession]);
+
+	const handleSelectChat = useCallback(
+		async (id: string) => {
+			try {
+				await createStream(env.NEXT_PUBLIC_STREAMS_URL, id);
+			} catch (err) {
+				console.error("[chats] Failed to ensure stream exists:", err);
+			}
+			navigate({ to: "/chats/$chatId", params: { chatId: id } });
+		},
+		[navigate],
+	);
+
+	return (
+		<div className="flex h-full">
+			{/* Sidebar */}
+			<div className="w-64 border-r border-border flex flex-col bg-muted/30">
+				<div className="p-3 border-b border-border">
+					<Button onClick={handleCreateChat} className="w-full" size="sm">
+						+ New Chat
+					</Button>
+				</div>
+
+				<ScrollArea className="flex-1">
+					<div className="p-2 space-y-1">
+						{sessions.length === 0 ? (
+							<div className="text-center text-muted-foreground text-sm py-8 px-4">
+								No chats yet.
+							</div>
+						) : (
+							sessions.map((session) => (
+								<button
+									key={session.id}
+									type="button"
+									onClick={() => handleSelectChat(session.id)}
+									className={cn(
+										"w-full text-left px-3 py-2 rounded-md text-sm transition-colors",
+										"hover:bg-accent hover:text-accent-foreground",
+										chatId === session.id && "bg-accent text-accent-foreground",
+									)}
+								>
+									<span className="truncate block">{session.name}</span>
+									<span className="text-xs text-muted-foreground">
+										{new Date(session.createdAt).toLocaleDateString()}
+									</span>
+								</button>
+							))
+						)}
+					</div>
+				</ScrollArea>
+			</div>
+
+			{/* Chat View */}
+			<div className="flex-1 min-w-0">
+				<ChatView sessionId={chatId} className="h-full" />
+			</div>
+		</div>
+	);
+}
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ChatMessage/ChatMessage.tsx b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ChatMessage/ChatMessage.tsx
new file mode 100644
index 00000000000..b779959c25a
--- /dev/null
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ChatMessage/ChatMessage.tsx
@@ -0,0 +1,157 @@
+/**
+ * Individual chat message component
+ */
+
+import type { BetaContentBlock, ToolResult } from "@superset/ai-chat/stream";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@superset/ui/collapsible";
+import { cn } from "@superset/ui/utils";
+import { useState } from "react";
+import { LuChevronRight } from "react-icons/lu";
+import ReactMarkdown from "react-markdown";
+import rehypeRaw from "rehype-raw";
+import rehypeSanitize from "rehype-sanitize";
+import remarkGfm from "remark-gfm";
+import { ToolCallPart } from "../ToolCallPart";
+
+export interface ChatMessageProps {
+	role?: "user" | "assistant";
+	content: string;
+	contentBlocks?: BetaContentBlock[];
+	toolResults?: Map<string, ToolResult>;
+	timestamp?: Date;
+	isStreaming?: boolean;
+}
+
+function ThinkingBlock({ thinking }: { thinking: string }) {
+	const [isOpen, setIsOpen] = useState(false);
+
+	return (
+		<Collapsible open={isOpen} onOpenChange={setIsOpen}>
+			<CollapsibleTrigger className="flex items-center gap-1 text-xs text-muted-foreground hover:text-foreground transition-colors">
+				<LuChevronRight
+					className={cn("h-3 w-3 transition-transform", isOpen && "rotate-90")}
+				/>
+				Thinking
+			</CollapsibleTrigger>
+			<CollapsibleContent>
+				<div className="mt-1 rounded border border-border bg-muted/30 p-2 text-xs text-muted-foreground italic whitespace-pre-wrap">
+					{thinking}
+				</div>
+			</CollapsibleContent>
+		</Collapsible>
+	);
+}
+
+function AssistantContent({
+	content,
+	contentBlocks,
+	toolResults,
+}: {
+	content: string;
+	contentBlocks?: BetaContentBlock[];
+	toolResults?: Map<string, ToolResult>;
+}) {
+	if (!contentBlocks || contentBlocks.length === 0) {
+		return (
+			<div className="prose prose-sm dark:prose-invert max-w-none">
+				<ReactMarkdown
+					remarkPlugins={[remarkGfm]}
+					rehypePlugins={[rehypeRaw, rehypeSanitize]}
+				>
+					{content}
+				</ReactMarkdown>
+			</div>
+		);
+	}
+
+	return (
+		<div className="space-y-3">
+			{contentBlocks.map((block, index) => {
+				const key = `${block.type}-${index}`;
+				switch (block.type) {
+					case "text":
+						return (
+							<div
+								key={key}
+								className="prose prose-sm dark:prose-invert max-w-none"
+							>
+								<ReactMarkdown
+									remarkPlugins={[remarkGfm]}
+									rehypePlugins={[rehypeRaw, rehypeSanitize]}
+								>
+									{block.text}
+								</ReactMarkdown>
+							</div>
+						);
+					case "tool_use":
+						return (
+							<ToolCallPart
+								key={block.id}
+								block={block}
+								result={toolResults?.get(block.id)}
+							/>
+						);
+					case "thinking":
+						return <ThinkingBlock key={key} thinking={block.thinking} />;
+					default:
+						return (
+							<div
+								key={key}
+								className="rounded border border-border bg-muted/30 p-2 text-xs text-muted-foreground"
+							>
+								<span className="font-mono">{block.type}</span> block
+							</div>
+						);
+				}
+			})}
+		</div>
+	);
+}
+
+export function ChatMessage({
+	role = "assistant",
+	content,
+	contentBlocks,
+	toolResults,
+	timestamp,
+	isStreaming,
+}: ChatMessageProps) {
+	const isUser = role === "user";
+
+	return (
+		<div
+			className={cn("flex w-full", isUser ? "justify-end" : "justify-start")}
+		>
+			<div
+				className={cn(
+					"max-w-[80%] rounded-lg px-4 py-3",
+					isUser
+						? "bg-primary text-primary-foreground"
+						: "bg-muted text-foreground",
+				)}
+			>
+				{isUser ? (
+					<p className="whitespace-pre-wrap">{content}</p>
+				) : (
+					<AssistantContent
+						content={content}
+						contentBlocks={contentBlocks}
+						toolResults={toolResults}
+					/>
+				)}
+				{timestamp && (
+					<span className="mt-1 block text-xs opacity-60">
+						{timestamp.toLocaleTimeString()}
+					</span>
+				)}
+				{isStreaming && (
+					<span className="mt-1 inline-block h-4 w-1 animate-pulse bg-current" />
+				)}
+			</div>
+		</div>
+	);
+}
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ChatMessage/index.ts b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ChatMessage/index.ts
new file mode 100644
index 00000000000..33fe9a96dee
--- /dev/null
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ChatMessage/index.ts
@@ -0,0 +1,2 @@
+export type { ChatMessageProps } from "./ChatMessage";
+export { ChatMessage } from "./ChatMessage";
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ChatMessageList/ChatMessageList.tsx b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ChatMessageList/ChatMessageList.tsx
new file mode 100644
index 00000000000..c53c8cc6d14
--- /dev/null
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ChatMessageList/ChatMessageList.tsx
@@ -0,0 +1,79 @@
+/**
+ * Chat message list with auto-scroll
+ */
+
+import type { BetaContentBlock, ToolResult } from "@superset/ai-chat/stream";
+import { ScrollArea } from "@superset/ui/scroll-area";
+import { cn } from "@superset/ui/utils";
+import { useEffect, useRef } from "react";
+import { ChatMessage } from "../ChatMessage";
+
+export interface Message {
+	id: string;
+	role: "user" | "assistant";
+	content: string;
+	contentBlocks?: BetaContentBlock[];
+	toolResults?: Map<string, ToolResult>;
+	createdAt: Date;
+}
+
+export interface StreamingMessage {
+	type: "streaming";
+	content: string;
+	contentBlocks?: BetaContentBlock[];
+	toolResults?: Map<string, ToolResult>;
+}
+
+export interface ChatMessageListProps {
+	messages: Array<Message | StreamingMessage>;
+	className?: string;
+	autoScroll?: boolean;
+}
+
+export function ChatMessageList({
+	messages,
+	className,
+	autoScroll = true,
+}: ChatMessageListProps) {
+	const scrollRef = useRef<HTMLDivElement>(null);
+	const bottomRef = useRef<HTMLDivElement>(null);
+
+	useEffect(() => {
+		if (autoScroll && bottomRef.current) {
+			bottomRef.current.scrollIntoView({ behavior: "smooth" });
+		}
+	}, [autoScroll, messages]);
+
+	return (
+		<ScrollArea className={cn("flex-1", className)}>
+			<div ref={scrollRef} className="flex flex-col gap-4 p-4">
+				{messages.map((msg, index) => {
+					if ("type" in msg && msg.type === "streaming") {
+						return (
+							<ChatMessage
+								key="streaming"
+								content={msg.content}
+								contentBlocks={msg.contentBlocks}
+								toolResults={msg.toolResults}
+								isStreaming
+							/>
+						);
+					}
+
+					const message = msg as Message;
+					return (
+						<ChatMessage
+							key={message.id || index}
+							role={message.role}
+							content={message.content}
+							contentBlocks={message.contentBlocks}
+							toolResults={message.toolResults}
+							timestamp={message.createdAt}
+						/>
+					);
+				})}
+				<div ref={bottomRef} />
+			</div>
+		</ScrollArea>
+	);
+}
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ChatMessageList/index.ts b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ChatMessageList/index.ts
new file mode 100644
index 00000000000..10ab1635ba5
--- /dev/null
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ChatMessageList/index.ts
@@ -0,0 +1,6 @@
+export type {
+	ChatMessageListProps,
+	Message,
+	StreamingMessage,
+} from "./ChatMessageList";
+export { ChatMessageList } from "./ChatMessageList";
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ChatView/ChatView.tsx b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ChatView/ChatView.tsx
new file mode 100644
index 00000000000..ecfbf4ab4d6
--- /dev/null
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ChatView/ChatView.tsx
@@ -0,0 +1,147 @@
+/**
+ * Chat View - desktop app chat interface
+ *
+ * Messages are materialized from the durable stream via useChatSession.
+ * This provides persistence and multi-client sync.
+ */
+
+import { ChatInput, PresenceBar } from "@superset/ai-chat/components";
+import { useChatSession } from "@superset/ai-chat/stream";
+import { cn } from "@superset/ui/utils";
+import { useCallback, useMemo, useState } from "react";
+import { env } from "renderer/env.renderer";
+import { authClient } from "renderer/lib/auth-client";
+import { electronTrpc } from "renderer/lib/electron-trpc";
+import { getMostRecentWorkspacePath } from "renderer/lib/workspace-utils";
+import {
+	ChatMessageList,
+	type Message,
+	type StreamingMessage,
+} from "../ChatMessageList";
+
+export interface ChatViewProps {
+	sessionId: string;
+	className?: string;
+}
+
+export function ChatView({ sessionId, className }: ChatViewProps) {
+	const { data: session } = authClient.useSession();
+	const user = session?.user
+		? { userId: session.user.id, name: session.user.name ?? "Unknown" }
+		: null;
+
+	const { users, messages, streamingMessage, draft, setDraft, sendMessage } =
+		useChatSession({
+			proxyUrl: env.NEXT_PUBLIC_STREAMS_URL,
+			sessionId,
+			user,
+			autoConnect: !!user,
+		});
+
+	const startSessionMutation = electronTrpc.aiChat.startSession.useMutation();
+	const { data: isActive, refetch: refetchIsActive } =
+		electronTrpc.aiChat.isSessionActive.useQuery({ sessionId });
+
+	// Query workspaces to get the most recently opened workspace path for cwd
+	const { data: workspaceGroups } =
+		electronTrpc.workspaces.getAllGrouped.useQuery();
+	const mostRecentWorkspacePath = useMemo(
+		() =>
+			workspaceGroups ? getMostRecentWorkspacePath(workspaceGroups) : null,
+		[workspaceGroups],
+	);
+
+	const handleStartSession = useCallback(async () => {
+		if (!mostRecentWorkspacePath) {
+			console.error("[ChatView] No workspace available to start session");
+			return;
+		}
+		await startSessionMutation.mutateAsync({
+			sessionId,
+			cwd: mostRecentWorkspacePath,
+		});
+		await refetchIsActive();
+	}, [
+		sessionId,
+		startSessionMutation,
+		refetchIsActive,
+		mostRecentWorkspacePath,
+	]);
+
+	const [isSending, setIsSending] = useState(false);
+	const handleSend = useCallback(
+		async (content: string) => {
+			setIsSending(true);
+			setDraft("");
+			try {
+				await sendMessage(content);
+			} finally {
+				setIsSending(false);
+			}
+		},
+		[sendMessage, setDraft],
+	);
+
+	const allMessages = useMemo((): Array<Message | StreamingMessage> => {
+		const result: Array<Message | StreamingMessage> = messages.map((m) => ({
+			id: m.id,
+			role: m.role as "user" | "assistant",
+			content: m.content,
+			contentBlocks: m.contentBlocks,
+			toolResults: m.toolResults,
+			createdAt: m.createdAt,
+		}));
+		if (streamingMessage) {
+			result.push({
+				type: "streaming",
+				content: streamingMessage.content,
+				contentBlocks: streamingMessage.contentBlocks,
+				toolResults: streamingMessage.toolResults,
+			});
+		}
+		return result;
+	}, [messages, streamingMessage]);
+
+	return (
+		<div className={cn("flex flex-col h-full", className)}>
+			<PresenceBar viewers={users} typingUsers={[]} />
+
+			<ChatMessageList
+				messages={allMessages}
+				className="flex-1 min-h-0 overflow-hidden"
+			/>
+
+			<div className="border-t border-border p-4">
+				{isActive ? (
+					<ChatInput
+						value={draft}
+						onChange={setDraft}
+						onSend={handleSend}
+						disabled={isSending}
+						placeholder="Type a message..."
+						buttonVariant="text"
+						autoResize={false}
+					/>
+				) : (
+					<div className="flex items-center justify-center gap-4">
+						<span className="text-muted-foreground">
+							{mostRecentWorkspacePath
+								? "Session not active"
+								: "No workspace available"}
+						</span>
+						<button
+							type="button"
+							onClick={handleStartSession}
+							disabled={
+								startSessionMutation.isPending || !mostRecentWorkspacePath
+							}
+							className="px-4 py-2 bg-primary text-primary-foreground rounded-md hover:bg-primary/90 disabled:opacity-50"
+						>
+							{startSessionMutation.isPending ? "Starting..." : "Start Session"}
+						</button>
+					</div>
+				)}
+			</div>
+		</div>
+	);
+}
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ChatView/index.ts b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ChatView/index.ts
new file mode 100644
index 00000000000..a6ee6b7ea81
--- /dev/null
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ChatView/index.ts
@@ -0,0 +1,2 @@
+export type { ChatViewProps } from "./ChatView";
+export { ChatView } from "./ChatView";
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ToolCallPart/ToolCallPart.tsx b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ToolCallPart/ToolCallPart.tsx
new file mode 100644
index 00000000000..b2ae47bf164
--- /dev/null
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ToolCallPart/ToolCallPart.tsx
@@ -0,0 +1,59 @@
+import type { BetaToolUseBlock, ToolResult } from "@superset/ai-chat/stream";
+import { Badge } from "@superset/ui/badge";
+import { cn } from "@superset/ui/utils";
+
+interface ToolCallPartProps {
+	block: BetaToolUseBlock;
+	result?: ToolResult;
+}
+
+function getToolState(result?: ToolResult) {
+	if (!result) return { label: "Running", variant: "secondary" as const };
+	if (result.isError)
+		return { label: "Error", variant: "destructive" as const };
+	return { label: "Completed", variant: "default" as const };
+}
+
+export function ToolCallPart({ block, result }: ToolCallPartProps) {
+	const state = getToolState(result);
+
+	return (
+		<div className="rounded-md border border-border bg-muted/50 p-3 space-y-2">
+			<div className="flex items-center gap-2">
+				<span className="font-mono text-xs font-medium">{block.name}</span>
+				<Badge variant={state.variant} className="ml-auto text-xs">
+					{state.label}
+				</Badge>
+			</div>
+			{block.input != null &&
+				typeof block.input === "object" &&
+				Object.keys(block.input).length > 0 && (
+					<div>
+						<p className="mb-1 text-xs font-medium text-muted-foreground">
+							Input
+						</p>
+						<pre className="overflow-x-auto rounded bg-background p-2 text-xs">
+							{JSON.stringify(block.input, null, 2)}
+						</pre>
+					</div>
+				)}
+			{result && (
+				<div>
+					<p className="mb-1 text-xs font-medium text-muted-foreground">
+						Output
+					</p>
+					<pre
+						className={cn(
+							"overflow-x-auto rounded p-2 text-xs whitespace-pre-wrap",
+							result.isError
+								? "bg-destructive/10 text-destructive"
+								: "bg-background",
+						)}
+					>
+						{result.output || "(empty)"}
+					</pre>
+				</div>
+			)}
+		</div>
+	);
+}
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ToolCallPart/index.ts b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ToolCallPart/index.ts
new file mode 100644
index 00000000000..3ef8afecd22
--- /dev/null
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/components/ToolCallPart/index.ts
@@ -0,0 +1 @@
+export { ToolCallPart } from "./ToolCallPart";
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/page.tsx b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/page.tsx
new file mode 100644
index 00000000000..9f59779cc83
--- /dev/null
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/page.tsx
@@ -0,0 +1,89 @@
+import { createStream } from "@superset/ai-chat/stream";
+import { Button } from "@superset/ui/button";
+import { ScrollArea } from "@superset/ui/scroll-area";
+import { cn } from "@superset/ui/utils";
+import { createFileRoute, useNavigate } from "@tanstack/react-router";
+import { useCallback } from "react";
+import { env } from "renderer/env.renderer";
+import { useChatStore } from "./stores/chatStore";
+
+export const Route = createFileRoute("/_authenticated/_dashboard/chats/")({
+	component: ChatIndexPage,
+});
+
+function ChatIndexPage() {
+	const navigate = useNavigate();
+	const { sessions, createSession } = useChatStore();
+
+	const handleCreateChat = useCallback(async () => {
+		const session = createSession();
+		try {
+			await createStream(env.NEXT_PUBLIC_STREAMS_URL, session.id);
+		} catch (err) {
+			console.error("[chats] Failed to create stream:", err);
+		}
+		navigate({ to: "/chats/$chatId", params: { chatId: session.id } });
+	}, [navigate, createSession]);
+
+	const handleSelectChat = useCallback(
+		async (chatId: string) => {
+			try {
+				await createStream(env.NEXT_PUBLIC_STREAMS_URL, chatId);
+			} catch (err) {
+				console.error("[chats] Failed to ensure stream exists:", err);
+			}
+			navigate({ to: "/chats/$chatId", params: { chatId } });
+		},
+		[navigate],
+	);
+
+	return (
+		<div className="flex h-full">
+			{/* Sidebar */}
+			<div className="w-64 border-r border-border flex flex-col bg-muted/30">
+				<div className="p-3 border-b border-border">
+					<Button onClick={handleCreateChat} className="w-full" size="sm">
+						+ New Chat
+					</Button>
+				</div>
+
+				<ScrollArea className="flex-1">
+					<div className="p-2 space-y-1">
+						{sessions.length === 0 ? (
+							<div className="text-center text-muted-foreground text-sm py-8 px-4">
+								No chats yet.
+								<br />
+								Click "+ New Chat" to start.
+							</div>
+						) : (
+							sessions.map((session) => (
+								<button
+									key={session.id}
+									type="button"
+									onClick={() => handleSelectChat(session.id)}
+									className={cn(
+										"w-full text-left px-3 py-2 rounded-md text-sm transition-colors",
+										"hover:bg-accent hover:text-accent-foreground",
+									)}
+								>
+									<span className="truncate block">{session.name}</span>
+									<span className="text-xs text-muted-foreground">
+										{new Date(session.createdAt).toLocaleDateString()}
+									</span>
+								</button>
+							))
+						)}
+					</div>
+				</ScrollArea>
+			</div>
+
+			{/* Main area - empty state */}
+			<div className="flex-1 flex items-center justify-center text-muted-foreground">
+				<div className="text-center">
+					<p className="text-4xl mb-4 opacity-50">💬</p>
+					<p>Select a chat or create a new one</p>
+				</div>
+			</div>
+		</div>
+	);
+}
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/stores/chatStore.ts b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/stores/chatStore.ts
new file mode 100644
index 00000000000..28dd5d8db2f
--- /dev/null
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/chats/stores/chatStore.ts
@@ -0,0 +1,90 @@
+/**
+ * Local Chat Store
+ *
+ * Stores chat session metadata using zustand with localStorage persistence.
+ * Also syncs sessions with the streams server for cross-device access.
+ */
+
+import { env } from "renderer/env.renderer";
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+
+export interface ChatSession {
+	id: string;
+	name: string;
+	createdAt: string;
+	updatedAt: string;
+}
+
+interface ChatStore {
+	sessions: ChatSession[];
+	createSession: (name?: string) => ChatSession;
+	deleteSession: (id: string) => void;
+	renameSession: (id: string, name: string) => void;
+}
+
+/**
+ * Sync session to streams server (fire-and-forget)
+ */
+function syncToStreamsServer(session: ChatSession): void {
+	const streamsUrl = env.NEXT_PUBLIC_STREAMS_URL;
+	if (!streamsUrl) return;
+
+	fetch(`${streamsUrl}/sessions`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			sessionId: session.id,
+			title: session.name,
+		}),
+	}).catch((err) => {
+		console.warn("[chatStore] Failed to sync session to streams server:", err);
+	});
+}
+
+export const useChatStore = create<ChatStore>()(
+	persist(
+		(set, get) => ({
+			sessions: [],
+
+			createSession: (name?: string) => {
+				const id = crypto.randomUUID();
+				const now = new Date().toISOString();
+				const session: ChatSession = {
+					id,
+					name: name ?? `Chat ${get().sessions.length + 1}`,
+					createdAt: now,
+					updatedAt: now,
+				};
+
+				set((state) => ({
+					sessions: [session, ...state.sessions],
+				}));
+
+				// Sync to streams server for mobile access
+				syncToStreamsServer(session);
+
+				return session;
+			},
+
+			deleteSession: (id: string) => {
+				set((state) => ({
+					sessions: state.sessions.filter((s) => s.id !== id),
+				}));
+			},
+
+			renameSession: (id: string, name: string) => {
+				set((state) => ({
+					sessions: state.sessions.map((s) =>
+						s.id === id
+							? { ...s, name, updatedAt: new Date().toISOString() }
+							: s,
+					),
+				}));
+			},
+		}),
+		{
+			name: "chat-sessions",
+		},
+	),
+);
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/TopBar/components/ChatInputButton/ChatInputButton.tsx b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/TopBar/components/ChatInputButton/ChatInputButton.tsx
new file mode 100644
index 00000000000..ce17ffc6116
--- /dev/null
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/TopBar/components/ChatInputButton/ChatInputButton.tsx
@@ -0,0 +1,38 @@
+import { createStream } from "@superset/ai-chat/stream";
+import { cn } from "@superset/ui/utils";
+import { useNavigate } from "@tanstack/react-router";
+import { Sparkles } from "lucide-react";
+import { useCallback } from "react";
+import { env } from "renderer/env.renderer";
+import { useChatStore } from "../../../../chats/stores/chatStore";
+
+const STREAM_SERVER_URL = env.NEXT_PUBLIC_STREAMS_URL;
+
+export function ChatInputButton() {
+	const navigate = useNavigate();
+	const { createSession } = useChatStore();
+
+	const handleClick = useCallback(async () => {
+		const session = createSession();
+		await createStream(STREAM_SERVER_URL, session.id);
+		navigate({ to: "/chats/$chatId", params: { chatId: session.id } });
+	}, [navigate, createSession]);
+
+	return (
+		<button
+			type="button"
+			onClick={handleClick}
+			className={cn(
+				"no-drag flex items-center gap-2 h-8 px-3 rounded-md",
+				"bg-muted/50 border border-border/50",
+				"text-muted-foreground text-sm",
+				"hover:bg-muted hover:border-border hover:text-foreground",
+				"transition-colors cursor-text",
+				"min-w-[200px] max-w-[400px] flex-1",
+			)}
+		>
+			<Sparkles className="size-4 shrink-0" />
+			<span className="truncate">Ask AI...</span>
+		</button>
+	);
+}
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/TopBar/components/ChatInputButton/index.ts b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/TopBar/components/ChatInputButton/index.ts
new file mode 100644
index 00000000000..1217b5c6885
--- /dev/null
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/TopBar/components/ChatInputButton/index.ts
@@ -0,0 +1 @@
+export { ChatInputButton } from "./ChatInputButton";
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceSidebarHeader/WorkspaceSidebarHeader.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceSidebarHeader/WorkspaceSidebarHeader.tsx
index 36db8570ed5..f3aee925d81 100644
--- a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceSidebarHeader/WorkspaceSidebarHeader.tsx
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceSidebarHeader/WorkspaceSidebarHeader.tsx
@@ -1,8 +1,10 @@
+import { FEATURE_FLAGS } from "@superset/shared/constants";
 import { Tooltip, TooltipContent, TooltipTrigger } from "@superset/ui/tooltip";
 import { cn } from "@superset/ui/utils";
 import { useMatchRoute, useNavigate } from "@tanstack/react-router";
+import { useFeatureFlagEnabled } from "posthog-js/react";
 import { HiOutlineClipboardDocumentList } from "react-icons/hi2";
-import { LuLayers } from "react-icons/lu";
+import { LuLayers, LuMessageSquare } from "react-icons/lu";
 import {
 	GATED_FEATURES,
 	usePaywall,
@@ -20,9 +22,11 @@ export function WorkspaceSidebarHeader({
 	const navigate = useNavigate();
 	const matchRoute = useMatchRoute();
 	const { gateFeature } = usePaywall();
+	const showChat = useFeatureFlagEnabled(FEATURE_FLAGS.AI_CHAT);
 
 	const isWorkspacesListOpen = !!matchRoute({ to: "/workspaces" });
 	const isTasksOpen = !!matchRoute({ to: "/tasks", fuzzy: true });
+	const isChatOpen = !!matchRoute({ to: "/chats" });
 
 	const handleWorkspacesClick = () => {
 		if (isWorkspacesListOpen) {
@@ -39,6 +43,10 @@ export function WorkspaceSidebarHeader({
 		});
 	};
 
+	const handleChatClick = () => {
+		navigate({ to: "/chats" });
+	};
+
 	if (isCollapsed) {
 		return (
 			<div className="flex flex-col items-center border-b border-border py-2 gap-2">
@@ -81,6 +89,29 @@ export function WorkspaceSidebarHeader({
 					<TooltipContent side="right">Tasks</TooltipContent>
 				</Tooltip>
 
+				{showChat && (
+					<Tooltip delayDuration={300}>
+						<TooltipTrigger asChild>
+							<button
+								type="button"
+								onClick={handleChatClick}
+								className={cn(
+									"flex items-center justify-center size-8 rounded-md transition-colors",
+									isChatOpen
+										? "text-foreground bg-accent"
+										: "text-muted-foreground hover:text-foreground hover:bg-accent/50",
+								)}
+							>
+								<LuMessageSquare
+									className="size-4"
+									strokeWidth={STROKE_WIDTH}
+								/>
+							</button>
+						</TooltipTrigger>
+						<TooltipContent side="right">Chat</TooltipContent>
+					</Tooltip>
+				)}
+
 				<NewWorkspaceButton isCollapsed />
 			</div>
 		);
@@ -123,6 +154,24 @@ export function WorkspaceSidebarHeader({
 				<span className="text-sm font-medium flex-1 text-left">Tasks</span>
 			</button>
 
+			{showChat && (
+				<button
+					type="button"
+					onClick={handleChatClick}
+					className={cn(
+						"flex items-center gap-2 px-2 py-1.5 w-full rounded-md transition-colors",
+						isChatOpen
+							? "text-foreground bg-accent"
+							: "text-muted-foreground hover:text-foreground hover:bg-accent/50",
+					)}
+				>
+					<div className="flex items-center justify-center size-5">
+						<LuMessageSquare className="size-4" strokeWidth={STROKE_WIDTH} />
+					</div>
+					<span className="text-sm font-medium flex-1 text-left">Chat</span>
+				</button>
+			)}
+
 			<NewWorkspaceButton />
 		</div>
 	);
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx
index 6924e6c9571..cb32a2c9d9b 100644
--- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx
@@ -1,3 +1,4 @@
+import { createStream } from "@superset/ai-chat/stream";
 import { Button } from "@superset/ui/button";
 import {
 	DropdownMenu,
@@ -8,6 +9,7 @@ import {
 } from "@superset/ui/dropdown-menu";
 import { Tooltip, TooltipContent, TooltipTrigger } from "@superset/ui/tooltip";
 import { useNavigate, useParams } from "@tanstack/react-router";
+import { MessageCircle } from "lucide-react";
 import { useCallback, useMemo, useState } from "react";
 import {
 	HiMiniChevronDown,
@@ -21,7 +23,9 @@ import {
 	useIsDarkTheme,
 } from "renderer/assets/app-icons/preset-icons";
 import { HotkeyTooltipContent } from "renderer/components/HotkeyTooltipContent";
+import { env } from "renderer/env.renderer";
 import { usePresets } from "renderer/react-query/presets";
+import { useChatStore } from "renderer/routes/_authenticated/_dashboard/chats/stores/chatStore";
 import { useTabsStore } from "renderer/stores/tabs/store";
 import { useTabsWithPresets } from "renderer/stores/tabs/useTabsWithPresets";
 import {
@@ -33,6 +37,9 @@ import { PresetMenuItemShortcut } from "./components/PresetMenuItemShortcut";
 import { GroupItem } from "./GroupItem";
 import { NewTabDropZone } from "./NewTabDropZone";
 
+const STREAM_SERVER_URL =
+	env.NEXT_PUBLIC_STREAMS_URL || "http://localhost:8080";
+
 export function GroupStrip() {
 	const { workspaceId: activeWorkspaceId } = useParams({ strict: false });
 
@@ -47,7 +54,9 @@ export function GroupStrip() {
 	const movePaneToTab = useTabsStore((s) => s.movePaneToTab);
 	const movePaneToNewTab = useTabsStore((s) => s.movePaneToNewTab);
 	const reorderTabs = useTabsStore((s) => s.reorderTabs);
+	const addChatPane = useTabsStore((s) => s.addChatPane);
 
+	const { createSession } = useChatStore();
 	const { presets } = usePresets();
 	const isDark = useIsDarkTheme();
 	const navigate = useNavigate();
@@ -89,6 +98,16 @@ export function GroupStrip() {
 		addTab(activeWorkspaceId);
 	};
 
+	const handleAddChat = useCallback(async () => {
+		if (!activeWorkspaceId) return;
+		const session = createSession();
+		await createStream(STREAM_SERVER_URL, session.id);
+		addChatPane(activeWorkspaceId, {
+			sessionId: session.id,
+			name: session.name,
+		});
+	}, [activeWorkspaceId, createSession, addChatPane]);
+
 	const handleSelectPreset = (preset: Parameters<typeof openPreset>[1]) => {
 		if (!activeWorkspaceId) return;
 		openPreset(activeWorkspaceId, preset);
@@ -180,75 +199,92 @@ export function GroupStrip() {
 				onDrop={(paneId) => movePaneToNewTab(paneId)}
 				isLastPaneInTab={checkIsLastPaneInTab}
 			>
-				<DropdownMenu open={dropdownOpen} onOpenChange={setDropdownOpen}>
-					<div className="flex items-center shrink-0">
-						<Tooltip>
-							<TooltipTrigger asChild>
+				<div className="flex items-center shrink-0 gap-1">
+					<Tooltip>
+						<TooltipTrigger asChild>
+							<Button
+								variant="ghost"
+								size="icon"
+								className="size-7"
+								onClick={handleAddChat}
+							>
+								<MessageCircle className="size-4" />
+							</Button>
+						</TooltipTrigger>
+						<TooltipContent side="top" sideOffset={4}>
+							New Chat
+						</TooltipContent>
+					</Tooltip>
+					<DropdownMenu open={dropdownOpen} onOpenChange={setDropdownOpen}>
+						<div className="flex items-center shrink-0">
+							<Tooltip>
+								<TooltipTrigger asChild>
+									<Button
+										variant="ghost"
+										size="icon"
+										className="size-7 rounded-r-none pl-2"
+										onClick={handleAddGroup}
+									>
+										<HiMiniPlus className="size-4" />
+									</Button>
+								</TooltipTrigger>
+								<TooltipContent side="top" sideOffset={4}>
+									<HotkeyTooltipContent label="New Tab" hotkeyId="NEW_GROUP" />
+								</TooltipContent>
+							</Tooltip>
+							<DropdownMenuTrigger asChild>
 								<Button
 									variant="ghost"
 									size="icon"
-									className="size-7 rounded-r-none pl-2"
-									onClick={handleAddGroup}
+									className="size-7 rounded-l-none px-1"
 								>
-									<HiMiniPlus className="size-4" />
+									<HiMiniChevronDown className="size-3" />
 								</Button>
-							</TooltipTrigger>
-							<TooltipContent side="top" sideOffset={4}>
-								<HotkeyTooltipContent label="New Tab" hotkeyId="NEW_GROUP" />
-							</TooltipContent>
-						</Tooltip>
-						<DropdownMenuTrigger asChild>
-							<Button
-								variant="ghost"
-								size="icon"
-								className="size-7 rounded-l-none px-1"
+							</DropdownMenuTrigger>
+						</div>
+						<DropdownMenuContent align="end" className="w-56">
+							{presets.length > 0 && (
+								<>
+									{presets.map((preset, index) => {
+										const presetIcon = getPresetIcon(preset.name, isDark);
+										return (
+											<DropdownMenuItem
+												key={preset.id}
+												onClick={() => handleSelectPreset(preset)}
+												className="gap-2"
+											>
+												{presetIcon ? (
+													<img
+														src={presetIcon}
+														alt=""
+														className="size-4 object-contain"
+													/>
+												) : (
+													<HiMiniCommandLine className="size-4" />
+												)}
+												<span className="truncate">
+													{preset.name || "default"}
+												</span>
+												{preset.isDefault && (
+													<HiStar className="size-3 text-yellow-500 flex-shrink-0" />
+												)}
+												<PresetMenuItemShortcut index={index} />
+											</DropdownMenuItem>
+										);
+									})}
+									<DropdownMenuSeparator />
+								</>
+							)}
+							<DropdownMenuItem
+								onClick={handleOpenPresetsSettings}
+								className="gap-2"
 							>
-								<HiMiniChevronDown className="size-3" />
-							</Button>
-						</DropdownMenuTrigger>
-					</div>
-					<DropdownMenuContent align="end" className="w-56">
-						{presets.length > 0 && (
-							<>
-								{presets.map((preset, index) => {
-									const presetIcon = getPresetIcon(preset.name, isDark);
-									return (
-										<DropdownMenuItem
-											key={preset.id}
-											onClick={() => handleSelectPreset(preset)}
-											className="gap-2"
-										>
-											{presetIcon ? (
-												<img
-													src={presetIcon}
-													alt=""
-													className="size-4 object-contain"
-												/>
-											) : (
-												<HiMiniCommandLine className="size-4" />
-											)}
-											<span className="truncate">
-												{preset.name || "default"}
-											</span>
-											{preset.isDefault && (
-												<HiStar className="size-3 text-yellow-500 flex-shrink-0" />
-											)}
-											<PresetMenuItemShortcut index={index} />
-										</DropdownMenuItem>
-									);
-								})}
-								<DropdownMenuSeparator />
-							</>
-						)}
-						<DropdownMenuItem
-							onClick={handleOpenPresetsSettings}
-							className="gap-2"
-						>
-							<HiMiniCog6Tooth className="size-4" />
-							<span>Configure Presets</span>
-						</DropdownMenuItem>
-					</DropdownMenuContent>
-				</DropdownMenu>
+								<HiMiniCog6Tooth className="size-4" />
+								<span>Configure Presets</span>
+							</DropdownMenuItem>
+						</DropdownMenuContent>
+					</DropdownMenu>
+				</div>
 			</NewTabDropZone>
 		</div>
 	);
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/ChatPane/ChatPane.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/ChatPane/ChatPane.tsx
new file mode 100644
index 00000000000..188f72c557d
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/ChatPane/ChatPane.tsx
@@ -0,0 +1,408 @@
+/**
+ * Chat Pane - workspace chat interface using AI elements
+ *
+ * Messages are materialized from the durable stream via useChatSession.
+ * This mirrors the dashboard ChatView but with improved UI using AI elements.
+ */
+
+import type { BetaContentBlock, ToolResult } from "@superset/ai-chat/stream";
+import { useChatSession } from "@superset/ai-chat/stream";
+import {
+	Conversation,
+	ConversationContent,
+	ConversationEmptyState,
+	ConversationScrollButton,
+} from "@superset/ui/ai-elements/conversation";
+import { Loader } from "@superset/ui/ai-elements/loader";
+import {
+	Message,
+	MessageContent,
+	MessageResponse,
+} from "@superset/ui/ai-elements/message";
+import { Button } from "@superset/ui/button";
+import { CornerDownLeft, MessageCircle, Sparkles } from "lucide-react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import type { MosaicBranch } from "react-mosaic-component";
+import { env } from "renderer/env.renderer";
+import { authClient } from "renderer/lib/auth-client";
+import { electronTrpc } from "renderer/lib/electron-trpc";
+import { getMostRecentWorkspacePath } from "renderer/lib/workspace-utils";
+import { useTabsStore } from "renderer/stores/tabs/store";
+import type { Tab } from "renderer/stores/tabs/types";
+import { BasePaneWindow, PaneToolbarActions } from "../components";
+
+interface ChatPaneProps {
+	paneId: string;
+	path: MosaicBranch[];
+	isActive: boolean;
+	tabId: string;
+	splitPaneAuto: (
+		tabId: string,
+		sourcePaneId: string,
+		dimensions: { width: number; height: number },
+		path?: MosaicBranch[],
+	) => void;
+	splitPaneHorizontal: (
+		tabId: string,
+		sourcePaneId: string,
+		path?: MosaicBranch[],
+	) => void;
+	splitPaneVertical: (
+		tabId: string,
+		sourcePaneId: string,
+		path?: MosaicBranch[],
+	) => void;
+	removePane: (paneId: string) => void;
+	setFocusedPane: (tabId: string, paneId: string) => void;
+	availableTabs: Tab[];
+	onMoveToTab: (targetTabId: string) => void;
+	onMoveToNewTab: () => void;
+}
+
+interface ChatMessageItem {
+	id: string;
+	role: "user" | "assistant";
+	content: string;
+	contentBlocks?: BetaContentBlock[];
+	toolResults?: Map<string, ToolResult>;
+	isStreaming?: boolean;
+}
+
+function ChatMessageBlock({ msg }: { msg: ChatMessageItem }) {
+	if (msg.role === "user") {
+		return (
+			<Message from="user">
+				<MessageContent>{msg.content}</MessageContent>
+			</Message>
+		);
+	}
+
+	// Extract text from content blocks, falling back to content string
+	const textContent =
+		msg.contentBlocks
+			?.filter(
+				(b): b is BetaContentBlock & { type: "text" } => b.type === "text",
+			)
+			.map((b) => b.text)
+			.join("\n") || msg.content;
+
+	return (
+		<Message from="assistant">
+			<MessageContent>
+				<MessageResponse mode={msg.isStreaming ? "streaming" : "static"}>
+					{textContent}
+				</MessageResponse>
+			</MessageContent>
+		</Message>
+	);
+}
+
+export function ChatPane({
+	paneId,
+	path,
+	isActive,
+	tabId,
+	splitPaneAuto,
+	splitPaneHorizontal: _splitPaneHorizontal,
+	splitPaneVertical: _splitPaneVertical,
+	removePane,
+	setFocusedPane,
+	availableTabs: _availableTabs,
+	onMoveToTab: _onMoveToTab,
+	onMoveToNewTab: _onMoveToNewTab,
+}: ChatPaneProps) {
+	const sessionId = useTabsStore((s) => s.panes[paneId]?.chat?.sessionId);
+	const paneName = useTabsStore((s) => s.panes[paneId]?.name);
+
+	console.log(`[ChatPane] Render paneId=${paneId} sessionId=${sessionId}`);
+
+	const { data: session } = authClient.useSession();
+	const user = session?.user
+		? { userId: session.user.id, name: session.user.name ?? "Unknown" }
+		: null;
+
+	// Hook up to durable stream - same as dashboard ChatView
+	const {
+		messages,
+		streamingMessage,
+		draft,
+		setDraft,
+		sendMessage,
+		connectionStatus,
+		isLoading,
+	} = useChatSession({
+		proxyUrl: env.NEXT_PUBLIC_STREAMS_URL,
+		sessionId: sessionId ?? "",
+		user,
+		autoConnect: !!user && !!sessionId,
+	});
+
+	console.log(
+		`[ChatPane] connectionStatus=${connectionStatus} isLoading=${isLoading} messages=${messages.length} streaming=${!!streamingMessage}`,
+	);
+
+	const startSessionMutation = electronTrpc.aiChat.startSession.useMutation();
+	const { data: isSessionActive, refetch: refetchIsActive } =
+		electronTrpc.aiChat.isSessionActive.useQuery(
+			{ sessionId: sessionId ?? "" },
+			{ enabled: !!sessionId },
+		);
+
+	console.log(
+		`[ChatPane] isSessionActive=${isSessionActive} user=${!!user}`,
+	);
+
+	const { data: workspaceGroups } =
+		electronTrpc.workspaces.getAllGrouped.useQuery();
+	const mostRecentWorkspacePath = useMemo(
+		() =>
+			workspaceGroups ? getMostRecentWorkspacePath(workspaceGroups) : null,
+		[workspaceGroups],
+	);
+
+	// Auto-start session when pane mounts and session is not active
+	const hasAutoStarted = useRef(false);
+	useEffect(() => {
+		if (
+			hasAutoStarted.current ||
+			!sessionId ||
+			isSessionActive ||
+			isSessionActive === undefined ||
+			!mostRecentWorkspacePath ||
+			startSessionMutation.isPending
+		) {
+			return;
+		}
+
+		hasAutoStarted.current = true;
+		console.log(
+			`[ChatPane] Auto-starting session ${sessionId} in ${mostRecentWorkspacePath}`,
+		);
+		startSessionMutation
+			.mutateAsync({ sessionId, cwd: mostRecentWorkspacePath })
+			.then(() => {
+				console.log(`[ChatPane] Session started successfully`);
+				return refetchIsActive();
+			})
+			.catch((err) =>
+				console.error("[ChatPane] Failed to auto-start session:", err),
+			);
+	}, [
+		sessionId,
+		isSessionActive,
+		mostRecentWorkspacePath,
+		startSessionMutation,
+		refetchIsActive,
+	]);
+
+	const [isAwaitingResponse, setIsAwaitingResponse] = useState(false);
+
+	const handleSend = useCallback(
+		async (content: string) => {
+			console.log(`[ChatPane] Sending message: "${content.slice(0, 50)}..."`);
+			setIsAwaitingResponse(true);
+			setDraft("");
+			try {
+				await sendMessage(content);
+				console.log(`[ChatPane] Message sent successfully`);
+			} catch (err) {
+				console.error("[ChatPane] Failed to send message:", err);
+				setIsAwaitingResponse(false);
+			}
+		},
+		[sendMessage, setDraft],
+	);
+
+	// Clear awaiting state when streaming starts
+	useEffect(() => {
+		if (streamingMessage) {
+			console.log(`[ChatPane] Streaming started, clearing awaiting state`);
+			setIsAwaitingResponse(false);
+		}
+	}, [streamingMessage]);
+
+	// Handle case where response completes so fast it skips streaming
+	const prevAssistantCount = useRef(0);
+	useEffect(() => {
+		const assistantCount = messages.filter((m) => m.role === "assistant").length;
+		if (assistantCount > prevAssistantCount.current && isAwaitingResponse) {
+			console.log(`[ChatPane] New assistant message appeared, clearing awaiting state`);
+			setIsAwaitingResponse(false);
+		}
+		prevAssistantCount.current = assistantCount;
+	}, [messages, isAwaitingResponse]);
+
+	const handleKeyDown = useCallback(
+		(e: React.KeyboardEvent<HTMLTextAreaElement>) => {
+			if (e.key === "Enter" && !e.shiftKey) {
+				e.preventDefault();
+				if (draft.trim() && isSessionActive && !isAwaitingResponse) {
+					handleSend(draft);
+				}
+			}
+		},
+		[draft, isSessionActive, isAwaitingResponse, handleSend],
+	);
+
+	// Build allMessages array - same pattern as dashboard ChatView
+	const allMessages = useMemo((): ChatMessageItem[] => {
+		console.log(
+			`[ChatPane] Building allMessages: messages=${messages.length} streamingMessage=${streamingMessage ? `id=${streamingMessage.id.slice(0, 8)} role=${streamingMessage.role} content="${streamingMessage.content.slice(0, 80)}" blocks=${streamingMessage.contentBlocks.length} isComplete=${streamingMessage.isComplete} isStreaming=${streamingMessage.isStreaming}` : "null"}`,
+		);
+		const result: ChatMessageItem[] = messages.map((m) => ({
+			id: m.id,
+			role: m.role as "user" | "assistant",
+			content: m.content,
+			contentBlocks: m.contentBlocks,
+			toolResults: m.toolResults,
+		}));
+		if (streamingMessage) {
+			result.push({
+				id: "streaming",
+				role: "assistant",
+				content: streamingMessage.content,
+				contentBlocks: streamingMessage.contentBlocks,
+				toolResults: streamingMessage.toolResults,
+				isStreaming: true,
+			});
+		}
+		console.log(
+			`[ChatPane] allMessages: ${result.length} items:`,
+			result.map((m) => ({
+				id: m.id.slice(0, 8),
+				role: m.role,
+				contentLen: m.content.length,
+				blocks: m.contentBlocks?.length ?? 0,
+				isStreaming: m.isStreaming,
+			})),
+		);
+		return result;
+	}, [messages, streamingMessage]);
+
+	const renderToolbar = useCallback(
+		(handlers: {
+			splitOrientation: "horizontal" | "vertical";
+			onSplitPane: (e: React.MouseEvent) => void;
+			onClosePane: (e: React.MouseEvent) => void;
+		}) => (
+			<div className="flex h-full w-full items-center justify-between px-3">
+				<div className="flex items-center gap-2 text-muted-foreground">
+					<MessageCircle className="size-4" />
+					<span className="text-sm truncate max-w-[150px]">
+						{paneName ?? "Chat"}
+					</span>
+				</div>
+				<PaneToolbarActions
+					splitOrientation={handlers.splitOrientation}
+					onSplitPane={handlers.onSplitPane}
+					onClosePane={handlers.onClosePane}
+					closeHotkeyId="CLOSE_TERMINAL"
+				/>
+			</div>
+		),
+		[paneName],
+	);
+
+	if (!sessionId) {
+		return (
+			<BasePaneWindow
+				paneId={paneId}
+				path={path}
+				tabId={tabId}
+				isActive={isActive}
+				splitPaneAuto={splitPaneAuto}
+				removePane={removePane}
+				setFocusedPane={setFocusedPane}
+				renderToolbar={renderToolbar}
+			>
+				<div className="flex h-full items-center justify-center text-muted-foreground">
+					Session not found
+				</div>
+			</BasePaneWindow>
+		);
+	}
+
+	const hasMessages = allMessages.length > 0;
+	const inputDisabled = !isSessionActive || isAwaitingResponse;
+
+	console.log(
+		`[ChatPane] Render state: hasMessages=${hasMessages} isAwaitingResponse=${isAwaitingResponse} isThinking=${isAwaitingResponse && !streamingMessage} inputDisabled=${inputDisabled} streamingMessage=${!!streamingMessage}`,
+	);
+
+	// Show thinking when awaiting response and no streaming response yet
+	const isThinking = isAwaitingResponse && !streamingMessage;
+
+	return (
+		<BasePaneWindow
+			paneId={paneId}
+			path={path}
+			tabId={tabId}
+			isActive={isActive}
+			splitPaneAuto={splitPaneAuto}
+			removePane={removePane}
+			setFocusedPane={setFocusedPane}
+			renderToolbar={renderToolbar}
+		>
+			<div className="flex flex-col h-full">
+				<Conversation className="flex-1 min-h-0">
+					{hasMessages || isThinking ? (
+						<ConversationContent className="gap-4 px-2 max-w-2xl mx-auto">
+							{allMessages.map((msg) => (
+								<ChatMessageBlock key={msg.id} msg={msg} />
+							))}
+							{isThinking && (
+								<Message from="assistant">
+									<MessageContent>
+										<div className="flex items-center gap-2 text-muted-foreground">
+											<Loader size={14} />
+											<span className="text-sm">Thinking...</span>
+										</div>
+									</MessageContent>
+								</Message>
+							)}
+						</ConversationContent>
+					) : (
+						<ConversationEmptyState
+							icon={<Sparkles className="size-8" />}
+							title="Start a conversation"
+							description={
+								isLoading
+									? `Connecting... (${connectionStatus})`
+									: "Ask anything to get started"
+							}
+						/>
+					)}
+					<ConversationScrollButton />
+				</Conversation>
+
+				<div className="px-3 pb-3 relative z-10">
+					<div className="w-full max-w-2xl mx-auto">
+						<div className="border border-input rounded-xl p-2 transition-[border-color,box-shadow] duration-150 focus-within:border-ring focus-within:ring-ring/50 focus-within:ring-[3px]">
+							<textarea
+								value={draft}
+								onChange={(e) => setDraft(e.target.value)}
+								onKeyDown={handleKeyDown}
+								placeholder="Type a message..."
+								disabled={inputDisabled}
+								rows={1}
+								className="w-full min-h-10 max-h-48 resize-none border-0 bg-transparent p-1 text-sm outline-none placeholder:text-muted-foreground disabled:opacity-50 field-sizing-content"
+							/>
+							<div className="flex justify-end">
+								<Button
+									type="button"
+									variant="default"
+									size="icon"
+									className="size-7 rounded-lg"
+									onClick={() => draft.trim() && handleSend(draft)}
+									disabled={inputDisabled || !draft.trim()}
+								>
+									<CornerDownLeft className="size-4" />
+								</Button>
+							</div>
+						</div>
+					</div>
+				</div>
+			</div>
+		</BasePaneWindow>
+	);
+}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/ChatPane/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/ChatPane/index.ts
new file mode 100644
index 00000000000..50356fa07cf
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/ChatPane/index.ts
@@ -0,0 +1 @@
+export { ChatPane } from "./ChatPane";
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 d4f6ed59fe3..6916f405ded 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
@@ -16,6 +16,7 @@ import {
 	cleanLayout,
 	extractPaneIdsFromLayout,
 } from "renderer/stores/tabs/utils";
+import { ChatPane } from "./ChatPane";
 import { FileViewerPane } from "./FileViewerPane";
 import { TabPane } from "./TabPane";
 
@@ -157,6 +158,26 @@ export function TabView({ tab }: TabViewProps) {
 				);
 			}
 
+			// Route chat panes to ChatPane component
+			if (paneInfo.type === "chat") {
+				return (
+					<ChatPane
+						paneId={paneId}
+						path={path}
+						isActive={isActive}
+						tabId={tab.id}
+						splitPaneAuto={splitPaneAuto}
+						splitPaneHorizontal={splitPaneHorizontal}
+						splitPaneVertical={splitPaneVertical}
+						removePane={removePane}
+						setFocusedPane={setFocusedPane}
+						availableTabs={workspaceTabs}
+						onMoveToTab={(targetTabId) => movePaneToTab(paneId, targetTabId)}
+						onMoveToNewTab={() => movePaneToNewTab(paneId)}
+					/>
+				);
+			}
+
 			// Default: terminal panes
 			return (
 				<TabPane
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/mosaic-theme.css b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/mosaic-theme.css
index 7d0b113540e..fb92eb55f91 100644
--- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/mosaic-theme.css
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/mosaic-theme.css
@@ -76,6 +76,9 @@
 	border-radius: 0;
 	overflow: hidden;
 }
+.mosaic-theme-dark .mosaic-window .mosaic-preview {
+	display: none;
+}
 
 .mosaic-window-content {
 	outline: none;
diff --git a/apps/desktop/src/renderer/stores/chat-panel-state.ts b/apps/desktop/src/renderer/stores/chat-panel-state.ts
deleted file mode 100644
index 0d1ec7e6d47..00000000000
--- a/apps/desktop/src/renderer/stores/chat-panel-state.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-import { create } from "zustand";
-import { devtools, persist } from "zustand/middleware";
-
-const DEFAULT_CHAT_PANEL_SIZE = 30;
-
-interface ChatPanelState {
-	isOpen: boolean;
-	size: number;
-	togglePanel: () => void;
-	setOpen: (open: boolean) => void;
-	setSize: (size: number) => void;
-}
-
-export const useChatPanelStore = create<ChatPanelState>()(
-	devtools(
-		persist(
-			(set, get) => ({
-				isOpen: true,
-				size: DEFAULT_CHAT_PANEL_SIZE,
-
-				togglePanel: () => {
-					const { isOpen, size } = get();
-					if (isOpen) {
-						set({ isOpen: false });
-					} else {
-						set({
-							isOpen: true,
-							size: size === 0 ? DEFAULT_CHAT_PANEL_SIZE : size,
-						});
-					}
-				},
-
-				setOpen: (open) => {
-					const { size } = get();
-					set({
-						isOpen: open,
-						size: open && size === 0 ? DEFAULT_CHAT_PANEL_SIZE : size,
-					});
-				},
-
-				setSize: (size) => {
-					set({
-						size,
-						isOpen: size > 0,
-					});
-				},
-			}),
-			{ name: "chat-panel-store" },
-		),
-		{ name: "ChatPanelStore" },
-	),
-);
diff --git a/apps/desktop/src/renderer/stores/tabs/store.ts b/apps/desktop/src/renderer/stores/tabs/store.ts
index 5ca5d82bb4d..0ef1e51706c 100644
--- a/apps/desktop/src/renderer/stores/tabs/store.ts
+++ b/apps/desktop/src/renderer/stores/tabs/store.ts
@@ -5,6 +5,7 @@ import { create } from "zustand";
 import { devtools, persist } from "zustand/middleware";
 import { movePaneToNewTab, movePaneToTab } from "./actions/move-pane";
 import type {
+	AddChatPaneOptions,
 	AddFileViewerPaneOptions,
 	AddTabWithMultiplePanesOptions,
 	TabsState,
@@ -13,6 +14,7 @@ import type {
 import {
 	buildMultiPaneLayout,
 	type CreatePaneOptions,
+	createChatPane,
 	createFileViewerPane,
 	createPane,
 	createTabWithPane,
@@ -656,6 +658,84 @@ export const useTabsStore = create<TabsStore>()(
 					return newPane.id;
 				},
 
+				addChatPane: (workspaceId: string, options: AddChatPaneOptions) => {
+					const state = get();
+					const resolvedActiveTabId = resolveActiveTabIdForWorkspace({
+						workspaceId,
+						tabs: state.tabs,
+						activeTabIds: state.activeTabIds,
+						tabHistoryStacks: state.tabHistoryStacks,
+					});
+					const activeTab = resolvedActiveTabId
+						? state.tabs.find((t) => t.id === resolvedActiveTabId)
+						: null;
+
+					// If no active tab, create a new one with the chat pane
+					if (!activeTab) {
+						const tabId = generateId("tab");
+						const newPane = createChatPane(tabId, options);
+
+						const tab = {
+							id: tabId,
+							name: options.name ?? "Chat",
+							workspaceId,
+							layout: newPane.id,
+							createdAt: Date.now(),
+						};
+
+						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, [newPane.id]: newPane },
+							activeTabIds: {
+								...state.activeTabIds,
+								[workspaceId]: tab.id,
+							},
+							focusedPaneIds: {
+								...state.focusedPaneIds,
+								[tab.id]: newPane.id,
+							},
+							tabHistoryStacks: {
+								...state.tabHistoryStacks,
+								[workspaceId]: newHistoryStack,
+							},
+						});
+
+						return newPane.id;
+					}
+
+					// Add chat pane to the active tab
+					const newPane = createChatPane(activeTab.id, options);
+
+					const newLayout: MosaicNode<string> = {
+						direction: "row",
+						first: activeTab.layout,
+						second: newPane.id,
+						splitPercentage: 50,
+					};
+
+					set({
+						tabs: state.tabs.map((t) =>
+							t.id === activeTab.id ? { ...t, layout: newLayout } : t,
+						),
+						panes: { ...state.panes, [newPane.id]: newPane },
+						focusedPaneIds: {
+							...state.focusedPaneIds,
+							[activeTab.id]: newPane.id,
+						},
+					});
+
+					return newPane.id;
+				},
+
 				removePane: (paneId) => {
 					const state = get();
 					const pane = state.panes[paneId];
diff --git a/apps/desktop/src/renderer/stores/tabs/types.ts b/apps/desktop/src/renderer/stores/tabs/types.ts
index 58a613e88d0..876dd7553c3 100644
--- a/apps/desktop/src/renderer/stores/tabs/types.ts
+++ b/apps/desktop/src/renderer/stores/tabs/types.ts
@@ -59,6 +59,14 @@ export interface AddFileViewerPaneOptions {
 	isPinned?: boolean;
 }
 
+/**
+ * Options for opening a chat pane
+ */
+export interface AddChatPaneOptions {
+	sessionId: string;
+	name?: string;
+}
+
 /**
  * Actions available on the tabs store
  */
@@ -94,6 +102,7 @@ export interface TabsStore extends TabsState {
 		workspaceId: string,
 		options: AddFileViewerPaneOptions,
 	) => string;
+	addChatPane: (workspaceId: string, options: AddChatPaneOptions) => string;
 	removePane: (paneId: string) => void;
 	setFocusedPane: (tabId: string, paneId: string) => void;
 	markPaneAsUsed: (paneId: string) => void;
diff --git a/apps/desktop/src/renderer/stores/tabs/utils.ts b/apps/desktop/src/renderer/stores/tabs/utils.ts
index d638edb5aac..f667acd6ab1 100644
--- a/apps/desktop/src/renderer/stores/tabs/utils.ts
+++ b/apps/desktop/src/renderer/stores/tabs/utils.ts
@@ -2,6 +2,7 @@ import type { MosaicBranch, MosaicNode } from "react-mosaic-component";
 import type { ChangeCategory } from "shared/changes-types";
 import { hasRenderedPreview, isImageFile } from "shared/file-types";
 import type {
+	ChatState,
 	DiffLayout,
 	FileViewerMode,
 	FileViewerState,
@@ -173,6 +174,14 @@ export interface CreateFileViewerPaneOptions {
 	column?: number;
 }
 
+/**
+ * Options for creating a chat pane
+ */
+export interface CreateChatPaneOptions {
+	sessionId: string;
+	name?: string;
+}
+
 /**
  * Creates a new file-viewer pane with the given properties
  */
@@ -212,6 +221,28 @@ export const createFileViewerPane = (
 	};
 };
 
+/**
+ * Creates a new chat pane with the given properties
+ */
+export const createChatPane = (
+	tabId: string,
+	options: CreateChatPaneOptions,
+): Pane => {
+	const id = generateId("pane");
+
+	const chat: ChatState = {
+		sessionId: options.sessionId,
+	};
+
+	return {
+		id,
+		tabId,
+		type: "chat",
+		name: options.name ?? "Chat",
+		chat,
+	};
+};
+
 /**
  * Generates a static tab name based on existing tabs
  * (e.g., "Terminal 1", "Terminal 2", finding the next available number)
diff --git a/apps/desktop/src/shared/tabs-types.ts b/apps/desktop/src/shared/tabs-types.ts
index cdc8c56923f..f4ab0a94868 100644
--- a/apps/desktop/src/shared/tabs-types.ts
+++ b/apps/desktop/src/shared/tabs-types.ts
@@ -8,7 +8,7 @@ import type { ChangeCategory } from "./changes-types";
 /**
  * Pane types that can be displayed within a tab
  */
-export type PaneType = "terminal" | "webview" | "file-viewer";
+export type PaneType = "terminal" | "webview" | "file-viewer" | "chat";
 
 /**
  * Pane status for agent lifecycle indicators
@@ -102,6 +102,14 @@ export interface FileViewerState {
 	initialColumn?: number;
 }
 
+/**
+ * Chat pane-specific properties
+ */
+export interface ChatState {
+	/** Unique session ID for the chat */
+	sessionId: string;
+}
+
 /**
  * Base Pane interface - shared between main and renderer
  */
@@ -118,6 +126,7 @@ export interface Pane {
 	cwd?: string | null; // Current working directory
 	cwdConfirmed?: boolean; // True if cwd confirmed via OSC-7, false if seeded
 	fileViewer?: FileViewerState; // For file-viewer panes
+	chat?: ChatState; // For chat panes
 }
 
 /**
diff --git a/apps/mobile/app/(authenticated)/chat/[sessionId].tsx b/apps/mobile/app/(authenticated)/chat/[sessionId].tsx
new file mode 100644
index 00000000000..f8c75a8d269
--- /dev/null
+++ b/apps/mobile/app/(authenticated)/chat/[sessionId].tsx
@@ -0,0 +1,3 @@
+import { ChatScreen } from "@/screens/(authenticated)/chat/[sessionId]";
+
+export default ChatScreen;
diff --git a/apps/mobile/app/(authenticated)/chat/index.tsx b/apps/mobile/app/(authenticated)/chat/index.tsx
new file mode 100644
index 00000000000..d4284f8bd4b
--- /dev/null
+++ b/apps/mobile/app/(authenticated)/chat/index.tsx
@@ -0,0 +1,3 @@
+import { ChatListScreen } from "@/screens/(authenticated)/chat";
+
+export default ChatListScreen;
diff --git a/apps/mobile/lib/env.ts b/apps/mobile/lib/env.ts
index 5173ffcf431..d2d9693f117 100644
--- a/apps/mobile/lib/env.ts
+++ b/apps/mobile/lib/env.ts
@@ -6,6 +6,7 @@ const envSchema = z.object({
 		.default("development"),
 	EXPO_PUBLIC_API_URL: z.url(),
 	EXPO_PUBLIC_WEB_URL: z.url().optional(),
+	EXPO_PUBLIC_STREAMS_URL: z.url().optional(),
 	EXPO_PUBLIC_DEEP_LINK_SCHEME: z.string().default("superset"),
 	EXPO_PUBLIC_DEEP_LINK_DOMAIN: z.string().optional(),
 	EXPO_PUBLIC_POSTHOG_KEY: z.string(),
@@ -16,6 +17,7 @@ export const env = envSchema.parse({
 	NODE_ENV: process.env.NODE_ENV as unknown,
 	EXPO_PUBLIC_API_URL: process.env.EXPO_PUBLIC_API_URL as unknown,
 	EXPO_PUBLIC_WEB_URL: process.env.EXPO_PUBLIC_WEB_URL as unknown,
+	EXPO_PUBLIC_STREAMS_URL: process.env.EXPO_PUBLIC_STREAMS_URL as unknown,
 	EXPO_PUBLIC_DEEP_LINK_SCHEME: process.env
 		.EXPO_PUBLIC_DEEP_LINK_SCHEME as unknown,
 	EXPO_PUBLIC_DEEP_LINK_DOMAIN: process.env
diff --git a/apps/mobile/lib/streams/client.ts b/apps/mobile/lib/streams/client.ts
new file mode 100644
index 00000000000..2ea0dde0fcb
--- /dev/null
+++ b/apps/mobile/lib/streams/client.ts
@@ -0,0 +1,119 @@
+/**
+ * Streams API Client
+ *
+ * Client for interacting with the session registry API on the streams server.
+ */
+
+import { env } from "../env";
+
+/**
+ * Generate a UUID using crypto.getRandomValues (polyfilled by react-native-get-random-values)
+ */
+export function generateUUID(): string {
+	const bytes = new Uint8Array(16);
+	crypto.getRandomValues(bytes);
+	bytes[6] = (bytes[6] & 0x0f) | 0x40; // Version 4
+	bytes[8] = (bytes[8] & 0x3f) | 0x80; // Variant 10
+	const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join(
+		"",
+	);
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+export interface SessionInfo {
+	sessionId: string;
+	title: string;
+	createdAt: string;
+	createdBy?: string;
+}
+
+function getStreamsUrl(): string {
+	const url = env.EXPO_PUBLIC_STREAMS_URL;
+	if (!url) {
+		throw new Error("EXPO_PUBLIC_STREAMS_URL is not configured");
+	}
+	return url;
+}
+
+export async function listSessions(): Promise<SessionInfo[]> {
+	const url = getStreamsUrl();
+	const res = await fetch(`${url}/sessions`);
+
+	if (!res.ok) {
+		throw new Error(`Failed to list sessions: ${res.status} ${res.statusText}`);
+	}
+
+	return res.json();
+}
+
+export async function getSession(
+	sessionId: string,
+): Promise<SessionInfo | null> {
+	const url = getStreamsUrl();
+	const res = await fetch(`${url}/sessions/${sessionId}`);
+
+	if (res.status === 404) {
+		return null;
+	}
+
+	if (!res.ok) {
+		throw new Error(`Failed to get session: ${res.status} ${res.statusText}`);
+	}
+
+	return res.json();
+}
+
+export async function createSession({
+	title,
+	createdBy,
+}: {
+	title: string;
+	createdBy?: string;
+}): Promise<SessionInfo> {
+	const url = getStreamsUrl();
+	const sessionId = generateUUID();
+
+	const res = await fetch(`${url}/sessions`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ sessionId, title, createdBy }),
+	});
+
+	if (!res.ok) {
+		throw new Error(
+			`Failed to create session: ${res.status} ${res.statusText}`,
+		);
+	}
+
+	return res.json();
+}
+
+export async function getOrCreateSession({
+	sessionId,
+	title,
+	createdBy,
+}: {
+	sessionId: string;
+	title: string;
+	createdBy?: string;
+}): Promise<SessionInfo> {
+	const existing = await getSession(sessionId);
+	if (existing) {
+		return existing;
+	}
+
+	const url = getStreamsUrl();
+	const res = await fetch(`${url}/sessions`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ sessionId, title, createdBy }),
+	});
+
+	if (!res.ok) {
+		throw new Error(
+			`Failed to create session: ${res.status} ${res.statusText}`,
+		);
+	}
+
+	return res.json();
+}
diff --git a/apps/mobile/lib/streams/index.ts b/apps/mobile/lib/streams/index.ts
new file mode 100644
index 00000000000..a3cb5c33259
--- /dev/null
+++ b/apps/mobile/lib/streams/index.ts
@@ -0,0 +1,7 @@
+export {
+	createSession,
+	getOrCreateSession,
+	getSession,
+	listSessions,
+	type SessionInfo,
+} from "./client";
diff --git a/apps/mobile/package.json b/apps/mobile/package.json
index 03cb5f14f20..1fd58d5ef81 100644
--- a/apps/mobile/package.json
+++ b/apps/mobile/package.json
@@ -19,11 +19,12 @@
 		"@rn-primitives/portal": "^1.3.0",
 		"@rn-primitives/slot": "^1.2.0",
 		"@rn-primitives/switch": "^1.2.0",
+		"@superset/ai-chat": "workspace:*",
 		"@superset/db": "workspace:*",
 		"@superset/trpc": "workspace:*",
-		"@tanstack/db": "0.5.22",
-		"@tanstack/electric-db-collection": "0.2.27",
-		"@tanstack/react-db": "0.1.66",
+		"@tanstack/db": "^0.5.24",
+		"@tanstack/electric-db-collection": "0.2.30",
+		"@tanstack/react-db": "^0.1.68",
 		"@tanstack/react-query": "^5.90.19",
 		"@trpc/client": "^11.7.1",
 		"@trpc/react-query": "^11.7.1",
diff --git a/apps/mobile/screens/(authenticated)/chat/ChatListScreen.tsx b/apps/mobile/screens/(authenticated)/chat/ChatListScreen.tsx
new file mode 100644
index 00000000000..4e4068d5498
--- /dev/null
+++ b/apps/mobile/screens/(authenticated)/chat/ChatListScreen.tsx
@@ -0,0 +1,218 @@
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { Stack, useRouter } from "expo-router";
+import { MessageSquare, Plus } from "lucide-react-native";
+import { useCallback, useState } from "react";
+import { Alert, FlatList, Pressable, RefreshControl, View } from "react-native";
+import { Button } from "@/components/ui/button";
+import { Card, CardContent } from "@/components/ui/card";
+import { Input } from "@/components/ui/input";
+import { Text } from "@/components/ui/text";
+import { useSession } from "@/lib/auth/client";
+import { env } from "@/lib/env";
+import {
+	createSession,
+	listSessions,
+	type SessionInfo,
+} from "@/lib/streams/client";
+
+export function ChatListScreen() {
+	const router = useRouter();
+	const queryClient = useQueryClient();
+	const { data: authSession } = useSession();
+
+	const [showNewChat, setShowNewChat] = useState(false);
+	const [newChatTitle, setNewChatTitle] = useState("");
+	const [isCreating, setIsCreating] = useState(false);
+
+	const streamsUrl = env.EXPO_PUBLIC_STREAMS_URL;
+
+	const {
+		data: sessions = [],
+		isLoading,
+		refetch,
+		isRefetching,
+	} = useQuery({
+		queryKey: ["sessions"],
+		queryFn: listSessions,
+		enabled: !!streamsUrl,
+	});
+
+	const handleCreateSession = useCallback(async () => {
+		if (!newChatTitle.trim()) {
+			Alert.alert("Error", "Please enter a chat title");
+			return;
+		}
+
+		setIsCreating(true);
+		try {
+			const session = await createSession({
+				title: newChatTitle.trim(),
+				createdBy: authSession?.user?.id,
+			});
+
+			setNewChatTitle("");
+			setShowNewChat(false);
+			queryClient.invalidateQueries({ queryKey: ["sessions"] });
+
+			// Navigate to the new chat
+			router.push({
+				pathname: "/(authenticated)/chat/[sessionId]",
+				params: { sessionId: session.sessionId, title: session.title },
+			});
+		} catch (err) {
+			console.error("[chat-list] Failed to create session:", err);
+			Alert.alert("Error", "Failed to create chat session");
+		} finally {
+			setIsCreating(false);
+		}
+	}, [newChatTitle, authSession?.user?.id, queryClient, router]);
+
+	const handleSelectSession = useCallback(
+		(session: SessionInfo) => {
+			router.push({
+				pathname: "/(authenticated)/chat/[sessionId]",
+				params: { sessionId: session.sessionId, title: session.title },
+			});
+		},
+		[router],
+	);
+
+	const renderSession = useCallback(
+		({ item }: { item: SessionInfo }) => (
+			<Pressable onPress={() => handleSelectSession(item)}>
+				<Card className="mx-4 mb-3">
+					<CardContent className="flex-row items-center py-4">
+						<View className="w-10 h-10 rounded-full bg-muted items-center justify-center mr-3">
+							<MessageSquare size={20} color="#6b7280" />
+						</View>
+						<View className="flex-1">
+							<Text className="font-medium">{item.title}</Text>
+							<Text className="text-sm text-muted-foreground">
+								{formatDate(item.createdAt)}
+							</Text>
+						</View>
+					</CardContent>
+				</Card>
+			</Pressable>
+		),
+		[handleSelectSession],
+	);
+
+	const keyExtractor = useCallback((item: SessionInfo) => item.sessionId, []);
+
+	if (!streamsUrl) {
+		return (
+			<>
+				<Stack.Screen
+					options={{
+						title: "Chat",
+						headerShown: true,
+					}}
+				/>
+				<View className="flex-1 bg-background items-center justify-center p-4">
+					<Text className="text-destructive text-center">
+						EXPO_PUBLIC_STREAMS_URL is not configured
+					</Text>
+				</View>
+			</>
+		);
+	}
+
+	return (
+		<>
+			<Stack.Screen
+				options={{
+					title: "Chat",
+					headerShown: true,
+					headerRight: () => (
+						<Pressable
+							onPress={() => setShowNewChat(true)}
+							className="mr-4 p-2"
+						>
+							<Plus size={24} color="#6b7280" />
+						</Pressable>
+					),
+				}}
+			/>
+			<View className="flex-1 bg-background">
+				{showNewChat && (
+					<View className="p-4 border-b border-border bg-card">
+						<Text className="font-medium mb-2">New Chat</Text>
+						<Input
+							placeholder="Enter chat title..."
+							value={newChatTitle}
+							onChangeText={setNewChatTitle}
+							autoFocus
+						/>
+						<View className="flex-row gap-2 mt-3">
+							<Button
+								variant="outline"
+								className="flex-1"
+								onPress={() => {
+									setShowNewChat(false);
+									setNewChatTitle("");
+								}}
+								disabled={isCreating}
+							>
+								<Text>Cancel</Text>
+							</Button>
+							<Button
+								className="flex-1"
+								onPress={handleCreateSession}
+								disabled={isCreating || !newChatTitle.trim()}
+							>
+								<Text>{isCreating ? "Creating..." : "Create"}</Text>
+							</Button>
+						</View>
+					</View>
+				)}
+
+				<FlatList
+					className="flex-1"
+					data={sessions}
+					renderItem={renderSession}
+					keyExtractor={keyExtractor}
+					contentContainerStyle={{ paddingTop: 16 }}
+					refreshControl={
+						<RefreshControl refreshing={isRefetching} onRefresh={refetch} />
+					}
+					ListEmptyComponent={
+						<View className="flex-1 items-center justify-center py-20">
+							{isLoading ? (
+								<Text className="text-muted-foreground">Loading chats...</Text>
+							) : (
+								<View className="items-center">
+									<MessageSquare size={48} color="#9ca3af" />
+									<Text className="text-muted-foreground mt-4">
+										No chats yet
+									</Text>
+									<Button className="mt-4" onPress={() => setShowNewChat(true)}>
+										<Text>Start a Chat</Text>
+									</Button>
+								</View>
+							)}
+						</View>
+					}
+				/>
+			</View>
+		</>
+	);
+}
+
+function formatDate(dateString: string): string {
+	const date = new Date(dateString);
+	const now = new Date();
+	const diff = now.getTime() - date.getTime();
+
+	// Less than 24 hours
+	if (diff < 24 * 60 * 60 * 1000) {
+		return date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+	}
+
+	// Less than 7 days
+	if (diff < 7 * 24 * 60 * 60 * 1000) {
+		return date.toLocaleDateString([], { weekday: "short" });
+	}
+
+	return date.toLocaleDateString([], { month: "short", day: "numeric" });
+}
diff --git a/apps/mobile/screens/(authenticated)/chat/[sessionId]/ChatScreen.tsx b/apps/mobile/screens/(authenticated)/chat/[sessionId]/ChatScreen.tsx
new file mode 100644
index 00000000000..7267b119a2c
--- /dev/null
+++ b/apps/mobile/screens/(authenticated)/chat/[sessionId]/ChatScreen.tsx
@@ -0,0 +1,211 @@
+import { type MessageRow, useChatSession } from "@superset/ai-chat/stream";
+import { Stack, useLocalSearchParams } from "expo-router";
+import { useCallback, useEffect, useRef } from "react";
+import {
+	ActivityIndicator,
+	FlatList,
+	KeyboardAvoidingView,
+	Platform,
+	View,
+} from "react-native";
+import { Text } from "@/components/ui/text";
+import { useSession } from "@/lib/auth/client";
+import { env } from "@/lib/env";
+import { generateUUID } from "@/lib/streams/client";
+import { ChatInput } from "./components/ChatInput";
+import { ChatMessage } from "./components/ChatMessage";
+import { PresenceBar } from "./components/PresenceBar";
+
+/**
+ * Send a message to the durable stream.
+ * Local implementation that uses generateUUID instead of crypto.randomUUID
+ * which isn't available in React Native.
+ */
+async function sendMessageToStream({
+	proxyUrl,
+	sessionId,
+	userId,
+	content,
+}: {
+	proxyUrl: string;
+	sessionId: string;
+	userId: string;
+	content: string;
+}): Promise<void> {
+	const uuid = generateUUID();
+
+	const events = [
+		{
+			type: "chunk",
+			key: uuid,
+			value: {
+				type: "user_input",
+				content,
+				actorId: userId,
+				createdAt: new Date().toISOString(),
+			},
+			headers: { operation: "insert" },
+		},
+	];
+
+	const response = await fetch(`${proxyUrl}/streams/${sessionId}`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(events),
+	});
+
+	if (!response.ok) {
+		throw new Error(`Failed to send message: ${response.status}`);
+	}
+}
+
+export function ChatScreen() {
+	const params = useLocalSearchParams<{ sessionId: string; title?: string }>();
+	const { sessionId, title } = params;
+
+	const { data: authSession } = useSession();
+	const user = authSession?.user
+		? { userId: authSession.user.id, name: authSession.user.name ?? "Unknown" }
+		: null;
+
+	const flatListRef = useRef<FlatList<MessageRow>>(null);
+
+	const streamsUrl = env.EXPO_PUBLIC_STREAMS_URL;
+
+	const {
+		messages,
+		streamingMessage,
+		users,
+		draft,
+		setDraft,
+		isLoading,
+		connectionStatus,
+		error,
+	} = useChatSession({
+		proxyUrl: streamsUrl ?? "",
+		sessionId: sessionId ?? "",
+		user,
+		autoConnect: !!user && !!streamsUrl && !!sessionId,
+	});
+
+	// Scroll to bottom when new messages arrive
+	useEffect(() => {
+		if (messages.length > 0 || streamingMessage) {
+			setTimeout(() => {
+				flatListRef.current?.scrollToEnd({ animated: true });
+			}, 100);
+		}
+	}, [messages.length, streamingMessage?.content, streamingMessage]);
+
+	const handleSend = useCallback(
+		async (content: string) => {
+			if (!user?.userId || !streamsUrl || !sessionId) {
+				console.error(
+					"[chat] Cannot send message: missing user, URL, or sessionId",
+				);
+				return;
+			}
+			try {
+				await sendMessageToStream({
+					proxyUrl: streamsUrl,
+					sessionId,
+					userId: user.userId,
+					content,
+				});
+			} catch (err) {
+				console.error("[chat] Failed to send message:", err);
+			}
+		},
+		[user?.userId, sessionId],
+	);
+
+	const allMessages = streamingMessage
+		? [...messages, streamingMessage]
+		: messages;
+
+	const renderMessage = useCallback(
+		({ item }: { item: MessageRow }) => (
+			<ChatMessage
+				message={item}
+				isCurrentUser={item.actorId === user?.userId}
+			/>
+		),
+		[user?.userId],
+	);
+
+	const keyExtractor = useCallback((item: MessageRow) => item.id, []);
+
+	if (!sessionId) {
+		return (
+			<View className="flex-1 bg-background items-center justify-center">
+				<Text className="text-muted-foreground">No session selected</Text>
+			</View>
+		);
+	}
+
+	if (!streamsUrl) {
+		return (
+			<View className="flex-1 bg-background items-center justify-center p-4">
+				<Text className="text-destructive text-center">
+					EXPO_PUBLIC_STREAMS_URL is not configured
+				</Text>
+			</View>
+		);
+	}
+
+	return (
+		<>
+			<Stack.Screen
+				options={{
+					title: title ?? "Chat",
+					headerShown: true,
+				}}
+			/>
+			<KeyboardAvoidingView
+				className="flex-1 bg-background"
+				behavior={Platform.OS === "ios" ? "padding" : "height"}
+				keyboardVerticalOffset={Platform.OS === "ios" ? 0 : 0}
+			>
+				<PresenceBar users={users} currentUserId={user?.userId} />
+
+				{connectionStatus === "connecting" && (
+					<View className="flex-row items-center justify-center py-2 bg-muted/50">
+						<ActivityIndicator size="small" className="mr-2" />
+						<Text className="text-sm text-muted-foreground">Connecting...</Text>
+					</View>
+				)}
+
+				{error && (
+					<View className="px-4 py-2 bg-destructive/10">
+						<Text className="text-sm text-destructive">
+							Error: {error.message}
+						</Text>
+					</View>
+				)}
+
+				<FlatList
+					ref={flatListRef}
+					className="flex-1"
+					data={allMessages}
+					renderItem={renderMessage}
+					keyExtractor={keyExtractor}
+					contentContainerStyle={{ paddingVertical: 16 }}
+					ListEmptyComponent={
+						<View className="flex-1 items-center justify-center py-20">
+							<Text className="text-muted-foreground">
+								{isLoading ? "Loading messages..." : "No messages yet"}
+							</Text>
+						</View>
+					}
+				/>
+
+				<ChatInput
+					value={draft}
+					onChange={setDraft}
+					onSend={handleSend}
+					disabled={connectionStatus !== "connected"}
+				/>
+			</KeyboardAvoidingView>
+		</>
+	);
+}
diff --git a/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/ChatInput/ChatInput.tsx b/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/ChatInput/ChatInput.tsx
new file mode 100644
index 00000000000..d19fac07210
--- /dev/null
+++ b/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/ChatInput/ChatInput.tsx
@@ -0,0 +1,67 @@
+import { Send } from "lucide-react-native";
+import { useState } from "react";
+import { Pressable, TextInput, View } from "react-native";
+
+export interface ChatInputProps {
+	value: string;
+	onChange: (value: string) => void;
+	onSend: (message: string) => void;
+	disabled?: boolean;
+	placeholder?: string;
+}
+
+export function ChatInput({
+	value,
+	onChange,
+	onSend,
+	disabled = false,
+	placeholder = "Type a message...",
+}: ChatInputProps) {
+	const [isFocused, setIsFocused] = useState(false);
+
+	const handleSend = () => {
+		const trimmed = value.trim();
+		if (trimmed && !disabled) {
+			onSend(trimmed);
+			onChange("");
+		}
+	};
+
+	const canSend = value.trim().length > 0 && !disabled;
+
+	return (
+		<View className="flex-row items-end gap-2 px-4 py-3 border-t border-border bg-background">
+			<View
+				className={`flex-1 flex-row items-center bg-muted rounded-2xl px-4 py-2 ${
+					isFocused ? "border border-primary" : ""
+				}`}
+			>
+				<TextInput
+					className="flex-1 text-base text-foreground min-h-[24px] max-h-[120px]"
+					value={value}
+					onChangeText={onChange}
+					placeholder={placeholder}
+					placeholderTextColor="#9ca3af"
+					multiline
+					editable={!disabled}
+					onFocus={() => setIsFocused(true)}
+					onBlur={() => setIsFocused(false)}
+					onSubmitEditing={handleSend}
+				/>
+			</View>
+			<Pressable
+				onPress={handleSend}
+				disabled={!canSend}
+				className={`w-10 h-10 rounded-full items-center justify-center ${
+					canSend ? "bg-primary" : "bg-muted"
+				}`}
+			>
+				<Send
+					size={20}
+					color={canSend ? "#ffffff" : "#9ca3af"}
+					strokeWidth={2}
+				/>
+			</Pressable>
+		</View>
+	);
+}
diff --git a/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/ChatInput/index.ts b/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/ChatInput/index.ts
new file mode 100644
index 00000000000..eabdf78c145
--- /dev/null
+++ b/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/ChatInput/index.ts
@@ -0,0 +1 @@
+export { ChatInput, type ChatInputProps } from "./ChatInput";
diff --git a/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/ChatMessage/ChatMessage.tsx b/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/ChatMessage/ChatMessage.tsx
new file mode 100644
index 00000000000..dfd8f6657be
--- /dev/null
+++ b/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/ChatMessage/ChatMessage.tsx
@@ -0,0 +1,36 @@
+import type { MessageRow } from "@superset/ai-chat/stream";
+import { View } from "react-native";
+import { Text } from "@/components/ui/text";
+
+export interface ChatMessageProps {
+	message: MessageRow;
+	isCurrentUser: boolean;
+}
+
+export function ChatMessage({ message, isCurrentUser }: ChatMessageProps) {
+	const alignment = isCurrentUser ? "items-end" : "items-start";
+	const bgColor = isCurrentUser ? "bg-primary" : "bg-muted";
+	const textColor = isCurrentUser
+		? "text-primary-foreground"
+		: "text-foreground";
+
+	return (
+		<View className={`px-4 py-1 ${alignment}`}>
+			<View className={`max-w-[85%] ${bgColor} rounded-2xl px-4 py-2`}>
+				{!isCurrentUser && message.role !== "user" && (
+					<Text className={`text-xs ${textColor} opacity-70 mb-1`}>
+						{message.role}
+					</Text>
+				)}
+				<Text className={textColor}>{message.content}</Text>
+				<Text className={`text-xs ${textColor} opacity-50 mt-1`}>
+					{formatTime(message.createdAt)}
+				</Text>
+			</View>
+		</View>
+	);
+}
+
+function formatTime(date: Date): string {
+	return date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+}
diff --git a/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/ChatMessage/index.ts b/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/ChatMessage/index.ts
new file mode 100644
index 00000000000..6cce2515a23
--- /dev/null
+++ b/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/ChatMessage/index.ts
@@ -0,0 +1 @@
+export { ChatMessage, type ChatMessageProps } from "./ChatMessage";
diff --git a/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/PresenceBar/PresenceBar.tsx b/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/PresenceBar/PresenceBar.tsx
new file mode 100644
index 00000000000..63fa416accf
--- /dev/null
+++ b/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/PresenceBar/PresenceBar.tsx
@@ -0,0 +1,32 @@
+import type { ChatUser } from "@superset/ai-chat/stream";
+import { View } from "react-native";
+import { Text } from "@/components/ui/text";
+
+export interface PresenceBarProps {
+	users: ChatUser[];
+	currentUserId?: string;
+}
+
+export function PresenceBar({ users, currentUserId }: PresenceBarProps) {
+	const otherUsers = users.filter((u) => u.userId !== currentUserId);
+
+	if (otherUsers.length === 0) {
+		return null;
+	}
+
+	const displayNames =
+		otherUsers.length <= 3
+			? otherUsers.map((u) => u.name).join(", ")
+			: `${otherUsers
+					.slice(0, 2)
+					.map((u) => u.name)
+					.join(", ")} +${otherUsers.length - 2}`;
+
+	return (
+		<View className="px-4 py-2 bg-muted/50 border-b border-border">
+			<Text className="text-sm text-muted-foreground">
+				{displayNames} {otherUsers.length === 1 ? "is" : "are"} here
+			</Text>
+		</View>
+	);
+}
diff --git a/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/PresenceBar/index.ts b/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/PresenceBar/index.ts
new file mode 100644
index 00000000000..accc01d8d92
--- /dev/null
+++ b/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/PresenceBar/index.ts
@@ -0,0 +1 @@
+export { PresenceBar, type PresenceBarProps } from "./PresenceBar";
diff --git a/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/index.ts b/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/index.ts
new file mode 100644
index 00000000000..47e55ac80f3
--- /dev/null
+++ b/apps/mobile/screens/(authenticated)/chat/[sessionId]/components/index.ts
@@ -0,0 +1,3 @@
+export { ChatInput, type ChatInputProps } from "./ChatInput";
+export { ChatMessage, type ChatMessageProps } from "./ChatMessage";
+export { PresenceBar, type PresenceBarProps } from "./PresenceBar";
diff --git a/apps/mobile/screens/(authenticated)/chat/[sessionId]/index.ts b/apps/mobile/screens/(authenticated)/chat/[sessionId]/index.ts
new file mode 100644
index 00000000000..7c2a8af1ac1
--- /dev/null
+++ b/apps/mobile/screens/(authenticated)/chat/[sessionId]/index.ts
@@ -0,0 +1 @@
+export { ChatScreen } from "./ChatScreen";
diff --git a/apps/mobile/screens/(authenticated)/chat/index.ts b/apps/mobile/screens/(authenticated)/chat/index.ts
new file mode 100644
index 00000000000..6fe1aad06fe
--- /dev/null
+++ b/apps/mobile/screens/(authenticated)/chat/index.ts
@@ -0,0 +1,2 @@
+export { ChatScreen } from "./[sessionId]";
+export { ChatListScreen } from "./ChatListScreen";
diff --git a/apps/mobile/screens/(authenticated)/index/HomeScreen.tsx b/apps/mobile/screens/(authenticated)/index/HomeScreen.tsx
index 5e6cb6682c0..c8f591b9c58 100644
--- a/apps/mobile/screens/(authenticated)/index/HomeScreen.tsx
+++ b/apps/mobile/screens/(authenticated)/index/HomeScreen.tsx
@@ -82,6 +82,21 @@ export function HomeScreen() {
 					</View>
 				</View>
 
+				{/* Chat */}
+				<Card>
+					<CardHeader>
+						<CardTitle>Real-time Chat</CardTitle>
+						<CardDescription>
+							Chat with durable streams - syncs across all devices
+						</CardDescription>
+					</CardHeader>
+					<CardContent>
+						<Button onPress={() => router.push("/(authenticated)/chat")}>
+							<Text>Open Chat</Text>
+						</Button>
+					</CardContent>
+				</Card>
+
 				{/* Electric Collections Demo Link */}
 				<Card>
 					<CardHeader>
diff --git a/apps/streams/.gitignore b/apps/streams/.gitignore
new file mode 100644
index 00000000000..8fce603003c
--- /dev/null
+++ b/apps/streams/.gitignore
@@ -0,0 +1 @@
+data/
diff --git a/apps/streams/ARCHITECTURE.md b/apps/streams/ARCHITECTURE.md
new file mode 100644
index 00000000000..01f5b1f2757
--- /dev/null
+++ b/apps/streams/ARCHITECTURE.md
@@ -0,0 +1,118 @@
+# Durable Streams Architecture
+
+## System Overview
+
+```mermaid
+flowchart TB
+    subgraph Clients["Clients (packages/ai-chat)"]
+        subgraph ClientPkg["@durable-streams/client"]
+            DS[DurableStream]
+            DS --> |".create(url)"| DS
+            DS --> |".append(data)"| DS
+            DS --> |".read(offset?)"| DS
+            DS --> |".subscribe(cb)"| DS
+        end
+        subgraph StatePkg["@durable-streams/state"]
+            State[State Protocol]
+            State --> |"TanStack DB"| Collections[Reactive Collections]
+        end
+    end
+
+    subgraph Server["Server (apps/streams)"]
+        subgraph ServerPkg["@durable-streams/server"]
+            DST[DurableStreamTestServer]
+            DST --> |"port, host, dataDir"| DST
+
+            subgraph HTTP["HTTP Protocol"]
+                PUT["PUT /streams/:id<br/>Create stream"]
+                POST["POST /streams/:id<br/>Append data"]
+                GET["GET /streams/:id<br/>Read / SSE"]
+                HEAD["HEAD /streams/:id<br/>Metadata"]
+                DELETE["DELETE /streams/:id<br/>Delete"]
+            end
+
+            Store[FileBackedStreamStore]
+        end
+    end
+
+    subgraph Storage["Storage (./data)"]
+        LMDB[(LMDB<br/>Metadata Index)]
+        Logs[(Append-Only Logs<br/>Stream Data)]
+    end
+
+    DS <--> |"HTTP + SSE"| HTTP
+    State <--> |"HTTP + SSE"| HTTP
+    HTTP --> Store
+    Store --> LMDB
+    Store --> Logs
+```
+
+## Request/Response Flow
+
+```mermaid
+sequenceDiagram
+    participant A as Agent A (Writer)
+    participant S as Server
+    participant B as Agent B (Reader)
+
+    A->>S: PUT /streams/session-123<br/>Content-Type: application/json
+    S-->>A: 201 Created<br/>Stream-Next-Offset: 0_0
+
+    A->>S: POST /streams/session-123<br/>Producer-Id: agent-a<br/>Producer-Epoch: 0<br/>Producer-Seq: 0<br/>[{"type":"message",...}]
+    S-->>A: 204 No Content<br/>Stream-Next-Offset: 0_45
+
+    B->>S: GET /streams/session-123<br/>Accept: text/event-stream
+    S-->>B: SSE: event: data<br/>[{"type":"message",...}]
+
+    A->>S: POST (more messages)<br/>Producer-Seq: 1
+    S-->>A: 204 No Content
+    S-->>B: SSE: event: data<br/>(real-time update)
+```
+
+## Producer Idempotency Headers
+
+```mermaid
+flowchart LR
+    subgraph Request["POST Request Headers"]
+        PID[Producer-Id<br/>Unique producer identifier]
+        PE[Producer-Epoch<br/>Fencing/leader election]
+        PS[Producer-Seq<br/>Sequence number]
+    end
+
+    subgraph Response["Response Headers"]
+        SNO[Stream-Next-Offset<br/>Next read position]
+        SUD[Stream-Up-To-Date<br/>No more data]
+        SC[Stream-Cursor<br/>CDN cache key]
+    end
+
+    Request --> |"Enables"| Features
+
+    subgraph Features["Features"]
+        Idem[Idempotent Writes<br/>Duplicate detection]
+        Fence[Zombie Fencing<br/>Stale producer rejection]
+        Order[Ordering<br/>Gap detection]
+    end
+```
+
+## Package Dependencies
+
+```mermaid
+flowchart TB
+    subgraph apps/streams
+        Index[src/index.ts]
+        Index --> DSServer["@durable-streams/server@0.2.0"]
+    end
+
+    subgraph packages/ai-chat
+        AiChat[src/index.ts]
+        AiChat --> DSClient["@durable-streams/client@0.2.0"]
+        AiChat --> DSState["@durable-streams/state@0.2.0"]
+    end
+
+    DSServer --> |"DurableStreamTestServer<br/>FileBackedStreamStore"| ServerAPI[Server API]
+    DSClient --> |"DurableStream"| ClientAPI[Client API]
+    DSState --> |"State Protocol<br/>TanStack DB"| StateAPI[State API]
+
+    ClientAPI <--> |"HTTP/SSE"| ServerAPI
+    StateAPI <--> |"HTTP/SSE"| ServerAPI
+```
diff --git a/apps/streams/Dockerfile b/apps/streams/Dockerfile
new file mode 100644
index 00000000000..a5548f39f60
--- /dev/null
+++ b/apps/streams/Dockerfile
@@ -0,0 +1,32 @@
+FROM node:22-slim AS builder
+
+WORKDIR /app
+
+# Install dependencies
+COPY package.json bun.lock ./
+RUN npm install
+
+# Copy source
+COPY tsconfig.json ./
+COPY src ./src
+
+# Build
+RUN npm run build
+
+# Production image
+FROM node:22-slim
+
+WORKDIR /app
+
+ENV NODE_ENV=production
+
+# Copy built files and production dependencies
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/package.json ./
+
+# Install production dependencies only
+RUN npm install --omit=dev
+
+EXPOSE 8080
+
+CMD ["node", "dist/index.js"]
diff --git a/apps/streams/fly.toml b/apps/streams/fly.toml
new file mode 100644
index 00000000000..97c5fe19935
--- /dev/null
+++ b/apps/streams/fly.toml
@@ -0,0 +1,35 @@
+# fly.toml for Superset Stream Server
+app = "superset-stream"
+primary_region = "iad"
+
+[build]
+  dockerfile = "Dockerfile"
+
+[env]
+  PORT = "8080"
+  NODE_ENV = "production"
+  DATA_DIR = "/data"
+
+[http_service]
+  internal_port = 8080
+  force_https = true
+  auto_stop_machines = "stop"
+  auto_start_machines = true
+  min_machines_running = 1
+  processes = ["app"]
+
+[[http_service.checks]]
+  interval = "15s"
+  timeout = "2s"
+  grace_period = "5s"
+  method = "GET"
+  path = "/health"
+
+[mounts]
+  source = "stream_data"
+  destination = "/data"
+
+[[vm]]
+  memory = "256mb"
+  cpu_kind = "shared"
+  cpus = 1
diff --git a/apps/streams/package.json b/apps/streams/package.json
new file mode 100644
index 00000000000..08d5c917bd7
--- /dev/null
+++ b/apps/streams/package.json
@@ -0,0 +1,29 @@
+{
+	"name": "@superset/streams",
+	"version": "0.0.1",
+	"description": "Durable Stream server for real-time token streaming",
+	"type": "module",
+	"main": "./dist/index.js",
+	"scripts": {
+		"dev": "tsx watch src/index.ts",
+		"build": "tsup src/index.ts --format esm --dts",
+		"start": "node dist/index.js",
+		"typecheck": "tsc --noEmit",
+		"test": "vitest run",
+		"test:conformance": "npx @durable-streams/server-conformance-tests --run http://localhost:8080"
+	},
+	"dependencies": {
+		"@durable-streams/server": "^0.2.0"
+	},
+	"devDependencies": {
+		"@durable-streams/client": "^0.2.0",
+		"@durable-streams/server-conformance-tests": "^0.2.0",
+		"@superset/typescript": "workspace:*",
+		"@types/node": "^24.9.1",
+		"fast-check": "^4.5.3",
+		"tsup": "^8.5.0",
+		"tsx": "^4.19.3",
+		"typescript": "^5.9.3",
+		"vitest": "^4.0.0"
+	}
+}
diff --git a/apps/streams/src/index.ts b/apps/streams/src/index.ts
new file mode 100644
index 00000000000..f1bff42be2f
--- /dev/null
+++ b/apps/streams/src/index.ts
@@ -0,0 +1,204 @@
+/**
+ * Durable Streams Server with Session Registry
+ *
+ * Combines the official @durable-streams/server with a session registry API.
+ * The durable streams server runs on an internal port, and this Hono server
+ * proxies requests to it while handling /sessions routes directly.
+ */
+
+import {
+	createServer as createHttpServer,
+	request as httpRequest,
+} from "node:http";
+import { DurableStreamTestServer } from "@durable-streams/server";
+import { SessionRegistry } from "./session-registry.js";
+
+const dataDir = process.env.DATA_DIR || "./data";
+const port = Number.parseInt(process.env.PORT || "8080", 10);
+const internalPort = port + 1; // Durable streams runs on internal port
+
+const registry = new SessionRegistry(dataDir);
+
+// Start the durable streams server on internal port
+const durableServer = new DurableStreamTestServer({
+	port: internalPort,
+	host: "127.0.0.1",
+	dataDir,
+});
+
+// Create main HTTP server that routes requests
+const server = createHttpServer(async (req, res) => {
+	const url = new URL(req.url || "/", `http://${req.headers.host}`);
+
+	// CORS headers
+	res.setHeader("Access-Control-Allow-Origin", "*");
+	res.setHeader(
+		"Access-Control-Allow-Methods",
+		"GET, POST, PUT, DELETE, HEAD, OPTIONS",
+	);
+	res.setHeader(
+		"Access-Control-Allow-Headers",
+		"Content-Type, Producer-Id, Producer-Epoch, Producer-Seq, Authorization",
+	);
+	res.setHeader("Access-Control-Expose-Headers", "*");
+
+	if (req.method === "OPTIONS") {
+		res.writeHead(204);
+		res.end();
+		return;
+	}
+
+	// Handle session registry routes
+	if (url.pathname === "/sessions" || url.pathname === "/sessions/") {
+		if (req.method === "GET") {
+			// List all sessions
+			const sessions = registry.list();
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(JSON.stringify(sessions));
+			return;
+		}
+
+		if (req.method === "POST") {
+			// Register a new session
+			try {
+				const body = await readBody(req);
+				const { sessionId, title, createdBy } = JSON.parse(body);
+
+				if (!sessionId || !title) {
+					res.writeHead(400, { "Content-Type": "application/json" });
+					res.end(
+						JSON.stringify({ error: "sessionId and title are required" }),
+					);
+					return;
+				}
+
+				const session = registry.register({ sessionId, title, createdBy });
+				res.writeHead(201, { "Content-Type": "application/json" });
+				res.end(JSON.stringify(session));
+				return;
+			} catch (error) {
+				console.error("[sessions] Failed to parse request body:", error);
+				res.writeHead(400, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({ error: "Invalid JSON body" }));
+				return;
+			}
+		}
+
+		res.writeHead(405, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ error: "Method not allowed" }));
+		return;
+	}
+
+	// Handle GET /sessions/:id
+	const sessionMatch = url.pathname.match(/^\/sessions\/([^/]+)$/);
+	if (sessionMatch?.[1]) {
+		const sessionId = sessionMatch[1];
+
+		if (req.method === "GET") {
+			const session = registry.get(sessionId);
+			if (!session) {
+				res.writeHead(404, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({ error: "Session not found" }));
+				return;
+			}
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(JSON.stringify(session));
+			return;
+		}
+
+		res.writeHead(405, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ error: "Method not allowed" }));
+		return;
+	}
+
+	// Health check
+	if (url.pathname === "/health") {
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ status: "ok" }));
+		return;
+	}
+
+	// Proxy all other requests to durable streams server
+	proxyToDurableStreams(req, res, url);
+});
+
+function readBody(req: import("node:http").IncomingMessage): Promise<string> {
+	return new Promise((resolve, reject) => {
+		const chunks: Buffer[] = [];
+		req.on("data", (chunk) => chunks.push(chunk));
+		req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+		req.on("error", reject);
+	});
+}
+
+function proxyToDurableStreams(
+	req: import("node:http").IncomingMessage,
+	res: import("node:http").ServerResponse,
+	url: URL,
+) {
+	const proxyReq = httpRequest(
+		{
+			hostname: "127.0.0.1",
+			port: internalPort,
+			path: url.pathname + url.search,
+			method: req.method,
+			headers: req.headers,
+		},
+		(proxyRes) => {
+			// Forward status and headers
+			res.writeHead(proxyRes.statusCode || 500, proxyRes.headers);
+			proxyRes.pipe(res);
+		},
+	);
+
+	proxyReq.on("error", (err: Error) => {
+		console.error("[proxy] Error proxying to durable streams:", err);
+		if (!res.headersSent) {
+			res.writeHead(502, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: "Bad gateway" }));
+		}
+	});
+
+	// Pipe request body for POST/PUT requests
+	req.pipe(proxyReq);
+}
+
+console.log(`[streams] Starting on port ${port}`);
+
+// Start both servers
+durableServer.start().then((durableUrl) => {
+	console.log(`[streams] Durable streams internal: ${durableUrl}`);
+
+	server.listen(port, "127.0.0.1", () => {
+		console.log(`[streams] Server running at http://127.0.0.1:${port}`);
+	});
+});
+
+// Graceful shutdown
+function shutdown(signal: string) {
+	console.log(`[streams] Received ${signal}, shutting down...`);
+	server.close(() => {
+		console.log("[streams] HTTP server closed");
+		durableServer
+			.stop()
+			.then(() => {
+				console.log("[streams] Durable streams server closed");
+				process.exit(0);
+			})
+			.catch((err) => {
+				console.error("[streams] Error stopping durable server:", err);
+				process.exit(1);
+			});
+	});
+
+	// Force exit if graceful shutdown takes too long
+	setTimeout(() => {
+		console.error("[streams] Graceful shutdown timed out, forcing exit");
+		process.exit(1);
+	}, 10_000);
+}
+
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+process.on("SIGINT", () => shutdown("SIGINT"));
+
+export default server;
diff --git a/apps/streams/src/session-registry.ts b/apps/streams/src/session-registry.ts
new file mode 100644
index 00000000000..23326e8211c
--- /dev/null
+++ b/apps/streams/src/session-registry.ts
@@ -0,0 +1,93 @@
+/**
+ * Session Registry
+ *
+ * In-memory session registry with file persistence for tracking chat sessions.
+ * This provides a lightweight session index without full database persistence.
+ */
+
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	renameSync,
+	writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+
+export interface SessionInfo {
+	sessionId: string;
+	title: string;
+	createdAt: string;
+	createdBy?: string;
+}
+
+export class SessionRegistry {
+	private sessions: Map<string, SessionInfo> = new Map();
+	private filePath: string;
+
+	constructor(dataDir: string) {
+		this.filePath = join(dataDir, "sessions.json");
+		this.load();
+	}
+
+	list(): SessionInfo[] {
+		return Array.from(this.sessions.values()).sort(
+			(a, b) =>
+				new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime(),
+		);
+	}
+
+	get(sessionId: string): SessionInfo | undefined {
+		return this.sessions.get(sessionId);
+	}
+
+	register(info: Omit<SessionInfo, "createdAt">): SessionInfo {
+		const existing = this.sessions.get(info.sessionId);
+		if (existing) {
+			return existing;
+		}
+
+		const session: SessionInfo = {
+			...info,
+			createdAt: new Date().toISOString(),
+		};
+
+		this.sessions.set(info.sessionId, session);
+		this.persist();
+
+		return session;
+	}
+
+	private persist(): void {
+		try {
+			const dir = dirname(this.filePath);
+			if (!existsSync(dir)) {
+				mkdirSync(dir, { recursive: true });
+			}
+			const data = JSON.stringify(Array.from(this.sessions.values()), null, 2);
+			// Write to temp file then rename for crash safety
+			const tmpPath = `${this.filePath}.tmp`;
+			writeFileSync(tmpPath, data, "utf-8");
+			renameSync(tmpPath, this.filePath);
+		} catch (error) {
+			console.error("[session-registry] Failed to persist sessions:", error);
+		}
+	}
+
+	private load(): void {
+		try {
+			if (existsSync(this.filePath)) {
+				const data = readFileSync(this.filePath, "utf-8");
+				const sessions: SessionInfo[] = JSON.parse(data);
+				for (const session of sessions) {
+					this.sessions.set(session.sessionId, session);
+				}
+				console.log(
+					`[session-registry] Loaded ${sessions.length} sessions from disk`,
+				);
+			}
+		} catch (error) {
+			console.error("[session-registry] Failed to load sessions:", error);
+		}
+	}
+}
diff --git a/apps/streams/tsconfig.json b/apps/streams/tsconfig.json
new file mode 100644
index 00000000000..d5b88c36c60
--- /dev/null
+++ b/apps/streams/tsconfig.json
@@ -0,0 +1,12 @@
+{
+	"extends": "@superset/typescript/base.json",
+	"compilerOptions": {
+		"outDir": "./dist",
+		"rootDir": "./src",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"target": "ES2022"
+	},
+	"include": ["src/**/*.ts"],
+	"exclude": ["node_modules", "dist"]
+}
diff --git a/bun.lock b/bun.lock
index 4620526f5c4..8b51446de94 100644
--- a/bun.lock
+++ b/bun.lock
@@ -133,10 +133,12 @@
       "name": "@superset/desktop",
       "version": "0.0.67",
       "dependencies": {
+        "@anthropic-ai/claude-agent-sdk": "^0.2.19",
         "@better-auth/stripe": "1.4.17",
         "@dnd-kit/core": "^6.3.1",
         "@dnd-kit/sortable": "^10.0.0",
         "@dnd-kit/utilities": "^3.2.2",
+        "@durable-streams/client": "^0.2.0",
         "@electric-sql/client": "https://pkg.pr.new/@electric-sql/client@3724",
         "@headless-tree/core": "^1.6.3",
         "@headless-tree/react": "^1.6.3",
@@ -145,6 +147,7 @@
         "@radix-ui/react-dialog": "^1.1.15",
         "@radix-ui/react-label": "^2.1.8",
         "@sentry/electron": "^7.7.0",
+        "@superset/ai-chat": "workspace:*",
         "@superset/auth": "workspace:*",
         "@superset/db": "workspace:*",
         "@superset/local-db": "workspace:*",
@@ -152,9 +155,9 @@
         "@superset/trpc": "workspace:*",
         "@superset/ui": "workspace:*",
         "@t3-oss/env-core": "^0.13.8",
-        "@tanstack/db": "0.5.22",
-        "@tanstack/electric-db-collection": "0.2.27",
-        "@tanstack/react-db": "0.1.66",
+        "@tanstack/db": "^0.5.24",
+        "@tanstack/electric-db-collection": "0.2.30",
+        "@tanstack/react-db": "^0.1.68",
         "@tanstack/react-query": "^5.90.19",
         "@tanstack/react-router": "^1.147.3",
         "@tanstack/react-table": "^8.21.3",
@@ -395,11 +398,12 @@
         "@rn-primitives/portal": "^1.3.0",
         "@rn-primitives/slot": "^1.2.0",
         "@rn-primitives/switch": "^1.2.0",
+        "@superset/ai-chat": "workspace:*",
         "@superset/db": "workspace:*",
         "@superset/trpc": "workspace:*",
-        "@tanstack/db": "0.5.22",
-        "@tanstack/electric-db-collection": "0.2.27",
-        "@tanstack/react-db": "0.1.66",
+        "@tanstack/db": "^0.5.24",
+        "@tanstack/electric-db-collection": "0.2.30",
+        "@tanstack/react-db": "^0.1.68",
         "@tanstack/react-query": "^5.90.19",
         "@trpc/client": "^11.7.1",
         "@trpc/react-query": "^11.7.1",
@@ -446,6 +450,24 @@
         "typescript": "^5.9.3",
       },
     },
+    "apps/streams": {
+      "name": "@superset/streams",
+      "version": "0.0.1",
+      "dependencies": {
+        "@durable-streams/server": "^0.2.0",
+      },
+      "devDependencies": {
+        "@durable-streams/client": "^0.2.0",
+        "@durable-streams/server-conformance-tests": "^0.2.0",
+        "@superset/typescript": "workspace:*",
+        "@types/node": "^24.9.1",
+        "fast-check": "^4.5.3",
+        "tsup": "^8.5.0",
+        "tsx": "^4.19.3",
+        "typescript": "^5.9.3",
+        "vitest": "^4.0.0",
+      },
+    },
     "apps/web": {
       "name": "@superset/web",
       "version": "0.1.0",
@@ -493,6 +515,31 @@
         "typescript": "^5.9.3",
       },
     },
+    "packages/ai-chat": {
+      "name": "@superset/ai-chat",
+      "version": "0.0.1",
+      "dependencies": {
+        "@anthropic-ai/claude-agent-sdk": "^0.2.19",
+        "@anthropic-ai/sdk": "^0.71.2",
+        "@durable-streams/client": "^0.2.0",
+        "@durable-streams/state": "^0.2.0",
+        "@superset/ui": "workspace:*",
+        "@tanstack/db": "^0.5.24",
+        "@tanstack/react-db": "^0.1.68",
+        "lucide-react": "^0.560.0",
+        "react": "19.1.0",
+        "zod": "^4.3.5",
+      },
+      "devDependencies": {
+        "@superset/typescript": "workspace:*",
+        "@types/node": "^24.9.1",
+        "@types/react": "~19.1.0",
+        "typescript": "^5.9.3",
+      },
+      "peerDependencies": {
+        "react": "^18.0.0 || ^19.0.0",
+      },
+    },
     "packages/auth": {
       "name": "@superset/auth",
       "version": "0.1.0",
@@ -727,6 +774,8 @@
 
     "@antfu/install-pkg": ["@antfu/install-pkg@1.1.0", "", { "dependencies": { "package-manager-detector": "^1.3.0", "tinyexec": "^1.0.1" } }, "sha512-MGQsmw10ZyI+EJo45CdSER4zEb+p31LpDAFp2Z3gkSd1yqVZGi0Ebx++YTEMonJy4oChEMLsxZ64j8FH6sSqtQ=="],
 
+    "@anthropic-ai/claude-agent-sdk": ["@anthropic-ai/claude-agent-sdk@0.2.31", "", { "optionalDependencies": { "@img/sharp-darwin-arm64": "^0.33.5", "@img/sharp-darwin-x64": "^0.33.5", "@img/sharp-linux-arm": "^0.33.5", "@img/sharp-linux-arm64": "^0.33.5", "@img/sharp-linux-x64": "^0.33.5", "@img/sharp-linuxmusl-arm64": "^0.33.5", "@img/sharp-linuxmusl-x64": "^0.33.5", "@img/sharp-win32-x64": "^0.33.5" }, "peerDependencies": { "zod": "^4.0.0" } }, "sha512-ZepnDG6r91je1LvrHST2C67m3olgmiYfrhnj4Elyj8AGqOHGYig1zDIPVhGF0u62y0rVVri2mGFDYQI0oW/LBw=="],
+
     "@anthropic-ai/sdk": ["@anthropic-ai/sdk@0.71.2", "", { "dependencies": { "json-schema-to-ts": "^3.1.1" }, "peerDependencies": { "zod": "^3.25.0 || ^4.0.0" }, "optionalPeers": ["zod"], "bin": { "anthropic-ai-sdk": "bin/cli" } }, "sha512-TGNDEUuEstk/DKu0/TflXAEt+p+p/WhTlFzEnoosvbaDU2LTjm42igSdlL0VijrKpWejtOKxX0b8A7uc+XiSAQ=="],
 
     "@apm-js-collab/code-transformer": ["@apm-js-collab/code-transformer@0.8.2", "", {}, "sha512-YRjJjNq5KFSjDUoqu5pFUWrrsvGOxl6c3bu+uMFc9HNNptZ2rNU/TI2nLw4jnhQNtka972Ee2m3uqbvDQtPeCA=="],
@@ -991,6 +1040,14 @@
 
     "@drizzle-team/brocli": ["@drizzle-team/brocli@0.10.2", "", {}, "sha512-z33Il7l5dKjUgGULTqBsQBQwckHh5AbIuxhdsIxDDiZAzBOrZO6q9ogcWC65kU382AfynTfgNumVcNIjuIua6w=="],
 
+    "@durable-streams/client": ["@durable-streams/client@0.2.1", "", { "dependencies": { "@microsoft/fetch-event-source": "^2.0.1", "fastq": "^1.19.1" } }, "sha512-+mGdK6TuDR9fJPo8jw6DufPfoUv6g+27xoPES76GXQc6y3val9Oe/SK2o2FV9sqqLSE19HEUSxTp0D6CZebfZw=="],
+
+    "@durable-streams/server": ["@durable-streams/server@0.2.1", "", { "dependencies": { "@durable-streams/client": "0.2.1", "@durable-streams/state": "0.2.1", "@neophi/sieve-cache": "^1.0.0", "lmdb": "^3.3.0" } }, "sha512-34Ss6CJIJJk0i8Leo9hhNqfbiAAfthSBWiYb13wYu4Wn72vJHorrCKH5Qr0stzZR7jp+fjdbZEnim4lExxEOjg=="],
+
+    "@durable-streams/server-conformance-tests": ["@durable-streams/server-conformance-tests@0.2.1", "", { "dependencies": { "@durable-streams/client": "0.2.1", "fast-check": "^4.4.0", "vitest": "^4.0.0" }, "bin": { "server-conformance-tests": "dist/cli.js", "durable-streams-server-conformance": "dist/cli.js", "durable-streams-server-conformance-dev": "bin/conformance-dev.mjs" } }, "sha512-Us94fOweskeGqWNkQJo1sYyPtHuvYR8BYVmpJtaJEWWNkrkXFKcirfIOsC1vdCVJJyTwSXM3ZV8EuP9vpgSNhw=="],
+
+    "@durable-streams/state": ["@durable-streams/state@0.2.1", "", { "dependencies": { "@durable-streams/client": "0.2.1", "@standard-schema/spec": "^1.0.0" }, "peerDependencies": { "@tanstack/db": ">=0.5.0" } }, "sha512-8piCcw/y1Jz6QJn0vOf+yhovFlp3xvRbzWRWtF51ndlorofJi3pOfCXnEINuvSueuNMIJosmKOg0AEvpMKfoCw=="],
+
     "@electric-sql/client": ["@electric-sql/client@https://pkg.pr.new/@electric-sql/client@3724", { "dependencies": { "@microsoft/fetch-event-source": "^2.0.1" }, "optionalDependencies": { "@rollup/rollup-darwin-arm64": "^4.18.1" } }],
 
     "@electron/asar": ["@electron/asar@3.4.1", "", { "dependencies": { "commander": "^5.0.0", "glob": "^7.1.6", "minimatch": "^3.0.4" }, "bin": { "asar": "bin/asar.js" } }, "sha512-i4/rNPRS84t0vSRa2HorerGRXWyF4vThfHesw0dmcWHp+cspK743UanA0suA5Q5y8kzY2y6YKrvbIUn69BCAiA=="],
@@ -1135,6 +1192,8 @@
 
     "@graphql-typed-document-node/core": ["@graphql-typed-document-node/core@3.2.0", "", { "peerDependencies": { "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0" } }, "sha512-mB9oAsNCm9aM3/SOv4YtBMqZbYj10R7dkq8byBqxGY/ncFwhf2oQzMV+LCRlWoDSEBJ3COiR1yeDvMtsoOsuFQ=="],
 
+    "@harperfast/extended-iterable": ["@harperfast/extended-iterable@1.0.3", "", {}, "sha512-sSAYhQca3rDWtQUHSAPeO7axFIUJOI6hn1gjRC5APVE1a90tuyT8f5WIgRsFhhWA7htNkju2veB9eWL6YHi/Lw=="],
+
     "@headless-tree/core": ["@headless-tree/core@1.6.3", "", {}, "sha512-en0EOaZfiCRF2B8DEnhGhSaUf3hVr9Bauye8G8aswPbHOKSyhJiN4bsczz1GvqF4Xb7Ga3LP0vLA6Zih7YLoyw=="],
 
     "@headless-tree/react": ["@headless-tree/react@1.6.3", "", { "peerDependencies": { "@headless-tree/core": "*", "react": "*", "react-dom": "*" } }, "sha512-aiRwG6e2EPBSec9uLLy9GlTvAuCtSTouU30Nwcr5ZTsYjG/i7B/ouC8f8Zu4unzo/v1h5ztbemp+EH2TPTKh+g=="],
@@ -1149,9 +1208,9 @@
 
     "@img/colour": ["@img/colour@1.0.0", "", {}, "sha512-A5P/LfWGFSl6nsckYtjw9da+19jB8hkJ6ACTGcDfEJ0aE+l2n2El7dsVM7UVHZQ9s2lmYMWlrS21YLy2IR1LUw=="],
 
-    "@img/sharp-darwin-arm64": ["@img/sharp-darwin-arm64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-arm64": "1.2.4" }, "os": "darwin", "cpu": "arm64" }, "sha512-imtQ3WMJXbMY4fxb/Ndp6HBTNVtWCUI0WdobyheGf5+ad6xX8VIDO8u2xE4qc/fr08CKG/7dDseFtn6M6g/r3w=="],
+    "@img/sharp-darwin-arm64": ["@img/sharp-darwin-arm64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-arm64": "1.0.4" }, "os": "darwin", "cpu": "arm64" }, "sha512-UT4p+iz/2H4twwAoLCqfA9UH5pI6DggwKEGuaPy7nCVQ8ZsiY5PIcrRvD1DzuY3qYL07NtIQcWnBSY/heikIFQ=="],
 
-    "@img/sharp-darwin-x64": ["@img/sharp-darwin-x64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-x64": "1.2.4" }, "os": "darwin", "cpu": "x64" }, "sha512-YNEFAF/4KQ/PeW0N+r+aVVsoIY0/qxxikF2SWdp+NRkmMB7y9LBZAVqQ4yhGCm/H3H270OSykqmQMKLBhBJDEw=="],
+    "@img/sharp-darwin-x64": ["@img/sharp-darwin-x64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-x64": "1.0.4" }, "os": "darwin", "cpu": "x64" }, "sha512-fyHac4jIc1ANYGRDxtiqelIbdWkIuQaI84Mv45KvGRRxSAa7o7d1ZKAOBaYbnepLC1WqxfpimdeWfvqqSGwR2Q=="],
 
     "@img/sharp-libvips-darwin-arm64": ["@img/sharp-libvips-darwin-arm64@1.2.4", "", { "os": "darwin", "cpu": "arm64" }, "sha512-zqjjo7RatFfFoP0MkQ51jfuFZBnVE2pRiaydKJ1G/rHZvnsrHAOcQALIi9sA5co5xenQdTugCvtb1cuf78Vf4g=="],
 
@@ -1173,9 +1232,9 @@
 
     "@img/sharp-libvips-linuxmusl-x64": ["@img/sharp-libvips-linuxmusl-x64@1.2.4", "", { "os": "linux", "cpu": "x64" }, "sha512-+LpyBk7L44ZIXwz/VYfglaX/okxezESc6UxDSoyo2Ks6Jxc4Y7sGjpgU9s4PMgqgjj1gZCylTieNamqA1MF7Dg=="],
 
-    "@img/sharp-linux-arm": ["@img/sharp-linux-arm@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-arm": "1.2.4" }, "os": "linux", "cpu": "arm" }, "sha512-9dLqsvwtg1uuXBGZKsxem9595+ujv0sJ6Vi8wcTANSFpwV/GONat5eCkzQo/1O6zRIkh0m/8+5BjrRr7jDUSZw=="],
+    "@img/sharp-linux-arm": ["@img/sharp-linux-arm@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-arm": "1.0.5" }, "os": "linux", "cpu": "arm" }, "sha512-JTS1eldqZbJxjvKaAkxhZmBqPRGmxgu+qFKSInv8moZ2AmT5Yib3EQ1c6gp493HvrvV8QgdOXdyaIBrhvFhBMQ=="],
 
-    "@img/sharp-linux-arm64": ["@img/sharp-linux-arm64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-arm64": "1.2.4" }, "os": "linux", "cpu": "arm64" }, "sha512-bKQzaJRY/bkPOXyKx5EVup7qkaojECG6NLYswgktOZjaXecSAeCWiZwwiFf3/Y+O1HrauiE3FVsGxFg8c24rZg=="],
+    "@img/sharp-linux-arm64": ["@img/sharp-linux-arm64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-arm64": "1.0.4" }, "os": "linux", "cpu": "arm64" }, "sha512-JMVv+AMRyGOHtO1RFBiJy/MBsgz0x4AWrT6QoEVVTyh1E39TrCUpTRI7mx9VksGX4awWASxqCYLCV4wBZHAYxA=="],
 
     "@img/sharp-linux-ppc64": ["@img/sharp-linux-ppc64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-ppc64": "1.2.4" }, "os": "linux", "cpu": "ppc64" }, "sha512-7zznwNaqW6YtsfrGGDA6BRkISKAAE1Jo0QdpNYXNMHu2+0dTrPflTLNkpc8l7MUP5M16ZJcUvysVWWrMefZquA=="],
 
@@ -1183,11 +1242,11 @@
 
     "@img/sharp-linux-s390x": ["@img/sharp-linux-s390x@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-s390x": "1.2.4" }, "os": "linux", "cpu": "s390x" }, "sha512-nQtCk0PdKfho3eC5MrbQoigJ2gd1CgddUMkabUj+rBevs8tZ2cULOx46E7oyX+04WGfABgIwmMC0VqieTiR4jg=="],
 
-    "@img/sharp-linux-x64": ["@img/sharp-linux-x64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-x64": "1.2.4" }, "os": "linux", "cpu": "x64" }, "sha512-MEzd8HPKxVxVenwAa+JRPwEC7QFjoPWuS5NZnBt6B3pu7EG2Ge0id1oLHZpPJdn3OQK+BQDiw9zStiHBTJQQQQ=="],
+    "@img/sharp-linux-x64": ["@img/sharp-linux-x64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-x64": "1.0.4" }, "os": "linux", "cpu": "x64" }, "sha512-opC+Ok5pRNAzuvq1AG0ar+1owsu842/Ab+4qvU879ippJBHvyY5n2mxF1izXqkPYlGuP/M556uh53jRLJmzTWA=="],
 
-    "@img/sharp-linuxmusl-arm64": ["@img/sharp-linuxmusl-arm64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linuxmusl-arm64": "1.2.4" }, "os": "linux", "cpu": "arm64" }, "sha512-fprJR6GtRsMt6Kyfq44IsChVZeGN97gTD331weR1ex1c1rypDEABN6Tm2xa1wE6lYb5DdEnk03NZPqA7Id21yg=="],
+    "@img/sharp-linuxmusl-arm64": ["@img/sharp-linuxmusl-arm64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-linuxmusl-arm64": "1.0.4" }, "os": "linux", "cpu": "arm64" }, "sha512-XrHMZwGQGvJg2V/oRSUfSAfjfPxO+4DkiRh6p2AFjLQztWUuY/o8Mq0eMQVIY7HJ1CDQUJlxGGZRw1a5bqmd1g=="],
 
-    "@img/sharp-linuxmusl-x64": ["@img/sharp-linuxmusl-x64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linuxmusl-x64": "1.2.4" }, "os": "linux", "cpu": "x64" }, "sha512-Jg8wNT1MUzIvhBFxViqrEhWDGzqymo3sV7z7ZsaWbZNDLXRJZoRGrjulp60YYtV4wfY8VIKcWidjojlLcWrd8Q=="],
+    "@img/sharp-linuxmusl-x64": ["@img/sharp-linuxmusl-x64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-linuxmusl-x64": "1.0.4" }, "os": "linux", "cpu": "x64" }, "sha512-WT+d/cgqKkkKySYmqoZ8y3pxx7lx9vVejxW/W4DOFMYVSkErR+w7mf2u8m/y4+xHe7yY9DAXQMWQhpnMuFfScw=="],
 
     "@img/sharp-wasm32": ["@img/sharp-wasm32@0.34.5", "", { "dependencies": { "@emnapi/runtime": "^1.7.0" }, "cpu": "none" }, "sha512-OdWTEiVkY2PHwqkbBI8frFxQQFekHaSSkUIJkwzclWZe64O1X4UlUjqqqLaPbUpMOQk6FBu/HtlGXNblIs0huw=="],
 
@@ -1195,7 +1254,7 @@
 
     "@img/sharp-win32-ia32": ["@img/sharp-win32-ia32@0.34.5", "", { "os": "win32", "cpu": "ia32" }, "sha512-FV9m/7NmeCmSHDD5j4+4pNI8Cp3aW+JvLoXcTUo0IqyjSfAZJ8dIUmijx1qaJsIiU+Hosw6xM5KijAWRJCSgNg=="],
 
-    "@img/sharp-win32-x64": ["@img/sharp-win32-x64@0.34.5", "", { "os": "win32", "cpu": "x64" }, "sha512-+29YMsqY2/9eFEiW93eqWnuLcWcufowXewwSNIT6UwZdUUCrM3oFjMWH/Z6/TMmb4hlFenmfAVbpWeup2jryCw=="],
+    "@img/sharp-win32-x64": ["@img/sharp-win32-x64@0.33.5", "", { "os": "win32", "cpu": "x64" }, "sha512-MpY/o8/8kj+EcnxwvrP4aTJSWw/aZ7JIGR4aBeZkZw5B7/Jn+tY9/VNwtcoGmdT7GfggGIU4kygOMSbYnOrAbg=="],
 
     "@isaacs/balanced-match": ["@isaacs/balanced-match@4.0.1", "", {}, "sha512-yzMTt9lEb8Gv7zRioUilSglI0c0smZ9k5D65677DLWLtWJaXIS3CqcGyUFByYKlnUj6TkjLVs54fBl6+TiGQDQ=="],
 
@@ -1243,6 +1302,20 @@
 
     "@linear/sdk": ["@linear/sdk@68.1.1", "", { "dependencies": { "@graphql-typed-document-node/core": "^3.1.0", "graphql": "^15.4.0" } }, "sha512-6IDbyEGsOFORRrG9fL9oQkZ1FAbdtV4W1qfT82gYPVh4UzefXQwNpljgR3Nsm1Tb11cZyf3reoJpPFqGcj01zw=="],
 
+    "@lmdb/lmdb-darwin-arm64": ["@lmdb/lmdb-darwin-arm64@3.5.1", "", { "os": "darwin", "cpu": "arm64" }, "sha512-tpfN4kKrrMpQ+If1l8bhmoNkECJi0iOu6AEdrTJvWVC+32sLxTARX5Rsu579mPImRP9YFWfWgeRQ5oav7zApQQ=="],
+
+    "@lmdb/lmdb-darwin-x64": ["@lmdb/lmdb-darwin-x64@3.5.1", "", { "os": "darwin", "cpu": "x64" }, "sha512-+a2tTfc3rmWhLAolFUWRgJtpSuu+Fw/yjn4rF406NMxhfjbMuiOUTDRvRlMFV+DzyjkwnokisskHbCWkS3Ly5w=="],
+
+    "@lmdb/lmdb-linux-arm": ["@lmdb/lmdb-linux-arm@3.5.1", "", { "os": "linux", "cpu": "arm" }, "sha512-0EgcE6reYr8InjD7V37EgXcYrloqpxVPINy3ig1MwDSbl6LF/vXTYRH9OE1Ti1D8YZnB35ZH9aTcdfSb5lql2A=="],
+
+    "@lmdb/lmdb-linux-arm64": ["@lmdb/lmdb-linux-arm64@3.5.1", "", { "os": "linux", "cpu": "arm64" }, "sha512-aoERa5B6ywXdyFeYGQ1gbQpkMkDbEo45qVoXE5QpIRavqjnyPwjOulMkmkypkmsbJ5z4Wi0TBztON8agCTG0Vg=="],
+
+    "@lmdb/lmdb-linux-x64": ["@lmdb/lmdb-linux-x64@3.5.1", "", { "os": "linux", "cpu": "x64" }, "sha512-SqNDY1+vpji7bh0sFH5wlWyFTOzjbDOl0/kB5RLLYDAFyd/uw3n7wyrmas3rYPpAW7z18lMOi1yKlTPv967E3g=="],
+
+    "@lmdb/lmdb-win32-arm64": ["@lmdb/lmdb-win32-arm64@3.5.1", "", { "os": "win32", "cpu": "arm64" }, "sha512-50v0O1Lt37cwrmR9vWZK5hRW0Aw+KEmxJJ75fge/zIYdvNKB/0bSMSVR5Uc2OV9JhosIUyklOmrEvavwNJ8D6w=="],
+
+    "@lmdb/lmdb-win32-x64": ["@lmdb/lmdb-win32-x64@3.5.1", "", { "os": "win32", "cpu": "x64" }, "sha512-qwosvPyl+zpUlp3gRb7UcJ3H8S28XHCzkv0Y0EgQToXjQP91ZD67EHSCDmaLjtKhe+GVIW5om1KUpzVLA0l6pg=="],
+
     "@malept/cross-spawn-promise": ["@malept/cross-spawn-promise@2.0.0", "", { "dependencies": { "cross-spawn": "^7.0.1" } }, "sha512-1DpKU0Z5ThltBwjNySMC14g0CkbyhCaz9FkhxqNsZI6uAPJXFS8cMXlBKo26FJ8ZuW6S9GCMcR9IO5k2X5/9Fg=="],
 
     "@malept/flatpak-bundler": ["@malept/flatpak-bundler@0.4.0", "", { "dependencies": { "debug": "^4.1.1", "fs-extra": "^9.0.0", "lodash": "^4.17.15", "tmp-promise": "^3.0.2" } }, "sha512-9QOtNffcOF/c1seMCDnjckb3R9WHcG34tky+FHpNKKCW0wc/scYLwMtO+ptyGUfMW0/b/n4qRiALlaFHc9Oj7Q=="],
@@ -1265,8 +1338,22 @@
 
     "@monogrid/gainmap-js": ["@monogrid/gainmap-js@3.4.0", "", { "dependencies": { "promise-worker-transferable": "^1.0.4" }, "peerDependencies": { "three": ">= 0.159.0" } }, "sha512-2Z0FATFHaoYJ8b+Y4y4Hgfn3FRFwuU5zRrk+9dFWp4uGAdHGqVEdP7HP+gLA3X469KXHmfupJaUbKo1b/aDKIg=="],
 
+    "@msgpackr-extract/msgpackr-extract-darwin-arm64": ["@msgpackr-extract/msgpackr-extract-darwin-arm64@3.0.3", "", { "os": "darwin", "cpu": "arm64" }, "sha512-QZHtlVgbAdy2zAqNA9Gu1UpIuI8Xvsd1v8ic6B2pZmeFnFcMWiPLfWXh7TVw4eGEZ/C9TH281KwhVoeQUKbyjw=="],
+
+    "@msgpackr-extract/msgpackr-extract-darwin-x64": ["@msgpackr-extract/msgpackr-extract-darwin-x64@3.0.3", "", { "os": "darwin", "cpu": "x64" }, "sha512-mdzd3AVzYKuUmiWOQ8GNhl64/IoFGol569zNRdkLReh6LRLHOXxU4U8eq0JwaD8iFHdVGqSy4IjFL4reoWCDFw=="],
+
+    "@msgpackr-extract/msgpackr-extract-linux-arm": ["@msgpackr-extract/msgpackr-extract-linux-arm@3.0.3", "", { "os": "linux", "cpu": "arm" }, "sha512-fg0uy/dG/nZEXfYilKoRe7yALaNmHoYeIoJuJ7KJ+YyU2bvY8vPv27f7UKhGRpY6euFYqEVhxCFZgAUNQBM3nw=="],
+
+    "@msgpackr-extract/msgpackr-extract-linux-arm64": ["@msgpackr-extract/msgpackr-extract-linux-arm64@3.0.3", "", { "os": "linux", "cpu": "arm64" }, "sha512-YxQL+ax0XqBJDZiKimS2XQaf+2wDGVa1enVRGzEvLLVFeqa5kx2bWbtcSXgsxjQB7nRqqIGFIcLteF/sHeVtQg=="],
+
+    "@msgpackr-extract/msgpackr-extract-linux-x64": ["@msgpackr-extract/msgpackr-extract-linux-x64@3.0.3", "", { "os": "linux", "cpu": "x64" }, "sha512-cvwNfbP07pKUfq1uH+S6KJ7dT9K8WOE4ZiAcsrSes+UY55E/0jLYc+vq+DO7jlmqRb5zAggExKm0H7O/CBaesg=="],
+
+    "@msgpackr-extract/msgpackr-extract-win32-x64": ["@msgpackr-extract/msgpackr-extract-win32-x64@3.0.3", "", { "os": "win32", "cpu": "x64" }, "sha512-x0fWaQtYp4E6sktbsdAqnehxDgEc/VwM7uLsRCYWaiGu0ykYdZPiS8zCWdnjHwyiumousxfBm4SO31eXqwEZhQ=="],
+
     "@neondatabase/serverless": ["@neondatabase/serverless@1.0.2", "", { "dependencies": { "@types/node": "^22.15.30", "@types/pg": "^8.8.0" } }, "sha512-I5sbpSIAHiB+b6UttofhrN/UJXII+4tZPAq1qugzwCwLIL8EZLV7F/JyHUrEIiGgQpEXzpnjlJ+zwcEhheGvCw=="],
 
+    "@neophi/sieve-cache": ["@neophi/sieve-cache@1.5.0", "", {}, "sha512-9T3nD5q51X1d4QYW6vouKW9hBSb2Tb/wB/2XoTr4oP5SCGtp3a7aTHHewQFylred1B21/Bhev6gy4x01FPBcbQ=="],
+
     "@next/env": ["@next/env@16.1.6", "", {}, "sha512-N1ySLuZjnAtN3kFnwhAwPvZah8RJxKasD7x1f8shFqhncnWZn4JMfg37diLNuoHsLAlrDfM3g4mawVdtAG8XLQ=="],
 
     "@next/swc-darwin-arm64": ["@next/swc-darwin-arm64@16.1.6", "", { "os": "darwin", "cpu": "arm64" }, "sha512-wTzYulosJr/6nFnqGW7FrG3jfUUlEf8UjGA0/pyypJl42ExdVgC6xJgcXQ+V8QFn6niSG2Pb8+MIG1mZr2vczw=="],
@@ -1795,6 +1882,8 @@
 
     "@superset/admin": ["@superset/admin@workspace:apps/admin"],
 
+    "@superset/ai-chat": ["@superset/ai-chat@workspace:packages/ai-chat"],
+
     "@superset/api": ["@superset/api@workspace:apps/api"],
 
     "@superset/auth": ["@superset/auth@workspace:packages/auth"],
@@ -1821,6 +1910,8 @@
 
     "@superset/shared": ["@superset/shared@workspace:packages/shared"],
 
+    "@superset/streams": ["@superset/streams@workspace:apps/streams"],
+
     "@superset/trpc": ["@superset/trpc@workspace:packages/trpc"],
 
     "@superset/typescript": ["@superset/typescript@workspace:tooling/typescript"],
@@ -1871,11 +1962,11 @@
 
     "@tailwindcss/vite": ["@tailwindcss/vite@4.1.18", "", { "dependencies": { "@tailwindcss/node": "4.1.18", "@tailwindcss/oxide": "4.1.18", "tailwindcss": "4.1.18" }, "peerDependencies": { "vite": "^5.2.0 || ^6 || ^7" } }, "sha512-jVA+/UpKL1vRLg6Hkao5jldawNmRo7mQYrZtNHMIVpLfLhDml5nMRUo/8MwoX2vNXvnaXNNMedrMfMugAVX1nA=="],
 
-    "@tanstack/db": ["@tanstack/db@0.5.22", "", { "dependencies": { "@standard-schema/spec": "^1.1.0", "@tanstack/db-ivm": "0.1.17", "@tanstack/pacer-lite": "^0.2.0" }, "peerDependencies": { "typescript": ">=4.7" } }, "sha512-Qh33d9Idw7lEa/sg7veJfG8EUmSMtBzRkk/ghAVIDA3MJWAjyGOzU29TVZaM7K36BegTL8T/yVVlAFqjn/G2pw=="],
+    "@tanstack/db": ["@tanstack/db@0.5.25", "", { "dependencies": { "@standard-schema/spec": "^1.1.0", "@tanstack/db-ivm": "0.1.17", "@tanstack/pacer-lite": "^0.2.0" }, "peerDependencies": { "typescript": ">=4.7" } }, "sha512-VqVchs6Mm4rw2GyiOkaoD+PJw6lCJT8EI/TzPu8KWZy3QxyOlilpMvEuDTCl0LZdp1iLYlQT1NdgDg0gimV3kQ=="],
 
     "@tanstack/db-ivm": ["@tanstack/db-ivm@0.1.17", "", { "dependencies": { "fractional-indexing": "^3.2.0", "sorted-btree": "^1.8.1" }, "peerDependencies": { "typescript": ">=4.7" } }, "sha512-DK7vm56CDxNuRAdsbiPs+gITJ+16tUtYgZg3BRTLYKGIDsy8sdIO7sQFq5zl7Y+aIKAPmMAbVp9UjJ75FTtwgQ=="],
 
-    "@tanstack/electric-db-collection": ["@tanstack/electric-db-collection@0.2.27", "", { "dependencies": { "@electric-sql/client": "^1.3.1", "@standard-schema/spec": "^1.1.0", "@tanstack/db": "0.5.22", "@tanstack/store": "^0.8.0", "debug": "^4.4.3" } }, "sha512-nCJosh3GV8iX0w5b1LNys8a6l8k0I28bU86Zw3lIN/xN/blZ/dOO7nVDWE+jFBfu7UWYK2qFSzHATPKezWrHfw=="],
+    "@tanstack/electric-db-collection": ["@tanstack/electric-db-collection@0.2.30", "", { "dependencies": { "@electric-sql/client": "^1.3.1", "@standard-schema/spec": "^1.1.0", "@tanstack/db": "0.5.24", "@tanstack/store": "^0.8.0", "debug": "^4.4.3" } }, "sha512-fQKMKNrsza/XClcg1uMw9hy7F/43LmNRvtosRz6l8ghGeSBER8zzg3NZI8E0NS4KXzB9zUqW3ywLwP1nd4+lRg=="],
 
     "@tanstack/history": ["@tanstack/history@1.154.14", "", {}, "sha512-xyIfof8eHBuub1CkBnbKNKQXeRZC4dClhmzePHVOEel4G7lk/dW+TQ16da7CFdeNLv6u6Owf5VoBQxoo6DFTSA=="],
 
@@ -1885,7 +1976,7 @@
 
     "@tanstack/query-devtools": ["@tanstack/query-devtools@5.93.0", "", {}, "sha512-+kpsx1NQnOFTZsw6HAFCW3HkKg0+2cepGtAWXjiiSOJJ1CtQpt72EE2nyZb+AjAbLRPoeRmPJ8MtQd8r8gsPdg=="],
 
-    "@tanstack/react-db": ["@tanstack/react-db@0.1.66", "", { "dependencies": { "@tanstack/db": "0.5.22", "use-sync-external-store": "^1.6.0" }, "peerDependencies": { "react": ">=16.8.0" } }, "sha512-BEFrXv0pa3KPZfLmfrR6KU1QwUtDPQoV/PdJYGhVEsOwYf61yVQkuFOqK2aGYOynipMdACl5N6TXs82mS4fB6A=="],
+    "@tanstack/react-db": ["@tanstack/react-db@0.1.69", "", { "dependencies": { "@tanstack/db": "0.5.25", "use-sync-external-store": "^1.6.0" }, "peerDependencies": { "react": ">=16.8.0" } }, "sha512-rqhajRK5InIEKT9RABE9zNbYZL5NGkySjGNVANyilu/ADFHV8rhtkMEnhHcbrzv0grIKpcSlx1AvTgJNbbzjkw=="],
 
     "@tanstack/react-query": ["@tanstack/react-query@5.90.20", "", { "dependencies": { "@tanstack/query-core": "5.90.20" }, "peerDependencies": { "react": "^18 || ^19" } }, "sha512-vXBxa+qeyveVO7OA0jX1z+DeyCA4JKnThKv411jd5SORpBKgkcVnYKCiBgECvADvniBX7tobwBmg01qq9JmMJw=="],
 
@@ -2021,6 +2112,8 @@
 
     "@types/cacheable-request": ["@types/cacheable-request@6.0.3", "", { "dependencies": { "@types/http-cache-semantics": "*", "@types/keyv": "^3.1.4", "@types/node": "*", "@types/responselike": "^1.0.0" } }, "sha512-IQ3EbTzGxIigb1I3qPZc1rWJnH0BmSKv5QYTalEwweFvyBDLSAe24zP0le/hyi7ecGfZVlIVAg4BZqb8WBwKqw=="],
 
+    "@types/chai": ["@types/chai@5.2.3", "", { "dependencies": { "@types/deep-eql": "*", "assertion-error": "^2.0.1" } }, "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA=="],
+
     "@types/connect": ["@types/connect@3.4.38", "", { "dependencies": { "@types/node": "*" } }, "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug=="],
 
     "@types/cors": ["@types/cors@2.8.19", "", { "dependencies": { "@types/node": "*" } }, "sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg=="],
@@ -2091,6 +2184,8 @@
 
     "@types/debug": ["@types/debug@4.1.12", "", { "dependencies": { "@types/ms": "*" } }, "sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ=="],
 
+    "@types/deep-eql": ["@types/deep-eql@4.0.2", "", {}, "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw=="],
+
     "@types/draco3d": ["@types/draco3d@1.4.10", "", {}, "sha512-AX22jp8Y7wwaBgAixaSvkoG4M/+PlAcm3Qs4OW8yT9DM4xUpWKeFhLueTAyZF39pviAdcDdeJoACapiAceqNcw=="],
 
     "@types/eslint": ["@types/eslint@9.6.1", "", { "dependencies": { "@types/estree": "*", "@types/json-schema": "*" } }, "sha512-FXx2pKgId/WyYo2jXw63kk7/+TY7u7AziEJxJAnSFzHlqTAS3Ync6SvgYAN/k4/PQpnnVuzoMuVnByKK2qp0ag=="],
@@ -2251,6 +2346,20 @@
 
     "@vitejs/plugin-react": ["@vitejs/plugin-react@5.1.3", "", { "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.2", "@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" } }, "sha512-NVUnA6gQCl8jfoYqKqQU5Clv0aPw14KkZYCsX6T9Lfu9slI0LOU10OTwFHS/WmptsMMpshNd/1tuWsHQ2Uk+cg=="],
 
+    "@vitest/expect": ["@vitest/expect@4.0.18", "", { "dependencies": { "@standard-schema/spec": "^1.0.0", "@types/chai": "^5.2.2", "@vitest/spy": "4.0.18", "@vitest/utils": "4.0.18", "chai": "^6.2.1", "tinyrainbow": "^3.0.3" } }, "sha512-8sCWUyckXXYvx4opfzVY03EOiYVxyNrHS5QxX3DAIi5dpJAAkyJezHCP77VMX4HKA2LDT/Jpfo8i2r5BE3GnQQ=="],
+
+    "@vitest/mocker": ["@vitest/mocker@4.0.18", "", { "dependencies": { "@vitest/spy": "4.0.18", "estree-walker": "^3.0.3", "magic-string": "^0.30.21" }, "peerDependencies": { "msw": "^2.4.9", "vite": "^6.0.0 || ^7.0.0-0" }, "optionalPeers": ["msw", "vite"] }, "sha512-HhVd0MDnzzsgevnOWCBj5Otnzobjy5wLBe4EdeeFGv8luMsGcYqDuFRMcttKWZA5vVO8RFjexVovXvAM4JoJDQ=="],
+
+    "@vitest/pretty-format": ["@vitest/pretty-format@4.0.18", "", { "dependencies": { "tinyrainbow": "^3.0.3" } }, "sha512-P24GK3GulZWC5tz87ux0m8OADrQIUVDPIjjj65vBXYG17ZeU3qD7r+MNZ1RNv4l8CGU2vtTRqixrOi9fYk/yKw=="],
+
+    "@vitest/runner": ["@vitest/runner@4.0.18", "", { "dependencies": { "@vitest/utils": "4.0.18", "pathe": "^2.0.3" } }, "sha512-rpk9y12PGa22Jg6g5M3UVVnTS7+zycIGk9ZNGN+m6tZHKQb7jrP7/77WfZy13Y/EUDd52NDsLRQhYKtv7XfPQw=="],
+
+    "@vitest/snapshot": ["@vitest/snapshot@4.0.18", "", { "dependencies": { "@vitest/pretty-format": "4.0.18", "magic-string": "^0.30.21", "pathe": "^2.0.3" } }, "sha512-PCiV0rcl7jKQjbgYqjtakly6T1uwv/5BQ9SwBLekVg/EaYeQFPiXcgrC2Y7vDMA8dM1SUEAEV82kgSQIlXNMvA=="],
+
+    "@vitest/spy": ["@vitest/spy@4.0.18", "", {}, "sha512-cbQt3PTSD7P2OARdVW3qWER5EGq7PHlvE+QfzSC0lbwO+xnt7+XH06ZzFjFRgzUX//JmpxrCu92VdwvEPlWSNw=="],
+
+    "@vitest/utils": ["@vitest/utils@4.0.18", "", { "dependencies": { "@vitest/pretty-format": "4.0.18", "tinyrainbow": "^3.0.3" } }, "sha512-msMRKLMVLWygpK3u2Hybgi4MNjcYJvwTb0Ru09+fOyCXIgT5raYP041DRRdiJiI3k/2U6SEbAETB3YtBrUkCFA=="],
+
     "@vue/compiler-core": ["@vue/compiler-core@3.5.27", "", { "dependencies": { "@babel/parser": "^7.28.5", "@vue/shared": "3.5.27", "entities": "^7.0.0", "estree-walker": "^2.0.2", "source-map-js": "^1.2.1" } }, "sha512-gnSBQjZA+//qDZen+6a2EdHqJ68Z7uybrMf3SPjEGgG4dicklwDVmMC1AeIHxtLVPT7sn6sH1KOO+tS6gwOUeQ=="],
 
     "@vue/compiler-dom": ["@vue/compiler-dom@3.5.27", "", { "dependencies": { "@vue/compiler-core": "3.5.27", "@vue/shared": "3.5.27" } }, "sha512-oAFea8dZgCtVVVTEC7fv3T5CbZW9BxpFzGGxC79xakTr6ooeEqmRuvQydIiDAkglZEAd09LgVf1RoDnL54fu5w=="],
@@ -2383,6 +2492,8 @@
 
     "assert-plus": ["assert-plus@1.0.0", "", {}, "sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw=="],
 
+    "assertion-error": ["assertion-error@2.0.1", "", {}, "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA=="],
+
     "ast-types": ["ast-types@0.16.1", "", { "dependencies": { "tslib": "^2.0.1" } }, "sha512-6t10qk83GOG8p0vKmaCr8eiilZwO171AvbROMtvvNiwrTly62t+7XkA8RdIIVbpMhCASAsxgAzdRSwh6nw/5Dg=="],
 
     "astral-regex": ["astral-regex@2.0.0", "", {}, "sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ=="],
@@ -2501,6 +2612,8 @@
 
     "bun-types": ["bun-types@1.3.8", "", { "dependencies": { "@types/node": "*" } }, "sha512-fL99nxdOWvV4LqjmC+8Q9kW3M4QTtTR1eePs94v5ctGqU8OeceWrSUaRw3JYb7tU3FkMIAjkueehrHPPPGKi5Q=="],
 
+    "bundle-require": ["bundle-require@5.1.0", "", { "dependencies": { "load-tsconfig": "^0.2.3" }, "peerDependencies": { "esbuild": ">=0.18" } }, "sha512-3WrrOuZiyaaZPWiEt4G3+IffISVC9HYlWueJEBWED4ZH4aIAC2PnkdnuRrR94M+w6yGWn4AglWtJtBI8YqvgoA=="],
+
     "bytes": ["bytes@3.1.2", "", {}, "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg=="],
 
     "cac": ["cac@6.7.14", "", {}, "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ=="],
@@ -2529,6 +2642,8 @@
 
     "ccount": ["ccount@2.0.1", "", {}, "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg=="],
 
+    "chai": ["chai@6.2.2", "", {}, "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg=="],
+
     "chalk": ["chalk@5.6.2", "", {}, "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA=="],
 
     "character-entities": ["character-entities@2.0.2", "", {}, "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ=="],
@@ -2941,7 +3056,7 @@
 
     "es-errors": ["es-errors@1.3.0", "", {}, "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="],
 
-    "es-module-lexer": ["es-module-lexer@2.0.0", "", {}, "sha512-5POEcUuZybH7IdmGsD8wlf0AI55wMecM9rVBTI/qEAy2c1kTOm3DjFYjrBdI2K3BaJjJYfYFeRtM0t9ssnRuxw=="],
+    "es-module-lexer": ["es-module-lexer@1.7.0", "", {}, "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA=="],
 
     "es-object-atoms": ["es-object-atoms@1.1.1", "", { "dependencies": { "es-errors": "^1.3.0" } }, "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA=="],
 
@@ -3009,6 +3124,8 @@
 
     "expand-template": ["expand-template@2.0.3", "", {}, "sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg=="],
 
+    "expect-type": ["expect-type@1.3.0", "", {}, "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA=="],
+
     "expo": ["expo@54.0.33", "", { "dependencies": { "@babel/runtime": "^7.20.0", "@expo/cli": "54.0.23", "@expo/config": "~12.0.13", "@expo/config-plugins": "~54.0.4", "@expo/devtools": "0.1.8", "@expo/fingerprint": "0.15.4", "@expo/metro": "~54.2.0", "@expo/metro-config": "54.0.14", "@expo/vector-icons": "^15.0.3", "@ungap/structured-clone": "^1.3.0", "babel-preset-expo": "~54.0.10", "expo-asset": "~12.0.12", "expo-constants": "~18.0.13", "expo-file-system": "~19.0.21", "expo-font": "~14.0.11", "expo-keep-awake": "~15.0.8", "expo-modules-autolinking": "3.0.24", "expo-modules-core": "3.0.29", "pretty-format": "^29.7.0", "react-refresh": "^0.14.2", "whatwg-url-without-unicode": "8.0.0-3" }, "peerDependencies": { "@expo/dom-webview": "*", "@expo/metro-runtime": "*", "react": "*", "react-native": "*", "react-native-webview": "*" }, "optionalPeers": ["@expo/dom-webview", "@expo/metro-runtime", "react-native-webview"], "bin": { "expo": "bin/cli", "fingerprint": "bin/fingerprint", "expo-modules-autolinking": "bin/autolinking" } }, "sha512-3yOEfAKqo+gqHcV8vKcnq0uA5zxlohnhA3fu4G43likN8ct5ZZ3LjAh9wDdKteEkoad3tFPvwxmXW711S5OHUw=="],
 
     "expo-application": ["expo-application@7.0.8", "", { "peerDependencies": { "expo": "*" } }, "sha512-qFGyxk7VJbrNOQWBbE09XUuGuvkOgFS9QfToaK2FdagM2aQ+x3CvGV2DuVgl/l4ZxPgIf3b/MNh9xHpwSwn74Q=="],
@@ -3081,6 +3198,8 @@
 
     "fast-base64-decode": ["fast-base64-decode@1.0.0", "", {}, "sha512-qwaScUgUGBYeDNRnbc/KyllVU88Jk1pRHPStuF/lO7B0/RTRLj7U0lkdTAutlBblY08rwZDff6tNU9cjv6j//Q=="],
 
+    "fast-check": ["fast-check@4.5.3", "", { "dependencies": { "pure-rand": "^7.0.0" } }, "sha512-IE9csY7lnhxBnA8g/WI5eg/hygA6MGWJMSNfFRrBlXUciADEhS1EDB0SIsMSvzubzIlOBbVITSsypCsW717poA=="],
+
     "fast-content-type-parse": ["fast-content-type-parse@3.0.0", "", {}, "sha512-ZvLdcY8P+N8mGQJahJV5G4U88CSvT1rP8ApL6uETe88MBXrBHAkZlSEySdUlyztF7ccb+Znos3TFqaepHxdhBg=="],
 
     "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="],
@@ -3121,6 +3240,8 @@
 
     "find-up": ["find-up@5.0.0", "", { "dependencies": { "locate-path": "^6.0.0", "path-exists": "^4.0.0" } }, "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng=="],
 
+    "fix-dts-default-cjs-exports": ["fix-dts-default-cjs-exports@1.0.1", "", { "dependencies": { "magic-string": "^0.30.17", "mlly": "^1.7.4", "rollup": "^4.34.8" } }, "sha512-pVIECanWFC61Hzl2+oOCtoJ3F17kglZC/6N94eRWycFgBH35hHx0Li604ZIzhseh97mf2p0cv7vVrOZGoqhlEg=="],
+
     "flow-enums-runtime": ["flow-enums-runtime@0.0.6", "", {}, "sha512-3PYnM29RFXwvAN6Pc/scUfkI7RwhQ/xqyLUyPNlXUp9S40zI8nup9tUSrTLSVnWGBN38FNiGWbwZOB6uR4OGdw=="],
 
     "follow-redirects": ["follow-redirects@1.15.11", "", {}, "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ=="],
@@ -3477,6 +3598,8 @@
 
     "jose": ["jose@6.1.3", "", {}, "sha512-0TpaTfihd4QMNwrz/ob2Bp7X04yuxJkjRGi4aKmOqwhov54i6u79oCv7T+C7lo70MKH6BesI3vscD1yb/yzKXQ=="],
 
+    "joycon": ["joycon@3.1.1", "", {}, "sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw=="],
+
     "js-base64": ["js-base64@3.7.8", "", {}, "sha512-hNngCeKxIUQiEUN3GPJOkz4wF/YvdUdbNL9hsBcMQTkKzboD7T/q3OYOuuPZLUE6dBxSGpwhk5mwuDud7JVAow=="],
 
     "js-string-escape": ["js-string-escape@1.0.1", "", {}, "sha512-Smw4xcfIQ5LVjAOuJCvN/zIodzA/BBSsluuoSykP+lUvScIi4U6RJLfwHet5cxFnCswUjISV8oAXaqaJDY3chg=="],
@@ -3565,6 +3688,8 @@
 
     "lightningcss-win32-x64-msvc": ["lightningcss-win32-x64-msvc@1.30.2", "", { "os": "win32", "cpu": "x64" }, "sha512-5g1yc73p+iAkid5phb4oVFMB45417DkRevRbt/El/gKXJk4jid+vPFF/AXbxn05Aky8PapwzZrdJShv5C0avjw=="],
 
+    "lilconfig": ["lilconfig@3.1.3", "", {}, "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw=="],
+
     "line-column-path": ["line-column-path@3.0.0", "", { "dependencies": { "type-fest": "^2.0.0" } }, "sha512-Atocnm7Wr9nuvAn97yEPQa3pcQI5eLQGBz+m6iTb+CVw+IOzYB9MrYK7jI7BfC9ISnT4Fu0eiwhAScV//rp4Hw=="],
 
     "lines-and-columns": ["lines-and-columns@1.2.4", "", {}, "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg=="],
@@ -3573,8 +3698,12 @@
 
     "linkifyjs": ["linkifyjs@4.3.2", "", {}, "sha512-NT1CJtq3hHIreOianA8aSXn6Cw0JzYOuDQbOrSPe7gqFnCpKP++MQe3ODgO3oh2GJFORkAAdqredOa60z63GbA=="],
 
+    "lmdb": ["lmdb@3.5.1", "", { "dependencies": { "@harperfast/extended-iterable": "^1.0.3", "msgpackr": "^1.11.2", "node-addon-api": "^6.1.0", "node-gyp-build-optional-packages": "5.2.2", "ordered-binary": "^1.5.3", "weak-lru-cache": "^1.2.2" }, "optionalDependencies": { "@lmdb/lmdb-darwin-arm64": "3.5.1", "@lmdb/lmdb-darwin-x64": "3.5.1", "@lmdb/lmdb-linux-arm": "3.5.1", "@lmdb/lmdb-linux-arm64": "3.5.1", "@lmdb/lmdb-linux-x64": "3.5.1", "@lmdb/lmdb-win32-arm64": "3.5.1", "@lmdb/lmdb-win32-x64": "3.5.1" }, "bin": { "download-lmdb-prebuilds": "bin/download-prebuilds.js" } }, "sha512-NYHA0MRPjvNX+vSw8Xxg6FLKxzAG+e7Pt8RqAQA/EehzHVXq9SxDqJIN3JL1hK0dweb884y8kIh6rkWvPyg9Wg=="],
+
     "load-json-file": ["load-json-file@7.0.1", "", {}, "sha512-Gnxj3ev3mB5TkVBGad0JM6dmLiQL+o0t23JPBZ9sd+yvSLk05mFoqKBw5N8gbbkU4TNXyqCgIrl/VM17OgUIgQ=="],
 
+    "load-tsconfig": ["load-tsconfig@0.2.5", "", {}, "sha512-IXO6OCs9yg8tMKzfPZ1YmheJbZCiEsnBdcB03l0OcfK9prKnJb96siuHCr5Fl37/yo9DnKU+TLpxzTUspw9shg=="],
+
     "loader-runner": ["loader-runner@4.3.1", "", {}, "sha512-IWqP2SCPhyVFTBtRcgMHdzlf9ul25NwaFx4wCEH/KjAXuuHY4yNjvPXsBokp8jCB936PyWRaPKUNh8NvylLp2Q=="],
 
     "locate-path": ["locate-path@6.0.0", "", { "dependencies": { "p-locate": "^5.0.0" } }, "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw=="],
@@ -3865,6 +3994,10 @@
 
     "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
 
+    "msgpackr": ["msgpackr@1.11.8", "", { "optionalDependencies": { "msgpackr-extract": "^3.0.2" } }, "sha512-bC4UGzHhVvgDNS7kn9tV8fAucIYUBuGojcaLiz7v+P63Lmtm0Xeji8B/8tYKddALXxJLpwIeBmUN3u64C4YkRA=="],
+
+    "msgpackr-extract": ["msgpackr-extract@3.0.3", "", { "dependencies": { "node-gyp-build-optional-packages": "5.2.2" }, "optionalDependencies": { "@msgpackr-extract/msgpackr-extract-darwin-arm64": "3.0.3", "@msgpackr-extract/msgpackr-extract-darwin-x64": "3.0.3", "@msgpackr-extract/msgpackr-extract-linux-arm": "3.0.3", "@msgpackr-extract/msgpackr-extract-linux-arm64": "3.0.3", "@msgpackr-extract/msgpackr-extract-linux-x64": "3.0.3", "@msgpackr-extract/msgpackr-extract-win32-x64": "3.0.3" }, "bin": { "download-msgpackr-prebuilds": "bin/download-prebuilds.js" } }, "sha512-P0efT1C9jIdVRefqjzOQ9Xml57zpOXnIuS+csaB4MdZbTdmGDLo8XhzBG1N7aO11gKDDkJvBLULeFTo46wwreA=="],
+
     "mz": ["mz@2.7.0", "", { "dependencies": { "any-promise": "^1.0.0", "object-assign": "^4.0.1", "thenify-all": "^1.0.0" } }, "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q=="],
 
     "nanoid": ["nanoid@5.1.6", "", { "bin": { "nanoid": "bin/nanoid.js" } }, "sha512-c7+7RQ+dMB5dPwwCp4ee1/iV/q2P6aK1mTZcfr1BTuVlyW9hJYiMPybJCcnBlQtuSmTIWNeazm/zqNoZSSElBg=="],
@@ -3899,6 +4032,8 @@
 
     "node-gyp": ["node-gyp@11.5.0", "", { "dependencies": { "env-paths": "^2.2.0", "exponential-backoff": "^3.1.1", "graceful-fs": "^4.2.6", "make-fetch-happen": "^14.0.3", "nopt": "^8.0.0", "proc-log": "^5.0.0", "semver": "^7.3.5", "tar": "^7.4.3", "tinyglobby": "^0.2.12", "which": "^5.0.0" }, "bin": { "node-gyp": "bin/node-gyp.js" } }, "sha512-ra7Kvlhxn5V9Slyus0ygMa2h+UqExPqUIkfk7Pc8QTLT956JLSy51uWFwHtIYy0vI8cB4BDhc/S03+880My/LQ=="],
 
+    "node-gyp-build-optional-packages": ["node-gyp-build-optional-packages@5.2.2", "", { "dependencies": { "detect-libc": "^2.0.1" }, "bin": { "node-gyp-build-optional-packages": "bin.js", "node-gyp-build-optional-packages-optional": "optional.js", "node-gyp-build-optional-packages-test": "build-test.js" } }, "sha512-s+w+rBWnpTMwSFbaE0UXsRlg7hU4FjekKU4eyAih5T8nJuNZT1nNsskXpxmeqSK9UzkBl6UgRlnKc8hz8IEqOw=="],
+
     "node-int64": ["node-int64@0.4.0", "", {}, "sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw=="],
 
     "node-pty": ["node-pty@1.1.0", "", { "dependencies": { "node-addon-api": "^7.1.0" } }, "sha512-20JqtutY6JPXTUnL0ij1uad7Qe1baT46lyolh2sSENDd4sTzKZ4nmAFkeAARDKwmlLjPx6XKRlwRUxwjOy+lUg=="],
@@ -3937,6 +4072,8 @@
 
     "object-keys": ["object-keys@1.1.1", "", {}, "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA=="],
 
+    "obug": ["obug@2.1.1", "", {}, "sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ=="],
+
     "on-finished": ["on-finished@2.4.1", "", { "dependencies": { "ee-first": "1.1.1" } }, "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg=="],
 
     "on-headers": ["on-headers@1.1.0", "", {}, "sha512-737ZY3yNnXy37FHkQxPzt4UZ2UWPWiCZWLvFZ4fu5cueciegX0zGPnrlY6bwRg4FdQOe9YU8MkmJwGhoMybl8A=="],
@@ -3955,6 +4092,8 @@
 
     "ora": ["ora@8.2.0", "", { "dependencies": { "chalk": "^5.3.0", "cli-cursor": "^5.0.0", "cli-spinners": "^2.9.2", "is-interactive": "^2.0.0", "is-unicode-supported": "^2.0.0", "log-symbols": "^6.0.0", "stdin-discarder": "^0.2.2", "string-width": "^7.2.0", "strip-ansi": "^7.1.0" } }, "sha512-weP+BZ8MVNnlCm8c0Qdc1WSWq4Qn7I+9CJGm7Qali6g44e/PUzbjNqJX5NJ9ljlNMosfJvg1fKEGILklK9cwnw=="],
 
+    "ordered-binary": ["ordered-binary@1.6.1", "", {}, "sha512-QkCdPooczexPLiXIrbVOPYkR3VO3T6v2OyKRkR1Xbhpy7/LAVXwahnRCgRp78Oe/Ehf0C/HATAxfSr6eA1oX+w=="],
+
     "orderedmap": ["orderedmap@2.1.1", "", {}, "sha512-TvAWxi0nDe1j/rtMcWcIj94+Ffe6n7zhow33h40SKxmsmozs6dz/e+EajymfoFcHd7sxNn8yHM8839uixMOV6g=="],
 
     "os-locale": ["os-locale@6.0.2", "", { "dependencies": { "lcid": "^3.1.1" } }, "sha512-qIb8bzRqaN/vVqEYZ7lTAg6PonskO7xOmM7OClD28F6eFa4s5XGe4bGpHUHMoCHbNNuR0pDYFeSLiW5bnjWXIA=="],
@@ -4063,6 +4202,8 @@
 
     "postcss": ["postcss@8.5.6", "", { "dependencies": { "nanoid": "^3.3.11", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg=="],
 
+    "postcss-load-config": ["postcss-load-config@6.0.1", "", { "dependencies": { "lilconfig": "^3.1.1" }, "peerDependencies": { "jiti": ">=1.21.0", "postcss": ">=8.0.9", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["jiti", "postcss", "tsx", "yaml"] }, "sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g=="],
+
     "postcss-selector-parser": ["postcss-selector-parser@6.0.10", "", { "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" } }, "sha512-IQ7TZdoaqbT+LCpShg46jnZVlhWD2w6iQYAcYXfHARZ7X1t/UGhhceQDs5X0cGqKvYlHNOuv7Oa1xmb0oQuA3w=="],
 
     "postgres-array": ["postgres-array@2.0.0", "", {}, "sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA=="],
@@ -4165,6 +4306,8 @@
 
     "punycode.js": ["punycode.js@2.3.1", "", {}, "sha512-uxFIHU0YlHYhDQtV4R9J6a52SLx28BCjT+4ieh7IGbgwVJWO+km431c4yRlREUAsAmt/uMjQUyQHNEPf0M39CA=="],
 
+    "pure-rand": ["pure-rand@7.0.1", "", {}, "sha512-oTUZM/NAZS8p7ANR3SHh30kXB+zK2r2BPcEn/awJIbOvq82WoMN4p62AWWp3Hhw50G0xMsw1mhIBLqHw64EcNQ=="],
+
     "qrcode-terminal": ["qrcode-terminal@0.11.0", "", { "bin": { "qrcode-terminal": "./bin/qrcode-terminal.js" } }, "sha512-Uu7ii+FQy4Qf82G4xu7ShHhjhGahEpCWc3x8UavY3CTcWV+ufmmCtwkr7ZKsX42jdL0kr1B5FKUeqJvAn51jzQ=="],
 
     "qs": ["qs@6.14.1", "", { "dependencies": { "side-channel": "^1.1.0" } }, "sha512-4EK3+xJl8Ts67nLYNwqw/dsFVnCf+qR7RgXSK9jEEm9unao3njwMDdmsdvoKBKHzxd7tCYz5e5M+SnMjdtXGQQ=="],
@@ -4507,6 +4650,8 @@
 
     "side-channel-weakmap": ["side-channel-weakmap@1.0.2", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3", "side-channel-map": "^1.0.1" } }, "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A=="],
 
+    "siginfo": ["siginfo@2.0.0", "", {}, "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g=="],
+
     "signal-exit": ["signal-exit@3.0.7", "", {}, "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ=="],
 
     "simple-concat": ["simple-concat@1.0.1", "", {}, "sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q=="],
@@ -4573,6 +4718,8 @@
 
     "stack-utils": ["stack-utils@2.0.6", "", { "dependencies": { "escape-string-regexp": "^2.0.0" } }, "sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ=="],
 
+    "stackback": ["stackback@0.0.2", "", {}, "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw=="],
+
     "stackframe": ["stackframe@1.3.4", "", {}, "sha512-oeVtt7eWQS+Na6F//S4kJ2K2VbRlS9D43mAlMyVpVWovy9o+jfgH8O9agzANzaiLjclA0oYzUXEM4PurhSUChw=="],
 
     "stacktrace-parser": ["stacktrace-parser@0.1.11", "", { "dependencies": { "type-fest": "^0.7.1" } }, "sha512-WjlahMgHmCJpqzU8bIBy4qtsZdU9lRlcZE3Lvyej6t4tuOuv1vk57OW3MBrj6hXBFx/nNoC9MPMTcr5YA7NQbg=="],
@@ -4587,6 +4734,8 @@
 
     "statuses": ["statuses@2.0.2", "", {}, "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw=="],
 
+    "std-env": ["std-env@3.10.0", "", {}, "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg=="],
+
     "stdin-discarder": ["stdin-discarder@0.2.2", "", {}, "sha512-UhDfHmA92YAlNnCfhmq0VeNL5bDbiZGg7sZ2IvPsXubGkiNa9EC+tUTsjBRsYUAz87btI6/1wf4XoVvQ3uRnmQ=="],
 
     "steno": ["steno@4.0.2", "", {}, "sha512-yhPIQXjrlt1xv7dyPQg2P17URmXbuM5pdGkpiMB3RenprfiBlvK415Lctfe0eshk90oA7/tNq7WEiMK8RSP39A=="],
@@ -4709,10 +4858,14 @@
 
     "tiny-warning": ["tiny-warning@1.0.3", "", {}, "sha512-lBN9zLN/oAf68o3zNXYrdCt1kP8WsiGW8Oo2ka41b2IM5JL/S1CTyX1rW0mb/zSuJun0ZUrDxx4sqvYS2FWzPA=="],
 
+    "tinybench": ["tinybench@2.9.0", "", {}, "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg=="],
+
     "tinyexec": ["tinyexec@1.0.2", "", {}, "sha512-W/KYk+NFhkmsYpuHq5JykngiOCnxeVL8v8dFnqxSD8qEEdRfXk1SDM6JzNqcERbcGYj9tMrDQBYV9cjgnunFIg=="],
 
     "tinyglobby": ["tinyglobby@0.2.15", "", { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.3" } }, "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ=="],
 
+    "tinyrainbow": ["tinyrainbow@3.0.3", "", {}, "sha512-PSkbLUoxOFRzJYjjxHJt9xro7D+iilgMX/C9lawzVuYiIdcihh9DXmVibBe8lmcFrRi/VzlPjBxbN7rH24q8/Q=="],
+
     "tippy.js": ["tippy.js@6.3.7", "", { "dependencies": { "@popperjs/core": "^2.9.0" } }, "sha512-E1d3oP2emgJ9dRQZdf3Kkn0qJgI6ZLpyS5z6ZkY1DF3kaQaBsGZsndEpHwx+eC+tYM41HaSNvNtLx8tU57FzTQ=="],
 
     "tiptap-markdown": ["tiptap-markdown@0.9.0", "", { "dependencies": { "@types/markdown-it": "^13.0.7", "markdown-it": "^14.1.0", "markdown-it-task-lists": "^2.1.1", "prosemirror-markdown": "^1.11.1" }, "peerDependencies": { "@tiptap/core": "^3.0.1" } }, "sha512-dKLQ9iiuGNgrlGVjrNauF/UBzWu4LYOx5pkD0jNkmQt/GOwfCJsBuzZTsf1jZ204ANHOm572mZ9PYvGh1S7tpQ=="],
@@ -4765,6 +4918,8 @@
 
     "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
 
+    "tsup": ["tsup@8.5.1", "", { "dependencies": { "bundle-require": "^5.1.0", "cac": "^6.7.14", "chokidar": "^4.0.3", "consola": "^3.4.0", "debug": "^4.4.0", "esbuild": "^0.27.0", "fix-dts-default-cjs-exports": "^1.0.0", "joycon": "^3.1.1", "picocolors": "^1.1.1", "postcss-load-config": "^6.0.1", "resolve-from": "^5.0.0", "rollup": "^4.34.8", "source-map": "^0.7.6", "sucrase": "^3.35.0", "tinyexec": "^0.3.2", "tinyglobby": "^0.2.11", "tree-kill": "^1.2.2" }, "peerDependencies": { "@microsoft/api-extractor": "^7.36.0", "@swc/core": "^1", "postcss": "^8.4.12", "typescript": ">=4.5.0" }, "optionalPeers": ["@microsoft/api-extractor", "@swc/core", "postcss", "typescript"], "bin": { "tsup": "dist/cli-default.js", "tsup-node": "dist/cli-node.js" } }, "sha512-xtgkqwdhpKWr3tKPmCkvYmS9xnQK3m3XgxZHwSUjvfTjp7YfXe5tT3GgWi0F2N+ZSMsOeWeZFh7ZZFg5iPhing=="],
+
     "tsx": ["tsx@4.21.0", "", { "dependencies": { "esbuild": "~0.27.0", "get-tsconfig": "^4.7.5" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "bin": { "tsx": "dist/cli.mjs" } }, "sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw=="],
 
     "tunnel-agent": ["tunnel-agent@0.6.0", "", { "dependencies": { "safe-buffer": "^5.0.1" } }, "sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w=="],
@@ -4911,6 +5066,8 @@
 
     "vite-tsconfig-paths": ["vite-tsconfig-paths@5.1.4", "", { "dependencies": { "debug": "^4.1.1", "globrex": "^0.1.2", "tsconfck": "^3.0.3" }, "peerDependencies": { "vite": "*" }, "optionalPeers": ["vite"] }, "sha512-cYj0LRuLV2c2sMqhqhGpaO3LretdtMn/BVX4cPLanIZuwwrkVl+lK84E/miEXkCHWXuq65rhNN4rXsBcOB3S4w=="],
 
+    "vitest": ["vitest@4.0.18", "", { "dependencies": { "@vitest/expect": "4.0.18", "@vitest/mocker": "4.0.18", "@vitest/pretty-format": "4.0.18", "@vitest/runner": "4.0.18", "@vitest/snapshot": "4.0.18", "@vitest/spy": "4.0.18", "@vitest/utils": "4.0.18", "es-module-lexer": "^1.7.0", "expect-type": "^1.2.2", "magic-string": "^0.30.21", "obug": "^2.1.1", "pathe": "^2.0.3", "picomatch": "^4.0.3", "std-env": "^3.10.0", "tinybench": "^2.9.0", "tinyexec": "^1.0.2", "tinyglobby": "^0.2.15", "tinyrainbow": "^3.0.3", "vite": "^6.0.0 || ^7.0.0", "why-is-node-running": "^2.3.0" }, "peerDependencies": { "@edge-runtime/vm": "*", "@opentelemetry/api": "^1.9.0", "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0", "@vitest/browser-playwright": "4.0.18", "@vitest/browser-preview": "4.0.18", "@vitest/browser-webdriverio": "4.0.18", "@vitest/ui": "4.0.18", "happy-dom": "*", "jsdom": "*" }, "optionalPeers": ["@edge-runtime/vm", "@opentelemetry/api", "@types/node", "@vitest/browser-playwright", "@vitest/browser-preview", "@vitest/browser-webdriverio", "@vitest/ui", "happy-dom", "jsdom"], "bin": { "vitest": "vitest.mjs" } }, "sha512-hOQuK7h0FGKgBAas7v0mSAsnvrIgAvWmRFjmzpJ7SwFHH3g1k2u37JtYwOwmEKhK6ZO3v9ggDBBm0La1LCK4uQ=="],
+
     "vlq": ["vlq@1.0.1", "", {}, "sha512-gQpnTgkubC6hQgdIcRdYGDSDc+SaujOdyesZQMv6JlfQee/9Mp0Qhnys6WxDWvQnL5WZdT7o2Ul187aSt0Rq+w=="],
 
     "vscode-jsonrpc": ["vscode-jsonrpc@8.2.0", "", {}, "sha512-C+r0eKJUIfiDIfwJhria30+TYWPtuHJXHtI7J0YlOmKAo7ogxP20T0zxB7HZQIFhIyvoBPwWskjxrvAtfjyZfA=="],
@@ -4935,6 +5092,8 @@
 
     "wcwidth": ["wcwidth@1.0.1", "", { "dependencies": { "defaults": "^1.0.3" } }, "sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg=="],
 
+    "weak-lru-cache": ["weak-lru-cache@1.2.2", "", {}, "sha512-DEAoo25RfSYMuTGc9vPJzZcZullwIqRDSI9LOy+fkCJPi6hykCnfKaXTuPBDuXAUcqHXyOgFtHNp/kB2FjYHbw=="],
+
     "web-namespaces": ["web-namespaces@2.0.1", "", {}, "sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ=="],
 
     "web-vitals": ["web-vitals@4.2.4", "", {}, "sha512-r4DIlprAGwJ7YM11VZp4R884m0Vmgr6EAKe3P+kO0PPj3Unqyvv59rczf6UiGcb9Z8QxZVcqKNwv/g0WNdWwsw=="],
@@ -4963,6 +5122,8 @@
 
     "which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="],
 
+    "why-is-node-running": ["why-is-node-running@2.3.0", "", { "dependencies": { "siginfo": "^2.0.0", "stackback": "0.0.2" }, "bin": { "why-is-node-running": "cli.js" } }, "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w=="],
+
     "widest-line": ["widest-line@5.0.0", "", { "dependencies": { "string-width": "^7.0.0" } }, "sha512-c9bZp7b5YtRj2wOe6dlj32MK+Bx/M/d+9VB2SHM1OtsUHR0aV0tdP6DWh/iMt0kWi1t5g1Iudu6hQRNd1A4PVA=="],
 
     "wonka": ["wonka@6.3.5", "", {}, "sha512-SSil+ecw6B4/Dm7Pf2sAshKQ5hWFvfyGlfPbEd6A14dOH6VDjrmbY86u6nZvy9omGwwIPFR8V41+of1EezgoUw=="],
@@ -5115,6 +5276,20 @@
 
     "@fumadocs/ui/postcss-selector-parser": ["postcss-selector-parser@7.1.1", "", { "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" } }, "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg=="],
 
+    "@img/sharp-darwin-arm64/@img/sharp-libvips-darwin-arm64": ["@img/sharp-libvips-darwin-arm64@1.0.4", "", { "os": "darwin", "cpu": "arm64" }, "sha512-XblONe153h0O2zuFfTAbQYAX2JhYmDHeWikp1LM9Hul9gVPjFY427k6dFEcOL72O01QxQsWi761svJ/ev9xEDg=="],
+
+    "@img/sharp-darwin-x64/@img/sharp-libvips-darwin-x64": ["@img/sharp-libvips-darwin-x64@1.0.4", "", { "os": "darwin", "cpu": "x64" }, "sha512-xnGR8YuZYfJGmWPvmlunFaWJsb9T/AO2ykoP3Fz/0X5XV2aoYBPkX6xqCQvUTKKiLddarLaxpzNe+b1hjeWHAQ=="],
+
+    "@img/sharp-linux-arm/@img/sharp-libvips-linux-arm": ["@img/sharp-libvips-linux-arm@1.0.5", "", { "os": "linux", "cpu": "arm" }, "sha512-gvcC4ACAOPRNATg/ov8/MnbxFDJqf/pDePbBnuBDcjsI8PssmjoKMAz4LtLaVi+OnSb5FK/yIOamqDwGmXW32g=="],
+
+    "@img/sharp-linux-arm64/@img/sharp-libvips-linux-arm64": ["@img/sharp-libvips-linux-arm64@1.0.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-9B+taZ8DlyyqzZQnoeIvDVR/2F4EbMepXMc/NdVbkzsJbzkUjhXv/70GQJ7tdLA4YJgNP25zukcxpX2/SueNrA=="],
+
+    "@img/sharp-linux-x64/@img/sharp-libvips-linux-x64": ["@img/sharp-libvips-linux-x64@1.0.4", "", { "os": "linux", "cpu": "x64" }, "sha512-MmWmQ3iPFZr0Iev+BAgVMb3ZyC4KeFc3jFxnNbEPas60e1cIfevbtuyf9nDGIzOaW9PdnDciJm+wFFaTlj5xYw=="],
+
+    "@img/sharp-linuxmusl-arm64/@img/sharp-libvips-linuxmusl-arm64": ["@img/sharp-libvips-linuxmusl-arm64@1.0.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-9Ti+BbTYDcsbp4wfYib8Ctm1ilkugkA/uscUn6UXK1ldpC1JjiXbLfFZtRlBhjPZ5o1NCLiDbg8fhUPKStHoTA=="],
+
+    "@img/sharp-linuxmusl-x64/@img/sharp-libvips-linuxmusl-x64": ["@img/sharp-libvips-linuxmusl-x64@1.0.4", "", { "os": "linux", "cpu": "x64" }, "sha512-viYN1KX9m+/hGkJtvYYp+CCLgnJXwiQB39damAO7WMdKWlIhmYTfHjwSbQeUK/20vY154mwezd9HflVFM1wVSw=="],
+
     "@isaacs/cliui/string-width": ["string-width@5.1.2", "", { "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", "strip-ansi": "^7.0.1" } }, "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA=="],
 
     "@isaacs/cliui/wrap-ansi": ["wrap-ansi@8.1.0", "", { "dependencies": { "ansi-styles": "^6.1.0", "string-width": "^5.0.1", "strip-ansi": "^7.0.1" } }, "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ=="],
@@ -5251,6 +5426,8 @@
 
     "@tailwindcss/oxide-wasm32-wasi/tslib": ["tslib@2.8.1", "", { "bundled": true }, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
 
+    "@tanstack/electric-db-collection/@tanstack/db": ["@tanstack/db@0.5.24", "", { "dependencies": { "@standard-schema/spec": "^1.1.0", "@tanstack/db-ivm": "0.1.17", "@tanstack/pacer-lite": "^0.2.0" }, "peerDependencies": { "typescript": ">=4.7" } }, "sha512-hlmTG3k9e1NE8pzIQgwV9e/W/Nwe36aENrXJ+KhTuy6jLJ6F+PmnOzfc2z7Vx9YUz1jepRQ61rxnIuq5w0bxmQ=="],
+
     "@tanstack/router-generator/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
 
     "@tanstack/router-plugin/unplugin": ["unplugin@2.3.11", "", { "dependencies": { "@jridgewell/remapping": "^2.3.5", "acorn": "^8.15.0", "picomatch": "^4.0.3", "webpack-virtual-modules": "^0.6.2" } }, "sha512-5uKD0nqiYVzlmCRs01Fhs2BdkEgBS3SAVP6ndrBsuK42iC2+JHyxM05Rm9G8+5mkmRtzMZGY8Ct5+mliZxU/Ww=="],
@@ -5265,6 +5442,8 @@
 
     "@upstash/qstash/jose": ["jose@5.10.0", "", {}, "sha512-s+3Al/p9g32Iq+oqXxkW//7jk2Vig6FF1CFqzVXoTUXt2qz89YWbL+OwS17NFYEvxC35n0FKeGO2LGYSxeM2Gg=="],
 
+    "@vitest/mocker/estree-walker": ["estree-walker@3.0.3", "", { "dependencies": { "@types/estree": "^1.0.0" } }, "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g=="],
+
     "@vue/compiler-core/entities": ["entities@7.0.1", "", {}, "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA=="],
 
     "@xyflow/react/zustand": ["zustand@4.5.7", "", { "dependencies": { "use-sync-external-store": "^1.2.2" }, "peerDependencies": { "@types/react": ">=16.8", "immer": ">=9.0.6", "react": ">=16.8" }, "optionalPeers": ["@types/react", "immer", "react"] }, "sha512-CHOUy7mu3lbD6o6LJLfllpjkzhHXSBlX8B9+qPddUsIfeF5S/UZ5q0kmCsnRqT1UHFQZchNFDDzMbQsuesHWlw=="],
@@ -5473,6 +5652,8 @@
 
     "line-column-path/type-fest": ["type-fest@2.19.0", "", {}, "sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA=="],
 
+    "lmdb/node-addon-api": ["node-addon-api@6.1.0", "", {}, "sha512-+eawOlIgy680F0kBzPUNFhMZGtJ1YmqM6l4+Crf4IkImjYrO/mqPwRMh352g23uIaQKFItcQ64I7KMaJxHgAVA=="],
+
     "make-fetch-happen/proc-log": ["proc-log@5.0.0", "", {}, "sha512-Azwzvl90HaF0aCz1JrDdXQykFakSSNPaPoiZ9fm5qJIMHioDZEi7OAdRwSm6rSoPtY3Qutnm3L7ogmg3dc+wbQ=="],
 
     "matcher/escape-string-regexp": ["escape-string-regexp@5.0.0", "", {}, "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw=="],
@@ -5641,6 +5822,22 @@
 
     "serialize-error/type-fest": ["type-fest@0.13.1", "", {}, "sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg=="],
 
+    "sharp/@img/sharp-darwin-arm64": ["@img/sharp-darwin-arm64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-arm64": "1.2.4" }, "os": "darwin", "cpu": "arm64" }, "sha512-imtQ3WMJXbMY4fxb/Ndp6HBTNVtWCUI0WdobyheGf5+ad6xX8VIDO8u2xE4qc/fr08CKG/7dDseFtn6M6g/r3w=="],
+
+    "sharp/@img/sharp-darwin-x64": ["@img/sharp-darwin-x64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-x64": "1.2.4" }, "os": "darwin", "cpu": "x64" }, "sha512-YNEFAF/4KQ/PeW0N+r+aVVsoIY0/qxxikF2SWdp+NRkmMB7y9LBZAVqQ4yhGCm/H3H270OSykqmQMKLBhBJDEw=="],
+
+    "sharp/@img/sharp-linux-arm": ["@img/sharp-linux-arm@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-arm": "1.2.4" }, "os": "linux", "cpu": "arm" }, "sha512-9dLqsvwtg1uuXBGZKsxem9595+ujv0sJ6Vi8wcTANSFpwV/GONat5eCkzQo/1O6zRIkh0m/8+5BjrRr7jDUSZw=="],
+
+    "sharp/@img/sharp-linux-arm64": ["@img/sharp-linux-arm64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-arm64": "1.2.4" }, "os": "linux", "cpu": "arm64" }, "sha512-bKQzaJRY/bkPOXyKx5EVup7qkaojECG6NLYswgktOZjaXecSAeCWiZwwiFf3/Y+O1HrauiE3FVsGxFg8c24rZg=="],
+
+    "sharp/@img/sharp-linux-x64": ["@img/sharp-linux-x64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-x64": "1.2.4" }, "os": "linux", "cpu": "x64" }, "sha512-MEzd8HPKxVxVenwAa+JRPwEC7QFjoPWuS5NZnBt6B3pu7EG2Ge0id1oLHZpPJdn3OQK+BQDiw9zStiHBTJQQQQ=="],
+
+    "sharp/@img/sharp-linuxmusl-arm64": ["@img/sharp-linuxmusl-arm64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linuxmusl-arm64": "1.2.4" }, "os": "linux", "cpu": "arm64" }, "sha512-fprJR6GtRsMt6Kyfq44IsChVZeGN97gTD331weR1ex1c1rypDEABN6Tm2xa1wE6lYb5DdEnk03NZPqA7Id21yg=="],
+
+    "sharp/@img/sharp-linuxmusl-x64": ["@img/sharp-linuxmusl-x64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linuxmusl-x64": "1.2.4" }, "os": "linux", "cpu": "x64" }, "sha512-Jg8wNT1MUzIvhBFxViqrEhWDGzqymo3sV7z7ZsaWbZNDLXRJZoRGrjulp60YYtV4wfY8VIKcWidjojlLcWrd8Q=="],
+
+    "sharp/@img/sharp-win32-x64": ["@img/sharp-win32-x64@0.34.5", "", { "os": "win32", "cpu": "x64" }, "sha512-+29YMsqY2/9eFEiW93eqWnuLcWcufowXewwSNIT6UwZdUUCrM3oFjMWH/Z6/TMmb4hlFenmfAVbpWeup2jryCw=="],
+
     "simple-plist/bplist-parser": ["bplist-parser@0.3.1", "", { "dependencies": { "big-integer": "1.6.x" } }, "sha512-PyJxiNtA5T2PlLIeBot4lbp7rj4OadzjnMZD/G5zuBNt8ei/yCU7+wW0h2bag9vr8c+/WuRWmSxbqAl9hL1rBA=="],
 
     "simple-swizzle/is-arrayish": ["is-arrayish@0.3.4", "", {}, "sha512-m6UrgzFVUYawGBh1dUsWR5M2Clqic9RVXC/9f8ceNlv2IcO9j9J/z8UoCLPqtsPBFNzEpfR3xftohbfqDx8EQA=="],
@@ -5697,6 +5894,12 @@
 
     "tiny-async-pool/semver": ["semver@5.7.2", "", { "bin": { "semver": "bin/semver" } }, "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g=="],
 
+    "tsup/chokidar": ["chokidar@4.0.3", "", { "dependencies": { "readdirp": "^4.0.1" } }, "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA=="],
+
+    "tsup/esbuild": ["esbuild@0.27.2", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.27.2", "@esbuild/android-arm": "0.27.2", "@esbuild/android-arm64": "0.27.2", "@esbuild/android-x64": "0.27.2", "@esbuild/darwin-arm64": "0.27.2", "@esbuild/darwin-x64": "0.27.2", "@esbuild/freebsd-arm64": "0.27.2", "@esbuild/freebsd-x64": "0.27.2", "@esbuild/linux-arm": "0.27.2", "@esbuild/linux-arm64": "0.27.2", "@esbuild/linux-ia32": "0.27.2", "@esbuild/linux-loong64": "0.27.2", "@esbuild/linux-mips64el": "0.27.2", "@esbuild/linux-ppc64": "0.27.2", "@esbuild/linux-riscv64": "0.27.2", "@esbuild/linux-s390x": "0.27.2", "@esbuild/linux-x64": "0.27.2", "@esbuild/netbsd-arm64": "0.27.2", "@esbuild/netbsd-x64": "0.27.2", "@esbuild/openbsd-arm64": "0.27.2", "@esbuild/openbsd-x64": "0.27.2", "@esbuild/openharmony-arm64": "0.27.2", "@esbuild/sunos-x64": "0.27.2", "@esbuild/win32-arm64": "0.27.2", "@esbuild/win32-ia32": "0.27.2", "@esbuild/win32-x64": "0.27.2" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-HyNQImnsOC7X9PMNaCIeAm4ISCQXs5a5YasTXVliKv4uuBo1dKrG0A+uQS8M5eXjVMnLg3WgXaKvprHlFJQffw=="],
+
+    "tsup/tinyexec": ["tinyexec@0.3.2", "", {}, "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA=="],
+
     "tsx/esbuild": ["esbuild@0.27.2", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.27.2", "@esbuild/android-arm": "0.27.2", "@esbuild/android-arm64": "0.27.2", "@esbuild/android-x64": "0.27.2", "@esbuild/darwin-arm64": "0.27.2", "@esbuild/darwin-x64": "0.27.2", "@esbuild/freebsd-arm64": "0.27.2", "@esbuild/freebsd-x64": "0.27.2", "@esbuild/linux-arm": "0.27.2", "@esbuild/linux-arm64": "0.27.2", "@esbuild/linux-ia32": "0.27.2", "@esbuild/linux-loong64": "0.27.2", "@esbuild/linux-mips64el": "0.27.2", "@esbuild/linux-ppc64": "0.27.2", "@esbuild/linux-riscv64": "0.27.2", "@esbuild/linux-s390x": "0.27.2", "@esbuild/linux-x64": "0.27.2", "@esbuild/netbsd-arm64": "0.27.2", "@esbuild/netbsd-x64": "0.27.2", "@esbuild/openbsd-arm64": "0.27.2", "@esbuild/openbsd-x64": "0.27.2", "@esbuild/openharmony-arm64": "0.27.2", "@esbuild/sunos-x64": "0.27.2", "@esbuild/win32-arm64": "0.27.2", "@esbuild/win32-ia32": "0.27.2", "@esbuild/win32-x64": "0.27.2" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-HyNQImnsOC7X9PMNaCIeAm4ISCQXs5a5YasTXVliKv4uuBo1dKrG0A+uQS8M5eXjVMnLg3WgXaKvprHlFJQffw=="],
 
     "tunnel-rat/zustand": ["zustand@4.5.7", "", { "dependencies": { "use-sync-external-store": "^1.2.2" }, "peerDependencies": { "@types/react": ">=16.8", "immer": ">=9.0.6", "react": ">=16.8" }, "optionalPeers": ["@types/react", "immer", "react"] }, "sha512-CHOUy7mu3lbD6o6LJLfllpjkzhHXSBlX8B9+qPddUsIfeF5S/UZ5q0kmCsnRqT1UHFQZchNFDDzMbQsuesHWlw=="],
@@ -5715,6 +5918,8 @@
 
     "vite/esbuild": ["esbuild@0.27.2", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.27.2", "@esbuild/android-arm": "0.27.2", "@esbuild/android-arm64": "0.27.2", "@esbuild/android-x64": "0.27.2", "@esbuild/darwin-arm64": "0.27.2", "@esbuild/darwin-x64": "0.27.2", "@esbuild/freebsd-arm64": "0.27.2", "@esbuild/freebsd-x64": "0.27.2", "@esbuild/linux-arm": "0.27.2", "@esbuild/linux-arm64": "0.27.2", "@esbuild/linux-ia32": "0.27.2", "@esbuild/linux-loong64": "0.27.2", "@esbuild/linux-mips64el": "0.27.2", "@esbuild/linux-ppc64": "0.27.2", "@esbuild/linux-riscv64": "0.27.2", "@esbuild/linux-s390x": "0.27.2", "@esbuild/linux-x64": "0.27.2", "@esbuild/netbsd-arm64": "0.27.2", "@esbuild/netbsd-x64": "0.27.2", "@esbuild/openbsd-arm64": "0.27.2", "@esbuild/openbsd-x64": "0.27.2", "@esbuild/openharmony-arm64": "0.27.2", "@esbuild/sunos-x64": "0.27.2", "@esbuild/win32-arm64": "0.27.2", "@esbuild/win32-ia32": "0.27.2", "@esbuild/win32-x64": "0.27.2" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-HyNQImnsOC7X9PMNaCIeAm4ISCQXs5a5YasTXVliKv4uuBo1dKrG0A+uQS8M5eXjVMnLg3WgXaKvprHlFJQffw=="],
 
+    "webpack/es-module-lexer": ["es-module-lexer@2.0.0", "", {}, "sha512-5POEcUuZybH7IdmGsD8wlf0AI55wMecM9rVBTI/qEAy2c1kTOm3DjFYjrBdI2K3BaJjJYfYFeRtM0t9ssnRuxw=="],
+
     "webpack/mime-types": ["mime-types@2.1.35", "", { "dependencies": { "mime-db": "1.52.0" } }, "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw=="],
 
     "whatwg-url/webidl-conversions": ["webidl-conversions@3.0.1", "", {}, "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ=="],
@@ -6213,6 +6418,60 @@
 
     "test-exclude/minimatch/brace-expansion": ["brace-expansion@1.1.12", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg=="],
 
+    "tsup/chokidar/readdirp": ["readdirp@4.1.2", "", {}, "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg=="],
+
+    "tsup/esbuild/@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.27.2", "", { "os": "aix", "cpu": "ppc64" }, "sha512-GZMB+a0mOMZs4MpDbj8RJp4cw+w1WV5NYD6xzgvzUJ5Ek2jerwfO2eADyI6ExDSUED+1X8aMbegahsJi+8mgpw=="],
+
+    "tsup/esbuild/@esbuild/android-arm": ["@esbuild/android-arm@0.27.2", "", { "os": "android", "cpu": "arm" }, "sha512-DVNI8jlPa7Ujbr1yjU2PfUSRtAUZPG9I1RwW4F4xFB1Imiu2on0ADiI/c3td+KmDtVKNbi+nffGDQMfcIMkwIA=="],
+
+    "tsup/esbuild/@esbuild/android-arm64": ["@esbuild/android-arm64@0.27.2", "", { "os": "android", "cpu": "arm64" }, "sha512-pvz8ZZ7ot/RBphf8fv60ljmaoydPU12VuXHImtAs0XhLLw+EXBi2BLe3OYSBslR4rryHvweW5gmkKFwTiFy6KA=="],
+
+    "tsup/esbuild/@esbuild/android-x64": ["@esbuild/android-x64@0.27.2", "", { "os": "android", "cpu": "x64" }, "sha512-z8Ank4Byh4TJJOh4wpz8g2vDy75zFL0TlZlkUkEwYXuPSgX8yzep596n6mT7905kA9uHZsf/o2OJZubl2l3M7A=="],
+
+    "tsup/esbuild/@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.27.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-davCD2Zc80nzDVRwXTcQP/28fiJbcOwvdolL0sOiOsbwBa72kegmVU0Wrh1MYrbuCL98Omp5dVhQFWRKR2ZAlg=="],
+
+    "tsup/esbuild/@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.27.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-ZxtijOmlQCBWGwbVmwOF/UCzuGIbUkqB1faQRf5akQmxRJ1ujusWsb3CVfk/9iZKr2L5SMU5wPBi1UWbvL+VQA=="],
+
+    "tsup/esbuild/@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.27.2", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-lS/9CN+rgqQ9czogxlMcBMGd+l8Q3Nj1MFQwBZJyoEKI50XGxwuzznYdwcav6lpOGv5BqaZXqvBSiB/kJ5op+g=="],
+
+    "tsup/esbuild/@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.27.2", "", { "os": "freebsd", "cpu": "x64" }, "sha512-tAfqtNYb4YgPnJlEFu4c212HYjQWSO/w/h/lQaBK7RbwGIkBOuNKQI9tqWzx7Wtp7bTPaGC6MJvWI608P3wXYA=="],
+
+    "tsup/esbuild/@esbuild/linux-arm": ["@esbuild/linux-arm@0.27.2", "", { "os": "linux", "cpu": "arm" }, "sha512-vWfq4GaIMP9AIe4yj1ZUW18RDhx6EPQKjwe7n8BbIecFtCQG4CfHGaHuh7fdfq+y3LIA2vGS/o9ZBGVxIDi9hw=="],
+
+    "tsup/esbuild/@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.27.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-hYxN8pr66NsCCiRFkHUAsxylNOcAQaxSSkHMMjcpx0si13t1LHFphxJZUiGwojB1a/Hd5OiPIqDdXONia6bhTw=="],
+
+    "tsup/esbuild/@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.27.2", "", { "os": "linux", "cpu": "ia32" }, "sha512-MJt5BRRSScPDwG2hLelYhAAKh9imjHK5+NE/tvnRLbIqUWa+0E9N4WNMjmp/kXXPHZGqPLxggwVhz7QP8CTR8w=="],
+
+    "tsup/esbuild/@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.27.2", "", { "os": "linux", "cpu": "none" }, "sha512-lugyF1atnAT463aO6KPshVCJK5NgRnU4yb3FUumyVz+cGvZbontBgzeGFO1nF+dPueHD367a2ZXe1NtUkAjOtg=="],
+
+    "tsup/esbuild/@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.27.2", "", { "os": "linux", "cpu": "none" }, "sha512-nlP2I6ArEBewvJ2gjrrkESEZkB5mIoaTswuqNFRv/WYd+ATtUpe9Y09RnJvgvdag7he0OWgEZWhviS1OTOKixw=="],
+
+    "tsup/esbuild/@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.27.2", "", { "os": "linux", "cpu": "ppc64" }, "sha512-C92gnpey7tUQONqg1n6dKVbx3vphKtTHJaNG2Ok9lGwbZil6DrfyecMsp9CrmXGQJmZ7iiVXvvZH6Ml5hL6XdQ=="],
+
+    "tsup/esbuild/@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.27.2", "", { "os": "linux", "cpu": "none" }, "sha512-B5BOmojNtUyN8AXlK0QJyvjEZkWwy/FKvakkTDCziX95AowLZKR6aCDhG7LeF7uMCXEJqwa8Bejz5LTPYm8AvA=="],
+
+    "tsup/esbuild/@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.27.2", "", { "os": "linux", "cpu": "s390x" }, "sha512-p4bm9+wsPwup5Z8f4EpfN63qNagQ47Ua2znaqGH6bqLlmJ4bx97Y9JdqxgGZ6Y8xVTixUnEkoKSHcpRlDnNr5w=="],
+
+    "tsup/esbuild/@esbuild/linux-x64": ["@esbuild/linux-x64@0.27.2", "", { "os": "linux", "cpu": "x64" }, "sha512-uwp2Tip5aPmH+NRUwTcfLb+W32WXjpFejTIOWZFw/v7/KnpCDKG66u4DLcurQpiYTiYwQ9B7KOeMJvLCu/OvbA=="],
+
+    "tsup/esbuild/@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.27.2", "", { "os": "none", "cpu": "arm64" }, "sha512-Kj6DiBlwXrPsCRDeRvGAUb/LNrBASrfqAIok+xB0LxK8CHqxZ037viF13ugfsIpePH93mX7xfJp97cyDuTZ3cw=="],
+
+    "tsup/esbuild/@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.27.2", "", { "os": "none", "cpu": "x64" }, "sha512-HwGDZ0VLVBY3Y+Nw0JexZy9o/nUAWq9MlV7cahpaXKW6TOzfVno3y3/M8Ga8u8Yr7GldLOov27xiCnqRZf0tCA=="],
+
+    "tsup/esbuild/@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.27.2", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-DNIHH2BPQ5551A7oSHD0CKbwIA/Ox7+78/AWkbS5QoRzaqlev2uFayfSxq68EkonB+IKjiuxBFoV8ESJy8bOHA=="],
+
+    "tsup/esbuild/@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.27.2", "", { "os": "openbsd", "cpu": "x64" }, "sha512-/it7w9Nb7+0KFIzjalNJVR5bOzA9Vay+yIPLVHfIQYG/j+j9VTH84aNB8ExGKPU4AzfaEvN9/V4HV+F+vo8OEg=="],
+
+    "tsup/esbuild/@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.27.2", "", { "os": "none", "cpu": "arm64" }, "sha512-LRBbCmiU51IXfeXk59csuX/aSaToeG7w48nMwA6049Y4J4+VbWALAuXcs+qcD04rHDuSCSRKdmY63sruDS5qag=="],
+
+    "tsup/esbuild/@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.27.2", "", { "os": "sunos", "cpu": "x64" }, "sha512-kMtx1yqJHTmqaqHPAzKCAkDaKsffmXkPHThSfRwZGyuqyIeBvf08KSsYXl+abf5HDAPMJIPnbBfXvP2ZC2TfHg=="],
+
+    "tsup/esbuild/@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.27.2", "", { "os": "win32", "cpu": "arm64" }, "sha512-Yaf78O/B3Kkh+nKABUF++bvJv5Ijoy9AN1ww904rOXZFLWVc5OLOfL56W+C8F9xn5JQZa3UX6m+IktJnIb1Jjg=="],
+
+    "tsup/esbuild/@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.27.2", "", { "os": "win32", "cpu": "ia32" }, "sha512-Iuws0kxo4yusk7sw70Xa2E2imZU5HoixzxfGCdxwBdhiDgt9vX9VUCBhqcwY7/uh//78A1hMkkROMJq9l27oLQ=="],
+
+    "tsup/esbuild/@esbuild/win32-x64": ["@esbuild/win32-x64@0.27.2", "", { "os": "win32", "cpu": "x64" }, "sha512-sRdU18mcKf7F+YgheI/zGf5alZatMUTKj/jNS6l744f9u3WFu4v7twcUI9vu4mknF4Y9aDlblIie0IM+5xxaqQ=="],
+
     "tsx/esbuild/@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.27.2", "", { "os": "aix", "cpu": "ppc64" }, "sha512-GZMB+a0mOMZs4MpDbj8RJp4cw+w1WV5NYD6xzgvzUJ5Ek2jerwfO2eADyI6ExDSUED+1X8aMbegahsJi+8mgpw=="],
 
     "tsx/esbuild/@esbuild/android-arm": ["@esbuild/android-arm@0.27.2", "", { "os": "android", "cpu": "arm" }, "sha512-DVNI8jlPa7Ujbr1yjU2PfUSRtAUZPG9I1RwW4F4xFB1Imiu2on0ADiI/c3td+KmDtVKNbi+nffGDQMfcIMkwIA=="],
diff --git a/docs/ai-chat-plan.md b/docs/ai-chat-plan.md
new file mode 100644
index 00000000000..5bbad92812e
--- /dev/null
+++ b/docs/ai-chat-plan.md
@@ -0,0 +1,491 @@
+# Multiplayer AI Chat with Claude Code
+
+Build a real-time multiplayer AI chat powered by Claude Code SDK with Durable Streams for token streaming and Electric SQL for message persistence.
+
+## Architecture Overview
+
+```
+Any Client (Web/Mobile)                 API                        Desktop (Electron)
+┌─────────────────┐                 ┌─────────────────┐           ┌─────────────────┐
+│ "Start session" │ ───tRPC call──▶ │ Write request   │ ────────▶ │ Picks up via    │
+│ via API         │                 │ to Postgres     │           │ Electric sub    │
+└─────────────────┘                 └─────────────────┘           └────────┬────────┘
+                                                                           │
+                                                                           │ Runs Claude SDK
+                                                                           ▼
+┌─────────────────────────────────────────────────────────────────────────────────────┐
+│                              Durable Stream Server (Fly)                             │
+│  - Receives tokens from Desktop (POST)                                               │
+│  - Fans out to all clients (GET ?live=true SSE)                                     │
+│  - State Protocol for presence (typing, viewing)                                    │
+└────────────────────────────────────────────────────────────────────────┬────────────┘
+                                                                         │
+All Clients                                                              │
+┌─────────────────┐                                                      │
+│ Subscribe to    │◀─────────────────────────────────────────────────────┘
+│ Durable Stream  │
+│ for live tokens │
+└────────┬────────┘
+         │ on message complete
+         ▼
+┌─────────────────┐     ┌─────────────────┐
+│ Electric SQL    │◀────│ Postgres (Neon) │◀── Desktop writes final message
+│ syncs history   │     └─────────────────┘
+└─────────────────┘
+```
+
+## Key Design Decisions
+
+1. **Claude SDK runs locally on desktop** - Desktop has access to Keychain/API key, no token transport needed
+2. **API triggers sessions** - Any client can start a session via tRPC API; desktop with workspace open picks it up via Electric subscription
+3. **Durable Streams for live tokens** - Resumable, multi-client streaming (not Postgres per-token writes)
+4. **Postgres for completed messages only** - Single write on completion, Electric syncs history
+5. **State Protocol for presence** - Typing indicators, who's viewing
+6. **TanStack DB already installed** - Use existing `@tanstack/db` in desktop app
+7. **Separate Fly app for stream server** - Clean separation, independent scaling
+
+## Claude SDK Streaming Format
+
+The Claude Agent SDK provides a clean, structured streaming format when `includePartialMessages: true`:
+
+```typescript
+// SDK emits SDKPartialAssistantMessage for each streaming event
+type SDKPartialAssistantMessage = {
+  type: 'stream_event';
+  event: RawMessageStreamEvent; // Standard Anthropic streaming events
+  parent_tool_use_id: string | null;
+  uuid: UUID;
+  session_id: string;
+}
+
+// RawMessageStreamEvent follows Anthropic's standard protocol:
+// message_start → content_block_start → content_block_delta → content_block_stop → message_delta
+
+// Text deltas look like:
+{ type: "content_block_delta", index: 0, delta: { type: "text_delta", text: "Hello" } }
+
+// Tool use deltas:
+{ type: "content_block_delta", index: 1, delta: { type: "input_json_delta", partial_json: "{\"file" } }
+```
+
+This structured format maps cleanly to our Durable Stream events - we can forward each `content_block_delta` directly.
+
+---
+
+## Phase 1: Database Schema
+
+### Files to Create/Modify
+
+**`packages/db/src/schema/chat.ts`** (new)
+```typescript
+// Chat sessions - org-scoped
+export const chatSessions = pgTable("chat_sessions", {
+  id: uuid().primaryKey().defaultRandom(),
+  organizationId: uuid("organization_id").notNull().references(() => organizations.id),
+  repositoryId: uuid("repository_id").references(() => repositories.id),
+  workspaceId: text("workspace_id"),
+  title: text().notNull(),
+  claudeSessionId: text("claude_session_id"), // For resume
+  cwd: text(), // Working directory
+  createdById: uuid("created_by_id").notNull().references(() => users.id),
+  archivedAt: timestamp("archived_at"),
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+  updatedAt: timestamp("updated_at").notNull().defaultNow().$onUpdate(() => new Date()),
+});
+
+// Completed messages only (not streaming tokens)
+export const chatMessages = pgTable("chat_messages", {
+  id: uuid().primaryKey().defaultRandom(),
+  sessionId: uuid("session_id").notNull().references(() => chatSessions.id),
+  organizationId: uuid("organization_id").notNull().references(() => organizations.id),
+  role: text().notNull(), // "user" | "assistant"
+  content: text().notNull(),
+  toolCalls: jsonb("tool_calls"),
+  inputTokens: integer("input_tokens"),
+  outputTokens: integer("output_tokens"),
+  createdById: uuid("created_by_id").notNull().references(() => users.id),
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+});
+
+// Who can access each session
+export const chatParticipants = pgTable("chat_participants", {
+  id: uuid().primaryKey().defaultRandom(),
+  sessionId: uuid("session_id").notNull().references(() => chatSessions.id),
+  userId: uuid("user_id").notNull().references(() => users.id),
+  role: text().notNull().default("viewer"), // "owner" | "editor" | "viewer"
+  joinedAt: timestamp("joined_at").notNull().defaultNow(),
+});
+```
+
+**`packages/db/src/schema/index.ts`** - Export new tables
+
+**`apps/api/src/app/api/electric/[...path]/route.ts`** - Add WHERE clauses for chat tables
+
+---
+
+## Phase 2: Claude Binary Bundling
+
+### Files to Create/Modify
+
+**`apps/desktop/scripts/download-claude-binary.ts`** (new)
+- Download Claude Code binary from `https://storage.googleapis.com/claude-code-dist-86c565f3-f756-42ad-8dfa-d59b1c096819/claude-code-releases`
+- Platform detection: darwin-arm64, darwin-x64, linux-x64, win32-x64
+- SHA256 verification
+- Store at `apps/desktop/resources/bin/${platform}-${arch}/claude`
+
+**`apps/desktop/electron-builder.ts`** - Add to extraResources:
+```typescript
+extraResources: [
+  // ... existing
+  {
+    from: "resources/bin/${platform}-${arch}",
+    to: "bin",
+    filter: ["**/*"],
+  },
+],
+```
+
+**`apps/desktop/src/main/lib/claude/binary.ts`** (new)
+```typescript
+export function getBundledClaudeBinaryPath(): string {
+  const isDev = !app.isPackaged;
+  const resourcesPath = isDev
+    ? path.join(app.getAppPath(), "resources/bin", `${platform}-${arch}`)
+    : path.join(process.resourcesPath, "bin");
+  return path.join(resourcesPath, platform === "win32" ? "claude.exe" : "claude");
+}
+```
+
+**`apps/desktop/src/main/lib/claude/auth.ts`** (new)
+```typescript
+// Read from Keychain (macOS), credentials file (Windows/Linux), or ANTHROPIC_API_KEY
+export function getExistingClaudeCredentials(): { accessToken: string } | null
+export function buildClaudeEnv(): Record<string, string>
+```
+
+---
+
+## Phase 3: Claude SDK Integration (Desktop)
+
+### Files to Create
+
+**`apps/desktop/src/main/lib/claude/session-manager.ts`** (new)
+- Manages Claude SDK sessions
+- Spawns bundled binary with user's auth
+- Streams tokens to Durable Stream
+- Emits events for local tRPC subscription
+
+**`apps/desktop/src/main/lib/trpc/routers/ai-chat.ts`** (new)
+```typescript
+export const aiChatRouter = router({
+  // Start or resume a session
+  startSession: publicProcedure
+    .input(z.object({
+      sessionId: z.string(),
+      cwd: z.string(),
+      claudeSessionId: z.string().optional(),
+    }))
+    .mutation(async ({ input }) => { ... }),
+
+  // Send message and trigger Claude
+  sendMessage: publicProcedure
+    .input(z.object({
+      sessionId: z.string(),
+      content: z.string(),
+    }))
+    .mutation(async ({ input }) => { ... }),
+
+  // Local token stream (observable pattern per AGENTS.md)
+  streamTokens: publicProcedure
+    .input(z.object({ sessionId: z.string() }))
+    .subscription(({ input }) => {
+      return observable<StreamEvent>((emit) => {
+        // Subscribe to session manager events
+        return () => { /* cleanup */ };
+      });
+    }),
+
+  // Interrupt generation
+  interrupt: publicProcedure
+    .input(z.object({ sessionId: z.string() }))
+    .mutation(async ({ input }) => { ... }),
+});
+```
+
+**`apps/desktop/src/main/lib/trpc/routers/index.ts`** - Add aiChatRouter
+
+---
+
+## Phase 4: API Session Trigger
+
+The API handles session creation and message sending. When a client (web/mobile) wants to start a chat:
+
+1. Client calls API `chat.createSession` or `chat.sendMessage`
+2. API writes session/message request to Postgres
+3. Desktop app subscribed to workspace picks up via Electric subscription
+4. Desktop runs Claude SDK and streams to Durable Stream
+5. All clients see tokens via Durable Stream subscription
+
+**API Router (in `packages/trpc/src/router/chat/index.ts`):**
+```typescript
+export const chatRouter = createTRPCRouter({
+  // Create a new chat session
+  createSession: protectedProcedure
+    .input(z.object({
+      repositoryId: z.string().uuid().optional(),
+      workspaceId: z.string().optional(),
+      title: z.string().optional(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      // Insert into chat_sessions table
+      // Returns sessionId
+    }),
+
+  // Send a message (triggers Claude on desktop)
+  sendMessage: protectedProcedure
+    .input(z.object({
+      sessionId: z.string().uuid(),
+      content: z.string(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      // Insert user message into chat_messages
+      // Desktop picks this up and runs Claude
+    }),
+
+  // ... other CRUD operations
+});
+```
+
+**Desktop subscription:**
+```typescript
+// Subscribe to pending messages for workspaces user has open
+const pendingMessages = electricClient.stream({
+  shape: {
+    table: "chat_messages",
+    where: `session_id IN (...) AND role = 'user' AND NOT processed`,
+  }
+});
+
+pendingMessages.subscribe((messages) => {
+  for (const msg of messages) {
+    runClaudeSession(msg);
+  }
+});
+```
+
+---
+
+## Phase 5: Durable Stream Server (Separate Fly App)
+
+**`apps/stream-server/`** (new Fly app)
+```
+apps/stream-server/
+├── package.json
+├── Dockerfile
+├── fly.toml
+└── src/
+    ├── index.ts          # Hono server
+    ├── streams.ts        # Durable Stream handlers
+    └── presence.ts       # State Protocol handlers
+```
+
+Dependencies: `@durable-streams/server`, `@durable-streams/state`, `hono`
+
+Endpoints:
+- `PUT /streams/:sessionId` - Create stream
+- `POST /streams/:sessionId` - Append tokens
+- `GET /streams/:sessionId` - Read with `?live=true` for SSE
+- `POST /streams/:sessionId/presence` - Update presence
+- `GET /streams/:sessionId/presence` - Get presence state
+
+---
+
+## Phase 6: API tRPC Router (Full Implementation)
+
+Extends the router from Phase 4 with all CRUD operations:
+
+**`packages/trpc/src/router/chat/index.ts`**
+```typescript
+export const chatRouter = createTRPCRouter({
+  // From Phase 4
+  createSession: protectedProcedure.input(...).mutation(...),
+  sendMessage: protectedProcedure.input(...).mutation(...),
+
+  // Additional endpoints
+  listSessions: protectedProcedure
+    .input(z.object({ repositoryId: z.string().uuid().optional() }))
+    .query(...),
+  getSession: protectedProcedure
+    .input(z.object({ sessionId: z.string().uuid() }))
+    .query(...),
+  getMessages: protectedProcedure
+    .input(z.object({ sessionId: z.string().uuid() }))
+    .query(...),
+  saveAssistantMessage: protectedProcedure  // Called by desktop on complete
+    .input(z.object({
+      sessionId: z.string().uuid(),
+      content: z.string(),
+      toolCalls: z.any().optional(),
+      inputTokens: z.number().optional(),
+      outputTokens: z.number().optional(),
+    }))
+    .mutation(...),
+  archiveSession: protectedProcedure
+    .input(z.object({ sessionId: z.string().uuid() }))
+    .mutation(...),
+});
+```
+
+**`packages/trpc/src/root.ts`** - Add chatRouter
+
+---
+
+## Phase 7: Client Hooks
+
+### Shared Hook Package
+
+**`packages/ai-chat/src/hooks/useDurableStream.ts`** (new)
+```typescript
+export function useDurableStream(sessionId: string | null) {
+  // Subscribe to Durable Stream via SSE
+  // Track offset for resume
+  // Return: { streamingContent, isConnected, events }
+}
+```
+
+**`packages/ai-chat/src/hooks/usePresence.ts`** (new)
+```typescript
+export function usePresence(sessionId: string | null, user: User) {
+  // Poll/subscribe to presence
+  // Heartbeat for viewing status
+  // Return: { viewers, typingUsers, setTyping }
+}
+```
+
+**`packages/ai-chat/src/hooks/useMultiplayerChat.ts`** (new)
+```typescript
+export function useMultiplayerChat(sessionId: string) {
+  // Combine:
+  // - Electric SQL for completed messages
+  // - Durable Stream for live tokens
+  // - Presence for typing indicators
+  // Return: { messages, sendMessage, viewers, typingUsers, isStreaming }
+}
+```
+
+---
+
+## Phase 8: Desktop Chat UI
+
+**`apps/desktop/src/renderer/screens/chat/`** (new)
+```
+screens/chat/
+├── index.tsx              # Route component
+├── components/
+│   ├── ChatSidebar.tsx    # Session list
+│   ├── ChatMessageList.tsx
+│   ├── ChatMessage.tsx
+│   ├── ChatInput.tsx
+│   ├── PresenceBar.tsx
+│   └── TypingIndicator.tsx
+└── stores/
+    └── chat-store.ts      # Zustand for UI state
+```
+
+Use existing UI components from `@superset/ui` and `packages/ui/src/components/ai-elements/`
+
+---
+
+## Phase 9: Web Chat UI
+
+Web can create sessions and send messages via API. Desktop picks up and runs Claude.
+
+**`apps/web/src/app/(dashboard)/chat/`** (new)
+```
+chat/
+├── page.tsx               # Session list
+├── [sessionId]/
+│   └── page.tsx           # Chat room (view + send via API)
+└── components/
+    ├── ChatMessageList.tsx
+    ├── ChatMessage.tsx
+    ├── ChatInput.tsx       # Calls api.chat.sendMessage
+    ├── PresenceBar.tsx
+    └── TypingIndicator.tsx
+```
+
+**Key difference from desktop**: Web sends messages via API, doesn't run Claude locally. Desktop with workspace open handles execution.
+
+---
+
+## Dependencies to Add
+
+**Root `package.json`:**
+```json
+{
+  "@anthropic-ai/claude-agent-sdk": "^0.2.12",
+  "@durable-streams/client": "^0.1.0",
+  "@durable-streams/server": "^0.1.0",
+  "@durable-streams/state": "^0.1.0"
+}
+```
+
+Note: `@tanstack/db`, `@tanstack/react-db`, `@electric-sql/client` already installed in desktop app.
+
+---
+
+## Environment Variables
+
+```bash
+# Desktop
+DURABLE_STREAM_URL=https://stream.superset.sh
+
+# API
+DURABLE_STREAM_INTERNAL_URL=http://stream-server.internal:8080
+
+# Stream Server (Fly)
+STREAM_STORAGE=cloudflare-kv  # or redis
+```
+
+---
+
+## Verification
+
+1. **Binary bundling**: `bun run build` in desktop, verify claude binary in release/
+2. **Auth resolution**: Test with API key env var, then with existing Keychain auth
+3. **Local streaming**: Send message, verify tokens appear in desktop UI
+4. **Durable Stream**: Disconnect/reconnect, verify resume from offset
+5. **Multi-client**: Open web + desktop, verify both see same tokens
+6. **Presence**: Start typing in one client, verify indicator in other
+7. **Persistence**: Refresh page, verify completed messages load from Electric
+
+---
+
+## Implementation Order
+
+1. **Database schema** - Chat tables + migration
+2. **API chat router** - Session/message CRUD (triggers desktop via Electric)
+3. **Claude binary** - Download script + electron-builder bundling
+4. **Auth resolution** - Keychain/API key reading
+5. **Session manager** - Claude SDK integration + Electric subscription for triggers
+6. **Durable Stream server** - Deploy to Fly with stream + presence endpoints
+7. **Desktop → Durable Stream** - POST tokens from session manager
+8. **Client hooks** - useDurableStream, usePresence, useMultiplayerChat
+9. **Desktop chat UI** - Chat screen with Electric SQL history
+10. **Web chat UI** - View + send messages via API
+
+---
+
+## Critical Files Summary
+
+| File | Purpose |
+|------|---------|
+| `packages/db/src/schema/chat.ts` | Chat tables |
+| `packages/trpc/src/router/chat/index.ts` | API tRPC (session/message CRUD, triggers desktop) |
+| `apps/desktop/scripts/download-claude-binary.ts` | Binary download |
+| `apps/desktop/src/main/lib/claude/` | Binary path, auth, session manager |
+| `apps/desktop/src/main/lib/trpc/routers/ai-chat.ts` | Desktop tRPC (local control) |
+| `apps/stream-server/` | Durable Stream server (Fly) |
+| `packages/ai-chat/src/hooks/` | Shared client hooks |
+| `apps/desktop/src/renderer/screens/chat/` | Desktop UI |
+| `apps/web/src/app/(dashboard)/chat/` | Web UI |
diff --git a/package.json b/package.json
index b576bcc17c8..26de33bb782 100644
--- a/package.json
+++ b/package.json
@@ -15,7 +15,7 @@
 	"packageManager": "bun@1.3.0",
 	"private": true,
 	"scripts": {
-		"dev": "turbo dev --filter=@superset/api --filter=@superset/web --filter=@superset/desktop",
+		"dev": "turbo dev --filter=@superset/api --filter=@superset/web --filter=@superset/desktop --filter=@superset/streams",
 		"dev:all": "turbo dev",
 		"dev:docs": "turbo dev --filter=@superset/docs",
 		"dev:cli": "turbo dev --filter=@superset/cli",
diff --git a/packages/ai-chat/package.json b/packages/ai-chat/package.json
new file mode 100644
index 00000000000..687051bd84e
--- /dev/null
+++ b/packages/ai-chat/package.json
@@ -0,0 +1,37 @@
+{
+	"name": "@superset/ai-chat",
+	"version": "0.0.1",
+	"description": "Shared AI chat hooks and utilities",
+	"type": "module",
+	"main": "./src/index.ts",
+	"exports": {
+		".": "./src/index.ts",
+		"./hooks": "./src/hooks/index.ts",
+		"./components": "./src/components/index.ts",
+		"./stream": "./src/stream/index.ts"
+	},
+	"scripts": {
+		"typecheck": "tsc --noEmit --emitDeclarationOnly false"
+	},
+	"dependencies": {
+		"@anthropic-ai/claude-agent-sdk": "^0.2.19",
+		"@anthropic-ai/sdk": "^0.71.2",
+		"@durable-streams/client": "^0.2.0",
+		"@durable-streams/state": "^0.2.0",
+		"@superset/ui": "workspace:*",
+		"@tanstack/db": "^0.5.24",
+		"@tanstack/react-db": "^0.1.68",
+		"lucide-react": "^0.560.0",
+		"react": "19.1.0",
+		"zod": "^4.3.5"
+	},
+	"devDependencies": {
+		"@superset/typescript": "workspace:*",
+		"@types/node": "^24.9.1",
+		"@types/react": "~19.1.0",
+		"typescript": "^5.9.3"
+	},
+	"peerDependencies": {
+		"react": "^18.0.0 || ^19.0.0"
+	}
+}
diff --git a/packages/ai-chat/src/components/ChatInput/ChatInput.tsx b/packages/ai-chat/src/components/ChatInput/ChatInput.tsx
new file mode 100644
index 00000000000..bc893e83a0b
--- /dev/null
+++ b/packages/ai-chat/src/components/ChatInput/ChatInput.tsx
@@ -0,0 +1,137 @@
+/**
+ * Chat input component with send button
+ */
+
+import { Button } from "@superset/ui/button";
+import { Textarea } from "@superset/ui/textarea";
+import { cn } from "@superset/ui/utils";
+import { Send } from "lucide-react";
+import { type KeyboardEvent, useCallback, useRef, useState } from "react";
+
+export interface ChatInputProps {
+	onSend: (content: string) => void;
+	onTypingChange?: (isTyping: boolean) => void;
+	disabled?: boolean;
+	placeholder?: string;
+	className?: string;
+	/** Button style: "icon" shows Send icon, "text" shows "Send" label */
+	buttonVariant?: "icon" | "text";
+	/** Auto-resize textarea as content grows (default: true) */
+	autoResize?: boolean;
+	/** Controlled value (optional - if provided, component is controlled) */
+	value?: string;
+	/** Controlled onChange (optional - required if value is provided) */
+	onChange?: (value: string) => void;
+}
+
+export function ChatInput({
+	onSend,
+	onTypingChange,
+	disabled = false,
+	placeholder = "Type a message...",
+	className,
+	buttonVariant = "icon",
+	autoResize = true,
+	value: controlledValue,
+	onChange: controlledOnChange,
+}: ChatInputProps) {
+	const [internalValue, setInternalValue] = useState("");
+	const textareaRef = useRef<HTMLTextAreaElement>(null);
+	const typingTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+	// Support both controlled and uncontrolled modes
+	const isControlled = controlledValue !== undefined;
+	const value = isControlled ? controlledValue : internalValue;
+	const setValue = isControlled
+		? (v: string) => controlledOnChange?.(v)
+		: setInternalValue;
+
+	const handleSubmit = useCallback(() => {
+		const trimmed = value.trim();
+		if (!trimmed || disabled) return;
+
+		onSend(trimmed);
+		setValue("");
+		onTypingChange?.(false);
+
+		// Reset textarea height and focus
+		if (textareaRef.current) {
+			if (autoResize) {
+				textareaRef.current.style.height = "auto";
+			}
+			textareaRef.current.focus();
+		}
+	}, [value, disabled, onSend, onTypingChange, autoResize, setValue]);
+
+	const handleKeyDown = useCallback(
+		(e: KeyboardEvent<HTMLTextAreaElement>) => {
+			if (e.key === "Enter" && !e.shiftKey) {
+				e.preventDefault();
+				handleSubmit();
+			}
+		},
+		[handleSubmit],
+	);
+
+	const handleChange = useCallback(
+		(e: React.ChangeEvent<HTMLTextAreaElement>) => {
+			const newValue = e.target.value;
+			setValue(newValue);
+
+			// Auto-resize textarea
+			if (autoResize) {
+				const textarea = e.target;
+				textarea.style.height = "auto";
+				textarea.style.height = `${Math.min(textarea.scrollHeight, 200)}px`;
+			}
+
+			// Typing indicator with debounce
+			if (typingTimeoutRef.current) {
+				clearTimeout(typingTimeoutRef.current);
+			}
+
+			if (newValue.trim()) {
+				onTypingChange?.(true);
+				typingTimeoutRef.current = setTimeout(() => {
+					onTypingChange?.(false);
+				}, 2000);
+			} else {
+				onTypingChange?.(false);
+			}
+		},
+		[onTypingChange, autoResize, setValue],
+	);
+
+	return (
+		<div className={cn("flex gap-2 items-end", className)}>
+			<Textarea
+				ref={textareaRef}
+				value={value}
+				onChange={handleChange}
+				onKeyDown={handleKeyDown}
+				placeholder={placeholder}
+				disabled={disabled}
+				rows={1}
+				className="min-h-[40px] max-h-[200px] resize-none"
+			/>
+			{buttonVariant === "icon" ? (
+				<Button
+					size="icon"
+					onClick={handleSubmit}
+					disabled={disabled || !value.trim()}
+					className="shrink-0"
+				>
+					<Send className="h-4 w-4" />
+				</Button>
+			) : (
+				<Button
+					onClick={handleSubmit}
+					disabled={disabled || !value.trim()}
+					size="default"
+				>
+					Send
+				</Button>
+			)}
+		</div>
+	);
+}
diff --git a/packages/ai-chat/src/components/ChatInput/index.ts b/packages/ai-chat/src/components/ChatInput/index.ts
new file mode 100644
index 00000000000..eabdf78c145
--- /dev/null
+++ b/packages/ai-chat/src/components/ChatInput/index.ts
@@ -0,0 +1 @@
+export { ChatInput, type ChatInputProps } from "./ChatInput";
diff --git a/packages/ai-chat/src/components/PresenceBar/PresenceBar.tsx b/packages/ai-chat/src/components/PresenceBar/PresenceBar.tsx
new file mode 100644
index 00000000000..b43af801c96
--- /dev/null
+++ b/packages/ai-chat/src/components/PresenceBar/PresenceBar.tsx
@@ -0,0 +1,82 @@
+/**
+ * Presence bar showing viewers and typing indicators
+ */
+
+import { Avatar, AvatarFallback, AvatarImage } from "@superset/ui/avatar";
+import { cn } from "@superset/ui/utils";
+import type { PresenceUser } from "../../types";
+
+export interface PresenceBarProps {
+	viewers: PresenceUser[];
+	typingUsers: PresenceUser[];
+	className?: string;
+}
+
+function getInitials(name: string): string {
+	return name
+		.split(" ")
+		.map((n) => n[0])
+		.join("")
+		.toUpperCase()
+		.slice(0, 2);
+}
+
+export function PresenceBar({
+	viewers,
+	typingUsers,
+	className,
+}: PresenceBarProps) {
+	if (viewers.length === 0 && typingUsers.length === 0) {
+		return null;
+	}
+
+	return (
+		<div
+			className={cn(
+				"flex items-center gap-2 px-4 py-2 border-b border-border bg-muted/50",
+				className,
+			)}
+		>
+			{/* Viewers */}
+			{viewers.length > 0 && (
+				<div className="flex items-center gap-1">
+					<div className="flex -space-x-2">
+						{viewers.slice(0, 5).map((user) => (
+							<Avatar
+								key={user.userId}
+								className="h-6 w-6 border-2 border-background"
+							>
+								{user.image && <AvatarImage src={user.image} />}
+								<AvatarFallback className="text-xs">
+									{getInitials(user.name)}
+								</AvatarFallback>
+							</Avatar>
+						))}
+					</div>
+					{viewers.length > 5 && (
+						<span className="text-xs text-muted-foreground">
+							+{viewers.length - 5}
+						</span>
+					)}
+					<span className="text-xs text-muted-foreground ml-1">viewing</span>
+				</div>
+			)}
+
+			{/* Typing indicator */}
+			{typingUsers.length > 0 && (
+				<div className="flex items-center gap-1 ml-auto">
+					<span className="text-xs text-muted-foreground">
+						{typingUsers.length === 1
+							? `${typingUsers[0]?.name} is typing`
+							: `${typingUsers.length} people typing`}
+					</span>
+					<span className="flex gap-0.5">
+						<span className="h-1.5 w-1.5 rounded-full bg-primary animate-bounce [animation-delay:-0.3s]" />
+						<span className="h-1.5 w-1.5 rounded-full bg-primary animate-bounce [animation-delay:-0.15s]" />
+						<span className="h-1.5 w-1.5 rounded-full bg-primary animate-bounce" />
+					</span>
+				</div>
+			)}
+		</div>
+	);
+}
diff --git a/packages/ai-chat/src/components/PresenceBar/index.ts b/packages/ai-chat/src/components/PresenceBar/index.ts
new file mode 100644
index 00000000000..accc01d8d92
--- /dev/null
+++ b/packages/ai-chat/src/components/PresenceBar/index.ts
@@ -0,0 +1 @@
+export { PresenceBar, type PresenceBarProps } from "./PresenceBar";
diff --git a/packages/ai-chat/src/components/index.ts b/packages/ai-chat/src/components/index.ts
new file mode 100644
index 00000000000..134ece8df83
--- /dev/null
+++ b/packages/ai-chat/src/components/index.ts
@@ -0,0 +1,2 @@
+export { ChatInput, type ChatInputProps } from "./ChatInput";
+export { PresenceBar, type PresenceBarProps } from "./PresenceBar";
diff --git a/packages/ai-chat/src/index.ts b/packages/ai-chat/src/index.ts
new file mode 100644
index 00000000000..a44ec03885c
--- /dev/null
+++ b/packages/ai-chat/src/index.ts
@@ -0,0 +1,3 @@
+export * from "./components";
+export * from "./stream";
+export * from "./types";
diff --git a/packages/ai-chat/src/stream/actions.ts b/packages/ai-chat/src/stream/actions.ts
new file mode 100644
index 00000000000..9ed5719aedb
--- /dev/null
+++ b/packages/ai-chat/src/stream/actions.ts
@@ -0,0 +1,129 @@
+/**
+ * Stream Actions
+ *
+ * Simple async functions for writing to the durable stream.
+ * Follows the Electric SQL pattern of plain functions over complex hooks.
+ */
+
+export interface SessionUser {
+	userId: string;
+	name: string;
+}
+
+/**
+ * Create a new stream (PUT request)
+ * Returns true if created, false if already exists
+ */
+export async function createStream(
+	baseUrl: string,
+	sessionId: string,
+): Promise<boolean> {
+	const response = await fetch(`${baseUrl}/streams/${sessionId}`, {
+		method: "PUT",
+		headers: { "Content-Type": "application/json" },
+	});
+
+	// 201 = created, 200 = already exists
+	return response.status === 201;
+}
+
+/**
+ * Helper to POST events to the stream with correct content-type
+ */
+async function appendToStream(url: string, events: unknown[]): Promise<void> {
+	const response = await fetch(url, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(events),
+	});
+
+	if (!response.ok) {
+		throw new Error(`Failed to append to stream: ${response.status}`);
+	}
+}
+
+export interface SessionActions {
+	/** Announce presence when joining */
+	join: () => Promise<void>;
+	/** Remove presence when leaving */
+	leave: () => Promise<void>;
+	/** Update draft content (empty content = delete draft) */
+	updateDraft: (content: string) => Promise<void>;
+}
+
+/**
+ * Creates action functions for a chat session
+ *
+ * @example
+ * ```ts
+ * const actions = createSessionActions({
+ *   baseUrl: "http://localhost:8080",
+ *   sessionId: "abc123",
+ *   user: { userId: "user-1", name: "Alice" }
+ * });
+ *
+ * await actions.join();
+ * await actions.updateDraft("Hello...");
+ * await actions.leave();
+ * ```
+ */
+export function createSessionActions({
+	baseUrl,
+	sessionId,
+	user,
+}: {
+	baseUrl: string;
+	sessionId: string;
+	user: SessionUser;
+}): SessionActions {
+	const streamUrl = `${baseUrl}/streams/${sessionId}`;
+
+	return {
+		join: async () => {
+			await appendToStream(streamUrl, [
+				{
+					type: "presence",
+					key: user.userId,
+					value: {
+						userId: user.userId,
+						userName: user.name,
+						joinedAt: new Date().toISOString(),
+					},
+					headers: { operation: "upsert" },
+				},
+			]);
+		},
+
+		leave: async () => {
+			// Delete presence and draft on leave
+			await appendToStream(streamUrl, [
+				{
+					type: "presence",
+					key: user.userId,
+					headers: { operation: "delete" },
+				},
+				{
+					type: "draft",
+					key: user.userId,
+					headers: { operation: "delete" },
+				},
+			]);
+		},
+
+		updateDraft: async (content: string) => {
+			await appendToStream(streamUrl, [
+				{
+					type: "draft",
+					key: user.userId,
+					value: {
+						userId: user.userId,
+						userName: user.name,
+						content,
+						updatedAt: new Date().toISOString(),
+					},
+					headers: { operation: content ? "upsert" : "delete" },
+				},
+			]);
+		},
+	};
+}
diff --git a/packages/ai-chat/src/stream/client.ts b/packages/ai-chat/src/stream/client.ts
new file mode 100644
index 00000000000..0da066d8ead
--- /dev/null
+++ b/packages/ai-chat/src/stream/client.ts
@@ -0,0 +1,410 @@
+/**
+ * DurableChatClient - Chat session client adapted from Electric SQL.
+ *
+ * Follows the same patterns as @electric-sql/durable-session:
+ * - Synchronous construction (collections available immediately)
+ * - Async connection via connect()
+ * - Proper dispose lifecycle
+ *
+ * Simplified for our schema: chunks, presence, drafts (no agents, tool calls, etc.)
+ */
+
+import { createStreamDB, type StreamDB } from "@durable-streams/state";
+import type { Collection } from "@tanstack/db";
+import type { SessionUser } from "./actions";
+import {
+	type SessionStateSchema,
+	type StreamChunk,
+	type StreamDraft,
+	type StreamPresence,
+	sessionStateSchema,
+} from "./schema";
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+/** UUID generator with fallback for environments without crypto.randomUUID (React Native). */
+function generateUUID(): string {
+	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+		return crypto.randomUUID();
+	}
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+		const r = (Math.random() * 16) | 0;
+		const v = c === "x" ? r : (r & 0x3) | 0x8;
+		return v.toString(16);
+	});
+}
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type ConnectionStatus =
+	| "disconnected"
+	| "connecting"
+	| "connected"
+	| "error";
+
+export interface DurableChatClientOptions {
+	sessionId: string;
+	proxyUrl: string;
+	actorId?: string;
+	user?: SessionUser | null;
+	onError?: (error: Error) => void;
+	onStatusChange?: (status: ConnectionStatus) => void;
+}
+
+/**
+ * Collections map with correct row types.
+ *
+ * stream-db injects the primary key field at runtime, so our types
+ * include the `id` field for chunks.
+ */
+export interface SessionCollections {
+	chunks: Collection<StreamChunk & { id: string }, string>;
+	presence: Collection<StreamPresence, string>;
+	drafts: Collection<StreamDraft, string>;
+}
+
+// ============================================================================
+// DurableChatClient
+// ============================================================================
+
+/**
+ * DurableChatClient - Adapted from @electric-sql/durable-session.
+ *
+ * Provides a simple chat interface backed by Durable Streams.
+ * All collections are available immediately after construction.
+ *
+ * @example
+ * ```typescript
+ * const client = new DurableChatClient({
+ *   sessionId: 'my-session',
+ *   proxyUrl: 'http://localhost:8080',
+ * })
+ *
+ * // Collections available immediately
+ * const chunks = client.collections.chunks
+ *
+ * // Connect to start syncing
+ * await client.connect()
+ *
+ * // Send messages
+ * await client.sendMessage('Hello!')
+ *
+ * // Cleanup
+ * client.dispose()
+ * ```
+ */
+export class DurableChatClient {
+	readonly sessionId: string;
+	readonly actorId: string;
+
+	private readonly options: DurableChatClientOptions;
+
+	// Stream-db instance (created synchronously in constructor)
+	private readonly _db: StreamDB<SessionStateSchema>;
+
+	// Collections are always available after construction
+	private readonly _collections: SessionCollections;
+
+	private _isConnected = false;
+	private _isDisposed = false;
+	private _connectionStatus: ConnectionStatus = "disconnected";
+	private _error: Error | undefined;
+
+	// AbortController for canceling stream sync
+	private readonly _abortController: AbortController;
+
+	// =========================================================================
+	// Constructor
+	// =========================================================================
+
+	constructor(options: DurableChatClientOptions) {
+		this.options = options;
+		this.sessionId = options.sessionId;
+		this.actorId =
+			options.actorId ?? options.user?.userId ?? generateUUID();
+
+		// Create abort controller before anything else
+		this._abortController = new AbortController();
+
+		// Create stream-db synchronously (connection happens on preload)
+		this._db = createStreamDB({
+			streamOptions: {
+				url: `${options.proxyUrl}/streams/${options.sessionId}`,
+				signal: this._abortController.signal,
+			},
+			state: sessionStateSchema,
+		});
+
+		// Collections are available immediately
+		this._collections = this._db.collections as unknown as SessionCollections;
+	}
+
+	// =========================================================================
+	// Getters
+	// =========================================================================
+
+	/**
+	 * Get all collections for direct access.
+	 * Collections are available immediately after construction.
+	 */
+	get collections(): SessionCollections {
+		return this._collections;
+	}
+
+	/**
+	 * Get current connection status.
+	 */
+	get connectionStatus(): ConnectionStatus {
+		return this._connectionStatus;
+	}
+
+	/**
+	 * Check if the client has been disposed.
+	 */
+	get isDisposed(): boolean {
+		return this._isDisposed;
+	}
+
+	/**
+	 * Get the current error, if any.
+	 */
+	get error(): Error | undefined {
+		return this._error;
+	}
+
+	// =========================================================================
+	// Status Management
+	// =========================================================================
+
+	private _setConnectionStatus(status: ConnectionStatus): void {
+		if (this._connectionStatus === status) return;
+		this._connectionStatus = status;
+		this.options.onStatusChange?.(status);
+	}
+
+	// =========================================================================
+	// Lifecycle
+	// =========================================================================
+
+	/**
+	 * Connect to the durable stream and start syncing.
+	 *
+	 * This method handles network operations only - collections are already
+	 * created synchronously in the constructor and are immediately available.
+	 */
+	async connect(): Promise<void> {
+		if (this._isConnected) return;
+		if (this._isDisposed) {
+			throw new Error("Cannot connect disposed client");
+		}
+
+		try {
+			this._setConnectionStatus("connecting");
+			console.log(`[ai-chat/client] connect() sessionId=${this.sessionId} url=${this.options.proxyUrl}`);
+
+			// Preload stream data
+			await this._db.preload();
+
+			this._isConnected = true;
+			this._setConnectionStatus("connected");
+			console.log(`[ai-chat/client] connected, preload complete`);
+
+			// Announce presence if we have a user
+			if (this.options.user) {
+				await this._announcePresence();
+			}
+		} catch (error) {
+			this._error = error instanceof Error ? error : new Error(String(error));
+			this._setConnectionStatus("error");
+			this.options.onError?.(this._error);
+			throw error;
+		}
+	}
+
+	/**
+	 * Disconnect from the stream.
+	 */
+	disconnect(): void {
+		// Remove presence before disconnecting
+		if (this.options.user && this._isConnected) {
+			this._removePresence().catch(() => {});
+		}
+
+		this._db.close();
+		this._abortController.abort();
+		this._isConnected = false;
+		this._setConnectionStatus("disconnected");
+	}
+
+	/**
+	 * Dispose the client and clean up resources.
+	 *
+	 * Note: We only disconnect here - we don't manually cleanup collections.
+	 * TanStack DB will GC collections automatically when they have no subscribers.
+	 */
+	dispose(): void {
+		if (this._isDisposed) return;
+		this._isDisposed = true;
+		this.disconnect();
+	}
+
+	// =========================================================================
+	// Actions
+	// =========================================================================
+
+	/**
+	 * Send a user message.
+	 */
+	async sendMessage(content: string): Promise<void> {
+		if (!this._isConnected) {
+			throw new Error("Client not connected. Call connect() first.");
+		}
+
+		const user = this.options.user;
+		if (!user) {
+			throw new Error("Cannot send message without user");
+		}
+
+		const uuid = generateUUID();
+		console.log(`[ai-chat/client] sendMessage uuid=${uuid} content="${content.slice(0, 50)}"`);
+
+		await this._appendToStream([
+			{
+				type: "chunk",
+				key: uuid,
+				value: {
+					type: "user_input",
+					content,
+					actorId: user.userId,
+					createdAt: new Date().toISOString(),
+				},
+				headers: { operation: "insert" },
+			},
+		]);
+		console.log(`[ai-chat/client] sendMessage POST complete`);
+	}
+
+	/**
+	 * Update the user's draft.
+	 */
+	async updateDraft(content: string): Promise<void> {
+		const user = this.options.user;
+		if (!user) return;
+
+		const now = new Date().toISOString();
+
+		await this._appendToStream([
+			{
+				type: "draft",
+				key: user.userId,
+				value: {
+					userId: user.userId,
+					userName: user.name,
+					content,
+					updatedAt: now,
+				},
+				headers: { operation: content ? "upsert" : "delete" },
+			},
+		]);
+	}
+
+	/**
+	 * Update the user associated with this client.
+	 * Useful for late binding when user auth completes after client creation.
+	 */
+	setUser(user: SessionUser | null): void {
+		const previousUser = this.options.user;
+		(this.options as { user: SessionUser | null }).user = user;
+
+		// If connected, update presence
+		if (this._isConnected) {
+			if (previousUser && !user) {
+				// User logged out - remove presence
+				this._removePresence().catch(this.options.onError ?? console.error);
+			} else if (user && !previousUser) {
+				// User logged in - announce presence
+				this._announcePresence().catch(this.options.onError ?? console.error);
+			} else if (user && previousUser && user.userId !== previousUser.userId) {
+				// User changed - update presence
+				this._removePresence()
+					.then(() => this._announcePresence())
+					.catch(this.options.onError ?? console.error);
+			}
+		}
+	}
+
+	// =========================================================================
+	// Private Helpers
+	// =========================================================================
+
+	private async _announcePresence(): Promise<void> {
+		const user = this.options.user;
+		if (!user) return;
+
+		await this._appendToStream([
+			{
+				type: "presence",
+				key: user.userId,
+				value: {
+					userId: user.userId,
+					userName: user.name,
+					joinedAt: new Date().toISOString(),
+				},
+				headers: { operation: "upsert" },
+			},
+		]);
+	}
+
+	private async _removePresence(): Promise<void> {
+		const user = this.options.user;
+		if (!user) return;
+
+		await this._appendToStream([
+			{
+				type: "presence",
+				key: user.userId,
+				headers: { operation: "delete" },
+			},
+			{
+				type: "draft",
+				key: user.userId,
+				headers: { operation: "delete" },
+			},
+		]);
+	}
+
+	private async _appendToStream(events: unknown[]): Promise<void> {
+		const response = await fetch(
+			`${this.options.proxyUrl}/streams/${this.sessionId}`,
+			{
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(events),
+			},
+		);
+
+		if (!response.ok) {
+			throw new Error(`Failed to append to stream: ${response.status}`);
+		}
+	}
+}
+
+// ============================================================================
+// Factory Function
+// ============================================================================
+
+/**
+ * Create a new DurableChatClient instance.
+ *
+ * @param options - Client options
+ * @returns New client instance
+ */
+export function createDurableChatClient(
+	options: DurableChatClientOptions,
+): DurableChatClient {
+	return new DurableChatClient(options);
+}
diff --git a/packages/ai-chat/src/stream/index.ts b/packages/ai-chat/src/stream/index.ts
new file mode 100644
index 00000000000..e7273a9682e
--- /dev/null
+++ b/packages/ai-chat/src/stream/index.ts
@@ -0,0 +1,42 @@
+/**
+ * Stream module exports
+ */
+
+export type {
+	BetaContentBlock,
+	BetaToolUseBlock,
+} from "@anthropic-ai/sdk/resources/beta/messages/messages";
+export {
+	createSessionActions,
+	createStream,
+	type SessionActions,
+	type SessionUser,
+} from "./actions";
+export {
+	type ConnectionStatus,
+	createDurableChatClient,
+	DurableChatClient,
+	type DurableChatClientOptions,
+	type SessionCollections,
+} from "./client";
+export {
+	type ChunkRow,
+	type MessageRole,
+	type MessageRow,
+	materializeMessages,
+	type ToolResult,
+} from "./materialize";
+export {
+	type SessionStateSchema,
+	type StreamChunk,
+	type StreamDraft,
+	type StreamPresence,
+	sessionStateSchema,
+} from "./schema";
+export {
+	type ChatUser,
+	type UseChatSessionOptions,
+	type UseChatSessionReturn,
+	useChatSession,
+} from "./useChatSession";
+export { useCollectionData } from "./useCollectionData";
diff --git a/packages/ai-chat/src/stream/materialize.ts b/packages/ai-chat/src/stream/materialize.ts
new file mode 100644
index 00000000000..7b1fb3c8368
--- /dev/null
+++ b/packages/ai-chat/src/stream/materialize.ts
@@ -0,0 +1,338 @@
+/**
+ * Message Materialization (SDK-Native, Zero Envelope)
+ *
+ * Processes raw SDK messages and user input chunks from the durable stream
+ * in collection order. Turn boundaries are detected from SDK message type
+ * transitions (stream_event after user = new turn).
+ *
+ * No envelope fields (messageId, seq, role, actorId) — SDK messages are
+ * stored as-is, user input uses { type: "user_input", content, actorId }.
+ */
+
+import type {
+	SDKAssistantMessage,
+	SDKMessage,
+	SDKPartialAssistantMessage,
+	SDKUserMessage,
+} from "@anthropic-ai/claude-agent-sdk";
+import type {
+	BetaContentBlock,
+	BetaRawContentBlockDeltaEvent,
+	BetaRawContentBlockStartEvent,
+	BetaTextBlock,
+	BetaToolUseBlock,
+} from "@anthropic-ai/sdk/resources/beta/messages/messages";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type MessageRole = "user" | "assistant" | "system";
+
+/** Pre-merged tool result — SDK has no joined tool_use + tool_result concept */
+export interface ToolResult {
+	output: string;
+	isError: boolean;
+}
+
+/** Materialized UI state from durable stream chunks */
+export interface MessageRow {
+	id: string;
+	role: MessageRole;
+	content: string;
+	contentBlocks: BetaContentBlock[];
+	toolResults: Map<string, ToolResult>;
+	actorId: string;
+	isComplete: boolean;
+	isStreaming: boolean;
+	createdAt: Date;
+}
+
+/** Raw chunk row from the durable stream collection */
+export type ChunkRow = Record<string, unknown> & { id: string };
+
+// ============================================================================
+// Materialize All Messages
+// ============================================================================
+
+/**
+ * Materialize all messages from raw chunk rows.
+ *
+ * Chunks are sorted by createdAt + _seq before processing to ensure
+ * correct ordering regardless of collection insertion order (which
+ * may not match stream append order after Electric SQL sync/reconnect).
+ *
+ * User input chunks become user messages. SDK message chunks are grouped
+ * into assistant turns with automatic boundary detection.
+ */
+export function materializeMessages(chunks: ChunkRow[]): MessageRow[] {
+	if (chunks.length === 0) return [];
+
+	// Sort by createdAt, then _seq as tiebreaker for same-millisecond chunks
+	const sorted = [...chunks].sort((a, b) => {
+		const aTime = a.createdAt ? new Date(String(a.createdAt)).getTime() : 0;
+		const bTime = b.createdAt ? new Date(String(b.createdAt)).getTime() : 0;
+		if (aTime !== bTime) return aTime - bTime;
+		const aSeq = typeof a._seq === "number" ? a._seq : 0;
+		const bSeq = typeof b._seq === "number" ? b._seq : 0;
+		return aSeq - bSeq;
+	});
+
+	console.log(`[ai-chat/materialize] processing ${sorted.length} sorted chunks, types: ${sorted.map(c => c.type).join(", ")}`);
+
+	const messages: MessageRow[] = [];
+	let currentTurnChunks: ChunkRow[] = [];
+	let lastRenderingType: string | null = null;
+
+	for (const chunk of sorted) {
+		const chunkType = chunk.type as string | undefined;
+
+		// User input from client
+		if (chunkType === "user_input") {
+			// Flush current assistant turn
+			if (currentTurnChunks.length > 0) {
+				messages.push(materializeTurn(currentTurnChunks));
+				currentTurnChunks = [];
+				lastRenderingType = null;
+			}
+			messages.push({
+				id: chunk.id,
+				role: "user",
+				content: String(chunk.content ?? ""),
+				contentBlocks: [],
+				toolResults: new Map(),
+				actorId: String(chunk.actorId ?? ""),
+				isComplete: true,
+				isStreaming: false,
+				createdAt: new Date(
+					String(chunk.createdAt ?? new Date().toISOString()),
+				),
+			});
+			continue;
+		}
+
+		// SDK message — only process rendering-relevant types for turns
+		// Note: "result" is excluded — materializeTurn doesn't handle it,
+		// and including it creates ghost streaming messages from lone result
+		// chunks. It also masks the user→stream_event turn boundary.
+		const isRenderingType =
+			chunkType === "stream_event" ||
+			chunkType === "assistant" ||
+			chunkType === "user";
+
+		if (!isRenderingType) continue;
+
+		// Turn boundary: stream_event after user (tool result) = new turn
+		if (chunkType === "stream_event" && lastRenderingType === "user") {
+			if (currentTurnChunks.length > 0) {
+				messages.push(materializeTurn(currentTurnChunks));
+				currentTurnChunks = [];
+			}
+		}
+
+		currentTurnChunks.push(chunk);
+		lastRenderingType = chunkType;
+	}
+
+	// Flush remaining turn
+	if (currentTurnChunks.length > 0) {
+		messages.push(materializeTurn(currentTurnChunks));
+	}
+
+	return messages;
+}
+
+// ============================================================================
+// Turn Materialization
+// ============================================================================
+
+/**
+ * Materialize a single assistant turn from its SDK message chunks.
+ */
+function materializeTurn(chunks: ChunkRow[]): MessageRow {
+	const firstChunk = chunks[0]!;
+
+	console.log(
+		`[ai-chat/materialize] materializeTurn: ${chunks.length} chunks, types: ${chunks.map((c) => c.type).join(", ")}`,
+	);
+
+	let assistantMsg: SDKAssistantMessage | null = null;
+	const streamEvents: SDKPartialAssistantMessage[] = [];
+	const userMsgs: SDKUserMessage[] = [];
+	for (const chunk of chunks) {
+		const msg = chunk as unknown as SDKMessage;
+		switch (msg.type) {
+			case "assistant":
+				assistantMsg = msg;
+				break;
+			case "stream_event":
+				streamEvents.push(msg);
+				break;
+			case "user":
+				userMsgs.push(msg);
+				break;
+		}
+	}
+
+	// Build content blocks: prefer authoritative assistant message
+	let contentBlocks: BetaContentBlock[];
+	let isStreaming: boolean;
+
+	if (assistantMsg) {
+		contentBlocks = assistantMsg.message.content;
+		isStreaming = false;
+	} else {
+		contentBlocks = buildBlocksFromStreamEvents(streamEvents);
+		isStreaming = true;
+	}
+
+	// Build tool results from user messages (tool_result blocks)
+	const toolResults = buildToolResults(userMsgs);
+
+	// Join text blocks for backward-compat content field
+	const content = contentBlocks
+		.filter((b): b is BetaTextBlock => b.type === "text")
+		.map((b) => b.text)
+		.join("");
+
+	console.log(
+		`[ai-chat/materialize] turn result: id=${firstChunk.id.slice(0, 8)} hasAssistant=${!!assistantMsg} streamEvents=${streamEvents.length} userMsgs=${userMsgs.length} blocks=${contentBlocks.length} contentLen=${content.length} isComplete=${assistantMsg !== null} isStreaming=${isStreaming}`,
+	);
+
+	return {
+		id: firstChunk.id,
+		role: "assistant",
+		content,
+		contentBlocks,
+		toolResults,
+		actorId: "claude",
+		isComplete: assistantMsg !== null,
+		isStreaming,
+		createdAt: firstChunk.createdAt
+			? new Date(String(firstChunk.createdAt))
+			: new Date(),
+	};
+}
+
+// ============================================================================
+// Tool Result Extraction
+// ============================================================================
+
+function buildToolResults(userMsgs: SDKUserMessage[]): Map<string, ToolResult> {
+	const toolResults = new Map<string, ToolResult>();
+
+	for (const userMsg of userMsgs) {
+		const msgContent = userMsg.message.content;
+		if (!Array.isArray(msgContent)) continue;
+
+		for (const block of msgContent) {
+			if (typeof block !== "object" || block === null) continue;
+			if (!("type" in block) || block.type !== "tool_result") continue;
+
+			const tr = block as {
+				tool_use_id?: string;
+				content?: string | Array<{ type: string; text?: string }>;
+				is_error?: boolean;
+			};
+			if (!tr.tool_use_id) continue;
+
+			let output = "";
+			if (typeof tr.content === "string") {
+				output = tr.content;
+			} else if (Array.isArray(tr.content)) {
+				output = tr.content
+					.filter((c) => c.type === "text" && c.text)
+					.map((c) => c.text as string)
+					.join("");
+			}
+
+			toolResults.set(tr.tool_use_id, {
+				output,
+				isError: tr.is_error ?? false,
+			});
+		}
+	}
+
+	return toolResults;
+}
+
+// ============================================================================
+// Stream Event Reconstruction
+// ============================================================================
+
+function buildBlocksFromStreamEvents(
+	events: SDKPartialAssistantMessage[],
+): BetaContentBlock[] {
+	const blocks: BetaContentBlock[] = [];
+	const jsonAccumulators = new Map<number, string>();
+
+	for (const { event } of events) {
+		switch (event.type) {
+			case "content_block_start": {
+				const e = event as BetaRawContentBlockStartEvent;
+				blocks[e.index] = { ...e.content_block };
+				if (e.content_block.type === "tool_use") {
+					jsonAccumulators.set(e.index, "");
+				}
+				break;
+			}
+
+			case "content_block_delta": {
+				const e = event as BetaRawContentBlockDeltaEvent;
+				const block = blocks[e.index];
+				if (!block) break;
+
+				const delta = e.delta;
+				if (delta.type === "text_delta" && block.type === "text") {
+					(block as BetaTextBlock).text += delta.text;
+				} else if (delta.type === "input_json_delta") {
+					const accumulated =
+						(jsonAccumulators.get(e.index) ?? "") + delta.partial_json;
+					jsonAccumulators.set(e.index, accumulated);
+					if (block.type === "tool_use") {
+						try {
+							(block as BetaToolUseBlock).input = JSON.parse(accumulated);
+						} catch {
+							// Partial JSON
+						}
+					}
+				} else if (
+					delta.type === "thinking_delta" &&
+					block.type === "thinking"
+				) {
+					(block as { thinking: string }).thinking += delta.thinking;
+				}
+				break;
+			}
+
+			case "content_block_stop": {
+				const index = (event as { index: number }).index;
+				const accumulated = jsonAccumulators.get(index);
+				const block = blocks[index];
+				if (accumulated && block?.type === "tool_use") {
+					try {
+						(block as BetaToolUseBlock).input = JSON.parse(accumulated);
+					} catch {
+						// Best effort
+					}
+					jsonAccumulators.delete(index);
+				}
+				break;
+			}
+		}
+	}
+
+	return blocks.filter(Boolean);
+}
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+export function isUserMessage(row: MessageRow): boolean {
+	return row.role === "user";
+}
+
+export function isAssistantMessage(row: MessageRow): boolean {
+	return row.role === "assistant";
+}
diff --git a/packages/ai-chat/src/stream/schema.ts b/packages/ai-chat/src/stream/schema.ts
new file mode 100644
index 00000000000..c72444a10ef
--- /dev/null
+++ b/packages/ai-chat/src/stream/schema.ts
@@ -0,0 +1,79 @@
+/**
+ * Durable Streams State Schema
+ *
+ * Defines the state protocol schemas for real-time chat streaming with TanStack DB.
+ * Uses @durable-streams/state for protocol-compliant state management.
+ *
+ * Simplified design:
+ * - Presence = who's in the room (no status field - typing is derived from drafts)
+ * - Drafts = content being typed (non-empty content = user is typing)
+ * - Chunks = streaming message tokens
+ */
+
+import { createStateSchema } from "@durable-streams/state";
+import { z } from "zod";
+
+/**
+ * Chunk schema - raw SDK messages and user input stored directly.
+ *
+ * No envelope wrapping — SDK messages are passthrough, user input uses
+ * { type: "user_input", content, actorId, createdAt }.
+ * The `id` field (primary key) is injected at runtime from the event's `key`.
+ */
+export const chunkSchema = z.record(z.string(), z.unknown());
+
+export type StreamChunk = z.infer<typeof chunkSchema>;
+
+/**
+ * Presence schema - user presence tracking
+ *
+ * Simplified: No status field. Typing is derived from drafts with non-empty content.
+ */
+export const presenceSchema = z.object({
+	userId: z.string(),
+	userName: z.string(),
+	joinedAt: z.string(),
+});
+
+export type StreamPresence = z.infer<typeof presenceSchema>;
+
+/**
+ * Draft schema - user draft messages
+ *
+ * Non-empty content = user is typing.
+ */
+export const draftSchema = z.object({
+	userId: z.string(),
+	userName: z.string(),
+	content: z.string(),
+	cursorPosition: z.number().optional(),
+	updatedAt: z.string(),
+});
+
+export type StreamDraft = z.infer<typeof draftSchema>;
+
+/**
+ * Combined session state schema
+ *
+ * This creates a typed schema that routes different event types
+ * to their respective TanStack DB collections.
+ */
+export const sessionStateSchema = createStateSchema({
+	chunks: {
+		schema: chunkSchema,
+		type: "chunk",
+		primaryKey: "id",
+	},
+	presence: {
+		schema: presenceSchema,
+		type: "presence",
+		primaryKey: "userId",
+	},
+	drafts: {
+		schema: draftSchema,
+		type: "draft",
+		primaryKey: "userId",
+	},
+});
+
+export type SessionStateSchema = typeof sessionStateSchema;
diff --git a/packages/ai-chat/src/stream/useChatSession.ts b/packages/ai-chat/src/stream/useChatSession.ts
new file mode 100644
index 00000000000..14b75d886bc
--- /dev/null
+++ b/packages/ai-chat/src/stream/useChatSession.ts
@@ -0,0 +1,310 @@
+/**
+ * useChatSession - React hook for durable chat.
+ *
+ * Copied 1:1 from @electric-sql/react-durable-session/use-durable-chat.ts
+ * Adapted for our schema: chunks, presence, drafts (no agents, tool calls, etc.)
+ */
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import {
+	type ConnectionStatus,
+	DurableChatClient,
+	type DurableChatClientOptions,
+	type SessionCollections,
+} from "./client";
+import { type MessageRow, materializeMessages } from "./materialize";
+import type { StreamDraft, StreamPresence } from "./schema";
+import { useCollectionData } from "./useCollectionData";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface UseChatSessionOptions
+	extends Omit<DurableChatClientOptions, "onError"> {
+	/** Auto-connect when hook mounts. Defaults to true. */
+	autoConnect?: boolean;
+	/** Provide an existing client instead of creating one */
+	client?: DurableChatClient;
+	/** Error handler */
+	onError?: (error: Error) => void;
+}
+
+export interface ChatUser {
+	userId: string;
+	name: string;
+}
+
+export interface UseChatSessionReturn {
+	// Data
+	messages: MessageRow[];
+	streamingMessage: MessageRow | null;
+	users: ChatUser[];
+	draft: string;
+	drafts: StreamDraft[];
+
+	// Actions
+	sendMessage: (content: string) => Promise<void>;
+	setDraft: (content: string) => void; // Sync for onChange compatibility
+
+	// State
+	isLoading: boolean;
+	error: Error | undefined;
+	connectionStatus: ConnectionStatus;
+
+	// Extensions
+	client: DurableChatClient;
+	collections: SessionCollections;
+	connect: () => Promise<void>;
+	disconnect: () => void;
+}
+
+// ============================================================================
+// Hook Implementation
+// ============================================================================
+
+/**
+ * React hook for durable chat with TanStack AI-compatible API.
+ *
+ * Provides reactive data binding with automatic updates when underlying
+ * collection data changes. Supports SSR through proper `useSyncExternalStore`
+ * integration.
+ *
+ * The client and collections are always available synchronously.
+ * Connection state is managed separately via `connectionStatus`.
+ *
+ * @example Basic usage
+ * ```typescript
+ * function Chat() {
+ *   const { messages, sendMessage, isLoading, collections } = useChatSession({
+ *     sessionId: 'my-session',
+ *     proxyUrl: 'http://localhost:8080',
+ *   })
+ *
+ *   return (
+ *     <div>
+ *       {messages.map(m => <Message key={m.id} message={m} />)}
+ *       <Input onSubmit={sendMessage} disabled={isLoading} />
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+export function useChatSession(
+	options: UseChatSessionOptions,
+): UseChatSessionReturn {
+	const {
+		autoConnect = true,
+		client: providedClient,
+		onError: userOnError,
+		...clientOptions
+	} = options;
+
+	// Error handler ref - allows client's onError to call setError
+	const [error, setError] = useState<Error | undefined>();
+	const onErrorRef = useRef<(err: Error) => void>(() => {});
+	onErrorRef.current = (err) => {
+		setError(err);
+		userOnError?.(err);
+	};
+
+	// Connection status state - ensures React re-renders on status changes
+	const [connectionStatus, setConnectionStatus] =
+		useState<ConnectionStatus>("disconnected");
+	const onStatusChangeRef = useRef<(status: ConnectionStatus) => void>(
+		() => {},
+	);
+	onStatusChangeRef.current = (status) => {
+		setConnectionStatus(status);
+	};
+
+	// Create client synchronously - always available immediately
+	const clientRef = useRef<{
+		client: DurableChatClient;
+		key: string;
+	} | null>(null);
+	const key = `${clientOptions.sessionId}:${clientOptions.proxyUrl}`;
+
+	// Create or recreate client when key changes or client was disposed
+	// The isDisposed check handles React Strict Mode: cleanup disposes the client,
+	// so the next render must create a fresh one with a new AbortController.
+	if (providedClient) {
+		if (!clientRef.current || clientRef.current.client !== providedClient) {
+			clientRef.current = { client: providedClient, key: "provided" };
+		}
+	} else if (
+		!clientRef.current ||
+		clientRef.current.key !== key ||
+		clientRef.current.client.isDisposed
+	) {
+		// Dispose old client if exists (may already be disposed, which is fine)
+		clientRef.current?.client.dispose();
+		clientRef.current = {
+			client: new DurableChatClient({
+				...clientOptions,
+				onError: (err) => onErrorRef.current(err),
+				onStatusChange: (status) => onStatusChangeRef.current(status),
+			}),
+			key,
+		};
+	}
+
+	const client = clientRef.current.client;
+
+	// =========================================================================
+	// Collection Subscriptions (1:1 from Electric SQL)
+	// =========================================================================
+
+	const chunkRows = useCollectionData(client.collections.chunks);
+	const presenceRows = useCollectionData(client.collections.presence);
+	const draftRows = useCollectionData(client.collections.drafts);
+
+	// =========================================================================
+	// Derived State
+	// =========================================================================
+
+	// Materialize messages from chunks (processed in collection order)
+	const { messages, streamingMessage } = useMemo(() => {
+		console.log(`[ai-chat/session] materialize: ${chunkRows.length} chunks`);
+		if (chunkRows.length === 0) {
+			return { messages: [], streamingMessage: null };
+		}
+
+		const all = materializeMessages(
+			chunkRows as Array<Record<string, unknown> & { id: string }>,
+		);
+
+		// Separate complete messages from streaming (incomplete) message
+		const complete = all.filter((m) => m.isComplete);
+		const streaming = all.find((m) => !m.isComplete) ?? null;
+
+		console.log(
+			`[ai-chat/session] materialized: ${all.length} total, ${complete.length} complete, streaming=${streaming ? `id=${streaming.id} role=${streaming.role} content="${streaming.content.slice(0, 80)}" blocks=${streaming.contentBlocks.length} isComplete=${streaming.isComplete} isStreaming=${streaming.isStreaming}` : "null"}`,
+		);
+		if (all.length > 0) {
+			console.log(
+				`[ai-chat/session] all messages:`,
+				all.map((m) => ({
+					id: m.id.slice(0, 8),
+					role: m.role,
+					isComplete: m.isComplete,
+					isStreaming: m.isStreaming,
+					contentLen: m.content.length,
+					blocks: m.contentBlocks.length,
+				})),
+			);
+		}
+
+		return { messages: complete, streamingMessage: streaming };
+	}, [chunkRows]);
+
+	// Transform presence to ChatUser[]
+	const users = useMemo(
+		(): ChatUser[] =>
+			presenceRows.map((p: StreamPresence) => ({
+				userId: p.userId,
+				name: p.userName,
+			})),
+		[presenceRows],
+	);
+
+	// All drafts
+	const drafts = useMemo((): StreamDraft[] => draftRows, [draftRows]);
+
+	// Current user's draft
+	const draft = useMemo((): string => {
+		const user = clientOptions.user;
+		if (!user) return "";
+		const myDraft = draftRows.find(
+			(d: StreamDraft) => d.userId === user.userId,
+		);
+		return myDraft?.content ?? "";
+	}, [draftRows]);
+
+	const isLoading = connectionStatus !== "connected";
+
+	// =========================================================================
+	// Connection Lifecycle (1:1 from Electric SQL)
+	// =========================================================================
+
+	useEffect(() => {
+		if (autoConnect && client.connectionStatus === "disconnected") {
+			client.connect().catch((err) => {
+				setError(err instanceof Error ? err : new Error(String(err)));
+			});
+		}
+
+		// Cleanup: unsubscribe and dispose (disposal is idempotent)
+		return () => {
+			if (!providedClient) {
+				client.dispose();
+			}
+		};
+	}, [client, autoConnect, providedClient]);
+
+	// =========================================================================
+	// Action Callbacks (1:1 from Electric SQL)
+	// =========================================================================
+
+	const sendMessage = useCallback(
+		async (content: string) => {
+			try {
+				await client.sendMessage(content);
+			} catch (err) {
+				setError(err instanceof Error ? err : new Error(String(err)));
+				throw err;
+			}
+		},
+		[client],
+	);
+
+	// setDraft is sync (fire-and-forget) for onChange compatibility
+	const setDraft = useCallback(
+		(content: string) => {
+			client.updateDraft(content).catch((err) => {
+				setError(err instanceof Error ? err : new Error(String(err)));
+			});
+		},
+		[client],
+	);
+
+	const connect = useCallback(async () => {
+		try {
+			await client.connect();
+		} catch (err) {
+			setError(err instanceof Error ? err : new Error(String(err)));
+			throw err;
+		}
+	}, [client]);
+
+	const disconnect = useCallback(() => {
+		client.disconnect();
+	}, [client]);
+
+	// =========================================================================
+	// Return (1:1 structure from Electric SQL)
+	// =========================================================================
+
+	return {
+		// Data
+		messages,
+		streamingMessage,
+		users,
+		draft,
+		drafts,
+
+		// Actions
+		sendMessage,
+		setDraft,
+
+		// State
+		isLoading,
+		error,
+		connectionStatus,
+
+		// Extensions
+		client,
+		collections: client.collections,
+		connect,
+		disconnect,
+	};
+}
diff --git a/packages/ai-chat/src/stream/useCollectionData.ts b/packages/ai-chat/src/stream/useCollectionData.ts
new file mode 100644
index 00000000000..7c749c5a804
--- /dev/null
+++ b/packages/ai-chat/src/stream/useCollectionData.ts
@@ -0,0 +1,104 @@
+/**
+ * SSR-safe hook for subscribing to TanStack DB collection data.
+ *
+ * Copied verbatim from @electric-sql/react-durable-session.
+ * This is a workaround to useLiveQuery not yet supporting SSR
+ * as per https://github.com/TanStack/db/pull/709
+ */
+
+import type { Collection } from "@tanstack/db";
+import { useRef, useSyncExternalStore } from "react";
+
+/**
+ * Extract the item type from a Collection.
+ *
+ * TanStack DB's Collection has 5 type parameters:
+ * `Collection<T, TKey, TUtils, TSchema, TInsertInput>`
+ *
+ * This helper extracts `T` (the item type) from any Collection variant.
+ */
+type CollectionItem<C> =
+	C extends Collection<infer T, any, any, any, any> ? T : never;
+
+/**
+ * SSR-safe hook for subscribing to TanStack DB collection data.
+ * This is a workaround to useLiveQuery not yet supporting SSR
+ * as per https://github.com/TanStack/db/pull/709
+ */
+export function useCollectionData<
+	C extends Collection<any, any, any, any, any>,
+>(collection: C): CollectionItem<C>[] {
+	type T = CollectionItem<C>;
+
+	// Track version to know when to create a new snapshot.
+	// Incremented by subscription callback when collection changes.
+	const versionRef = useRef(0);
+
+	// Cache the last snapshot to maintain stable reference.
+	// useSyncExternalStore requires getSnapshot to return the same reference
+	// when data hasn't changed, otherwise it triggers infinite re-renders.
+	const snapshotRef = useRef<{ version: number; data: T[] }>({
+		version: -1, // Force initial snapshot creation
+		data: [],
+	});
+
+	// Subscribe callback - increments version to signal data changed.
+	// Stored in ref to maintain stable reference for useSyncExternalStore.
+	const subscribeRef = useRef((onStoreChange: () => void): (() => void) => {
+		const subscription = collection.subscribeChanges(() => {
+			versionRef.current++;
+			onStoreChange();
+		});
+		return () => subscription.unsubscribe();
+	});
+
+	// Update subscribe ref when collection changes
+	subscribeRef.current = (onStoreChange: () => void): (() => void) => {
+		const subscription = collection.subscribeChanges(() => {
+			versionRef.current++;
+			console.log(`[ai-chat/collection] change detected, version=${versionRef.current}, size=${collection.size}`);
+			onStoreChange();
+		});
+		return () => subscription.unsubscribe();
+	};
+
+	// Snapshot callback - returns cached data unless version changed.
+	// Stored in ref to maintain stable reference for useSyncExternalStore.
+	const getSnapshotRef = useRef((): T[] => {
+		const currentVersion = versionRef.current;
+		const cached = snapshotRef.current;
+
+		// Return cached snapshot if version hasn't changed
+		if (cached.version === currentVersion) {
+			return cached.data;
+		}
+
+		// Version changed - create new snapshot and cache it
+		const data = [...collection.values()] as T[];
+		snapshotRef.current = { version: currentVersion, data };
+		return data;
+	});
+
+	// Update getSnapshot ref when collection changes
+	getSnapshotRef.current = (): T[] => {
+		const currentVersion = versionRef.current;
+		const cached = snapshotRef.current;
+
+		if (cached.version === currentVersion) {
+			return cached.data;
+		}
+
+		const data = [...collection.values()] as T[];
+		snapshotRef.current = { version: currentVersion, data };
+		return data;
+	};
+
+	// Pass the same function for both getSnapshot and getServerSnapshot.
+	// This ensures server and client render the same initial state (empty array),
+	// preventing hydration mismatches while enabling proper SSR.
+	return useSyncExternalStore(
+		subscribeRef.current,
+		getSnapshotRef.current,
+		getSnapshotRef.current,
+	);
+}
diff --git a/packages/ai-chat/src/types.ts b/packages/ai-chat/src/types.ts
new file mode 100644
index 00000000000..ee2c9903b06
--- /dev/null
+++ b/packages/ai-chat/src/types.ts
@@ -0,0 +1,112 @@
+/**
+ * Shared types for AI chat
+ */
+
+export interface StreamTextDeltaEvent {
+	type: "text_delta";
+	text: string;
+	timestamp: number;
+}
+
+export interface StreamToolUseStartEvent {
+	type: "tool_use_start";
+	toolName: string;
+	toolId: string;
+	timestamp: number;
+}
+
+export interface StreamToolUseDeltaEvent {
+	type: "tool_use_delta";
+	toolId: string;
+	partialJson: string;
+	timestamp: number;
+}
+
+export interface StreamToolUseEndEvent {
+	type: "tool_use_end";
+	toolId: string;
+	timestamp: number;
+}
+
+export interface StreamMessageCompleteEvent {
+	type: "message_complete";
+	inputTokens?: number;
+	outputTokens?: number;
+	timestamp: number;
+}
+
+export interface StreamErrorEvent {
+	type: "error";
+	error: string;
+	timestamp: number;
+}
+
+export interface StreamSessionStartEvent {
+	type: "session_start";
+	timestamp: number;
+}
+
+export interface StreamSessionEndEvent {
+	type: "session_end";
+	exitCode: number | null;
+	timestamp: number;
+}
+
+export type StreamEvent =
+	| StreamTextDeltaEvent
+	| StreamToolUseStartEvent
+	| StreamToolUseDeltaEvent
+	| StreamToolUseEndEvent
+	| StreamMessageCompleteEvent
+	| StreamErrorEvent
+	| StreamSessionStartEvent
+	| StreamSessionEndEvent;
+
+export interface StreamEntry {
+	offset: number;
+	event: StreamEvent;
+}
+
+export interface PresenceUser {
+	userId: string;
+	name: string;
+	image?: string;
+}
+
+export interface PresenceState {
+	viewers: PresenceUser[];
+	typingUsers: PresenceUser[];
+}
+
+export interface Draft {
+	userId: string;
+	userName: string;
+	content: string;
+	updatedAt: number;
+}
+
+export interface ChatMessage {
+	id: string;
+	sessionId: string;
+	role: "user" | "assistant";
+	content: string;
+	toolCalls?: unknown[];
+	inputTokens?: number;
+	outputTokens?: number;
+	createdById: string;
+	createdAt: Date;
+}
+
+export interface ChatSession {
+	id: string;
+	organizationId: string;
+	repositoryId?: string | null;
+	workspaceId?: string | null;
+	title: string;
+	claudeSessionId?: string | null;
+	cwd?: string | null;
+	createdById: string;
+	archivedAt?: Date | null;
+	createdAt: Date;
+	updatedAt: Date;
+}
diff --git a/packages/ai-chat/tsconfig.json b/packages/ai-chat/tsconfig.json
new file mode 100644
index 00000000000..f875d92d3a9
--- /dev/null
+++ b/packages/ai-chat/tsconfig.json
@@ -0,0 +1,12 @@
+{
+	"extends": "@superset/typescript/base.json",
+	"compilerOptions": {
+		"outDir": "./dist",
+		"rootDir": "./src",
+		"lib": ["ES2022", "DOM", "DOM.Iterable"],
+		"jsx": "react-jsx",
+		"types": ["node"]
+	},
+	"include": ["src/**/*.ts", "src/**/*.tsx"],
+	"exclude": ["node_modules", "dist"]
+}
diff --git a/packages/shared/src/constants.ts b/packages/shared/src/constants.ts
index ca3eb3005a7..4bde833f91d 100644
--- a/packages/shared/src/constants.ts
+++ b/packages/shared/src/constants.ts
@@ -55,6 +55,8 @@ export const FEATURE_FLAGS = {
 	BILLING_ENABLED: "billing-enabled",
 	/** Gates access to GitHub integration (currently buggy, internal only). */
 	GITHUB_INTEGRATION_ACCESS: "github-integration-access",
+	/** Gates access to AI chat (@superset.sh internal only). */
+	AI_CHAT: "ai-chat",
 	/** Gates access to Slack integration (internal only). */
 	SLACK_INTEGRATION_ACCESS: "slack-integration-access",
 } as const;