@kmugalkhod/lightcode 0.17.3 → 0.18.1

package/server.js

@@ -4903,6 +4903,32 @@ async function executeGitStatus(input, workspaceContext = getDefaultWorkspaceCon
     error: null
   });
 }
+async function executeGitNumstat(workspaceContext = getDefaultWorkspaceContext()) {
+  const counts = new Map;
+  for (const staged of [false, true]) {
+    const args = ["diff", "--no-ext-diff", "--no-renames", "--numstat"];
+    if (staged)
+      args.push("--cached");
+    args.push("--", ".");
+    const result = await runGit(args, workspaceContext);
+    if (!result.ok)
+      continue;
+    for (const line of result.stdout.split(`
+`)) {
+      const match = /^(\d+|-)\t(\d+|-)\t(.+)$/.exec(line.trimEnd());
+      if (!match)
+        continue;
+      const [, addedText, removedText, path9] = match;
+      const binary = addedText === "-" || removedText === "-";
+      const previous = counts.get(path9);
+      counts.set(path9, {
+        added: binary || previous?.added === null ? null : (previous?.added ?? 0) + Number(addedText),
+        removed: binary || previous?.removed === null ? null : (previous?.removed ?? 0) + Number(removedText)
+      });
+    }
+  }
+  return counts;
+}
 async function executeGitDiff(input, workspaceContext = getDefaultWorkspaceContext()) {
   const parsedInput = gitDiffInputSchema.parse(input);
   const relativePath = resolveOptionalGitPath(parsedInput.path, workspaceContext);
@@ -9688,7 +9714,7 @@ var init_runtime16 = __esm(() => {
 
 // packages/ai/src/workspace-browser.ts
 import { z as z38 } from "zod";
-var workspaceLocationIdSchema, workspaceLocationStateSchema, workspaceLocationSchema, workspaceLocationsResponseSchema, workspaceBrowserOpenRequestSchema, workspaceBrowserIdSchema, workspaceBrowserOpenResponseSchema, workspacePathSegmentSchema, workspacePathSegmentsSchema, workspaceBrowserCursorSchema, workspaceBrowserEntriesRequestSchema, workspaceBrowserEntryKindSchema, workspaceBrowserSymlinkStateSchema, workspaceBrowserEntrySchema, workspaceBrowserEntriesResponseSchema, workspaceBrowserSelectRequestSchema, workspaceGrantIdSchema, workspaceGrantSchema, workspaceNativePickerRequestSchema, workspaceNativePickerResponseSchema, workspaceBrowserSelectResponseSchema, workspaceSessionPathParamsSchema, workspaceSessionCreateRequestSchema, workspaceBrowserPathParamsSchema, workspaceApiErrorCodeSchema, workspaceApiErrorResponseSchema;
+var workspaceLocationIdSchema, workspaceLocationStateSchema, workspaceLocationSchema, workspaceLocationsResponseSchema, workspaceBrowserOpenRequestSchema, workspaceBrowserIdSchema, workspaceBrowserOpenResponseSchema, workspacePathSegmentSchema, workspacePathSegmentsSchema, workspaceBrowserCursorSchema, workspaceBrowserEntriesRequestSchema, workspaceBrowserEntryKindSchema, workspaceBrowserSymlinkStateSchema, workspaceBrowserEntrySchema, workspaceBrowserEntriesResponseSchema, workspaceBrowserSelectRequestSchema, workspaceGrantIdSchema, workspaceGrantSchema, workspaceRecentKeySchema, workspaceRecentProjectSchema, workspaceRecentProjectsResponseSchema, workspaceRecentPathParamsSchema, workspaceRecentGrantRequestSchema, workspaceNativePickerRequestSchema, workspaceNativePickerResponseSchema, workspaceLaunchFolderResponseSchema, workspaceLaunchFolderGrantRequestSchema, workspaceBrowserSelectResponseSchema, workspaceSessionPathParamsSchema, workspaceSessionCreateRequestSchema, workspaceBrowserPathParamsSchema, workspaceApiErrorCodeSchema, workspaceApiErrorResponseSchema;
 var init_workspace_browser = __esm(() => {
   init_coding_agent_modes();
   init_permissions();
@@ -9697,7 +9723,8 @@ var init_workspace_browser = __esm(() => {
     "home",
     "documents",
     "downloads",
-    "projects"
+    "projects",
+    "drives"
   ]);
   workspaceLocationStateSchema = z38.enum([
     "unprobed",
@@ -9706,7 +9733,7 @@ var init_workspace_browser = __esm(() => {
   workspaceLocationSchema = z38.object({
     id: workspaceLocationIdSchema,
     name: z38.string().min(1).max(120),
-    kind: z38.literal("known-folder"),
+    kind: z38.enum(["known-folder", "drives"]),
     state: workspaceLocationStateSchema,
     pathLabel: z38.string().min(1).max(4096)
   }).strict();
@@ -9733,7 +9760,8 @@ var init_workspace_browser = __esm(() => {
     segments: workspacePathSegmentsSchema.default([]),
     cursor: workspaceBrowserCursorSchema.optional(),
     limit: z38.number().int().min(1).max(200).default(80),
-    includeHidden: z38.boolean().default(false)
+    includeHidden: z38.boolean().default(false),
+    directoriesOnly: z38.boolean().default(false)
   }).strict();
   workspaceBrowserEntryKindSchema = z38.enum([
     "file",
@@ -9768,8 +9796,24 @@ var init_workspace_browser = __esm(() => {
     id: workspaceGrantIdSchema,
     name: z38.string().min(1).max(255),
     pathLabel: z38.string().min(1).max(4096),
+    hostPath: z38.string().min(1).max(4096).optional(),
     createdAt: z38.string().min(1)
   }).strict();
+  workspaceRecentKeySchema = z38.string().regex(/^[A-Za-z0-9_-]{22}$/);
+  workspaceRecentProjectSchema = z38.object({
+    key: workspaceRecentKeySchema,
+    name: z38.string().min(1).max(255),
+    pathLabel: z38.string().min(1).max(4096),
+    lastUsedAt: z38.string().min(1),
+    available: z38.boolean()
+  }).strict();
+  workspaceRecentProjectsResponseSchema = z38.object({
+    projects: z38.array(workspaceRecentProjectSchema)
+  }).strict();
+  workspaceRecentPathParamsSchema = z38.object({
+    key: workspaceRecentKeySchema
+  }).strict();
+  workspaceRecentGrantRequestSchema = z38.object({}).strict();
   workspaceNativePickerRequestSchema = z38.object({}).strict();
   workspaceNativePickerResponseSchema = z38.discriminatedUnion("outcome", [
     z38.object({
@@ -9780,6 +9824,16 @@ var init_workspace_browser = __esm(() => {
       outcome: z38.literal("cancelled")
     }).strict()
   ]);
+  workspaceLaunchFolderResponseSchema = z38.discriminatedUnion("available", [
+    z38.object({
+      available: z38.literal(true),
+      name: z38.string().min(1).max(255),
+      pathLabel: z38.string().min(1).max(4096),
+      broad: z38.boolean()
+    }).strict(),
+    z38.object({ available: z38.literal(false) }).strict()
+  ]);
+  workspaceLaunchFolderGrantRequestSchema = z38.object({}).strict();
   workspaceBrowserSelectResponseSchema = z38.object({
     workspace: workspaceGrantSchema
   }).strict();
@@ -9797,6 +9851,8 @@ var init_workspace_browser = __esm(() => {
   workspaceApiErrorCodeSchema = z38.enum([
     "invalid_request",
     "location_not_found",
+    "location_missing",
+    "drive_root_not_selectable",
     "os_permission_denied",
     "workspace_missing",
     "workspace_replaced",
@@ -9819,6 +9875,61 @@ var init_workspace_browser = __esm(() => {
   }).strict();
 });
 
+// packages/ai/src/session-changes-schemas.ts
+import { z as z39 } from "zod";
+function changeKindFromGitStatus(indexStatus, workingTreeStatus) {
+  if (indexStatus === "?" || workingTreeStatus === "?") {
+    return "untracked";
+  }
+  const code = (workingTreeStatus.trim() || indexStatus.trim()).toUpperCase();
+  switch (code) {
+    case "A":
+      return "created";
+    case "D":
+      return "deleted";
+    case "R":
+      return "renamed";
+    default:
+      return "modified";
+  }
+}
+var sessionChangeFileIdSchema, sessionChangeKindSchema, sessionChangedFileSchema, sessionChangesResponseSchema, sessionChangeDiffParamsSchema, sessionChangeDiffResponseSchema;
+var init_session_changes_schemas = __esm(() => {
+  init_chat_schemas();
+  sessionChangeFileIdSchema = z39.string().regex(/^[A-Za-z0-9_-]{22}$/);
+  sessionChangeKindSchema = z39.enum([
+    "created",
+    "modified",
+    "deleted",
+    "renamed",
+    "untracked"
+  ]);
+  sessionChangedFileSchema = z39.object({
+    fileId: sessionChangeFileIdSchema,
+    path: z39.string().min(1).max(4096),
+    originalPath: z39.string().max(4096).nullable(),
+    changeKind: sessionChangeKindSchema,
+    added: z39.number().int().nonnegative().nullable(),
+    removed: z39.number().int().nonnegative().nullable()
+  }).strict();
+  sessionChangesResponseSchema = z39.object({
+    isRepo: z39.boolean(),
+    branch: z39.string().nullable(),
+    files: z39.array(sessionChangedFileSchema),
+    truncated: z39.boolean()
+  }).strict();
+  sessionChangeDiffParamsSchema = z39.object({
+    id: sessionIdentifierSchema,
+    fileId: sessionChangeFileIdSchema
+  }).strict();
+  sessionChangeDiffResponseSchema = z39.object({
+    path: z39.string().min(1),
+    diff: z39.string(),
+    truncated: z39.boolean(),
+    binary: z39.boolean()
+  }).strict();
+});
+
 // packages/ai/src/index.ts
 var init_src2 = __esm(() => {
   init_agent_tools();
@@ -9855,6 +9966,7 @@ var init_src2 = __esm(() => {
   init_tool_input();
   init_config2();
   init_workspace_browser();
+  init_session_changes_schemas();
 });
 
 // apps/server/src/lib/chat-interaction-store.ts
@@ -11547,6 +11659,37 @@ async function mergeSessionTurnDelta(sessionIdentifier, input) {
     appended: true
   };
 }
+async function listRecentWorkspaces(limit = 8) {
+  const sessions = await prisma.chatSession.findMany({
+    where: { cwd: { not: null } },
+    orderBy: [{ updatedAt: "desc" }, { createdAt: "desc" }],
+    take: 200,
+    select: {
+      cwd: true,
+      workspaceDevice: true,
+      workspaceInode: true,
+      updatedAt: true
+    }
+  });
+  const seen = new Set;
+  const recent = [];
+  for (const session of sessions) {
+    if (!session.cwd)
+      continue;
+    const key = process.platform === "win32" ? session.cwd.toLowerCase() : session.cwd;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    recent.push({
+      cwd: session.cwd,
+      identity: session.workspaceDevice && session.workspaceInode ? { device: session.workspaceDevice, inode: session.workspaceInode } : null,
+      lastUsedAt: session.updatedAt
+    });
+    if (recent.length >= limit)
+      break;
+  }
+  return recent;
+}
 async function listChatSessions(limit = 50) {
   const safeLimit = Math.min(Math.max(limit, 1), 100);
   const sessions = await prisma.chatSession.findMany({
@@ -13155,7 +13298,7 @@ var init_sse_heartbeat = __esm(() => {
 // apps/server/src/lib/openrouter-models.ts
 import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
 import path20 from "path";
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 function getCacheFilePath() {
   return path20.join(getLightcodeDataDir(), "cache", "openrouter-models.json");
 }
@@ -13218,7 +13361,7 @@ async function fetchModelsFromApi() {
   if (!response.ok) {
     throw new Error(`OpenRouter models API returned HTTP ${response.status}.`);
   }
-  const payload = z39.object({ data: z39.array(z39.unknown()) }).parse(await response.json());
+  const payload = z40.object({ data: z40.array(z40.unknown()) }).parse(await response.json());
   const models = payload.data.map(summarizeRawModel).filter((model) => model !== null);
   if (models.length === 0) {
     throw new Error("OpenRouter models API returned no models.");
@@ -13283,21 +13426,21 @@ var init_openrouter_models = __esm(() => {
   init_network_fetch();
   logger5 = createLogger("openrouter-models");
   cacheTtlMs = 24 * 60 * 60 * 1000;
-  openRouterModelSummarySchema = z39.object({
-    id: z39.string(),
-    name: z39.string(),
-    contextLength: z39.number().int().positive().nullable(),
-    maxCompletionTokens: z39.number().int().positive().nullable().default(null),
-    supportsTools: z39.boolean(),
-    supportsReasoning: z39.boolean(),
-    pricing: z39.object({
-      prompt: z39.string().nullable(),
-      completion: z39.string().nullable()
+  openRouterModelSummarySchema = z40.object({
+    id: z40.string(),
+    name: z40.string(),
+    contextLength: z40.number().int().positive().nullable(),
+    maxCompletionTokens: z40.number().int().positive().nullable().default(null),
+    supportsTools: z40.boolean(),
+    supportsReasoning: z40.boolean(),
+    pricing: z40.object({
+      prompt: z40.string().nullable(),
+      completion: z40.string().nullable()
     }).nullable()
   });
-  modelsCacheSchema = z39.object({
-    fetchedAt: z39.number(),
-    models: z39.array(openRouterModelSummarySchema)
+  modelsCacheSchema = z40.object({
+    fetchedAt: z40.number(),
+    models: z40.array(openRouterModelSummarySchema)
   });
 });
 
@@ -13929,7 +14072,7 @@ import {
 } from "fs/promises";
 import { platform as platform3 } from "os";
 import path21 from "path";
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 function isContainedPath(root, candidate) {
   const relative = path21.relative(root, candidate);
   return relative === "" || !relative.startsWith("..") && !path21.isAbsolute(relative);
@@ -14386,15 +14529,15 @@ var init_workspace_context = __esm(() => {
   init_src();
   logger7 = createLogger("workspace-context");
   projectInstructionNames = ["AGENTS.md", "CLAUDE.md"];
-  instructionEpochSchema = z40.object({
-    epoch: z40.number().int().positive(),
-    source: z40.string().min(1),
-    sha256: z40.string().regex(/^[a-f0-9]{64}$/),
-    content: z40.string(),
-    discoveredAt: z40.string().min(1)
+  instructionEpochSchema = z41.object({
+    epoch: z41.number().int().positive(),
+    source: z41.string().min(1),
+    sha256: z41.string().regex(/^[a-f0-9]{64}$/),
+    content: z41.string(),
+    discoveredAt: z41.string().min(1)
   });
-  instructionEpochStateSchema = z40.object({
-    epochs: z40.array(instructionEpochSchema)
+  instructionEpochStateSchema = z41.object({
+    epochs: z41.array(instructionEpochSchema)
   });
   gitSummaryCache = new Map;
 });
@@ -16379,16 +16522,16 @@ var init_chat_routes = __esm(() => {
 
 // apps/server/src/routes/config-routes.ts
 import { Hono as Hono2 } from "hono";
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 var selectModelRequestSchema, configRoutes;
 var init_config_routes = __esm(() => {
   init_src2();
   init_src();
   init_openrouter_models();
   init_runtime_config();
-  selectModelRequestSchema = z41.object({
+  selectModelRequestSchema = z42.object({
     provider: lightcodeProviderSchema,
-    model: z41.string().min(1).max(240)
+    model: z42.string().min(1).max(240)
   });
   configRoutes = new Hono2().get("/status", (c) => c.json(configStatus)).post("/reload", (c) => c.json({ ok: true, configStatus: reloadRuntimeConfig() })).get("/models", async (c) => {
     const provider = c.req.query("provider") ?? "openrouter";
@@ -16835,20 +16978,20 @@ var init_diagnostics_routes = __esm(() => {
 // apps/server/src/routes/extension-routes.ts
 import { zValidator as zValidator2 } from "@hono/zod-validator";
 import { Hono as Hono4 } from "hono";
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 var skillParamsSchema, skillListQuerySchema, mcpServerParamsSchema, extensionRoutes;
 var init_extension_routes = __esm(() => {
   init_src2();
   init_extension_runtime();
   init_chat_store();
-  skillParamsSchema = z42.object({
-    name: z42.string().min(1).max(160)
+  skillParamsSchema = z43.object({
+    name: z43.string().min(1).max(160)
   });
-  skillListQuerySchema = z42.object({
+  skillListQuerySchema = z43.object({
     sessionId: sessionIdentifierSchema.optional()
   });
-  mcpServerParamsSchema = z42.object({
-    name: z42.string().min(1).max(120)
+  mcpServerParamsSchema = z43.object({
+    name: z43.string().min(1).max(120)
   });
   extensionRoutes = new Hono4().get("/skills", zValidator2("query", skillListQuerySchema), async (c) => {
     const { sessionId } = c.req.valid("query");
@@ -17017,6 +17160,16 @@ var init_web_routes = __esm(() => {
 import path24 from "path";
 import { accessSync, constants as fsConstants2 } from "fs";
 import { homedir as homedir4 } from "os";
+function unwrapClixml(stderr) {
+  if (!stderr.startsWith("#< CLIXML"))
+    return stderr;
+  const errors = [...stderr.matchAll(/<S S="Error">([^<]*)<\/S>/g)].map((match) => match[1] ?? "");
+  return errors.join("").replace(/_x000D_/g, "").replace(/_x000A_/g, " ");
+}
+function pickerDiagnostic(stderr) {
+  const cleaned = unwrapClixml(stderr).replace(/[\u0000-\u001F\u007F]/g, " ").replace(/ {2,}/g, " ").trim().slice(0, maximumDiagnosticLength);
+  return cleaned || undefined;
+}
 async function readBoundedStream(stream, maximumBytes) {
   const reader = stream.getReader();
   const chunks = [];
@@ -17059,7 +17212,7 @@ function assertPickerPath(value, pathApi) {
 function parseWindowsResult(result) {
   const output = stripToolLineEnding(result.stdout);
   if (result.exitCode !== 0) {
-    throw new NativeDirectoryPickerError("native_picker_failed", "The Windows folder picker could not be opened.");
+    throw new NativeDirectoryPickerError("native_picker_failed", "The Windows folder picker could not be opened.", pickerDiagnostic(result.stderr));
   }
   if (output === "cancelled")
     return { outcome: "cancelled" };
@@ -17090,7 +17243,7 @@ function parseMacosResult(result) {
     if (/\(-128\)|user canceled/i.test(result.stderr)) {
       return { outcome: "cancelled" };
     }
-    throw new NativeDirectoryPickerError("native_picker_failed", "The macOS folder picker could not be opened.");
+    throw new NativeDirectoryPickerError("native_picker_failed", "The macOS folder picker could not be opened.", pickerDiagnostic(result.stderr));
   }
   return {
     outcome: "selected",
@@ -17101,7 +17254,7 @@ function parseLinuxResult(result) {
   if (result.exitCode === 1)
     return { outcome: "cancelled" };
   if (result.exitCode !== 0) {
-    throw new NativeDirectoryPickerError("native_picker_failed", "The Linux folder picker could not be opened.");
+    throw new NativeDirectoryPickerError("native_picker_failed", "The Linux folder picker could not be opened.", pickerDiagnostic(result.stderr));
   }
   return {
     outcome: "selected",
@@ -17229,7 +17382,7 @@ function createNativeDirectoryPicker(options = {}) {
     }
   };
 }
-var maximumPickerOutputBytes, NativeDirectoryPickerError, trustedLinuxExecutableDirectories, PickerOutputTooLargeError, runNativePickerProcess = async (command, signal) => {
+var maximumPickerOutputBytes, NativeDirectoryPickerError, maximumDiagnosticLength = 500, trustedLinuxExecutableDirectories, PickerOutputTooLargeError, runNativePickerProcess = async (command, signal) => {
   if (signal?.aborted) {
     return { exitCode: 1, stdout: "", stderr: "" };
   }
@@ -17274,9 +17427,11 @@ var init_native_directory_picker = __esm(() => {
   maximumPickerOutputBytes = 16 * 1024;
   NativeDirectoryPickerError = class NativeDirectoryPickerError extends Error {
     code;
-    constructor(code, message) {
+    diagnostic;
+    constructor(code, message, diagnostic) {
       super(message);
       this.code = code;
+      this.diagnostic = diagnostic;
       this.name = "NativeDirectoryPickerError";
     }
   };
@@ -17289,31 +17444,139 @@ var init_native_directory_picker = __esm(() => {
   };
   windowsPickerScript = String.raw`
 $ErrorActionPreference = 'Stop'
+$ProgressPreference = 'SilentlyContinue'
 [Console]::OutputEncoding = [Text.UTF8Encoding]::new($false)
 Add-Type -AssemblyName System.Windows.Forms
-$dialog = New-Object System.Windows.Forms.FolderBrowserDialog
-$dialog.Description = 'Choose a project folder'
-$dialog.ShowNewFolderButton = $true
-$dialog.AutoUpgradeEnabled = $true
+$modernPicker = $false
+try {
+  Add-Type -Language CSharp -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+
+namespace Lightcode {
+  [ComImport, Guid("DC1C5A9C-E88A-4dde-A5A1-60F82A20AEF7")]
+  internal class FileOpenDialogCoClass {}
+
+  [ComImport, Guid("43826D1E-E718-42EE-BC55-A1E261C37BFE"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+  internal interface IShellItem {
+    void BindToHandler(IntPtr pbc, ref Guid bhid, ref Guid riid, out IntPtr ppv);
+    void GetParent(out IShellItem ppsi);
+    void GetDisplayName(uint sigdnName, out IntPtr ppszName);
+    void GetAttributes(uint sfgaoMask, out uint psfgaoAttribs);
+    void Compare(IShellItem psi, uint hint, out int piOrder);
+  }
+
+  // IFileOpenDialog; only the IModalWindow/IFileDialog prefix of the vtable
+  // is declared, in order.
+  [ComImport, Guid("d57c7288-d4ad-4768-be02-9d969532d960"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+  internal interface IFileOpenDialog {
+    [PreserveSig] int Show(IntPtr parent);
+    void SetFileTypes(uint cFileTypes, IntPtr rgFilterSpec);
+    void SetFileTypeIndex(uint iFileType);
+    void GetFileTypeIndex(out uint piFileType);
+    void Advise(IntPtr pfde, out uint pdwCookie);
+    void Unadvise(uint dwCookie);
+    void SetOptions(uint fos);
+    void GetOptions(out uint pfos);
+    void SetDefaultFolder(IShellItem psi);
+    void SetFolder(IShellItem psi);
+    void GetFolder(out IShellItem ppsi);
+    void GetCurrentSelection(out IShellItem ppsi);
+    void SetFileName([MarshalAs(UnmanagedType.LPWStr)] string pszName);
+    void GetFileName([MarshalAs(UnmanagedType.LPWStr)] out string pszName);
+    void SetTitle([MarshalAs(UnmanagedType.LPWStr)] string pszTitle);
+    void SetOkButtonLabel([MarshalAs(UnmanagedType.LPWStr)] string pszText);
+    void SetFileNameLabel([MarshalAs(UnmanagedType.LPWStr)] string pszLabel);
+    void GetResult(out IShellItem ppsi);
+  }
+
+  public static class FolderPicker {
+    const uint PickFolders = 0x20, ForceFileSystem = 0x40, PathMustExist = 0x800, NoChangeDir = 0x8;
+    const uint FileSystemPath = 0x80058000;
+    const int Cancelled = unchecked((int)0x800704C7);
+
+    // Returns the chosen folder, or null when the user cancels.
+    public static string Pick(IntPtr owner, string title) {
+      var dialog = (IFileOpenDialog)new FileOpenDialogCoClass();
+      try {
+        uint options;
+        dialog.GetOptions(out options);
+        dialog.SetOptions(options | PickFolders | ForceFileSystem | PathMustExist | NoChangeDir);
+        dialog.SetTitle(title);
+        dialog.SetOkButtonLabel("Open project");
+        int hr = dialog.Show(owner);
+        if (hr == Cancelled) return null;
+        Marshal.ThrowExceptionForHR(hr);
+        IShellItem item;
+        dialog.GetResult(out item);
+        IntPtr name;
+        item.GetDisplayName(FileSystemPath, out name);
+        try {
+          return Marshal.PtrToStringUni(name);
+        } finally {
+          Marshal.FreeCoTaskMem(name);
+        }
+      } finally {
+        Marshal.ReleaseComObject(dialog);
+      }
+    }
+  }
+}
+'@
+  $modernPicker = $true
+} catch {
+  $modernPicker = $false
+}
 $owner = New-Object System.Windows.Forms.Form
+$owner.Text = 'Lightcode - choose a project folder'
 $owner.TopMost = $true
-$owner.ShowInTaskbar = $false
+# A taskbar button keeps the dialog findable when Windows refuses to bring it
+# in front of the browser.
+$owner.ShowInTaskbar = $true
 $owner.StartPosition = [System.Windows.Forms.FormStartPosition]::Manual
-$owner.Location = New-Object System.Drawing.Point(-32000, -32000)
+$workArea = [System.Windows.Forms.Screen]::PrimaryScreen.WorkingArea
+$owner.Location = New-Object System.Drawing.Point(
+  [int]($workArea.Left + $workArea.Width / 2),
+  [int]($workArea.Top + $workArea.Height / 2))
 $owner.Size = New-Object System.Drawing.Size(1, 1)
 $owner.Opacity = 0
+# lightcode:show-dialog
 try {
+  # The spawner's windowsHide turns the process's first show into SW_HIDE.
+  # Showing again makes the owner, and its taskbar button, actually visible.
+  $owner.Show()
+  $owner.Hide()
   $owner.Show()
   $owner.Activate()
-  $result = $dialog.ShowDialog($owner)
-  if ($result -eq [System.Windows.Forms.DialogResult]::OK) {
-    $bytes = [Text.Encoding]::UTF8.GetBytes($dialog.SelectedPath)
+  $selected = $null
+  $shown = $false
+  if ($modernPicker) {
+    try {
+      $selected = [Lightcode.FolderPicker]::Pick($owner.Handle, 'Choose a project folder')
+      $shown = $true
+    } catch {
+      # The dialog failed to open; fall back to the classic picker below.
+    }
+  }
+  if (-not $shown) {
+    $dialog = New-Object System.Windows.Forms.FolderBrowserDialog
+    $dialog.Description = 'Choose a project folder'
+    $dialog.ShowNewFolderButton = $true
+    try {
+      if ($dialog.ShowDialog($owner) -eq [System.Windows.Forms.DialogResult]::OK) {
+        $selected = $dialog.SelectedPath
+      }
+    } finally {
+      $dialog.Dispose()
+    }
+  }
+  if ($selected) {
+    $bytes = [Text.Encoding]::UTF8.GetBytes($selected)
     [Console]::Out.Write('selected:' + [Convert]::ToBase64String($bytes))
   } else {
     [Console]::Out.Write('cancelled')
   }
 } finally {
-  $dialog.Dispose()
   $owner.Dispose()
 }
 `;
@@ -17327,6 +17590,187 @@ end try
 `;
 });
 
+// apps/server/src/lib/windows-known-folders.ts
+import path25 from "path";
+import { z as z44 } from "zod";
+function parseWindowsKnownFoldersOutput(output) {
+  if (Buffer.byteLength(output) > 16384)
+    return null;
+  try {
+    const parsed = knownFoldersOutputSchema.safeParse(JSON.parse(output));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+async function runKnownFoldersResolver(environment) {
+  try {
+    const systemRootCandidate = environment.SystemRoot?.trim() || environment.WINDIR?.trim() || "C:\\Windows";
+    if (!path25.win32.isAbsolute(systemRootCandidate))
+      return null;
+    const windowsRoot = path25.win32.normalize(systemRootCandidate);
+    if (windowsRoot === path25.win32.parse(windowsRoot).root)
+      return null;
+    const systemDirectory = path25.win32.join(windowsRoot, "System32");
+    const executable = path25.win32.join(systemDirectory, "WindowsPowerShell", "v1.0", "powershell.exe");
+    const child = Bun.spawn([
+      executable,
+      "-NoLogo",
+      "-NoProfile",
+      "-NonInteractive",
+      "-Command",
+      knownFoldersScript
+    ], {
+      cwd: systemDirectory,
+      env: {
+        SystemRoot: windowsRoot,
+        WINDIR: windowsRoot,
+        ...Object.fromEntries(["USERPROFILE", "APPDATA", "LOCALAPPDATA", "TEMP", "TMP"].flatMap((name) => environment[name] ? [[name, environment[name]]] : []))
+      },
+      stdout: "pipe",
+      stderr: "ignore",
+      stdin: "ignore",
+      windowsHide: true
+    });
+    const timeout = setTimeout(() => child.kill(), resolverKillMs);
+    timeout.unref();
+    try {
+      const [output, exitCode] = await Promise.all([
+        new Response(child.stdout).text(),
+        child.exited
+      ]);
+      return exitCode === 0 ? parseWindowsKnownFoldersOutput(output) : null;
+    } finally {
+      clearTimeout(timeout);
+    }
+  } catch {
+    return null;
+  }
+}
+function cacheKey(environment) {
+  return JSON.stringify(["SystemRoot", "WINDIR", "USERPROFILE", "APPDATA", "LOCALAPPDATA"].map((name) => environment[name] ?? null));
+}
+function resolveWindowsKnownFolders(environment, run = runKnownFoldersResolver) {
+  const key = cacheKey(environment);
+  const cached = resolverCache.get(key);
+  if (cached)
+    return cached;
+  const pending = run(environment).then((folders) => {
+    if (!folders)
+      resolverCache.delete(key);
+    return folders;
+  });
+  resolverCache.set(key, pending);
+  return pending;
+}
+async function resolveWindowsKnownFolder(environment, folder, {
+  budgetMs = defaultWaitBudgetMs,
+  run
+} = {}) {
+  let timer;
+  const budget = new Promise((resolve2) => {
+    timer = setTimeout(() => resolve2(null), budgetMs);
+  });
+  try {
+    const folders = await Promise.race([
+      resolveWindowsKnownFolders(environment, run),
+      budget
+    ]);
+    return folders?.[folder] ?? null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var resolverKillMs = 20000, defaultWaitBudgetMs = 2000, downloadsFolderGuid = "{374DE290-123F-4565-9164-39C4925E467B}", knownFoldersScript, knownFolderValueSchema, knownFoldersOutputSchema, resolverCache;
+var init_windows_known_folders = __esm(() => {
+  knownFoldersScript = [
+    "[Console]::OutputEncoding=[Text.UTF8Encoding]::new($false)",
+    "$desktop=[Environment]::GetFolderPath([Environment+SpecialFolder]::DesktopDirectory)",
+    "$documents=[Environment]::GetFolderPath([Environment+SpecialFolder]::MyDocuments)",
+    `$downloads=try{[Environment]::ExpandEnvironmentVariables([string](Get-ItemProperty -LiteralPath 'HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders' -Name '${downloadsFolderGuid}' -ErrorAction Stop).'${downloadsFolderGuid}')}catch{''}`,
+    "[Console]::Write((@{desktop=$desktop;documents=$documents;downloads=$downloads}|ConvertTo-Json -Compress))"
+  ].join(";");
+  knownFolderValueSchema = z44.string().max(4096).transform((value) => value.trim()).transform((value) => value && !/[\r\n\0]/.test(value) && path25.win32.isAbsolute(value) ? value : null);
+  knownFoldersOutputSchema = z44.object({
+    desktop: knownFolderValueSchema,
+    documents: knownFolderValueSchema,
+    downloads: knownFolderValueSchema
+  });
+  resolverCache = new Map;
+});
+
+// apps/server/src/lib/workspace-entry-filter.ts
+function isHiddenBrowserEntry(entry, platform4 = process.platform) {
+  if (entry.name.startsWith("."))
+    return true;
+  if (platform4 !== "win32")
+    return false;
+  if (windowsSystemEntryPattern.test(entry.name))
+    return true;
+  return entry.isSymbolicLink() && windowsLegacyJunctionNames.has(entry.name.toLowerCase());
+}
+function isOmittedFromFolderListing(entry) {
+  return entry.isFile();
+}
+var windowsSystemEntryPattern, windowsLegacyJunctionNames;
+var init_workspace_entry_filter = __esm(() => {
+  windowsSystemEntryPattern = /^(?:ntuser\.(?:dat|ini|pol)(?:[.{].*)?|desktop\.ini|thumbs\.db|\$recycle\.bin|system volume information|pagefile\.sys|hiberfil\.sys|swapfile\.sys|dumpstack\.log(?:\.tmp)?|config\.msi|\$windows\.~(?:bt|ws)|\$winreagent|\$sysreset)$/i;
+  windowsLegacyJunctionNames = new Set([
+    "application data",
+    "cookies",
+    "local settings",
+    "my documents",
+    "nethood",
+    "printhood",
+    "recent",
+    "sendto",
+    "start menu",
+    "templates",
+    "my music",
+    "my pictures",
+    "my videos",
+    "documents and settings"
+  ]);
+});
+
+// apps/server/src/lib/workspace-drives.ts
+import { promises as fs8 } from "fs";
+async function probeDriveRoot(root) {
+  let timer;
+  const timeout = new Promise((resolve2) => {
+    timer = setTimeout(() => resolve2("unresponsive"), driveProbeTimeoutMs);
+  });
+  try {
+    return await Promise.race([
+      fs8.stat(root).then((stats) => stats.isDirectory() ? "present" : "absent").catch((error) => {
+        const code = typeof error === "object" && error !== null ? Reflect.get(error, "code") : undefined;
+        return code === "EPERM" || code === "EACCES" || code === "EBUSY" ? "unresponsive" : "absent";
+      }),
+      timeout
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function listWindowsDrives(probe = probeDriveRoot) {
+  const letters = Array.from({ length: 24 }, (_2, index) => String.fromCharCode(67 + index));
+  const results = await Promise.all(letters.map(async (letter) => ({
+    token: `${letter}:`,
+    state: await probe(`${letter}:\\`)
+  })));
+  return results.filter((result) => result.state !== "absent").map((result) => ({
+    token: result.token,
+    readable: result.state === "present"
+  }));
+}
+function windowsDriveRoot(token) {
+  return `${token}\\`;
+}
+var windowsDriveTokenPattern, driveProbeTimeoutMs = 1500;
+var init_workspace_drives = __esm(() => {
+  windowsDriveTokenPattern = /^[A-Z]:$/;
+});
+
 // apps/server/src/routes/workspace-routes.ts
 import { zValidator as zValidator3 } from "@hono/zod-validator";
 import {
@@ -17335,12 +17779,17 @@ import {
   randomBytes,
   timingSafeEqual as timingSafeEqual2
 } from "crypto";
-import { constants as fsConstants3, promises as fs8 } from "fs";
+import { constants as fsConstants3, promises as fs9 } from "fs";
 import { homedir as homedir5 } from "os";
-import path25 from "path";
+import path26 from "path";
 import { Hono as Hono7 } from "hono";
+import { z as z45 } from "zod";
+function parseLaunchFolderPath(value) {
+  const parsed = launchFolderEnvironmentSchema.safeParse(value);
+  return parsed.success ? normalizeKnownFolderCandidate(parsed.data, process.platform) : null;
+}
 function pathImplementation(platform4) {
-  return platform4 === "win32" ? path25.win32 : path25.posix;
+  return platform4 === "win32" ? path26.win32 : path26.posix;
 }
 function isFilesystemRootPath(candidate, platform4 = process.platform) {
   const pathApi = pathImplementation(platform4);
@@ -17363,7 +17812,7 @@ function normalizeKnownFolderCandidate(candidate, platform4) {
 }
 async function probeDirectory(candidate) {
   try {
-    const metadata = await fs8.stat(candidate);
+    const metadata = await fs9.stat(candidate);
     return metadata.isDirectory() ? "available" : "missing";
   } catch (error) {
     const code = filesystemErrorCode(error);
@@ -17377,7 +17826,7 @@ async function readSmallUserDirsConfiguration(filePath) {
   const noFollowFlag = typeof fsConstants3.O_NOFOLLOW === "number" ? fsConstants3.O_NOFOLLOW : 0;
   let handle;
   try {
-    handle = await fs8.open(filePath, fsConstants3.O_RDONLY | noFollowFlag);
+    handle = await fs9.open(filePath, fsConstants3.O_RDONLY | noFollowFlag);
     const metadata = await handle.stat();
     if (!metadata.isFile() || metadata.size <= 0 || metadata.size > maximumUserDirsConfigurationBytes) {
       return null;
@@ -17391,59 +17840,6 @@ async function readSmallUserDirsConfiguration(filePath) {
     });
   }
 }
-async function resolveWindowsKnownFolder(environment, folder) {
-  try {
-    const systemRootCandidate = environment.SystemRoot?.trim() || environment.WINDIR?.trim() || "C:\\Windows";
-    const windowsRoot = normalizeKnownFolderCandidate(systemRootCandidate, "win32");
-    if (!windowsRoot) {
-      return null;
-    }
-    const systemDirectory = path25.win32.join(windowsRoot, "System32");
-    const executable = path25.win32.join(systemDirectory, "WindowsPowerShell", "v1.0", "powershell.exe");
-    const folderExpression = folder === "desktop" ? "[Environment]::GetFolderPath([Environment+SpecialFolder]::DesktopDirectory)" : folder === "documents" ? "[Environment]::GetFolderPath([Environment+SpecialFolder]::MyDocuments)" : "[Environment]::ExpandEnvironmentVariables([string](Get-ItemProperty -LiteralPath 'HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders' -Name '{374DE290-123F-4565-9164-39C4925E467B}' -ErrorAction Stop).'{374DE290-123F-4565-9164-39C4925E467B}')";
-    const child = Bun.spawn([
-      executable,
-      "-NoLogo",
-      "-NoProfile",
-      "-NonInteractive",
-      "-Command",
-      `[Console]::OutputEncoding=[Text.UTF8Encoding]::new($false);[Console]::Write(${folderExpression})`
-    ], {
-      cwd: systemDirectory,
-      env: {
-        SystemRoot: windowsRoot,
-        WINDIR: windowsRoot,
-        ...Object.fromEntries([
-          "USERPROFILE",
-          "APPDATA",
-          "LOCALAPPDATA",
-          "TEMP",
-          "TMP"
-        ].flatMap((name) => environment[name] ? [[name, environment[name]]] : []))
-      },
-      stdout: "pipe",
-      stderr: "ignore",
-      stdin: "ignore"
-    });
-    const timeout = setTimeout(() => child.kill(), 2000);
-    timeout.unref();
-    try {
-      const [output, exitCode] = await Promise.all([
-        new Response(child.stdout).text(),
-        child.exited
-      ]);
-      if (exitCode !== 0 || Buffer.byteLength(output) > 4096) {
-        return null;
-      }
-      const candidate = output.trim();
-      return candidate && !/[\r\n]/.test(candidate) ? candidate : null;
-    } finally {
-      clearTimeout(timeout);
-    }
-  } catch {
-    return null;
-  }
-}
 function parseXdgUserDirectory(contents, homeDirectory, variableName) {
   for (const line of contents.split(/\r?\n/)) {
     const match = line.match(/^\s*(XDG_(?:DESKTOP|DOCUMENTS|DOWNLOAD)_DIR)="([^"\r\n]*)"\s*$/);
@@ -17458,15 +17854,15 @@ function parseXdgUserDirectory(contents, homeDirectory, variableName) {
       return null;
     }
     if (configured.startsWith("$HOME/")) {
-      return path25.posix.resolve(homeDirectory, configured.slice(6));
+      return path26.posix.resolve(homeDirectory, configured.slice(6));
     }
     if (configured.startsWith("${HOME}/")) {
-      return path25.posix.resolve(homeDirectory, configured.slice(8));
+      return path26.posix.resolve(homeDirectory, configured.slice(8));
     }
     if (configured.includes("$")) {
       return null;
     }
-    return path25.posix.isAbsolute(configured) ? path25.posix.normalize(configured) : null;
+    return path26.posix.isAbsolute(configured) ? path26.posix.normalize(configured) : null;
   }
   return null;
 }
@@ -17520,17 +17916,17 @@ async function resolveDesktopDirectoryPath(options = {}) {
         return [];
       }
       return [
-        index === 0 ? trimmed : path25.win32.join(trimmed, "Desktop")
+        index === 0 ? trimmed : path26.win32.join(trimmed, "Desktop")
       ];
     });
-    candidates.push(path25.win32.join(userProfile, "Desktop"));
-    return await firstUsableKnownFolder(candidates, platform4, probe) ?? path25.win32.join(homeDirectory, "Desktop");
+    candidates.push(path26.win32.join(userProfile, "Desktop"));
+    return await firstUsableKnownFolder(candidates, platform4, probe) ?? path26.win32.join(homeDirectory, "Desktop");
   }
   if (platform4 === "linux") {
     const configHome = environment.XDG_CONFIG_HOME?.trim();
-    const safeConfigHome = configHome && path25.posix.isAbsolute(configHome) ? path25.posix.normalize(configHome) : path25.posix.join(homeDirectory, ".config");
+    const safeConfigHome = configHome && path26.posix.isAbsolute(configHome) ? path26.posix.normalize(configHome) : path26.posix.join(homeDirectory, ".config");
     const readConfiguration = options.readUserDirsConfiguration ?? readSmallUserDirsConfiguration;
-    const contents = await readConfiguration(path25.posix.join(safeConfigHome, "user-dirs.dirs"));
+    const contents = await readConfiguration(path26.posix.join(safeConfigHome, "user-dirs.dirs"));
     const configured = contents ? parseXdgUserDirectory(contents, homeDirectory, "XDG_DESKTOP_DIR") : null;
     if (configured) {
       const selected = await firstUsableKnownFolder([configured], platform4, probe);
@@ -17567,17 +17963,17 @@ async function resolveUserDirectoryPath(folder, options) {
     ];
     const candidates = [
       knownFolder,
-      ...cloudRoots.map((root) => root?.trim() ? path25.win32.join(root.trim(), displayName) : null),
-      path25.win32.join(userProfile, displayName),
-      path25.win32.join(homeDirectory, displayName)
+      ...cloudRoots.map((root) => root?.trim() ? path26.win32.join(root.trim(), displayName) : null),
+      path26.win32.join(userProfile, displayName),
+      path26.win32.join(homeDirectory, displayName)
     ];
-    return await firstUsableKnownFolder(candidates, platform4, probe) ?? path25.win32.join(homeDirectory, displayName);
+    return await firstUsableKnownFolder(candidates, platform4, probe) ?? path26.win32.join(homeDirectory, displayName);
   }
   if (platform4 === "linux") {
     const configHome = environment.XDG_CONFIG_HOME?.trim();
-    const safeConfigHome = configHome && path25.posix.isAbsolute(configHome) ? path25.posix.normalize(configHome) : path25.posix.join(homeDirectory, ".config");
+    const safeConfigHome = configHome && path26.posix.isAbsolute(configHome) ? path26.posix.normalize(configHome) : path26.posix.join(homeDirectory, ".config");
     const readConfiguration = options.readUserDirsConfiguration ?? readSmallUserDirsConfiguration;
-    const contents = await readConfiguration(path25.posix.join(safeConfigHome, "user-dirs.dirs"));
+    const contents = await readConfiguration(path26.posix.join(safeConfigHome, "user-dirs.dirs"));
     const configured = contents ? parseXdgUserDirectory(contents, homeDirectory, folder === "documents" ? "XDG_DOCUMENTS_DIR" : "XDG_DOWNLOAD_DIR") : null;
     const selected = await firstUsableKnownFolder([configured], platform4, probe);
     if (selected) {
@@ -17648,6 +18044,17 @@ function mapFilesystemError(error) {
   return new WorkspaceRouteError("workspace_unavailable", "Unable to access the selected workspace.", 500, true);
 }
 function mapNativePickerError(error) {
+  if (error instanceof NativeDirectoryPickerError) {
+    logger13.warn("native_picker_error", {
+      code: error.code,
+      ...error.diagnostic ? { diagnostic: error.diagnostic } : {}
+    });
+  } else {
+    logger13.warn("native_picker_error", {
+      code: "native_picker_failed",
+      error: getErrorMessage(error)
+    });
+  }
   if (!(error instanceof NativeDirectoryPickerError)) {
     return new WorkspaceRouteError("native_picker_failed", "The system folder picker could not be opened.", 500, true);
   }
@@ -17688,17 +18095,21 @@ function rootIdentity(stats) {
 function identitiesMatch(left, right) {
   return left.device === right.device && left.inode === right.inode;
 }
+async function realpathPreservingDriveRoot(candidate) {
+  const resolved = await fs9.realpath(candidate);
+  return /^[A-Za-z]:$/.test(resolved) ? `${resolved}${path26.win32.sep}` : resolved;
+}
 function isContainedPath2(root, candidate) {
-  const relative = path25.relative(root, candidate);
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${path25.sep}`) && !path25.isAbsolute(relative);
+  const relative = path26.relative(root, candidate);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path26.sep}`) && !path26.isAbsolute(relative);
 }
 async function resolveKnownDirectory(directory) {
   try {
-    const root = await fs8.realpath(path25.resolve(directory));
+    const root = await realpathPreservingDriveRoot(path26.resolve(directory));
     if (isFilesystemRootPath(root)) {
       throw new WorkspaceRouteError("workspace_unavailable", "A filesystem root cannot be opened as a workspace location.", 500, false);
     }
-    const stats = await fs8.stat(root, { bigint: true });
+    const stats = await fs9.stat(root, { bigint: true });
     if (!stats.isDirectory()) {
       throw new WorkspaceRouteError("workspace_not_directory", "The selected path is not a directory.", 422, false);
     }
@@ -17715,8 +18126,8 @@ async function assertRootIdentity({
   identity
 }) {
   try {
-    const canonical = await fs8.realpath(root);
-    const stats = await fs8.stat(canonical, { bigint: true });
+    const canonical = await realpathPreservingDriveRoot(root);
+    const stats = await fs9.stat(canonical, { bigint: true });
     if (canonical !== root || !stats.isDirectory() || !identitiesMatch(identity, rootIdentity(stats))) {
       throw new WorkspaceRouteError("workspace_replaced", "The selected workspace changed on disk. Select it again before continuing.", 409, true);
     }
@@ -17729,7 +18140,7 @@ async function assertRootIdentity({
 }
 async function symlinkFailure(root, candidate, locationName) {
   try {
-    const target = await fs8.realpath(candidate);
+    const target = await realpathPreservingDriveRoot(candidate);
     if (!isContainedPath2(root, target)) {
       return new WorkspaceRouteError("workspace_symlink_escape", `This symbolic link points outside the allowed ${locationName} location.`, 403, false);
     }
@@ -17744,13 +18155,13 @@ async function symlinkFailure(root, candidate, locationName) {
 async function resolveDirectoryFromSegments(root, segments, locationName) {
   let current = root;
   for (const segment of segments) {
-    const candidate = path25.join(current, segment);
+    const candidate = path26.join(current, segment);
     if (!isContainedPath2(root, candidate)) {
       throw new WorkspaceRouteError("workspace_symlink_escape", `The requested path is outside the allowed ${locationName} location.`, 403, false);
     }
     let stats;
     try {
-      stats = await fs8.lstat(candidate);
+      stats = await fs9.lstat(candidate);
     } catch (error) {
       throw mapFilesystemError(error);
     }
@@ -17762,13 +18173,13 @@ async function resolveDirectoryFromSegments(root, segments, locationName) {
     }
     current = candidate;
   }
-  const canonical = await fs8.realpath(current).catch((error) => {
+  const canonical = await realpathPreservingDriveRoot(current).catch((error) => {
     throw mapFilesystemError(error);
   });
   if (!isContainedPath2(root, canonical)) {
     throw new WorkspaceRouteError("workspace_symlink_escape", `The requested path is outside the allowed ${locationName} location.`, 403, false);
   }
-  const metadata = await fs8.lstat(canonical, { bigint: true });
+  const metadata = await fs9.lstat(canonical, { bigint: true });
   if (metadata.isSymbolicLink() || !metadata.isDirectory()) {
     throw new WorkspaceRouteError("workspace_replaced", "The selected folder changed while it was being opened.", 409, true);
   }
@@ -17776,11 +18187,11 @@ async function resolveDirectoryFromSegments(root, segments, locationName) {
 }
 async function assertDirectoryIdentity(root, directory) {
   try {
-    const lexical = await fs8.lstat(directory.path, { bigint: true });
+    const lexical = await fs9.lstat(directory.path, { bigint: true });
     if (lexical.isSymbolicLink() || !lexical.isDirectory()) {
       throw new WorkspaceRouteError("workspace_replaced", "The selected folder changed while it was being read.", 409, true);
     }
-    const canonical = await fs8.realpath(directory.path);
+    const canonical = await realpathPreservingDriveRoot(directory.path);
     const currentIdentity = rootIdentity(lexical);
     if (canonical !== directory.path || !isContainedPath2(root, canonical) || !identitiesMatch(directory.identity, currentIdentity)) {
       throw new WorkspaceRouteError("workspace_replaced", "The selected folder changed while it was being read.", 409, true);
@@ -17793,6 +18204,9 @@ async function assertDirectoryIdentity(root, directory) {
     throw mapFilesystemError(error);
   }
 }
+function cursorViewFlags(binding) {
+  return (binding.includeHidden ? 1 : 0) | (binding.directoriesOnly ? 2 : 0);
+}
 function cursorPathDigest(segments) {
   return createHash6("sha256").update(JSON.stringify(segments)).digest("base64url").slice(0, 22);
 }
@@ -17801,7 +18215,7 @@ function encodeCursor(secret, binding, offset) {
     1,
     binding.browserId,
     cursorPathDigest(binding.segments),
-    binding.includeHidden ? 1 : 0,
+    cursorViewFlags(binding),
     offset,
     binding.directory.identity.device,
     binding.directory.identity.inode,
@@ -17831,7 +18245,7 @@ function decodeCursor(secret, cursor, binding) {
       mtimeNs,
       signature
     ] = parsed;
-    if (version2 !== 1 || browserId !== binding.browserId || pathDigest !== cursorPathDigest(binding.segments) || hidden !== (binding.includeHidden ? 1 : 0) || !Number.isSafeInteger(offset) || offset < 0 || device !== binding.directory.identity.device || inode !== binding.directory.identity.inode || mtimeNs !== binding.mtimeNs || typeof signature !== "string") {
+    if (version2 !== 1 || browserId !== binding.browserId || pathDigest !== cursorPathDigest(binding.segments) || hidden !== cursorViewFlags(binding) || !Number.isSafeInteger(offset) || offset < 0 || device !== binding.directory.identity.device || inode !== binding.directory.identity.inode || mtimeNs !== binding.mtimeNs || typeof signature !== "string") {
       throw new Error("cursor binding mismatch");
     }
     const serialized = JSON.stringify(parsed.slice(0, 8));
@@ -17847,12 +18261,12 @@ function decodeCursor(secret, cursor, binding) {
   }
 }
 async function describeEntry(root, directory, name) {
-  const candidate = path25.join(directory, name);
+  const candidate = path26.join(directory, name);
   try {
-    const stats = await fs8.lstat(candidate);
+    const stats = await fs9.lstat(candidate);
     if (stats.isSymbolicLink()) {
       try {
-        const target = await fs8.realpath(candidate);
+        const target = await realpathPreservingDriveRoot(candidate);
         return {
           name,
           kind: "symlink",
@@ -17872,7 +18286,7 @@ async function describeEntry(root, directory, name) {
     }
     const kind = stats.isDirectory() ? "directory" : stats.isFile() ? "file" : "other";
     const requiredAccess = stats.isDirectory() ? fsConstants3.R_OK | fsConstants3.X_OK : fsConstants3.R_OK;
-    const readable = await fs8.access(candidate, requiredAccess).then(() => true).catch(() => false);
+    const readable = await fs9.access(candidate, requiredAccess).then(() => true).catch(() => false);
     return {
       name,
       kind,
@@ -17911,7 +18325,7 @@ function knownLocation(definition, state) {
   return {
     id: definition.id,
     name: definition.name,
-    kind: "known-folder",
+    kind: definition.kind,
     state,
     pathLabel: definition.pathLabel
   };
@@ -17933,6 +18347,7 @@ function createWorkspaceRoutes(options = {}) {
   const definitions = [
     {
       id: "desktop",
+      kind: "known-folder",
       name: "Desktop",
       rootName: "Desktop",
       pathLabel: options.locationPathLabels?.desktop ?? desktopPathLabel,
@@ -17940,6 +18355,7 @@ function createWorkspaceRoutes(options = {}) {
     },
     {
       id: "home",
+      kind: "known-folder",
       name: "Home (broad access)",
       rootName: "Home",
       pathLabel: options.locationPathLabels?.home ?? "Home",
@@ -17947,6 +18363,7 @@ function createWorkspaceRoutes(options = {}) {
     },
     {
       id: "documents",
+      kind: "known-folder",
       name: "Documents",
       rootName: "Documents",
       pathLabel: options.locationPathLabels?.documents ?? "Documents",
@@ -17954,6 +18371,7 @@ function createWorkspaceRoutes(options = {}) {
     },
     {
       id: "downloads",
+      kind: "known-folder",
       name: "Downloads",
       rootName: "Downloads",
       pathLabel: options.locationPathLabels?.downloads ?? "Downloads",
@@ -17961,16 +18379,45 @@ function createWorkspaceRoutes(options = {}) {
     },
     {
       id: "projects",
+      kind: "known-folder",
       name: "Projects",
       rootName: "Projects",
       pathLabel: options.locationPathLabels?.projects ?? "Projects",
       resolvePath: configuredKnownLocationResolver(options, "projects", () => resolveProjectsDirectoryPath())
     }
   ];
+  if (options.enableDrives ?? process.platform === "win32") {
+    definitions.push({
+      id: "drives",
+      kind: "drives",
+      name: "This PC",
+      rootName: "This PC",
+      pathLabel: "This PC",
+      resolvePath: async () => {
+        throw new Error("The Drives location has no single root.");
+      }
+    });
+  }
+  const listDrives = options.listDrives ?? (() => listWindowsDrives());
+  const driveRoot = options.driveRoot ?? windowsDriveRoot;
+  const usesDefaultKnownFolders = !options.locationPaths && !options.resolveLocationPaths && !options.resolveDesktopPath && !options.desktopPath;
+  const prewarmKnownFolders = options.prewarmKnownFolders ?? (process.platform === "win32" && usesDefaultKnownFolders ? () => void resolveWindowsKnownFolders(Bun.env) : () => {
+    return;
+  });
+  const listRecentWorkspaces2 = options.listRecentWorkspaces ?? listRecentWorkspaces;
+  const recentKeySecret = randomBytes(32);
+  const recentWorkspaceKey = (cwd) => createHmac("sha256", recentKeySecret).update(process.platform === "win32" ? cwd.toLowerCase() : cwd).digest("base64url").slice(0, 22);
   const definitionsById = new Map(definitions.map((definition) => [definition.id, definition]));
   const createSession = options.createSession ?? createChatSession;
   const nativeDirectoryPicker = options.nativeDirectoryPicker ?? createNativeDirectoryPicker();
   const authorizeNativePickerRequest = options.authorizeNativePickerRequest ?? isAuthenticatedWebRequest;
+  const launchFolderPath = parseLaunchFolderPath(options.launchFolderPath === undefined ? Bun.env.LIGHTCODE_WEB_LAUNCH_CWD : options.launchFolderPath);
+  const resolveLaunchFolder = async () => {
+    if (!launchFolderPath) {
+      throw new WorkspaceRouteError("workspace_unavailable", "Lightcode was not started from a project folder.", 404, false);
+    }
+    return resolveKnownDirectory(launchFolderPath);
+  };
   const cursorSecret = randomBytes(32);
   const browserCapabilities = new Map;
   const workspaceGrants = new Map;
@@ -17993,9 +18440,10 @@ function createWorkspaceRoutes(options = {}) {
     root,
     identity,
     name,
-    pathLabel
+    pathLabel,
+    request
   }) => {
-    await fs8.access(root, fsConstants3.R_OK | fsConstants3.X_OK);
+    await fs9.access(root, fsConstants3.R_OK | fsConstants3.X_OK);
     const createdAt = new Date(now()).toISOString();
     const id = crypto.randomUUID();
     const grant = {
@@ -18014,7 +18462,27 @@ function createWorkspaceRoutes(options = {}) {
       workspaceGrants.delete(id);
       throw error;
     }
-    return workspaceGrantSchema.parse({ id, name, pathLabel, createdAt });
+    return workspaceGrantSchema.parse({
+      id,
+      name,
+      pathLabel,
+      ...authorizeNativePickerRequest(request) ? { hostPath: root } : {},
+      createdAt
+    });
+  };
+  const resolveBrowseScope = async (capability2, segments) => {
+    if (capability2.kind === "folder") {
+      await assertRootIdentity(capability2);
+      return { root: capability2.root, segments, rootName: capability2.rootName };
+    }
+    const [token, ...rest] = segments;
+    if (!token || !windowsDriveTokenPattern.test(token) || !capability2.driveTokens?.has(token)) {
+      throw new WorkspaceRouteError("location_not_found", "That drive is not available. Open This PC again.", 404, true);
+    }
+    const root = await realpathPreservingDriveRoot(driveRoot(token)).catch((error) => {
+      throw mapFilesystemError(error);
+    });
+    return { root, segments: rest, rootName: token };
   };
   return new Hono7().post("/picker/open", zValidator3("json", workspaceNativePickerRequestSchema, (result, c) => {
     if (!result.success) {
@@ -18030,7 +18498,10 @@ function createWorkspaceRoutes(options = {}) {
     try {
       let picked;
       try {
-        picked = await nativeDirectoryPicker.pick(c.req.raw.signal);
+        picked = await nativeDirectoryPicker.pick(AbortSignal.any([
+          c.req.raw.signal,
+          AbortSignal.timeout(nativePickerMaximumMs)
+        ]));
       } catch (error) {
         throw mapNativePickerError(error);
       }
@@ -18041,8 +18512,9 @@ function createWorkspaceRoutes(options = {}) {
       }
       const directory = await resolveKnownDirectory(picked.directory);
       const workspace = await storeWorkspaceGrant({
+        request: c.req.raw,
         ...directory,
-        name: path25.basename(directory.root),
+        name: path26.basename(directory.root),
         pathLabel: directory.root
       });
       return c.json(workspaceNativePickerResponseSchema.parse({
@@ -18052,9 +18524,97 @@ function createWorkspaceRoutes(options = {}) {
     } catch (error) {
       return workspaceErrorResponse(c, error);
     }
-  }).get("/locations", (c) => c.json(workspaceLocationsResponseSchema.parse({
-    locations: definitions.map((definition) => knownLocation(definition, "unprobed"))
-  }))).post("/browser/open", zValidator3("json", workspaceBrowserOpenRequestSchema, (result, c) => {
+  }).get("/launch-folder", async (c) => {
+    try {
+      const { root } = await resolveLaunchFolder();
+      const home = await realpathPreservingDriveRoot(homedir5()).catch(() => homedir5());
+      return c.json(workspaceLaunchFolderResponseSchema.parse({
+        available: true,
+        name: path26.basename(root),
+        pathLabel: root,
+        broad: isContainedPath2(root, home)
+      }));
+    } catch {
+      return c.json(workspaceLaunchFolderResponseSchema.parse({ available: false }));
+    }
+  }).post("/launch-folder/grant", zValidator3("json", workspaceLaunchFolderGrantRequestSchema, (result, c) => {
+    if (!result.success) {
+      return invalidRequestResponse(c);
+    }
+  }), async (c) => {
+    if (!authorizeNativePickerRequest(c.req.raw)) {
+      return c.json({
+        error: "The launch folder can be opened only from an authenticated Lightcode web session.",
+        code: "web_browser_required"
+      }, 403);
+    }
+    try {
+      const directory = await resolveLaunchFolder();
+      const workspace = await storeWorkspaceGrant({
+        request: c.req.raw,
+        ...directory,
+        name: path26.basename(directory.root),
+        pathLabel: directory.root
+      });
+      return c.json(workspaceBrowserSelectResponseSchema.parse({ workspace }), 201);
+    } catch (error) {
+      return workspaceErrorResponse(c, error);
+    }
+  }).get("/locations", (c) => {
+    prewarmKnownFolders();
+    return c.json(workspaceLocationsResponseSchema.parse({
+      locations: definitions.map((definition) => knownLocation(definition, "unprobed"))
+    }));
+  }).get("/recent", async (c) => {
+    try {
+      const recent = (await listRecentWorkspaces2(12)).filter((workspace) => !isFilesystemRootPath(workspace.cwd)).slice(0, 8);
+      const projects = await Promise.all(recent.map(async (workspace) => ({
+        key: recentWorkspaceKey(workspace.cwd),
+        name: path26.basename(workspace.cwd) || workspace.cwd,
+        pathLabel: workspace.cwd,
+        lastUsedAt: workspace.lastUsedAt.toISOString(),
+        available: await fs9.stat(workspace.cwd).then((stats) => stats.isDirectory()).catch(() => false)
+      })));
+      return c.json(workspaceRecentProjectsResponseSchema.parse({ projects }));
+    } catch (error) {
+      return workspaceErrorResponse(c, error);
+    }
+  }).post("/recent/:key/grant", zValidator3("param", workspaceRecentPathParamsSchema, (result, c) => {
+    if (!result.success) {
+      return invalidRequestResponse(c);
+    }
+  }), zValidator3("json", workspaceRecentGrantRequestSchema, (result, c) => {
+    if (!result.success) {
+      return invalidRequestResponse(c);
+    }
+  }), async (c) => {
+    if (!authorizeNativePickerRequest(c.req.raw)) {
+      return c.json({
+        error: "Recent projects can be opened only from an authenticated Lightcode web session.",
+        code: "web_browser_required"
+      }, 403);
+    }
+    try {
+      const { key } = c.req.valid("param");
+      const recent = (await listRecentWorkspaces2(50)).find((workspace2) => recentWorkspaceKey(workspace2.cwd) === key);
+      if (!recent) {
+        throw new WorkspaceRouteError("location_not_found", "That recent project is no longer listed. Refresh and try again.", 404, false);
+      }
+      const directory = await resolveKnownDirectory(recent.cwd);
+      if (recent.identity && recent.identity.inode !== "unsupported" && directory.identity.inode !== "unsupported" && !identitiesMatch(recent.identity, directory.identity)) {
+        throw new WorkspaceRouteError("workspace_replaced", "This folder was replaced since it was last used. Choose it again with the folder picker.", 409, false);
+      }
+      const workspace = await storeWorkspaceGrant({
+        request: c.req.raw,
+        ...directory,
+        name: path26.basename(directory.root),
+        pathLabel: directory.root
+      });
+      return c.json(workspaceBrowserSelectResponseSchema.parse({ workspace }), 201);
+    } catch (error) {
+      return workspaceErrorResponse(c, error);
+    }
+  }).post("/browser/open", zValidator3("json", workspaceBrowserOpenRequestSchema, (result, c) => {
     if (!result.success) {
       return invalidRequestResponse(c);
     }
@@ -18065,17 +18625,43 @@ function createWorkspaceRoutes(options = {}) {
       if (!definition) {
         throw new WorkspaceRouteError("location_not_found", "Workspace location not found.", 404, false);
       }
+      if (definition.kind === "drives") {
+        const browserId2 = crypto.randomUUID();
+        const expiresAtMs2 = now() + capabilityTtlMs;
+        const location2 = knownLocation(definition, "available");
+        browserCapabilities.set(browserId2, {
+          id: browserId2,
+          kind: "drives",
+          root: "",
+          identity: { device: "drives", inode: "drives" },
+          location: location2,
+          rootName: definition.rootName,
+          expiresAtMs: expiresAtMs2
+        });
+        trimOldestEntries(browserCapabilities, maximumBrowserCapabilities);
+        return c.json(workspaceBrowserOpenResponseSchema.parse({
+          browserId: browserId2,
+          location: location2,
+          expiresAt: new Date(expiresAtMs2).toISOString()
+        }), 201);
+      }
       const discoveredPath = await definition.resolvePath();
       const safePath = normalizeKnownFolderCandidate(discoveredPath, process.platform);
       if (!safePath) {
         throw new WorkspaceRouteError("workspace_unavailable", `The resolved ${definition.rootName} location is not a safe absolute folder path.`, 500, false);
       }
-      const resolved = await resolveKnownDirectory(safePath);
+      const resolved = await resolveKnownDirectory(safePath).catch((error) => {
+        if (error instanceof WorkspaceRouteError && error.code === "workspace_missing") {
+          throw new WorkspaceRouteError("location_missing", definition.id === "projects" ? `No Projects folder at ${safePath}. Create it, or set LIGHTCODE_PROJECTS_PATH to the folder that holds your projects.` : `No ${definition.rootName} folder at ${safePath}.`, 404, false);
+        }
+        throw error;
+      });
       const browserId = crypto.randomUUID();
       const expiresAtMs = now() + capabilityTtlMs;
       const location = knownLocation(definition, "available");
       browserCapabilities.set(browserId, {
         id: browserId,
+        kind: "folder",
         ...resolved,
         location,
         rootName: definition.rootName,
@@ -18103,13 +18689,31 @@ function createWorkspaceRoutes(options = {}) {
       const { browserId } = c.req.valid("param");
       const input = c.req.valid("json");
       const capability2 = getBrowserCapability(browserId);
-      await assertRootIdentity(capability2);
-      const directory = await resolveDirectoryFromSegments(capability2.root, input.segments, capability2.rootName);
-      const beforeRead = await assertDirectoryIdentity(capability2.root, directory);
+      if (capability2.kind === "drives" && input.segments.length === 0) {
+        const drives = await listDrives();
+        capability2.driveTokens = new Set(drives.map((drive) => drive.token));
+        return c.json(workspaceBrowserEntriesResponseSchema.parse({
+          browserId,
+          segments: [],
+          entries: drives.map((drive) => ({
+            name: drive.token,
+            kind: "directory",
+            size: null,
+            readable: drive.readable,
+            symlinkState: null
+          })),
+          nextCursor: null,
+          truncated: false
+        }));
+      }
+      const scope = await resolveBrowseScope(capability2, input.segments);
+      const directory = await resolveDirectoryFromSegments(scope.root, scope.segments, scope.rootName);
+      const beforeRead = await assertDirectoryIdentity(scope.root, directory);
       const cursorBinding = {
         browserId,
         segments: input.segments,
         includeHidden: input.includeHidden,
+        directoriesOnly: input.directoriesOnly,
         directory,
         mtimeNs: beforeRead.mtimeNs
       };
@@ -18121,14 +18725,17 @@ function createWorkspaceRoutes(options = {}) {
       const describedEntries = [];
       let visibleOffset = 0;
       let truncated = false;
-      const directoryHandle = await fs8.opendir(directory.path);
+      const directoryHandle = await fs9.opendir(directory.path);
       try {
         while (true) {
           const entry = await directoryHandle.read();
           if (!entry) {
             break;
           }
-          if (!input.includeHidden && entry.name.startsWith(".")) {
+          if (!input.includeHidden && isHiddenBrowserEntry(entry)) {
+            continue;
+          }
+          if (input.directoriesOnly && isOmittedFromFolderListing(entry)) {
             continue;
           }
           if (visibleOffset < offset) {
@@ -18140,7 +18747,7 @@ function createWorkspaceRoutes(options = {}) {
             break;
           }
           visibleOffset += 1;
-          const described = await describeEntry(capability2.root, directory.path, entry.name);
+          const described = await describeEntry(scope.root, directory.path, entry.name);
           if (described) {
             describedEntries.push(described);
           }
@@ -18154,7 +18761,7 @@ function createWorkspaceRoutes(options = {}) {
           }
         }
       }
-      const afterRead = await assertDirectoryIdentity(capability2.root, directory);
+      const afterRead = await assertDirectoryIdentity(scope.root, directory);
       if (afterRead.mtimeNs !== beforeRead.mtimeNs) {
         throw new WorkspaceRouteError("invalid_cursor", "The folder changed while it was being listed. Refresh and try again.", 409, true);
       }
@@ -18181,19 +18788,20 @@ function createWorkspaceRoutes(options = {}) {
       const { browserId } = c.req.valid("param");
       const { segments } = c.req.valid("json");
       const capability2 = getBrowserCapability(browserId);
-      await assertRootIdentity(capability2);
-      const directory = await resolveDirectoryFromSegments(capability2.root, segments, capability2.rootName);
-      await assertDirectoryIdentity(capability2.root, directory);
+      if (capability2.kind === "drives" && segments.length < 2) {
+        throw new WorkspaceRouteError("drive_root_not_selectable", "A whole drive can't be a project. Open a folder inside it and choose that.", 422, false);
+      }
+      const scope = await resolveBrowseScope(capability2, segments);
+      const directory = await resolveDirectoryFromSegments(scope.root, scope.segments, scope.rootName);
+      await assertDirectoryIdentity(scope.root, directory);
       await options.beforeDirectoryOperation?.({
         operation: "select",
         directory: directory.path
       });
       const name = segments.at(-1) ?? capability2.rootName;
-      const pathLabel = [
-        capability2.location.pathLabel,
-        ...segments
-      ].join("/");
+      const pathLabel = capability2.kind === "drives" ? directory.path : [capability2.location.pathLabel, ...segments].join("/");
       const workspace = await storeWorkspaceGrant({
+        request: c.req.raw,
         root: directory.path,
         identity: directory.identity,
         name,
@@ -18232,7 +18840,7 @@ function createWorkspaceRoutes(options = {}) {
     }
   });
 }
-var logger13, defaultBrowserCapabilityTtlMs, maximumBrowserCapabilities = 64, maximumWorkspaceGrants = 256, maximumUserDirsConfigurationBytes, WorkspaceRouteError, workspaceRoutes;
+var logger13, defaultBrowserCapabilityTtlMs, maximumBrowserCapabilities = 64, maximumWorkspaceGrants = 256, maximumUserDirsConfigurationBytes, nativePickerMaximumMs, launchFolderEnvironmentSchema, WorkspaceRouteError, workspaceRoutes;
 var init_workspace_routes = __esm(() => {
   init_src2();
   init_src();
@@ -18240,9 +18848,14 @@ var init_workspace_routes = __esm(() => {
   init_runtime_config();
   init_native_directory_picker();
   init_web_auth();
+  init_windows_known_folders();
+  init_workspace_entry_filter();
+  init_workspace_drives();
   logger13 = createLogger("workspace-routes");
   defaultBrowserCapabilityTtlMs = 10 * 60 * 1000;
   maximumUserDirsConfigurationBytes = 16 * 1024;
+  nativePickerMaximumMs = 10 * 60 * 1000;
+  launchFolderEnvironmentSchema = z45.string().min(1).max(4096).refine((value) => !value.includes("\x00")).refine((value) => path26.isAbsolute(value));
   WorkspaceRouteError = class WorkspaceRouteError extends Error {
     code;
     status;
@@ -18258,12 +18871,151 @@ var init_workspace_routes = __esm(() => {
   workspaceRoutes = createWorkspaceRoutes();
 });
 
+// apps/server/src/routes/session-changes-routes.ts
+import { zValidator as zValidator4 } from "@hono/zod-validator";
+import { createHmac as createHmac2, randomBytes as randomBytes2 } from "crypto";
+import { promises as fs10 } from "fs";
+import path27 from "path";
+import { Hono as Hono8 } from "hono";
+async function defaultResolveSessionWorkspace(id) {
+  const sessionId = await resolveChatSessionIdentifier(id);
+  return (await assertSessionWorkspaceIdentity(sessionId)).cwd;
+}
+function isContained(root, candidate) {
+  const relative = path27.relative(root, candidate);
+  return relative !== "" && relative !== ".." && !relative.startsWith(`..${path27.sep}`) && !path27.isAbsolute(relative);
+}
+async function untrackedFileDiff(workspace, relativePath) {
+  const candidate = path27.resolve(workspace, relativePath);
+  const stats = await fs10.lstat(candidate).catch(() => null);
+  if (!stats || !stats.isFile() || !isContained(workspace, candidate)) {
+    return { diff: "", truncated: false, binary: false };
+  }
+  const handle = await fs10.open(candidate, "r");
+  try {
+    const length = Math.min(stats.size, maximumUntrackedBytes);
+    const buffer = Buffer.alloc(length);
+    await handle.read(buffer, 0, length, 0);
+    if (buffer.includes(0)) {
+      return { diff: "", truncated: false, binary: true };
+    }
+    const lines = buffer.toString("utf8").replace(/\r\n/g, `
+`).split(`
+`);
+    if (lines.at(-1) === "")
+      lines.pop();
+    const diff = [
+      "--- /dev/null",
+      `+++ b/${relativePath}`,
+      `@@ -0,0 +1,${lines.length} @@`,
+      ...lines.map((line) => `+${line}`)
+    ].join(`
+`);
+    return { diff, truncated: stats.size > maximumUntrackedBytes, binary: false };
+  } finally {
+    await handle.close();
+  }
+}
+function errorResponse(c, error, event) {
+  if (error instanceof SessionNotFoundError) {
+    return c.json({ error: error.message }, 404);
+  }
+  if (error instanceof SessionWorkspaceIdentityError) {
+    return c.json({ error: error.message, code: error.code }, error.code === "workspace_unavailable" ? 404 : 409);
+  }
+  return internalErrorResponse(c, {
+    event,
+    message: "Unable to read the session's changes.",
+    error
+  });
+}
+function createSessionChangesRoutes(options = {}) {
+  const resolveSessionWorkspace = options.resolveSessionWorkspace ?? defaultResolveSessionWorkspace;
+  const fileIdSecret = randomBytes2(32);
+  const fileId = (workspace, entryPath) => createHmac2("sha256", fileIdSecret).update(`${workspace}\x00${entryPath}`).digest("base64url").slice(0, 22);
+  return new Hono8().get("/:id/changes", zValidator4("param", sessionPathParamsSchema), async (c) => {
+    try {
+      const workspace = await resolveSessionWorkspace(c.req.valid("param").id);
+      const context2 = createWorkspaceContext(workspace);
+      const status = await executeGitStatus({}, context2);
+      if (!status.ok) {
+        return c.json(sessionChangesResponseSchema.parse({
+          isRepo: false,
+          branch: null,
+          files: [],
+          truncated: false
+        }));
+      }
+      const counts = await executeGitNumstat(context2);
+      const files = status.entries.slice(0, maximumChangedFiles).map((entry) => {
+        const lineCounts = counts.get(entry.path);
+        return {
+          fileId: fileId(workspace, entry.path),
+          path: entry.path,
+          originalPath: entry.originalPath,
+          changeKind: changeKindFromGitStatus(entry.indexStatus, entry.workingTreeStatus),
+          added: lineCounts ? lineCounts.added : null,
+          removed: lineCounts ? lineCounts.removed : null
+        };
+      });
+      return c.json(sessionChangesResponseSchema.parse({
+        isRepo: true,
+        branch: status.branch,
+        files,
+        truncated: status.truncated || status.entries.length > maximumChangedFiles
+      }));
+    } catch (error) {
+      return errorResponse(c, error, "session_changes_failed");
+    }
+  }).get("/:id/changes/:fileId/diff", zValidator4("param", sessionChangeDiffParamsSchema), async (c) => {
+    try {
+      const params = c.req.valid("param");
+      const workspace = await resolveSessionWorkspace(params.id);
+      const context2 = createWorkspaceContext(workspace);
+      const status = await executeGitStatus({}, context2);
+      const entry = status.ok ? status.entries.find((candidate) => fileId(workspace, candidate.path) === params.fileId) : undefined;
+      if (!entry) {
+        return c.json({ error: "That file is no longer changed. Refresh the list." }, 404);
+      }
+      if (changeKindFromGitStatus(entry.indexStatus, entry.workingTreeStatus) === "untracked") {
+        return c.json(sessionChangeDiffResponseSchema.parse({
+          path: entry.path,
+          ...await untrackedFileDiff(workspace, entry.path)
+        }));
+      }
+      let result = await executeGitDiff({ path: entry.path }, context2);
+      if (result.ok && !result.diff.trim()) {
+        const staged = await executeGitDiff({ path: entry.path, staged: true }, context2);
+        if (staged.ok && staged.diff.trim())
+          result = staged;
+      }
+      return c.json(sessionChangeDiffResponseSchema.parse({
+        path: entry.path,
+        diff: result.ok ? result.diff : "",
+        truncated: result.ok ? result.truncated : false,
+        binary: result.ok && /^Binary files /m.test(result.diff)
+      }));
+    } catch (error) {
+      return errorResponse(c, error, "session_change_diff_failed");
+    }
+  });
+}
+var maximumUntrackedBytes, maximumChangedFiles = 500, sessionChangesRoutes;
+var init_session_changes_routes = __esm(() => {
+  init_src2();
+  init_runtime17();
+  init_chat_store();
+  init_route_helpers();
+  maximumUntrackedBytes = 256 * 1024;
+  sessionChangesRoutes = createSessionChangesRoutes();
+});
+
 // apps/server/src/app.ts
 var exports_app = {};
 __export(exports_app, {
   app: () => app
 });
-import { Hono as Hono8 } from "hono";
+import { Hono as Hono9 } from "hono";
 import { bodyLimit } from "hono/body-limit";
 var maxRequestBodyBytes, app;
 var init_app = __esm(() => {
@@ -18275,11 +19027,12 @@ var init_app = __esm(() => {
   init_root_routes();
   init_web_routes();
   init_workspace_routes();
+  init_session_changes_routes();
   maxRequestBodyBytes = 32 * 1024 * 1024;
-  app = new Hono8().use("*", createWebSecurityMiddleware()).use(bodyLimit({
+  app = new Hono9().use("*", createWebSecurityMiddleware()).use(bodyLimit({
     maxSize: maxRequestBodyBytes,
     onError: (c) => c.json({ error: "Request body too large." }, 413)
-  })).get("/healthz", (c) => c.json({ ok: true, service: "lightcode", protocolVersion: 1 })).route("/", webRoutes).route("/", rootRoutes).route("/config", configRoutes).route("/diagnostics", diagnosticsRoutes).route("/extensions", extensionRoutes).route("/workspaces", workspaceRoutes).route("/sessions", sessionRoutes);
+  })).get("/healthz", (c) => c.json({ ok: true, service: "lightcode", protocolVersion: 1 })).route("/", webRoutes).route("/", rootRoutes).route("/config", configRoutes).route("/diagnostics", diagnosticsRoutes).route("/extensions", extensionRoutes).route("/workspaces", workspaceRoutes).route("/sessions", sessionRoutes).route("/sessions", sessionChangesRoutes);
 });
 
 // apps/server/src/lib/headroom-proxy.ts
@@ -18802,17 +19555,27 @@ function isLoopbackBindHost(hostname) {
   return isIP(normalized) === 6 && normalized === "::1";
 }
 
-// apps/server/src/index.ts
-var logger15 = createLogger("server");
-var httpIdleTimeoutSeconds = 30;
-var shutdownForceExitMs = 5000;
-function isChatStreamingRoute(request) {
+// apps/server/src/lib/long-running-routes.ts
+function isLongRunningRoute(request) {
   if (request.method !== "POST") {
     return false;
   }
   const pathname = new URL(request.url).pathname;
-  return /^\/sessions\/[^/]+\/(?:chat|turns)$/.test(pathname);
+  return /^\/sessions\/[^/]+\/(?:chat|turns)$/.test(pathname) || pathname === "/workspaces/picker/open";
 }
+function createServerFetch(app) {
+  return (request, server) => {
+    if (isLongRunningRoute(request)) {
+      server.timeout(request, 0);
+    }
+    return app.fetch(request);
+  };
+}
+
+// apps/server/src/index.ts
+var logger15 = createLogger("server");
+var httpIdleTimeoutSeconds = 30;
+var shutdownForceExitMs = 5000;
 function serverLockFailureMessage(error) {
   if (error instanceof ServerInstanceLockError && error.code === "server_already_running") {
     return [
@@ -18942,12 +19705,7 @@ async function startServer() {
       idleTimeout: httpIdleTimeoutSeconds,
       port,
       hostname,
-      async fetch(request, bunServer) {
-        if (isChatStreamingRoute(request)) {
-          bunServer.timeout(request, 0);
-        }
-        return app2.fetch(request);
-      }
+      fetch: createServerFetch(app2)
     });
   } catch (error) {
     await releaseServerLock(instanceLock, "bind-failure");