diff --git a/CLAUDE.md b/CLAUDE.md
index f4b6f42..fab37e2 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -21,7 +21,7 @@ dotnet run --project src/CodeShellManager/CodeShellManager.csproj
 | `--clean` | Debug isolation mode — see below. |
 
 **`--clean`** (parsed in `App.OnStartup`, exposed as `App.CleanStart`):
-- `MainWindow.OnLoaded` skips the restore loop and clears the in-memory `SessionManager` so any new sessions in the run don't co-mingle with the persisted set.
+- `MainWindow.OnLoaded` skips the restore loop and clears the in-memory `SessionManager` — both sessions AND groups — so any new work in the run starts from a blank slate.
 - `MainViewModel.SaveStateAsync` short-circuits — **nothing is written to `state.json`** for the entire run. Window bounds, layout changes, settings tweaks, and any sessions created during the clean run are all discarded on exit.
 - The user's prior `state.json` survives the run untouched, so this is the safe way to test from a blank slate.
 
@@ -53,10 +53,24 @@ PTY (ConPTY) → PseudoTerminal → TerminalBridge → WebView2 (xterm.js)
 |---|---|
 | `SessionManager` | CRUD for ShellSession models |
 | `StateService` | JSON persistence → `%AppData%/CodeShellManager/state.json` |
-| `SearchService` | SQLite FTS5 search of all terminal output |
+| `SearchService` | SQLite FTS5 search of all terminal output; also owns the `project_notes` table |
 | `ColorService` | FNV-1a hash of folder path → 12-color palette |
 | `GitService` | Async `git branch --show-current` + `git status --porcelain` |
 | `AlertDetector` | Pattern matching for Claude prompts/approvals |
+| `CommandPresetsService` | Launch presets + in-session shortcuts |
+| `ClaudeSessionService` | Detects `claude` invocations; finds last `--resume` session id under `~/.claude/projects/` |
+| `UpdateService` | GitHub Releases version check; caches result for 24h at `%AppData%/CodeShellManager/update-cache.json` |
+| `ImportExportService` | Read/write a full `AppState` to a JSON file (settings + sessions backup) |
+| `ToastHelper` | Tray balloon notifications |
+| `SessionRunner` | Per-session owner of `RunInstance` dictionary (run commands runtime) |
+| `RunInstance` | One headless PTY-backed run with ANSI-stripped output buffer |
+| `RunCommandTemplatesService` | Detects project type (dotnet/cargo/node/python/make) → seed run-command list |
+| `WindowsTerminalProfileService` | Reads Windows Terminal `settings.json` from all install variants |
+| `BuiltInTerminalSchemes` | Lookup table of WT default color schemes not present in user `settings.json` |
+| `SchemeMapper` | WT scheme JSON → xterm.js theme JSON (renames `purple` → `magenta`, rewrites background as `rgba()` when opacity < 1) |
+| `CursorShapeMapper` | WT `cursorShape` → xterm.js `cursorStyle` (+ optional forced blink) |
+| `PaddingParser` | WT `padding` shorthand (1/2/4 comma ints) → CSS `Npx` shorthand |
+| `CommandLineSplitter` | Helper — quote-aware split of a Windows commandline into `(exe, args)` |
 
 ## Project Structure
 
@@ -155,6 +169,19 @@ When any override is set, `LaunchSessionAsync` calls `bridge.ApplyProfileOverrid
 
 **Once stamped, profile overrides are independent.** A session keeps its appearance even if the user later edits or deletes the source profile in Windows Terminal.
 
+## Recently Closed Sessions
+
+Closing a session (`Ctrl+W`, sidebar `✕`, or terminal-toolbar close) pushes a snapshot onto a ring buffer (`AppState.RecentlyClosed`, cap `MainViewModel.MaxRecentlyClosed = 10`, newest first). Two ways to reopen:
+
+- **`Ctrl+Shift+T`** — pops the newest entry and re-launches it via `MainWindow.ReopenClosedSessionAsync`. The reopened session gets a **fresh Id** so it's independent of anything that may still reference the old one.
+- **"Recently closed" list at the top of the New Session dialog** — click an entry to reopen it; that entry is removed from the ring.
+
+Sleep/wake doesn't touch the ring (`SleepSession` bypasses `OnSessionCloseRequested`). `--clean` mode clears the ring at startup (full debug isolation) and never persists changes — `SaveStateAsync` is a no-op in clean mode.
+
+The snapshot model is `Models/RecentlyClosedEntry.cs` — a separate POCO from `ShellSession` so PTY/runtime fields (`IsDormant`, `Status`, `LastActivityAt`) don't leak into the ring buffer. `RunCommands` are deep-copied with fresh Ids on both snapshot creation and session recreation, so edits to either side never alias the other.
+
+FTS5 scrollback retention is **out of scope** for v1 — restored sessions start with an empty xterm buffer.
+
 ## Sleep / Wake (Dormant Sessions)
 
 Sessions can be put to sleep instead of closed — the PTY is torn down but the `ShellSession` is kept in `state.json` (`IsDormant = true`) so it can be relaunched from the sidebar later. Useful when you have many long-running projects but only need a few live at once.
@@ -175,7 +202,10 @@ Sessions can be put to sleep instead of closed — the PTY is torn down but the
 
 Each session can have a list of "run commands" — labelled command lines invoked by the toolbar ▶ button, the F5 keybinding, or the sidebar right-click submenu. Runs spawn a **separate headless `PseudoTerminal`** in the session's working folder (or a fresh `ssh` connection for SSH parents); they do **not** type into the parent PTY, so a Claude session is untouched.
 
-**Data:** `ShellSession.RunCommands: List<RunCommandItem> { Id, Label, CommandLine, IsDefault }`. Exactly one item has `IsDefault=true`; see `RunCommandItem.EnsureSingleDefault`. Persisted to `state.json`.
+**Data:** `ShellSession.RunCommands: List<RunCommandItem> { Id, Label, CommandLine, IsDefault, Mode, PostRunUrl }`. Exactly one item has `IsDefault=true`; see `RunCommandItem.EnsureSingleDefault`. Persisted to `state.json`.
+
+- **`Mode`** (`RunMode.Process` default / `RunMode.PowerShell`) — `Process` runs through `cmd /c` as before; `PowerShell` wraps the command line in `pwsh.exe -NonInteractive -NoLogo -ExecutionPolicy Bypass -EncodedCommand <utf16le-b64>` (falls back to `powershell.exe` if `pwsh` isn't on PATH). SSH parents ignore `Mode` — remote runs always go through bash. Use PowerShell when the command relies on pipes (`|`), redirection (`>`), `$env:` variables, or cmdlets.
+- **`PostRunUrl`** (`string?`, default `null`) — when set and the run exits with code 0, `Process.Start` opens the URL via `UseShellExecute=true` (default browser). Failures are swallowed; no health-check polling.
 
 **Templates:** `RunCommandTemplatesService.SeedFor(folder)` detects project type (top-level scan, first-match: dotnet → cargo → node → python → make) and returns a seed list with fresh Ids. Templates are *copied* onto new sessions at creation time; subsequent edits don't propagate back. SSH sessions skip detection (empty list).
 
@@ -193,7 +223,20 @@ Each session can have a list of "run commands" — labelled command lines invoke
 
 **Lifecycle:** All runs are killed on session close, session sleep, and app exit. `SessionViewModel.Dispose()` calls `Runner.Dispose()` which iterates and disposes every instance. `SleepSession` also calls `vm.Runner.StopAll()` defensively before UI teardown.
 
-## Alert / Waiting State
+## Per-Session Notes
+
+Each session gets a collapsible 📝 notepad panel between the terminal toolbar and the terminal. Toggled by the 📝 button on the terminal toolbar; the panel is a docked 160px-high `TextBox` (`Visibility.Collapsed` by default).
+
+**Storage:** notes are **not** on `ShellSession` and not in `state.json`. They live in the FTS5 SQLite DB owned by `SearchService` in a separate `project_notes` table keyed by `folder_path` (the session's `WorkingFolder`). Two sessions in the same folder share one note; SSH sessions and sessions with no working folder don't get a note (`vm.WorkingFolder` is empty → save is skipped).
+
+- `SearchService.GetNoteAsync(folderPath)` — `SELECT content FROM project_notes WHERE folder_path = ?`
+- `SearchService.SaveNoteAsync(folderPath, content)` — UPSERT on `folder_path`, stamps `updated_at` (ms since epoch)
+
+**UI lifecycle:** content is lazy-loaded on the first time the panel is opened (`notesLoaded` flag in the toolbar build). Each keystroke restarts a 1-second `System.Threading.Timer` debounce; when it fires, `SaveNoteAsync` is called on the dispatcher thread. No explicit save action — closing the panel or the session just leaves the last debounce to flush. There's no save-on-exit hook, so a note edited in the final ~1s before app close can be lost.
+
+**Search integration:** `SearchService.SearchAsync` queries notes alongside terminal output — notes use `LIKE %query%` (short free-text, FTS5 overkill) and are tagged `SearchResultType.Note` so the search panel can label them. The note's row in the search panel is keyed by folder, not session.
+
+**Dormant sessions:** because notes are folder-keyed and live outside `state.json`, a dormant or reopened session in the same folder transparently picks up the existing note on next wake/restore.
 
 `AlertDetector` fires `AlertRaised(AlertEvent)` after 1.5s idle when it detects:
 - **ToolApproval**: Claude asking to run a tool (regex on approval phrases)
@@ -231,6 +274,8 @@ Persisted in `state.json`. Key settings:
 | Key | Action |
 |---|---|
 | `Ctrl+T` | New session |
+| `Ctrl+Shift+T` | Reopen the most-recently-closed session (browser convention) |
+| `Ctrl+Alt+T` | Duplicate active session (was `Ctrl+Shift+T` pre-bundle) |
 | `Ctrl+W` | Close active session |
 | `Ctrl+F` | Toggle search |
 | `Ctrl+Tab` | Cycle sessions |
diff --git a/installer/CodeShellManager.wxs b/installer/CodeShellManager.wxs
index 84d87b0..b664156 100644
--- a/installer/CodeShellManager.wxs
+++ b/installer/CodeShellManager.wxs
@@ -53,6 +53,9 @@
       <Component Directory="AssetsFolder" Guid="*">
         <File Source="$(var.PublishDir)\Assets\app.ico" KeyPath="yes" />
       </Component>
+      <Component Directory="AssetsFolder" Guid="*">
+        <File Source="$(var.PublishDir)\Assets\app.png" KeyPath="yes" />
+      </Component>
 
       <!-- Assets — one component per file so auto-GUID works.
            If you add a new file to src/CodeShellManager/Assets, also add it here
diff --git a/src/CodeShellManager/Assets/terminal-init.js b/src/CodeShellManager/Assets/terminal-init.js
index f1ace5d..8722d17 100644
--- a/src/CodeShellManager/Assets/terminal-init.js
+++ b/src/CodeShellManager/Assets/terminal-init.js
@@ -69,6 +69,23 @@
         fitAddon.fit();
       }
       else if (msg.type === 'dropOverlayClear') overlay.classList.remove('active');
+      else if (msg.type === 'setBootState') {
+        const label = document.getElementById('bootLabel');
+        const spinner = document.getElementById('bootSpinner');
+        if (label && typeof msg.label === 'string') label.textContent = msg.label;
+        if (spinner && typeof msg.accentHex === 'string') {
+          spinner.style.setProperty('--boot-accent', msg.accentHex);
+        }
+      }
+      else if (msg.type === 'bootDone') {
+        const overlay = document.getElementById('bootOverlay');
+        if (overlay && !overlay.classList.contains('hidden')) {
+          overlay.classList.add('hidden');
+          overlay.addEventListener('transitionend', () => {
+            try { overlay.parentNode && overlay.parentNode.removeChild(overlay); } catch {}
+          }, { once: true });
+        }
+      }
     } catch {}
   });
 
diff --git a/src/CodeShellManager/Assets/terminal-transparent.html b/src/CodeShellManager/Assets/terminal-transparent.html
index 50abba5..8d1f3e8 100644
--- a/src/CodeShellManager/Assets/terminal-transparent.html
+++ b/src/CodeShellManager/Assets/terminal-transparent.html
@@ -37,11 +37,46 @@
     mix-blend-mode: multiply;
     z-index: 50;
   }
+
+  /* Boot overlay — visible until terminal-init.js receives bootDone */
+  #bootOverlay {
+    position: fixed; inset: 0;
+    background: #1e1e2e;
+    z-index: 200;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    flex-direction: column;
+    gap: 14px;
+    font-family: 'Segoe UI', sans-serif;
+    color: #cdd6f4;
+    transition: opacity 200ms ease-out;
+  }
+  #bootOverlay.hidden { opacity: 0; pointer-events: none; }
+  #bootSpinner {
+    width: 44px; height: 44px;
+    --boot-accent: #89b4fa;
+  }
+  #bootSpinner circle {
+    fill: none;
+    stroke: var(--boot-accent);
+    stroke-width: 4;
+    stroke-linecap: round;
+    stroke-dasharray: 90 150;
+    transform-origin: center;
+    animation: bootSpin 1.2s linear infinite;
+  }
+  @keyframes bootSpin { to { transform: rotate(360deg); } }
+  #bootLabel { font-size: 13px; opacity: 0.85; }
 </style>
 <link rel="stylesheet" href="xterm.css" />
 </head>
 <body>
 <div id="terminal"></div>
+<div id="bootOverlay">
+  <svg id="bootSpinner" viewBox="0 0 50 50"><circle cx="25" cy="25" r="20"/></svg>
+  <div id="bootLabel">Initializing terminal…</div>
+</div>
 <div id="dropOverlay">Drop files to insert path(s)</div>
 
 <script src="xterm.js"></script>
diff --git a/src/CodeShellManager/Assets/terminal.html b/src/CodeShellManager/Assets/terminal.html
index 11022e3..f43407f 100644
--- a/src/CodeShellManager/Assets/terminal.html
+++ b/src/CodeShellManager/Assets/terminal.html
@@ -37,11 +37,46 @@
     mix-blend-mode: multiply;
     z-index: 50;
   }
+
+  /* Boot overlay — visible until terminal-init.js receives bootDone */
+  #bootOverlay {
+    position: fixed; inset: 0;
+    background: #1e1e2e;
+    z-index: 200;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    flex-direction: column;
+    gap: 14px;
+    font-family: 'Segoe UI', sans-serif;
+    color: #cdd6f4;
+    transition: opacity 200ms ease-out;
+  }
+  #bootOverlay.hidden { opacity: 0; pointer-events: none; }
+  #bootSpinner {
+    width: 44px; height: 44px;
+    --boot-accent: #89b4fa;
+  }
+  #bootSpinner circle {
+    fill: none;
+    stroke: var(--boot-accent);
+    stroke-width: 4;
+    stroke-linecap: round;
+    stroke-dasharray: 90 150;
+    transform-origin: center;
+    animation: bootSpin 1.2s linear infinite;
+  }
+  @keyframes bootSpin { to { transform: rotate(360deg); } }
+  #bootLabel { font-size: 13px; opacity: 0.85; }
 </style>
 <link rel="stylesheet" href="xterm.css" />
 </head>
 <body>
 <div id="terminal"></div>
+<div id="bootOverlay">
+  <svg id="bootSpinner" viewBox="0 0 50 50"><circle cx="25" cy="25" r="20"/></svg>
+  <div id="bootLabel">Initializing terminal…</div>
+</div>
 <div id="dropOverlay">Drop files to insert path(s)</div>
 
 <script src="xterm.js"></script>
diff --git a/src/CodeShellManager/CodeShellManager.csproj b/src/CodeShellManager/CodeShellManager.csproj
index 61912aa..c96e53f 100644
--- a/src/CodeShellManager/CodeShellManager.csproj
+++ b/src/CodeShellManager/CodeShellManager.csproj
@@ -15,6 +15,17 @@
     <ApplicationIcon>Assets\app.ico</ApplicationIcon>
   </PropertyGroup>
 
+  <!-- Hot Reload (Microsoft.Extensions.DotNetDeltaApplier) crashes the app with
+       System.ExecutionEngineException on F5 under .NET 10.0.8 + VS 18. The primary
+       fix is "hotReloadEnabled": false in Properties/launchSettings.json which
+       prevents VS from injecting the delta applier at all. This runtime feature
+       switch is a belt-and-braces fallback for anyone whose launchSettings.json
+       has been overridden locally. Remove both when the runtime bug is fixed
+       upstream. -->
+  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <MetadataUpdaterSupport>false</MetadataUpdaterSupport>
+  </PropertyGroup>
+
   <ItemGroup>
     <PackageReference Include="CommunityToolkit.Mvvm" Version="8.4.2" />
     <PackageReference Include="Microsoft.Data.Sqlite" Version="10.0.8" />
@@ -42,6 +53,10 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
       <ExcludeFromSingleFile>true</ExcludeFromSingleFile>
     </Content>
+    <Content Include="Assets\app.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <ExcludeFromSingleFile>true</ExcludeFromSingleFile>
+    </Content>
     <Content Include="Assets\terminal-init.js">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
       <ExcludeFromSingleFile>true</ExcludeFromSingleFile>
diff --git a/src/CodeShellManager/MainWindow.xaml b/src/CodeShellManager/MainWindow.xaml
index 7c3ee6b..e602ed5 100644
--- a/src/CodeShellManager/MainWindow.xaml
+++ b/src/CodeShellManager/MainWindow.xaml
@@ -66,6 +66,7 @@
         </Style>
     </Window.Resources>
 
+    <Grid>
     <DockPanel>
         <!-- ── Top toolbar ─────────────────────────────────────────────── -->
         <Border DockPanel.Dock="Top" Background="#181825" BorderThickness="0,0,0,1"
@@ -139,6 +140,8 @@
                             Click="Layout_SixTwo_Click" FontSize="9" Padding="4,4"/>
                     <Button Content="6×3" Style="{StaticResource ToolBtn}" ToolTip="6×3 grid (18 panes)"
                             Click="Layout_SixThree_Click" FontSize="9" Padding="4,4"/>
+                    <Button Content="3×3" Style="{StaticResource ToolBtn}" ToolTip="3×3 grid (9 panes)"
+                            Click="Layout_ThreeByThree_Click" FontSize="9" Padding="4,4"/>
                 </StackPanel>
 
                 <Button DockPanel.Dock="Left" AutomationProperties.AutomationId="NewSessionBtn" Content="＋ New Session" Style="{StaticResource ToolBtn}"
@@ -288,4 +291,32 @@
                        LineHeight="24"/>
         </Grid>
     </DockPanel>
+
+        <Grid x:Name="ShutdownOverlay" Visibility="Collapsed" Background="#cc1e1e2e" Panel.ZIndex="100">
+            <StackPanel HorizontalAlignment="Center" VerticalAlignment="Center" Orientation="Vertical">
+                <Grid Width="48" Height="48">
+                    <Path Stroke="#89b4fa" StrokeThickness="4" StrokeStartLineCap="Round" StrokeEndLineCap="Round"
+                          Data="M 24 4 A 20 20 0 1 1 4 24"
+                          RenderTransformOrigin="0.5,0.5">
+                        <Path.RenderTransform>
+                            <RotateTransform x:Name="ShutdownSpinnerRotate" Angle="0"/>
+                        </Path.RenderTransform>
+                        <Path.Triggers>
+                            <EventTrigger RoutedEvent="Path.Loaded">
+                                <BeginStoryboard>
+                                    <Storyboard RepeatBehavior="Forever">
+                                        <DoubleAnimation Storyboard.TargetName="ShutdownSpinnerRotate"
+                                                         Storyboard.TargetProperty="Angle"
+                                                         From="0" To="360" Duration="0:0:1.2"/>
+                                    </Storyboard>
+                                </BeginStoryboard>
+                            </EventTrigger>
+                        </Path.Triggers>
+                    </Path>
+                </Grid>
+                <TextBlock Text="Shutting down…" Foreground="#cdd6f4" FontFamily="Segoe UI" FontSize="13"
+                           Margin="0,14,0,0" HorizontalAlignment="Center"/>
+            </StackPanel>
+        </Grid>
+    </Grid>
 </Window>
diff --git a/src/CodeShellManager/MainWindow.xaml.cs b/src/CodeShellManager/MainWindow.xaml.cs
index 610eef2..61bf63e 100644
--- a/src/CodeShellManager/MainWindow.xaml.cs
+++ b/src/CodeShellManager/MainWindow.xaml.cs
@@ -225,11 +225,16 @@ private async void OnLoaded(object sender, RoutedEventArgs e)
         Log($"OnLoaded: {saved.Count} saved sessions, AutoRestore={_vm.Settings.AutoRestoreSessions}, CleanStart={App.CleanStart}");
         if (App.CleanStart)
         {
-            // --clean: skip restore and leave state.json untouched. Drop the
-            // saved-session list from the in-memory SessionManager so any new
-            // work this run doesn't co-mingle with the persisted set.
+            // --clean: skip restore and leave state.json untouched. Drop sessions,
+            // groups, AND the recently-closed ring from in-memory state so any new
+            // work this run starts from a clean slate (no leftover scaffolding from
+            // prior debug sessions). SaveStateAsync is a no-op in --clean mode so
+            // these clears don't touch the persisted file.
             foreach (var s in saved)
                 _sessionManager.RemoveSession(s.Id);
+            foreach (var g in _sessionManager.Groups.ToList())
+                _sessionManager.RemoveGroup(g.Id);
+            _vm.ClearRecentlyClosed();
             return;
         }
         if (saved.Count == 0) return;
@@ -399,13 +404,27 @@ private void OpenNewSessionDialogCore(string defaultFolder, SessionViewModel? pa
             _vm.Settings.LaunchCommands,
             profiles,
             defaultCommand: parent?.Session.Command,
-            defaultArgs: parent?.Session.Args)
+            defaultArgs: parent?.Session.Args,
+            defaultName: null,
+            recentlyClosed: _vm.RecentlyClosed)
         {
             Owner = this
         };
 
         if (dialog.ShowDialog() != true) return;
 
+        // If the user picked an entry from the "Recently closed" list, reopen that
+        // session directly with copied settings and skip the rest of the form.
+        if (dialog.SelectedRecentlyClosed != null)
+        {
+            var entry = dialog.SelectedRecentlyClosed;
+            // Only drop the entry from the ring after reopen succeeds — a transient
+            // launch failure (bad folder, SSH unavailable) would otherwise lose the
+            // entry permanently and the user couldn't retry.
+            _ = ReopenAndRemoveOnSuccessAsync(entry);
+            return;
+        }
+
         // Group resolution priority:
         //   1. Explicit selection from the dialog (currently unused — no group picker there)
         //   2. Inherited from a parent session (spawn-near-parent flows)
@@ -459,6 +478,67 @@ private void OpenNewSessionDialogCore(string defaultFolder, SessionViewModel? pa
         _ = LaunchAndFollowUpWorktreesAsync(session, dialog.AdditionalWorktreePaths);
     }
 
+    /// <summary>
+    /// Recreates a session from a <see cref="RecentlyClosedEntry"/> snapshot. Gets a fresh
+    /// Id (so it's independent of the original) and goes through the normal launch path.
+    /// Returns the created session; callers can verify it remained in
+    /// <c>_sessionManager.Sessions</c> after the await to confirm launch success.
+    /// </summary>
+    private async Task<ShellSession> ReopenClosedSessionAsync(RecentlyClosedEntry entry)
+    {
+        var session = _sessionManager.CreateSession(
+            entry.Name,
+            entry.WorkingFolder,
+            entry.Command,
+            entry.Args,
+            string.IsNullOrEmpty(entry.GroupId) ? null : entry.GroupId,
+            colorOverride: entry.ColorOverride);
+
+        session.IsRemote = entry.IsRemote;
+        session.SshUser = entry.SshUser;
+        session.SshHost = entry.SshHost;
+        session.SshPort = entry.SshPort;
+        session.SshRemoteFolder = entry.SshRemoteFolder;
+
+        session.ProfileFontFamily = entry.ProfileFontFamily;
+        session.ProfileFontSize = entry.ProfileFontSize;
+        session.ProfileFontWeight = entry.ProfileFontWeight;
+        session.ProfileFontLigatures = entry.ProfileFontLigatures;
+        session.ProfileCursorShape = entry.ProfileCursorShape;
+        session.ProfileCursorBlink = entry.ProfileCursorBlink;
+        session.ProfilePadding = entry.ProfilePadding;
+        session.ProfileBackgroundOpacity = entry.ProfileBackgroundOpacity;
+        session.ProfileRetroEffect = entry.ProfileRetroEffect;
+        session.ProfileColorSchemeJson = entry.ProfileColorSchemeJson;
+
+        // Deep-copy RunCommands so subsequent edits don't mutate any other entry
+        // that may still share the same list reference.
+        session.RunCommands = entry.RunCommands.Select(r => new RunCommandItem
+        {
+            Id = Guid.NewGuid().ToString(),
+            Label = r.Label,
+            CommandLine = r.CommandLine,
+            IsDefault = r.IsDefault,
+            Mode = r.Mode,
+            PostRunUrl = r.PostRunUrl,
+        }).ToList();
+
+        await LaunchSessionAsync(session);
+        return session;
+    }
+
+    /// <summary>
+    /// Reopens a recently-closed entry and only drops it from the ring if the launch
+    /// actually succeeded. LaunchSessionAsync's catch path removes the session it
+    /// created on failure, so we use SessionManager membership as the success signal.
+    /// </summary>
+    private async Task ReopenAndRemoveOnSuccessAsync(RecentlyClosedEntry entry)
+    {
+        var session = await ReopenClosedSessionAsync(entry);
+        if (_sessionManager.Sessions.Any(s => s.Id == session.Id))
+            _vm.RemoveRecentlyClosed(entry);
+    }
+
     /// <summary>
     /// Launches the primary session, then any opt-in sibling worktrees from the dialog —
     /// each inheriting the primary's command, group, and profile overrides, and inserted
@@ -550,6 +630,8 @@ private async Task DuplicateSessionAsync(SessionViewModel parent)
                 Label = item.Label,
                 CommandLine = item.CommandLine,
                 IsDefault = item.IsDefault,
+                Mode = item.Mode,
+                PostRunUrl = item.PostRunUrl,
             });
         }
         // If the parent had no commands, fall back to detection.
@@ -886,6 +968,7 @@ private async Task LaunchSessionAsync(ShellSession session, bool restoring = fal
         var terminalWrapper = BuildTerminalWrapper(vm, webView);
         terminalWrapper.Visibility = Visibility.Collapsed;
         TerminalGrid.Children.Add(terminalWrapper);   // in tree → WebView2 can init
+        terminalWrapper.Visibility = Visibility.Visible; // show spinner immediately
 
         // Create bridge and initialize
         var bridge = new TerminalBridge(webView);
@@ -918,6 +1001,10 @@ private async Task LaunchSessionAsync(ShellSession session, bool restoring = fal
         string htmlFile = wantTransparent ? "terminal-transparent.html" : "terminal.html";
         string htmlPath = new Uri(Path.Combine(assetsDir, htmlFile)).AbsoluteUri;
 
+        string bootLabel = session.IsRemote
+            ? $"Connecting to {session.SshHost}…"
+            : $"Starting {(string.IsNullOrWhiteSpace(session.Command) ? "session" : session.Command)}…";
+        bridge.SetBootContext(bootLabel, GetAccentForSession(session));
         await bridge.InitializeAsync(htmlPath);
         bridge.ApplyFontSettings(_vm.Settings);
         bridge.ApplyProfileOverrides(session);
@@ -1022,7 +1109,6 @@ private async Task LaunchSessionAsync(ShellSession session, bool restoring = fal
         }
 
         Log($"terminalWrapper visible, TerminalGrid children={TerminalGrid.Children.Count}");
-        terminalWrapper.Visibility = Visibility.Visible;
 
         // Build sidebar entry
         var sidebarItem = BuildSidebarItem(vm);
@@ -3300,6 +3386,7 @@ private void UpdateAlertBadge()
     private void Layout_Six_Click(object s, RoutedEventArgs e) => SetLayout(LayoutMode.SixColumn);
     private void Layout_SixTwo_Click(object s, RoutedEventArgs e) => SetLayout(LayoutMode.SixByTwo);
     private void Layout_SixThree_Click(object s, RoutedEventArgs e) => SetLayout(LayoutMode.SixByThree);
+    private void Layout_ThreeByThree_Click(object s, RoutedEventArgs e) => SetLayout(LayoutMode.ThreeByThree);
 
     private void SetLayout(LayoutMode mode)
     {
@@ -3417,6 +3504,15 @@ private void RefreshTerminalLayout()
                 break;
             }
 
+            case LayoutMode.ThreeByThree:
+            {
+                var view = GetViewportSessions(sessions, 9);
+                for (int i = 0; i < 3; i++) TerminalGrid.ColumnDefinitions.Add(new ColumnDefinition());
+                for (int r = 0; r < 3; r++) TerminalGrid.RowDefinitions.Add(new RowDefinition());
+                for (int i = 0; i < 9; i++) PlaceTerminal(view, i, i / 3, i % 3);
+                break;
+            }
+
             default: // Single
             {
                 // If the active session is filtered out by the group filter, fall back
@@ -4661,7 +4757,18 @@ private void OnBridgeAcceleratorKey(object? sender, WpfKeyEventArgs e)
     private bool TryHandleGlobalShortcut(Key key, ModifierKeys mods)
     {
         if (key == Key.T && mods == ModifierKeys.Control) { OpenNewSessionDialog(); return true; }
+        // Browser convention: Ctrl+Shift+T reopens the most-recently-closed session.
+        // Duplicate moved to Ctrl+Alt+T to free this slot.
         if (key == Key.T && mods == (ModifierKeys.Control | ModifierKeys.Shift))
+        {
+            // Peek instead of pop — if the reopen fails, the entry stays available
+            // for retry. PeekMostRecentlyClosed returns the same entry PopMostRecently
+            // would have popped; ReopenAndRemoveOnSuccessAsync removes only on success.
+            var entry = _vm.PeekMostRecentlyClosed();
+            if (entry != null) _ = ReopenAndRemoveOnSuccessAsync(entry);
+            return true;
+        }
+        if (key == Key.T && mods == (ModifierKeys.Control | ModifierKeys.Alt))
         {
             if (_vm.ActiveSession != null) _ = DuplicateSessionAsync(_vm.ActiveSession);
             return true;
@@ -4727,6 +4834,13 @@ protected override async void OnClosing(System.ComponentModel.CancelEventArgs e)
         if (_isShuttingDown) return;
         _isShuttingDown = true;
 
+        // Show the shutdown overlay so the user sees progress while sessions tear down.
+        // The yield lets WPF render the overlay before the synchronous disposal below blocks
+        // the UI thread; without it, the overlay would only paint after Close() is reached.
+        ShutdownOverlay.Visibility = Visibility.Visible;
+        await Dispatcher.InvokeAsync(() => { },
+            System.Windows.Threading.DispatcherPriority.Background);
+
         _windowStateTimer.Stop();
         if (_windowStateReady)
             _vm.UpdateWindowState(WindowState, Left, Top, Width, Height);
diff --git a/src/CodeShellManager/Models/AppState.cs b/src/CodeShellManager/Models/AppState.cs
index 1d19592..f1a1dc5 100644
--- a/src/CodeShellManager/Models/AppState.cs
+++ b/src/CodeShellManager/Models/AppState.cs
@@ -140,6 +140,12 @@ public class AppState
 {
     public List<ShellSession> Sessions { get; set; } = [];
     public List<SessionGroup> Groups { get; set; } = [];
+    /// <summary>
+    /// Ring buffer of recently-closed sessions (newest first), capped at
+    /// <see cref="ViewModels.MainViewModel.MaxRecentlyClosed"/>. Reopen via
+    /// Ctrl+Shift+T or the "Recently closed" list in the New Session dialog.
+    /// </summary>
+    public List<RecentlyClosedEntry> RecentlyClosed { get; set; } = [];
     public string LastLayout { get; set; } = "Single";
     /// <summary>
     /// Per-group grid layouts when <see cref="AppSettings.PerGroupLayout"/> is on.
diff --git a/src/CodeShellManager/Models/RecentlyClosedEntry.cs b/src/CodeShellManager/Models/RecentlyClosedEntry.cs
new file mode 100644
index 0000000..ddff9b6
--- /dev/null
+++ b/src/CodeShellManager/Models/RecentlyClosedEntry.cs
@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace CodeShellManager.Models;
+
+/// <summary>
+/// A snapshot of a recently-closed session, kept so the user can reopen it with
+/// <c>Ctrl+Shift+T</c> or via the "Recently closed" list in the New Session dialog.
+/// Stored on <see cref="AppState.RecentlyClosed"/> (capped — see
+/// <c>MainViewModel.MaxRecentlyClosed</c>) and persisted to <c>state.json</c>.
+///
+/// Deliberately separate from <see cref="ShellSession"/> so PTY/runtime fields
+/// (IsDormant, Status, LastActivityAt) don't leak into the ring buffer and so the
+/// model can evolve independently.
+/// </summary>
+public class RecentlyClosedEntry
+{
+    public string Name { get; set; } = "";
+    public string WorkingFolder { get; set; } = "";
+    public string Command { get; set; } = "claude";
+    public string Args { get; set; } = "";
+    public string GroupId { get; set; } = "";
+    public string? ColorOverride { get; set; }
+
+    public bool IsRemote { get; set; }
+    public string SshUser { get; set; } = "";
+    public string SshHost { get; set; } = "";
+    public int SshPort { get; set; } = 22;
+    public string SshRemoteFolder { get; set; } = "";
+
+    public string? ProfileFontFamily { get; set; }
+    public int? ProfileFontSize { get; set; }
+    public string? ProfileFontWeight { get; set; }
+    public bool? ProfileFontLigatures { get; set; }
+    public string? ProfileCursorShape { get; set; }
+    public bool? ProfileCursorBlink { get; set; }
+    public string? ProfilePadding { get; set; }
+    public double? ProfileBackgroundOpacity { get; set; }
+    public bool? ProfileRetroEffect { get; set; }
+    public string? ProfileColorSchemeJson { get; set; }
+
+    public List<RunCommandItem> RunCommands { get; set; } = new();
+
+    public DateTime ClosedAt { get; set; } = DateTime.UtcNow;
+
+    /// <summary>
+    /// Shallow copies the persistable fields of a <see cref="ShellSession"/>.
+    /// RunCommands are deep-copied with fresh Ids so editing the reopened session
+    /// can't accidentally mutate the entry still in the ring buffer.
+    /// </summary>
+    public static RecentlyClosedEntry FromSession(ShellSession s) => new()
+    {
+        Name = s.Name,
+        WorkingFolder = s.WorkingFolder,
+        Command = s.Command,
+        Args = s.Args,
+        GroupId = s.GroupId,
+        ColorOverride = s.ColorOverride,
+        IsRemote = s.IsRemote,
+        SshUser = s.SshUser,
+        SshHost = s.SshHost,
+        SshPort = s.SshPort,
+        SshRemoteFolder = s.SshRemoteFolder,
+        ProfileFontFamily = s.ProfileFontFamily,
+        ProfileFontSize = s.ProfileFontSize,
+        ProfileFontWeight = s.ProfileFontWeight,
+        ProfileFontLigatures = s.ProfileFontLigatures,
+        ProfileCursorShape = s.ProfileCursorShape,
+        ProfileCursorBlink = s.ProfileCursorBlink,
+        ProfilePadding = s.ProfilePadding,
+        ProfileBackgroundOpacity = s.ProfileBackgroundOpacity,
+        ProfileRetroEffect = s.ProfileRetroEffect,
+        ProfileColorSchemeJson = s.ProfileColorSchemeJson,
+        RunCommands = s.RunCommands.Select(r => new RunCommandItem
+        {
+            Id = Guid.NewGuid().ToString(),
+            Label = r.Label,
+            CommandLine = r.CommandLine,
+            IsDefault = r.IsDefault,
+            Mode = r.Mode,
+            PostRunUrl = r.PostRunUrl,
+        }).ToList(),
+        ClosedAt = DateTime.UtcNow,
+    };
+
+    /// <summary>Friendly subtitle for the recents UI — folder or user@host.</summary>
+    public string Subtitle => IsRemote
+        ? (string.IsNullOrWhiteSpace(SshUser) ? SshHost : $"{SshUser}@{SshHost}")
+        : WorkingFolder;
+}
diff --git a/src/CodeShellManager/Models/RunCommandItem.cs b/src/CodeShellManager/Models/RunCommandItem.cs
index e808ffe..308e588 100644
--- a/src/CodeShellManager/Models/RunCommandItem.cs
+++ b/src/CodeShellManager/Models/RunCommandItem.cs
@@ -3,6 +3,19 @@
 
 namespace CodeShellManager.Models;
 
+/// <summary>
+/// How the run-command's command line is launched.
+///   Process:    cmd /c "<cmd>"  — bare ConPTY child, the historical default.
+///   PowerShell: pwsh.exe -EncodedCommand <b64>  (falls back to powershell.exe if pwsh is missing)
+///               needed when the command relies on pipes, $env:, cmdlets, or other PS syntax.
+/// SSH parents ignore this — remote runs always go through bash.
+/// </summary>
+public enum RunMode
+{
+    Process,
+    PowerShell,
+}
+
 /// <summary>
 /// One configured "run" command on a session. The user can have many of these;
 /// exactly one is the default (driven by the toolbar ▶ button and F5 keybinding).
@@ -15,6 +28,15 @@ public class RunCommandItem
     public string CommandLine { get; set; } = "";
     public bool IsDefault { get; set; }
 
+    /// <summary>Host process for the command. Defaults to Process for back-compat with pre-existing state.json entries.</summary>
+    public RunMode Mode { get; set; } = RunMode.Process;
+
+    /// <summary>
+    /// Optional URL opened in the default browser when the command exits with code 0.
+    /// Null / empty disables. Invoked via ShellExecute, so the OS handles validation.
+    /// </summary>
+    public string? PostRunUrl { get; set; }
+
     /// <summary>
     /// Normalizes the list so exactly one item has IsDefault=true (when non-empty).
     /// If multiple are marked, the LAST one wins — this matches the editor dialog's
diff --git a/src/CodeShellManager/Properties/launchSettings.json b/src/CodeShellManager/Properties/launchSettings.json
new file mode 100644
index 0000000..7b7223d
--- /dev/null
+++ b/src/CodeShellManager/Properties/launchSettings.json
@@ -0,0 +1,9 @@
+{
+  "profiles": {
+    "CodeShellManager": {
+      "commandName": "Project",
+      "commandLineArgs": "--clean",
+      "hotReloadEnabled": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/CodeShellManager/Services/AlertDetector.cs b/src/CodeShellManager/Services/AlertDetector.cs
index d5705a8..8d4976f 100644
--- a/src/CodeShellManager/Services/AlertDetector.cs
+++ b/src/CodeShellManager/Services/AlertDetector.cs
@@ -38,6 +38,7 @@ public void Feed(string rawOutput)
         }
 
         _idleTimer?.Dispose();
+        // 1.5s idle: long enough for Claude's prompt redraw bursts to settle, short enough to feel responsive.
         _idleTimer = new System.Threading.Timer(OnIdle, null, 1500, Timeout.Infinite);
     }
 
diff --git a/src/CodeShellManager/Services/RunInstance.cs b/src/CodeShellManager/Services/RunInstance.cs
index 07329b9..f2dbe12 100644
--- a/src/CodeShellManager/Services/RunInstance.cs
+++ b/src/CodeShellManager/Services/RunInstance.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics;
 using System.IO;
 using System.Text;
 using System.Text.RegularExpressions;
@@ -29,6 +30,8 @@ public partial class RunInstance : ObservableObject, IDisposable
     public string ItemId { get; }
     public string Label { get; }
     public string CommandLine { get; }
+    public RunMode Mode { get; }
+    public string? PostRunUrl { get; }
 
     [ObservableProperty] private RunState _state = RunState.Idle;
     [ObservableProperty] private int? _exitCode;
@@ -38,7 +41,8 @@ public partial class RunInstance : ObservableObject, IDisposable
 
     public TimeSpan? Duration => StartedAt is { } s && EndedAt is { } e ? e - s : null;
 
-    private PseudoTerminal? _pty;
+    private IPseudoTerminal? _pty;
+    private readonly Func<IPseudoTerminal> _ptyFactory;
     private readonly StringBuilder _ansiStripped = new();
     private readonly object _bufLock = new();
     private bool _disposed;
@@ -47,10 +51,22 @@ public partial class RunInstance : ObservableObject, IDisposable
     public event Action? StateChanged;
 
     public RunInstance(RunCommandItem item)
+        : this(item, static () => new PseudoTerminal())
+    {
+    }
+
+    /// <summary>
+    /// Test seam — accepts a factory that produces an <see cref="IPseudoTerminal"/>.
+    /// Production code uses the parameterless ctor which delegates to <see cref="PseudoTerminal"/>.
+    /// </summary>
+    internal RunInstance(RunCommandItem item, Func<IPseudoTerminal> ptyFactory)
     {
         ItemId = item.Id;
         Label = item.Label;
         CommandLine = item.CommandLine;
+        Mode = item.Mode;
+        PostRunUrl = item.PostRunUrl;
+        _ptyFactory = ptyFactory;
     }
 
     /// <summary>
@@ -69,17 +85,26 @@ public void Start(ShellSession parent)
         State = RunState.Running;
         StateChanged?.Invoke();
 
-        _pty = new PseudoTerminal();
+        _pty = _ptyFactory();
         _pty.DataReceived += OnPtyData;
         _pty.Exited += OnPtyExited;
 
         string command, args, workDir;
         if (parent.IsRemote)
         {
+            // SSH parents always go through bash — Mode is meaningless for remote runs.
             command = "ssh";
             args = BuildSshArgs(parent, CommandLine);
             workDir = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
         }
+        else if (Mode == RunMode.PowerShell)
+        {
+            command = ResolvePwsh();
+            args = BuildPwshArgs(CommandLine);
+            workDir = Directory.Exists(parent.WorkingFolder)
+                ? parent.WorkingFolder
+                : Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+        }
         else
         {
             command = "cmd";
@@ -120,6 +145,29 @@ private void OnPtyExited()
         ExitCode = _pty?.ExitCode;
         State = ExitCode == 0 ? RunState.ExitedOk : RunState.ExitedFailed;
         StateChanged?.Invoke();
+
+        // Open post-run URL on success only. ShellExecute hands the URL to the
+        // OS default browser. We can't pop UI from the PTY-exit callback thread,
+        // so failures are logged to crash.log for diagnosability rather than silenced.
+        if (State == RunState.ExitedOk && !string.IsNullOrWhiteSpace(PostRunUrl))
+        {
+            try { Process.Start(new ProcessStartInfo(PostRunUrl) { UseShellExecute = true }); }
+            catch (Exception ex) { LogPostRunUrlFailure(PostRunUrl, ex); }
+        }
+    }
+
+    private static void LogPostRunUrlFailure(string url, Exception ex)
+    {
+        try
+        {
+            string path = Path.Combine(
+                Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
+                "CodeShellManager", "crash.log");
+            Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+            File.AppendAllText(path,
+                $"[{DateTime.Now:HH:mm:ss.fff}] PostRunUrl failed '{url}': {ex.Message}\n");
+        }
+        catch { /* logger failure is not actionable */ }
     }
 
     /// <summary>
@@ -137,6 +185,61 @@ public string SnapshotOutput()
     /// </summary>
     internal static string BuildLocalCmd(string commandLine) => $"/c \"{commandLine}\"";
 
+    /// <summary>
+    /// Returns "pwsh.exe" if PowerShell 7+ is on PATH, otherwise falls back to
+    /// the Windows-bundled "powershell.exe". ConPTY's CreateProcess resolves PATH
+    /// for us — we just pick which name to ask for.
+    /// </summary>
+    internal static string ResolvePwsh()
+    {
+        // Cheap check: try to spawn pwsh -NoLogo -Command "exit". If it returns,
+        // we trust pwsh is on PATH. Use a one-shot Process so we don't perturb
+        // the user's environment. Skip the probe if we already know.
+        if (_pwshResolved is { } cached) return cached;
+
+        try
+        {
+            using var probe = Process.Start(new ProcessStartInfo
+            {
+                FileName = "pwsh.exe",
+                Arguments = "-NoLogo -NoProfile -Command \"exit 0\"",
+                UseShellExecute = false,
+                CreateNoWindow = true,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+            });
+            if (probe != null)
+            {
+                // Cache pwsh only if the probe actually exited cleanly. A hung probe
+                // (WaitForExit returns false) or non-zero exit means pwsh is in a bad
+                // state; fall back to powershell.exe instead of caching a broken choice.
+                if (probe.WaitForExit(2000) && probe.ExitCode == 0)
+                {
+                    _pwshResolved = "pwsh.exe";
+                    return _pwshResolved;
+                }
+                try { if (!probe.HasExited) probe.Kill(entireProcessTree: true); }
+                catch { }
+            }
+        }
+        catch { /* not on PATH */ }
+
+        _pwshResolved = "powershell.exe";
+        return _pwshResolved;
+    }
+    private static string? _pwshResolved;
+
+    /// <summary>
+    /// Builds powershell args using -EncodedCommand so we don't have to worry
+    /// about quoting in the user's command line. The payload is UTF-16 LE base64,
+    /// which is what -EncodedCommand expects.
+    /// </summary>
+    internal static string BuildPwshArgs(string commandLine)
+    {
+        string b64 = Convert.ToBase64String(Encoding.Unicode.GetBytes(commandLine));
+        return $"-NonInteractive -NoLogo -ExecutionPolicy Bypass -EncodedCommand {b64}";
+    }
+
     /// <summary>
     /// Builds ssh args for a remote run. Pattern:
     ///   -p PORT -t user@host "cd '/folder' &amp;&amp; bash -c '<escaped>'"
@@ -186,6 +289,9 @@ public void Dispose()
         }
     }
 
-    [GeneratedRegex(@"\x1B\[[0-9;]*[mGKHFJABCDsuhl]|\x1B\].*?\x07|\x1B[=>]|\r", RegexOptions.Compiled)]
+    // Mirrors the strip regex in OutputIndexer.AnsiPattern — keep them in sync.
+    // The `?` inside [?0-9;]* covers CSI private-mode sequences like ESC[?9001h
+    // (ConPTY's Win32 input-mode bootstrap), ESC[?1049h (alt screen), etc.
+    [GeneratedRegex(@"\x1B\[[?0-9;]*[mGKHFJABCDsuhl]|\x1B\].*?(?:\x07|\x1B\\)|\x1B[=>]|\r", RegexOptions.Compiled)]
     private static partial Regex AnsiPattern();
 }
diff --git a/src/CodeShellManager/Services/SessionRunner.cs b/src/CodeShellManager/Services/SessionRunner.cs
index 78598f8..255bc4b 100644
--- a/src/CodeShellManager/Services/SessionRunner.cs
+++ b/src/CodeShellManager/Services/SessionRunner.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using CodeShellManager.Models;
+using CodeShellManager.Terminal;
 
 namespace CodeShellManager.Services;
 
@@ -14,12 +15,24 @@ public class SessionRunner : IDisposable
 {
     private readonly ShellSession _session;
     private readonly Dictionary<string, RunInstance> _instances = new();
+    private readonly Func<IPseudoTerminal>? _ptyFactory;
 
     /// <summary>Fires when any instance is added, replaced, or removed, or any state changes.</summary>
     public event Action? InstancesChanged;
 
     public SessionRunner(ShellSession session) { _session = session; }
 
+    /// <summary>
+    /// Test seam — when a factory is supplied, <see cref="Run"/> wires every
+    /// <see cref="RunInstance"/> to it instead of letting RunInstance default
+    /// to a real <see cref="PseudoTerminal"/>.
+    /// </summary>
+    internal SessionRunner(ShellSession session, Func<IPseudoTerminal> ptyFactory)
+    {
+        _session = session;
+        _ptyFactory = ptyFactory;
+    }
+
     public IReadOnlyDictionary<string, RunInstance> Instances => _instances;
 
     public RunInstance? GetInstance(string itemId) =>
@@ -39,7 +52,9 @@ public RunInstance Run(RunCommandItem item)
             _instances.Remove(item.Id);
         }
 
-        var inst = new RunInstance(item);
+        var inst = _ptyFactory is null
+            ? new RunInstance(item)
+            : new RunInstance(item, _ptyFactory);
         inst.StateChanged += OnInstanceStateChanged;
         inst.OutputChanged += OnInstanceOutputChanged;
         _instances[item.Id] = inst;
diff --git a/src/CodeShellManager/Terminal/IPseudoTerminal.cs b/src/CodeShellManager/Terminal/IPseudoTerminal.cs
new file mode 100644
index 0000000..8337ee0
--- /dev/null
+++ b/src/CodeShellManager/Terminal/IPseudoTerminal.cs
@@ -0,0 +1,25 @@
+using System;
+
+namespace CodeShellManager.Terminal;
+
+/// <summary>
+/// Minimum surface of <see cref="PseudoTerminal"/> consumed by
+/// <see cref="Services.RunInstance"/>. Extracted so callers can be unit-tested
+/// without spawning a real ConPTY child — production code still constructs the
+/// concrete <see cref="PseudoTerminal"/>; tests substitute a fake.
+/// </summary>
+public interface IPseudoTerminal : IDisposable
+{
+    /// <summary>Fires from the PTY read loop's thread with a decoded UTF-8 chunk.</summary>
+    event Action<string>? DataReceived;
+
+    /// <summary>Fires once after the child process has exited and <see cref="ExitCode"/> is populated.</summary>
+    event Action? Exited;
+
+    /// <summary>Exit code of the child process. Null while running.</summary>
+    int? ExitCode { get; }
+
+    /// <summary>Spawns the child process. Mirrors <see cref="PseudoTerminal.Start"/>.</summary>
+    void Start(string command, string args, string workingDirectory,
+        int cols = 220, int rows = 50, bool useJobObject = false);
+}
diff --git a/src/CodeShellManager/Terminal/OutputIndexer.cs b/src/CodeShellManager/Terminal/OutputIndexer.cs
index 012d7c0..c94033e 100644
--- a/src/CodeShellManager/Terminal/OutputIndexer.cs
+++ b/src/CodeShellManager/Terminal/OutputIndexer.cs
@@ -81,6 +81,10 @@ public void Dispose()
         catch { /* AggregateException from worker exceptions — already swallowed inside */ }
     }
 
-    [GeneratedRegex(@"\x1B\[[0-9;]*[mGKHFJABCDsuhl]|\x1B\].*?\x07|\x1B[=>]|\r", RegexOptions.Compiled)]
+    // Mirrors the strip regex in RunInstance.AnsiPattern — keep them in sync.
+    // The `?` inside [?0-9;]* covers CSI private-mode sequences like ESC[?9001h
+    // (ConPTY's Win32 input-mode bootstrap), ESC[?1049h (alt screen), etc.
+    // OSC strings may terminate with BEL (\x07) or ST (ESC\).
+    [GeneratedRegex(@"\x1B\[[?0-9;]*[mGKHFJABCDsuhl]|\x1B\].*?(?:\x07|\x1B\\)|\x1B[=>]|\r", RegexOptions.Compiled)]
     private static partial Regex AnsiPattern();
 }
diff --git a/src/CodeShellManager/Terminal/PseudoTerminal.cs b/src/CodeShellManager/Terminal/PseudoTerminal.cs
index f5a45e6..1208e37 100644
--- a/src/CodeShellManager/Terminal/PseudoTerminal.cs
+++ b/src/CodeShellManager/Terminal/PseudoTerminal.cs
@@ -11,7 +11,7 @@ namespace CodeShellManager.Terminal;
 /// <summary>
 /// Wraps the Windows ConPTY (Pseudo Console) API to host an interactive terminal process.
 /// </summary>
-public sealed class PseudoTerminal : IDisposable
+public sealed class PseudoTerminal : IPseudoTerminal
 {
     // ── P/Invoke ──────────────────────────────────────────────────────────────
 
@@ -69,6 +69,16 @@ private static extern bool SetInformationJobObject(IntPtr hJob, int JobObjectInf
     [DllImport("kernel32.dll", SetLastError = true)]
     private static extern bool GetExitCodeProcess(IntPtr hProcess, out uint lpExitCode);
 
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern bool DuplicateHandle(IntPtr hSourceProcessHandle, IntPtr hSourceHandle,
+        IntPtr hTargetProcessHandle, out IntPtr lpTargetHandle, uint dwDesiredAccess,
+        bool bInheritHandle, uint dwOptions);
+
+    [DllImport("kernel32.dll")]
+    private static extern IntPtr GetCurrentProcess();
+
+    private const uint DUPLICATE_SAME_ACCESS = 0x00000002;
+
     // ── Structs ───────────────────────────────────────────────────────────────
 
     [StructLayout(LayoutKind.Sequential)]
@@ -345,9 +355,25 @@ private async Task ReadLoopAsync()
 
     private async Task MonitorExitAsync()
     {
-        await Task.Run(() => WaitForSingleObject(_hProcess, 0xFFFFFFFF));
-        if (_hProcess != IntPtr.Zero && GetExitCodeProcess(_hProcess, out uint code))
-            ExitCode = unchecked((int)code);
+        // Duplicate _hProcess so Dispose() can close the original without racing the wait.
+        // Closing a handle that another thread is waiting on is Win32 UB — the wait may
+        // return prematurely and we'd fire Exited before the child actually exits.
+        if (!DuplicateHandle(GetCurrentProcess(), _hProcess, GetCurrentProcess(),
+                out IntPtr waitHandle, 0, false, DUPLICATE_SAME_ACCESS))
+        {
+            Log($"DuplicateHandle failed: {Marshal.GetLastWin32Error()}");
+            return;
+        }
+        try
+        {
+            await Task.Run(() => WaitForSingleObject(waitHandle, 0xFFFFFFFF));
+            if (GetExitCodeProcess(waitHandle, out uint code))
+                ExitCode = unchecked((int)code);
+        }
+        finally
+        {
+            CloseHandle(waitHandle);
+        }
         Exited?.Invoke();
     }
 
diff --git a/src/CodeShellManager/Terminal/TerminalBridge.cs b/src/CodeShellManager/Terminal/TerminalBridge.cs
index 6f9e050..518e8b7 100644
--- a/src/CodeShellManager/Terminal/TerminalBridge.cs
+++ b/src/CodeShellManager/Terminal/TerminalBridge.cs
@@ -24,6 +24,15 @@ public sealed class TerminalBridge : IDisposable
     // so the PTY starts at the right dimensions even if resize fired before AttachPty.
     private (int cols, int rows) _lastSize = (80, 24);
 
+    // Boot overlay — set by MainWindow before InitializeAsync; posted as setBootState after
+    // navigation completes, and hidden via bootDone on the first PTY byte (see OnPtyData).
+    // Fallback hides the overlay after BootDoneFallbackMs so silent sessions (e.g. a child
+    // that prints nothing, an SSH connect that's mid-handshake) aren't locked out.
+    private const int BootDoneFallbackMs = 8000;
+    private string? _bootLabel;
+    private string? _bootAccentHex;
+    private int _bootDoneFlag; // 0 = overlay still visible, 1 = bootDone already posted
+
     // Output that arrived before the page finished loading is buffered here
     private readonly System.Text.StringBuilder _outputBuffer = new();
 
@@ -73,11 +82,33 @@ private void Trace(string msg)
         catch { }
     }
 
+    // Posts a one-shot bootDone message to the WebView2. Safe to call from any thread.
+    private void PostBootDoneIfNeeded()
+    {
+        if (System.Threading.Interlocked.CompareExchange(ref _bootDoneFlag, 1, 0) != 0) return;
+        WpfApplication.Current?.Dispatcher.BeginInvoke(() =>
+        {
+            try { _webView.CoreWebView2?.PostWebMessageAsString("{\"type\":\"bootDone\"}"); }
+            catch { }
+        });
+    }
+
     public TerminalBridge(WebView2 webView)
     {
         _webView = webView;
     }
 
+    /// <summary>
+    /// Sets the boot-overlay label and accent color. Must be called before
+    /// <see cref="InitializeAsync"/> — the bridge posts a setBootState message to the
+    /// page as soon as navigation completes.
+    /// </summary>
+    public void SetBootContext(string label, string accentHex)
+    {
+        _bootLabel = label;
+        _bootAccentHex = accentHex;
+    }
+
     /// <summary>
     /// Initializes WebView2, navigates to terminal.html and AWAITS full page load
     /// before returning. This ensures PTY output is never dropped.
@@ -96,6 +127,11 @@ public async Task InitializeAsync(string htmlPath)
         await _webView.EnsureCoreWebView2Async(env);
         Log("EnsureCoreWebView2Async done");
 
+        // Match the boot overlay background so the WebView2 init flicker (the gap between
+        // the control becoming visible and terminal.html rendering) is invisible.
+        try { _webView.DefaultBackgroundColor = System.Drawing.Color.FromArgb(0x1e, 0x1e, 0x2e); }
+        catch { }
+
         var settings = _webView.CoreWebView2.Settings;
         settings.AreDevToolsEnabled = true;  // enable for debugging
         settings.AreDefaultContextMenusEnabled = false;
@@ -137,6 +173,26 @@ void NavCompleted(object? s, CoreWebView2NavigationCompletedEventArgs e)
             Log($"NavigationCompleted: success={e.IsSuccess} httpStatus={e.HttpStatusCode} webErrorStatus={e.WebErrorStatus}");
             _ready = true;
 
+            // Apply boot-overlay state if MainWindow called SetBootContext before init.
+            if (_bootLabel != null && _bootAccentHex != null)
+            {
+                var bootJson = JsonSerializer.Serialize(new
+                {
+                    type = "setBootState",
+                    label = _bootLabel,
+                    accentHex = _bootAccentHex
+                });
+                try { _webView.CoreWebView2?.PostWebMessageAsString(bootJson); }
+                catch { }
+            }
+
+            // Silent-session fallback: if the child writes nothing (or exits without
+            // any output) the overlay would otherwise block the terminal indefinitely.
+            // PostBootDoneIfNeeded is idempotent via Interlocked, so this is a no-op
+            // when the first PTY byte beat the timer.
+            _ = Task.Delay(BootDoneFallbackMs).ContinueWith(
+                _ => PostBootDoneIfNeeded(), TaskScheduler.Default);
+
             // Flush any PTY output that arrived during page load
             string buffered;
             lock (_outputBuffer)
@@ -188,6 +244,7 @@ private void OnPtyData(string rawData)
         }
 
         RawOutputReceived?.Invoke(rawData);
+        PostBootDoneIfNeeded();
 
         if (!_ready)
         {
@@ -403,6 +460,7 @@ public void FocusTerminal()
 
     public void Dispose()
     {
+        PostBootDoneIfNeeded();
         if (_pty != null) _pty.DataReceived -= OnPtyData;
         if (_webView.CoreWebView2 != null)
         {
diff --git a/src/CodeShellManager/ViewModels/MainViewModel.cs b/src/CodeShellManager/ViewModels/MainViewModel.cs
index e1c8507..3802d43 100644
--- a/src/CodeShellManager/ViewModels/MainViewModel.cs
+++ b/src/CodeShellManager/ViewModels/MainViewModel.cs
@@ -10,7 +10,7 @@
 
 namespace CodeShellManager.ViewModels;
 
-public enum LayoutMode { Single, TwoColumn, ThreeColumn, TwoByTwo, TwoRow, FourColumn, SixColumn, SixByTwo, SixByThree }
+public enum LayoutMode { Single, TwoColumn, ThreeColumn, TwoByTwo, TwoRow, FourColumn, SixColumn, SixByTwo, SixByThree, ThreeByThree }
 
 /// <summary>Sentinel <see cref="MainViewModel.ActiveGroupId"/> value meaning "show only sessions with no group".</summary>
 public static class GroupFilter
@@ -28,6 +28,12 @@ public partial class MainViewModel : ObservableObject
 
     public ObservableCollection<SessionViewModel> Sessions { get; } = [];
 
+    /// <summary>Cap on the recently-closed ring buffer. Older entries fall off the end.</summary>
+    public const int MaxRecentlyClosed = 10;
+
+    /// <summary>Read-only view of the recently-closed ring buffer (newest first).</summary>
+    public IReadOnlyList<RecentlyClosedEntry> RecentlyClosed => _appState.RecentlyClosed;
+
     [ObservableProperty] private SessionViewModel? _activeSession;
     [ObservableProperty] private LayoutMode _layout = LayoutMode.Single;
     [ObservableProperty] private bool _showSearch;
@@ -305,6 +311,10 @@ public void RegisterSession(SessionViewModel vm)
     private void OnSessionCloseRequested(SessionViewModel vm)
     {
         vm.CloseRequested -= OnSessionCloseRequested;
+        // Snapshot the underlying ShellSession into the ring buffer BEFORE disposing —
+        // Dispose() doesn't actually null the model, but capturing here keeps the
+        // ordering deterministic (push → drop → save) regardless of future changes.
+        PushRecentlyClosed(vm.Session);
         Sessions.Remove(vm);
         if (SelectedSessionIds.Remove(vm.Id))
             SelectionChanged?.Invoke();
@@ -318,6 +328,51 @@ private void OnSessionCloseRequested(SessionViewModel vm)
         _ = SaveStateAsync();
     }
 
+    /// <summary>
+    /// Pushes a snapshot of the session onto the recently-closed ring buffer.
+    /// No-op in --clean mode (mirrors <see cref="SaveStateAsync"/> semantics —
+    /// debug runs must not pollute the persisted recent list).
+    /// </summary>
+    public void PushRecentlyClosed(ShellSession session)
+    {
+        if (App.CleanStart) return;
+        _appState.RecentlyClosed.Insert(0, RecentlyClosedEntry.FromSession(session));
+        while (_appState.RecentlyClosed.Count > MaxRecentlyClosed)
+            _appState.RecentlyClosed.RemoveAt(_appState.RecentlyClosed.Count - 1);
+    }
+
+    /// <summary>Pops and returns the most-recently-closed entry, or null if the ring is empty.</summary>
+    public RecentlyClosedEntry? PopMostRecentlyClosed()
+    {
+        if (_appState.RecentlyClosed.Count == 0) return null;
+        var e = _appState.RecentlyClosed[0];
+        _appState.RecentlyClosed.RemoveAt(0);
+        _ = SaveStateAsync();
+        return e;
+    }
+
+    /// <summary>
+    /// Returns the most-recently-closed entry without removing it. Use when the caller
+    /// wants to attempt a reopen and remove the entry only if it succeeds.
+    /// </summary>
+    public RecentlyClosedEntry? PeekMostRecentlyClosed()
+        => _appState.RecentlyClosed.Count == 0 ? null : _appState.RecentlyClosed[0];
+
+    /// <summary>Removes a specific entry from the ring (e.g. after the user reopens it from the dialog).</summary>
+    public void RemoveRecentlyClosed(RecentlyClosedEntry entry)
+    {
+        if (_appState.RecentlyClosed.Remove(entry))
+            _ = SaveStateAsync();
+    }
+
+    /// <summary>Empties the recently-closed ring. Used by <c>--clean</c> mode for full isolation.</summary>
+    public void ClearRecentlyClosed()
+    {
+        if (_appState.RecentlyClosed.Count == 0) return;
+        _appState.RecentlyClosed.Clear();
+        _ = SaveStateAsync();
+    }
+
     [RelayCommand]
     private void SetLayout(LayoutMode mode)
     {
diff --git a/src/CodeShellManager/Views/NewSessionDialog.xaml b/src/CodeShellManager/Views/NewSessionDialog.xaml
index d285b70..1d5b6da 100644
--- a/src/CodeShellManager/Views/NewSessionDialog.xaml
+++ b/src/CodeShellManager/Views/NewSessionDialog.xaml
@@ -1,7 +1,7 @@
 <Window x:Class="CodeShellManager.Views.NewSessionDialog"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-        Title="New Session" Height="480" Width="480"
+        Title="New Session" Height="560" Width="480"
         WindowStartupLocation="CenterOwner" ResizeMode="NoResize"
         Background="#1e1e2e" Foreground="#cdd6f4"
         FontFamily="Segoe UI">
@@ -157,8 +157,19 @@
             <RowDefinition Height="Auto"/>
         </Grid.RowDefinitions>
 
-        <!-- Session Type -->
+        <!-- Recently closed + Session Type -->
         <StackPanel Grid.Row="0" Margin="0,0,0,12">
+            <!-- Recently closed list (collapsed when empty). Click an entry to reopen. -->
+            <StackPanel x:Name="RecentlyClosedPanel" Visibility="Collapsed" Margin="0,0,0,12">
+                <TextBlock Text="Recently closed (click to reopen)" Style="{StaticResource Label}"/>
+                <Border Background="#181825" BorderBrush="#313244" BorderThickness="1"
+                        CornerRadius="3" Padding="4" MaxHeight="120">
+                    <ScrollViewer VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Disabled">
+                        <StackPanel x:Name="RecentlyClosedList"/>
+                    </ScrollViewer>
+                </Border>
+            </StackPanel>
+
             <TextBlock Text="Session Type" Style="{StaticResource Label}"/>
             <StackPanel Orientation="Horizontal">
                 <RadioButton x:Name="LocalRadio"
diff --git a/src/CodeShellManager/Views/NewSessionDialog.xaml.cs b/src/CodeShellManager/Views/NewSessionDialog.xaml.cs
index ad63e6d..f575d47 100644
--- a/src/CodeShellManager/Views/NewSessionDialog.xaml.cs
+++ b/src/CodeShellManager/Views/NewSessionDialog.xaml.cs
@@ -46,6 +46,13 @@ public partial class NewSessionDialog : Window
     /// <summary>Paths of sibling worktrees the user opted to also launch sessions for.</summary>
     public IReadOnlyList<string> AdditionalWorktreePaths { get; private set; } = Array.Empty<string>();
 
+    /// <summary>
+    /// When non-null, the user picked an entry from the "Recently closed" list instead of
+    /// filling in the form. The caller (<c>OpenNewSessionDialogCore</c>) should reopen this
+    /// session via <c>ReopenClosedSessionAsync</c> and ignore the rest of the form fields.
+    /// </summary>
+    public RecentlyClosedEntry? SelectedRecentlyClosed { get; private set; }
+
     private readonly IReadOnlyList<WindowsTerminalProfile> _profiles;
     private readonly System.Windows.Threading.DispatcherTimer _worktreeDebounce;
     private System.Threading.CancellationTokenSource? _worktreeProbeCts;
@@ -57,7 +64,8 @@ public NewSessionDialog(
         IReadOnlyList<WindowsTerminalProfile>? profiles = null,
         string? defaultCommand = null,
         string? defaultArgs = null,
-        string? defaultName = null)
+        string? defaultName = null,
+        IReadOnlyList<RecentlyClosedEntry>? recentlyClosed = null)
     {
         InitializeComponent();
         FolderBox.Text = defaultFolder;
@@ -99,6 +107,8 @@ public NewSessionDialog(
             ProfileCombo.SelectedIndex = 0;
         }
 
+        PopulateRecentlyClosed(recentlyClosed);
+
         _worktreeDebounce = new System.Windows.Threading.DispatcherTimer
         {
             Interval = TimeSpan.FromMilliseconds(700)
@@ -396,4 +406,57 @@ private void Cancel_Click(object sender, RoutedEventArgs e)
         DialogResult = false;
         Close();
     }
+
+    private void PopulateRecentlyClosed(IReadOnlyList<RecentlyClosedEntry>? entries)
+    {
+        if (entries == null || entries.Count == 0)
+        {
+            RecentlyClosedPanel.Visibility = Visibility.Collapsed;
+            return;
+        }
+        RecentlyClosedPanel.Visibility = Visibility.Visible;
+        var fg = new System.Windows.Media.SolidColorBrush(
+            System.Windows.Media.Color.FromRgb(0xcd, 0xd6, 0xf4));
+        var sub = new System.Windows.Media.SolidColorBrush(
+            System.Windows.Media.Color.FromRgb(0x6c, 0x70, 0x86));
+        foreach (var entry in entries)
+        {
+            var stack = new StackPanel { Orientation = System.Windows.Controls.Orientation.Vertical };
+            stack.Children.Add(new TextBlock
+            {
+                Text = string.IsNullOrWhiteSpace(entry.Name) ? "(unnamed)" : entry.Name,
+                Foreground = fg, FontSize = 13,
+            });
+            stack.Children.Add(new TextBlock
+            {
+                Text = entry.Subtitle,
+                Foreground = sub, FontSize = 11,
+                TextTrimming = System.Windows.TextTrimming.CharacterEllipsis,
+            });
+            var btn = new System.Windows.Controls.Button
+            {
+                Content = stack,
+                Tag = entry,
+                Background = System.Windows.Media.Brushes.Transparent,
+                BorderBrush = new System.Windows.Media.SolidColorBrush(
+                    System.Windows.Media.Color.FromRgb(0x31, 0x32, 0x44)),
+                BorderThickness = new Thickness(0, 0, 0, 1),
+                Padding = new Thickness(6, 5, 6, 5),
+                HorizontalContentAlignment = System.Windows.HorizontalAlignment.Left,
+                Cursor = System.Windows.Input.Cursors.Hand,
+            };
+            btn.Click += RecentlyClosed_Click;
+            RecentlyClosedList.Children.Add(btn);
+        }
+    }
+
+    private void RecentlyClosed_Click(object sender, RoutedEventArgs e)
+    {
+        if (sender is FrameworkElement fe && fe.Tag is RecentlyClosedEntry entry)
+        {
+            SelectedRecentlyClosed = entry;
+            DialogResult = true;
+            Close();
+        }
+    }
 }
diff --git a/src/CodeShellManager/Views/SessionRunCommandsDialog.xaml b/src/CodeShellManager/Views/SessionRunCommandsDialog.xaml
index 8d5dccf..2f89971 100644
--- a/src/CodeShellManager/Views/SessionRunCommandsDialog.xaml
+++ b/src/CodeShellManager/Views/SessionRunCommandsDialog.xaml
@@ -2,8 +2,8 @@
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         Title="Run commands"
-        Width="720" Height="500"
-        MinWidth="560" MinHeight="360"
+        Width="900" Height="520"
+        MinWidth="720" MinHeight="380"
         WindowStartupLocation="CenterOwner"
         Background="#1e1e2e"
         Foreground="#cdd6f4"
@@ -39,8 +39,10 @@
             <Grid>
                 <Grid.ColumnDefinitions>
                     <ColumnDefinition Width="44"/>
-                    <ColumnDefinition Width="*" MinWidth="120"/>
+                    <ColumnDefinition Width="*" MinWidth="110"/>
+                    <ColumnDefinition Width="92"/>
                     <ColumnDefinition Width="2*" MinWidth="200"/>
+                    <ColumnDefinition Width="*" MinWidth="140"/>
                     <ColumnDefinition Width="86"/>
                 </Grid.ColumnDefinitions>
                 <TextBlock Grid.Column="0" Text="★" FontSize="12"
@@ -49,10 +51,16 @@
                 <TextBlock Grid.Column="1" Text="LABEL" Margin="0,0,8,0" FontSize="10" FontWeight="SemiBold"
                            Foreground="#7f849c" VerticalAlignment="Center"
                            ToolTip="Short name shown on the chip and in the toolbar dropdown"/>
-                <TextBlock Grid.Column="2" Text="COMMAND LINE" Margin="0,0,8,0" FontSize="10" FontWeight="SemiBold"
+                <TextBlock Grid.Column="2" Text="HOST" Margin="0,0,8,0" FontSize="10" FontWeight="SemiBold"
+                           Foreground="#7f849c" VerticalAlignment="Center"
+                           ToolTip="Process = bare ConPTY child (cmd /c). PowerShell = pwsh -EncodedCommand (use for pipes, $env:, cmdlets). SSH parents ignore this."/>
+                <TextBlock Grid.Column="3" Text="COMMAND LINE" Margin="0,0,8,0" FontSize="10" FontWeight="SemiBold"
                            Foreground="#7f849c" VerticalAlignment="Center"
                            ToolTip="What runs in the session's folder (cmd locally, bash on SSH parents)"/>
-                <TextBlock Grid.Column="3" Text=""/>
+                <TextBlock Grid.Column="4" Text="OPEN URL ON SUCCESS" Margin="0,0,8,0" FontSize="10" FontWeight="SemiBold"
+                           Foreground="#7f849c" VerticalAlignment="Center"
+                           ToolTip="Optional. Opens this URL in the default browser when the command exits with code 0."/>
+                <TextBlock Grid.Column="5" Text=""/>
             </Grid>
         </Border>
 
@@ -64,8 +72,10 @@
                             <Grid>
                                 <Grid.ColumnDefinitions>
                                     <ColumnDefinition Width="44"/>
-                                    <ColumnDefinition Width="*" MinWidth="120"/>
+                                    <ColumnDefinition Width="*" MinWidth="110"/>
+                                    <ColumnDefinition Width="92"/>
                                     <ColumnDefinition Width="2*" MinWidth="200"/>
+                                    <ColumnDefinition Width="*" MinWidth="140"/>
                                     <ColumnDefinition Width="86"/>
                                 </Grid.ColumnDefinitions>
                                 <RadioButton Grid.Column="0" GroupName="DefaultGroup"
@@ -78,13 +88,26 @@
                                          CaretBrush="#cdd6f4" Padding="6,4" Margin="0,0,8,0"
                                          VerticalContentAlignment="Center"
                                          ToolTip="Short, friendly name — e.g. Test, Build, Watch"/>
-                                <TextBox Grid.Column="2" Text="{Binding CommandLine, UpdateSourceTrigger=PropertyChanged}"
+                                <ComboBox Grid.Column="2" SelectedIndex="{Binding ModeIndex, Mode=TwoWay}"
+                                          Background="#313244" Foreground="#cdd6f4" BorderBrush="#45475a"
+                                          Padding="6,3" Margin="0,0,8,0"
+                                          VerticalContentAlignment="Center"
+                                          ToolTip="Process = cmd /c &lt;cmd&gt; (bare ConPTY child). PowerShell = pwsh -EncodedCommand (use for pipes, $env:, cmdlets).">
+                                    <ComboBoxItem Content="Process"/>
+                                    <ComboBoxItem Content="PowerShell"/>
+                                </ComboBox>
+                                <TextBox Grid.Column="3" Text="{Binding CommandLine, UpdateSourceTrigger=PropertyChanged}"
                                          Background="#313244" Foreground="#cdd6f4" BorderBrush="#45475a"
                                          CaretBrush="#cdd6f4" Padding="6,4" Margin="0,0,8,0"
                                          FontFamily="Consolas"
                                          VerticalContentAlignment="Center"
                                          ToolTip="The actual command line — e.g. dotnet test, npm run build"/>
-                                <StackPanel Grid.Column="3" Orientation="Horizontal" VerticalAlignment="Center">
+                                <TextBox Grid.Column="4" Text="{Binding PostRunUrl, UpdateSourceTrigger=PropertyChanged}"
+                                         Background="#313244" Foreground="#cdd6f4" BorderBrush="#45475a"
+                                         CaretBrush="#cdd6f4" Padding="6,4" Margin="0,0,8,0"
+                                         VerticalContentAlignment="Center"
+                                         ToolTip="Optional. e.g. http://localhost:5173 — opens in the default browser when the command exits 0."/>
+                                <StackPanel Grid.Column="5" Orientation="Horizontal" VerticalAlignment="Center">
                                     <Button Content="▲" Tag="{Binding}" Click="MoveUp_Click" Width="26" Height="24"
                                             Background="Transparent" BorderThickness="0" Foreground="#a6adc8" Cursor="Hand"
                                             ToolTip="Move up"/>
diff --git a/src/CodeShellManager/Views/SessionRunCommandsDialog.xaml.cs b/src/CodeShellManager/Views/SessionRunCommandsDialog.xaml.cs
index b9624b1..75d9063 100644
--- a/src/CodeShellManager/Views/SessionRunCommandsDialog.xaml.cs
+++ b/src/CodeShellManager/Views/SessionRunCommandsDialog.xaml.cs
@@ -26,6 +26,8 @@ public SessionRunCommandsDialog(string sessionName, IReadOnlyList<RunCommandItem
                 Label = item.Label,
                 CommandLine = item.CommandLine,
                 IsDefault = item.IsDefault,
+                ModeIndex = (int)item.Mode,
+                PostRunUrl = item.PostRunUrl ?? "",
             });
         }
         RowsList.ItemsSource = _rows;
@@ -39,6 +41,8 @@ private void Add_Click(object sender, RoutedEventArgs e)
             Label = "",
             CommandLine = "",
             IsDefault = _rows.Count == 0,
+            ModeIndex = 0,
+            PostRunUrl = "",
         });
     }
 
@@ -91,6 +95,8 @@ private void Save_Click(object sender, RoutedEventArgs e)
             Label = r.Label.Trim(),
             CommandLine = r.CommandLine.Trim(),
             IsDefault = r.IsDefault,
+            Mode = (RunMode)r.ModeIndex,
+            PostRunUrl = string.IsNullOrWhiteSpace(r.PostRunUrl) ? null : r.PostRunUrl.Trim(),
         }).ToList();
         RunCommandItem.EnsureSingleDefault(list);
 
@@ -109,6 +115,8 @@ private class RunCommandRow : System.ComponentModel.INotifyPropertyChanged
         private string _label = "";
         private string _commandLine = "";
         private bool _isDefault;
+        private int _modeIndex;
+        private string _postRunUrl = "";
         public string Label
         {
             get => _label;
@@ -124,6 +132,16 @@ public bool IsDefault
             get => _isDefault;
             set { _isDefault = value; OnChanged(nameof(IsDefault)); }
         }
+        public int ModeIndex
+        {
+            get => _modeIndex;
+            set { _modeIndex = value; OnChanged(nameof(ModeIndex)); }
+        }
+        public string PostRunUrl
+        {
+            get => _postRunUrl;
+            set { _postRunUrl = value; OnChanged(nameof(PostRunUrl)); }
+        }
 
         public event System.ComponentModel.PropertyChangedEventHandler? PropertyChanged;
         private void OnChanged(string n) => PropertyChanged?.Invoke(this,
diff --git a/tests/CodeShellManager.Tests/AlertDetectorTests.cs b/tests/CodeShellManager.Tests/AlertDetectorTests.cs
new file mode 100644
index 0000000..e094039
--- /dev/null
+++ b/tests/CodeShellManager.Tests/AlertDetectorTests.cs
@@ -0,0 +1,381 @@
+using System;
+using System.Threading;
+using CodeShellManager.Models;
+using CodeShellManager.Services;
+using Xunit;
+
+namespace CodeShellManager.Tests;
+
+/// <summary>
+/// Tests for <see cref="AlertDetector"/>.
+///
+/// AlertDetector's only public surface for triggering an alert is <see cref="AlertDetector.Feed"/>,
+/// which starts a hardcoded 1500ms <see cref="System.Threading.Timer"/>. There is no clock-injection
+/// hook, and the regexes are private statics — so to assert on the regex behavior we have to let
+/// the real timer fire.
+///
+/// To stay deterministic we subscribe to <see cref="AlertDetector.AlertRaised"/> with a
+/// <see cref="ManualResetEventSlim"/> and wait with a generous timeout. The wait completes
+/// as soon as the event fires (typically ~1.5s after Feed) — it is NOT a blind Thread.Sleep.
+/// A short negative-case timeout (200ms past the idle threshold) is used when asserting that
+/// no alert was raised.
+///
+/// IMPORTANT: every test disposes the detector BEFORE the signal goes out of scope. Otherwise
+/// the in-flight Timer callback can race with the ManualResetEventSlim finalizer and throw
+/// ObjectDisposedException on a thread-pool thread, which crashes the test host.
+/// </summary>
+public class AlertDetectorTests
+{
+    // Generous upper bound; the event normally fires ~1500ms after Feed. The ManualResetEventSlim
+    // returns the instant the event fires, so a higher cap doesn't slow passing tests.
+    private const int WaitForAlertMs = 5000;
+
+    // Used to assert that *no* alert was raised. Anything > 1500ms is enough.
+    private const int WaitForNoAlertMs = 1800;
+
+    // ---- Tool approval detection -------------------------------------------------------------
+
+    [Theory]
+    [InlineData("Do you want to run this command?")]
+    [InlineData("Allow Claude to edit this file?")]
+    [InlineData("Approve this tool use?")]
+    [InlineData("Bash command: rm -rf /tmp/foo")]
+    [InlineData("Continue?")]
+    [InlineData("Proceed?")]
+    [InlineData("tool_use requested")]
+    [InlineData("Grant permission to read")]
+    public void Feed_ClaudeApprovalPhrasing_RaisesToolApprovalAlert(string line)
+    {
+        var detector = new AlertDetector("s1", "session");
+        using var signal = new ManualResetEventSlim(false);
+        AlertEvent? captured = null;
+        detector.AlertRaised += evt => { captured = evt; signal.Set(); };
+
+        try
+        {
+            detector.Feed(line + "\n");
+
+            Assert.True(signal.Wait(WaitForAlertMs), $"AlertRaised did not fire for: {line}");
+            Assert.NotNull(captured);
+            Assert.Equal(AlertType.ToolApproval, captured!.Type);
+            Assert.Equal("s1", captured.SessionId);
+            Assert.Equal("session", captured.SessionName);
+        }
+        finally
+        {
+            detector.Dispose();
+        }
+    }
+
+    // ---- Input-required detection ------------------------------------------------------------
+
+    [Theory]
+    [InlineData("Delete file [y/N]")]
+    [InlineData("Continue [Y/n]")]
+    [InlineData("Proceed [yes/no]")]
+    [InlineData("Are you sure (y/n)")]
+    [InlineData("Confirm (yes/no)")]
+    [InlineData("❯")]                 // Claude's "❯" prompt alone (U+276F)
+    [InlineData("something ❯")]       // ❯ at end of line
+    [InlineData("Pick an option ? ›")] // "? ›" pattern (U+203A)
+    [InlineData("What now?")]               // trailing "?"
+    public void Feed_InputRequiredPhrasing_RaisesInputRequiredAlert(string line)
+    {
+        var detector = new AlertDetector("s1", "session");
+        using var signal = new ManualResetEventSlim(false);
+        AlertEvent? captured = null;
+        detector.AlertRaised += evt => { captured = evt; signal.Set(); };
+
+        try
+        {
+            detector.Feed(line + "\n");
+
+            Assert.True(signal.Wait(WaitForAlertMs), $"AlertRaised did not fire for: {line}");
+            Assert.NotNull(captured);
+            Assert.Equal(AlertType.InputRequired, captured!.Type);
+        }
+        finally
+        {
+            detector.Dispose();
+        }
+    }
+
+    [Fact]
+    public void Feed_TrailingGreaterThanPrompt_RaisesInputRequiredAlert()
+    {
+        // The s_prompt regex matches ">" at end of line.
+        var detector = new AlertDetector("s1", "session");
+        using var signal = new ManualResetEventSlim(false);
+        AlertEvent? captured = null;
+        detector.AlertRaised += evt => { captured = evt; signal.Set(); };
+
+        try
+        {
+            detector.Feed("user@host:~$ >\n");
+
+            Assert.True(signal.Wait(WaitForAlertMs));
+            Assert.NotNull(captured);
+            Assert.Equal(AlertType.InputRequired, captured!.Type);
+        }
+        finally
+        {
+            detector.Dispose();
+        }
+    }
+
+    // ---- Negative cases ----------------------------------------------------------------------
+
+    [Theory]
+    [InlineData("just some regular log output")]
+    [InlineData("Compilation succeeded.")]
+    [InlineData("12 files indexed")]
+    public void Feed_NonMatchingLine_DoesNotRaiseAlert(string line)
+    {
+        var detector = new AlertDetector("s1", "session");
+        using var signal = new ManualResetEventSlim(false);
+        detector.AlertRaised += _ => signal.Set();
+
+        try
+        {
+            detector.Feed(line + "\n");
+
+            Assert.False(signal.Wait(WaitForNoAlertMs),
+                $"AlertRaised should NOT have fired for: {line}");
+        }
+        finally
+        {
+            detector.Dispose();
+        }
+    }
+
+    [Fact]
+    public void Feed_WhitespaceOnly_DoesNotRaiseAlert()
+    {
+        var detector = new AlertDetector("s1", "session");
+        using var signal = new ManualResetEventSlim(false);
+        detector.AlertRaised += _ => signal.Set();
+
+        try
+        {
+            detector.Feed("   \n\t\n");
+
+            Assert.False(signal.Wait(WaitForNoAlertMs));
+        }
+        finally
+        {
+            detector.Dispose();
+        }
+    }
+
+    // ---- ANSI stripping ----------------------------------------------------------------------
+
+    [Fact]
+    public void Feed_LineWrappedInAnsiEscapes_StillFiresAlert()
+    {
+        // Real Claude output is colorized — verify the detector strips ANSI before regex match.
+        var detector = new AlertDetector("s1", "session");
+        using var signal = new ManualResetEventSlim(false);
+        AlertEvent? captured = null;
+        detector.AlertRaised += evt => { captured = evt; signal.Set(); };
+
+        try
+        {
+            const string esc = "\x1B";
+            string ansiWrapped = $"{esc}[1;33mDo you want to proceed?{esc}[0m\n";
+
+            detector.Feed(ansiWrapped);
+
+            Assert.True(signal.Wait(WaitForAlertMs));
+            Assert.NotNull(captured);
+            Assert.Equal(AlertType.ToolApproval, captured!.Type);
+            // The captured message should contain the human-readable text from inside the ANSI wrapping.
+            Assert.Contains("Do you want to proceed?", captured.Message);
+        }
+        finally
+        {
+            detector.Dispose();
+        }
+    }
+
+    [Fact]
+    public void Feed_PromptWrappedInAnsiEscapes_StillFiresInputRequired()
+    {
+        var detector = new AlertDetector("s1", "session");
+        using var signal = new ManualResetEventSlim(false);
+        AlertEvent? captured = null;
+        detector.AlertRaised += evt => { captured = evt; signal.Set(); };
+
+        try
+        {
+            const string esc = "\x1B";
+            string ansiWrapped = $"{esc}[36m❯{esc}[0m\n";
+
+            detector.Feed(ansiWrapped);
+
+            Assert.True(signal.Wait(WaitForAlertMs));
+            Assert.NotNull(captured);
+            Assert.Equal(AlertType.InputRequired, captured!.Type);
+        }
+        finally
+        {
+            detector.Dispose();
+        }
+    }
+
+    // ---- NotifyUserInteracted ----------------------------------------------------------------
+
+    [Fact]
+    public void NotifyUserInteracted_BeforeIdleTimer_CancelsPendingAlert()
+    {
+        // Feed a matching line, but interact before the 1500ms idle window expires.
+        // The pending timer should be cancelled, so no AlertRaised should ever fire.
+        var detector = new AlertDetector("s1", "session");
+        using var signal = new ManualResetEventSlim(false);
+        detector.AlertRaised += _ => signal.Set();
+
+        try
+        {
+            detector.Feed("Do you want to continue?\n");
+            // Cancel immediately — no sleep, no race against the 1500ms timer.
+            detector.NotifyUserInteracted();
+
+            Assert.False(signal.Wait(WaitForNoAlertMs),
+                "NotifyUserInteracted should have cancelled the pending idle timer.");
+        }
+        finally
+        {
+            detector.Dispose();
+        }
+    }
+
+    [Fact]
+    public void NotifyUserInteracted_RaisesAlertCleared()
+    {
+        var detector = new AlertDetector("s1", "session");
+        using var signal = new ManualResetEventSlim(false);
+        string? clearedSessionId = null;
+        detector.AlertCleared += id => { clearedSessionId = id; signal.Set(); };
+
+        try
+        {
+            detector.NotifyUserInteracted();
+
+            Assert.True(signal.Wait(1000));
+            Assert.Equal("s1", clearedSessionId);
+        }
+        finally
+        {
+            detector.Dispose();
+        }
+    }
+
+    [Fact]
+    public void NotifyUserInteracted_ResetsFiredFlag_SoNextMatchingFeedFiresAgain()
+    {
+        // Once an alert has fired, _alertFired latches true. NotifyUserInteracted clears it
+        // so a subsequent matching feed re-fires.
+        var detector = new AlertDetector("s1", "session");
+        using var firstSignal = new ManualResetEventSlim(false);
+        using var secondSignal = new ManualResetEventSlim(false);
+
+        try
+        {
+            AlertEvent? first = null;
+            Action<AlertEvent> firstHandler = evt => { first = evt; firstSignal.Set(); };
+            detector.AlertRaised += firstHandler;
+
+            detector.Feed("Do you want to proceed?\n");
+            Assert.True(firstSignal.Wait(WaitForAlertMs), "First alert should have fired.");
+            Assert.NotNull(first);
+            detector.AlertRaised -= firstHandler;
+
+            // Clear, then re-feed; expect a second fire.
+            detector.NotifyUserInteracted();
+
+            AlertEvent? second = null;
+            detector.AlertRaised += evt => { second = evt; secondSignal.Set(); };
+
+            detector.Feed("Allow this action?\n");
+            Assert.True(secondSignal.Wait(WaitForAlertMs), "Second alert should have re-fired after NotifyUserInteracted.");
+            Assert.NotNull(second);
+            Assert.Equal(AlertType.ToolApproval, second!.Type);
+        }
+        finally
+        {
+            detector.Dispose();
+        }
+    }
+
+    // ---- Idle-timer reset behavior -----------------------------------------------------------
+
+    [Fact]
+    public void Feed_LastLineWins_OnlyFinalLineEvaluatedForAlertType()
+    {
+        // Feed() processes all non-empty lines but only the LAST trimmed line is kept in
+        // _lastLine. So if the final line is a tool-approval prompt, that's what we get —
+        // even if earlier lines would also have matched a different type.
+        var detector = new AlertDetector("s1", "session");
+        using var signal = new ManualResetEventSlim(false);
+        AlertEvent? captured = null;
+        detector.AlertRaised += evt => { captured = evt; signal.Set(); };
+
+        try
+        {
+            // Earlier line is an input-required pattern; final line is a tool-approval phrase.
+            detector.Feed("Continue [y/N]\nDo you want to run this?\n");
+
+            Assert.True(signal.Wait(WaitForAlertMs));
+            Assert.NotNull(captured);
+            Assert.Equal(AlertType.ToolApproval, captured!.Type);
+        }
+        finally
+        {
+            detector.Dispose();
+        }
+    }
+
+    [Fact]
+    public void Feed_MessageTruncatedAt100Chars_WhenLineIsLonger()
+    {
+        // Lines longer than 100 chars are truncated with "…".
+        var detector = new AlertDetector("s1", "session");
+        using var signal = new ManualResetEventSlim(false);
+        AlertEvent? captured = null;
+        detector.AlertRaised += evt => { captured = evt; signal.Set(); };
+
+        try
+        {
+            // Build a 140-char line ending with an approval phrase.
+            string padding = new string('x', 130);
+            string line = padding + " Continue?";
+            Assert.True(line.Length > 100);
+
+            detector.Feed(line + "\n");
+
+            Assert.True(signal.Wait(WaitForAlertMs));
+            Assert.NotNull(captured);
+            Assert.EndsWith("…", captured!.Message);  // U+2026 = …
+            Assert.Equal(101, captured.Message.Length); // 100 chars + the ellipsis
+        }
+        finally
+        {
+            detector.Dispose();
+        }
+    }
+
+    // ---- Dispose -----------------------------------------------------------------------------
+
+    [Fact]
+    public void Dispose_AfterFeed_PreventsAlertFromFiring()
+    {
+        var detector = new AlertDetector("s1", "session");
+        using var signal = new ManualResetEventSlim(false);
+        detector.AlertRaised += _ => signal.Set();
+
+        detector.Feed("Do you want to continue?\n");
+        detector.Dispose();
+
+        Assert.False(signal.Wait(WaitForNoAlertMs),
+            "Disposing should have stopped the pending idle timer.");
+    }
+}
diff --git a/tests/CodeShellManager.Tests/ColorServiceTests.cs b/tests/CodeShellManager.Tests/ColorServiceTests.cs
new file mode 100644
index 0000000..031cb59
--- /dev/null
+++ b/tests/CodeShellManager.Tests/ColorServiceTests.cs
@@ -0,0 +1,188 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using CodeShellManager.Services;
+using Xunit;
+
+namespace CodeShellManager.Tests;
+
+public class ColorServiceTests
+{
+    // The 12-color palette baked into ColorService. Kept here verbatim so a palette
+    // change in the source forces a deliberate update here too.
+    private static readonly string[] ExpectedPalette =
+    [
+        "#FF6B6B", "#FF9E42", "#FFD166", "#AEDE68",
+        "#51CF66", "#38D9A9", "#66D9E8", "#4DABF7",
+        "#748FFC", "#9775FA", "#F783AC", "#FF6B95",
+    ];
+
+    [Fact]
+    public void GetHexColor_IsDeterministic_SameInputProducesSameColor()
+    {
+        const string key = @"C:\projects\my-app";
+        var first = ColorService.GetHexColor(key);
+        var second = ColorService.GetHexColor(key);
+        Assert.Equal(first, second);
+    }
+
+    [Theory]
+    [InlineData(@"C:\projects\alpha")]
+    [InlineData(@"C:\projects\beta")]
+    [InlineData("user@host.example.com")]
+    [InlineData("")]
+    public void GetHexColor_IsDeterministic_AcrossMultipleCalls(string key)
+    {
+        // Call several times to make sure there's no hidden state.
+        var results = Enumerable.Range(0, 5)
+            .Select(_ => ColorService.GetHexColor(key))
+            .Distinct()
+            .ToList();
+        Assert.Single(results);
+    }
+
+    [Fact]
+    public void GetHexColor_DifferentKeys_MapToDifferentColors_OnSmallSample()
+    {
+        // Not strictly guaranteed by any hash function, but this small handpicked
+        // sample is known to spread across distinct palette entries for FNV-1a.
+        var a = ColorService.GetHexColor(@"C:\proj\a");
+        var b = ColorService.GetHexColor(@"C:\proj\b");
+        Assert.NotEqual(a, b);
+    }
+
+    [Theory]
+    [InlineData(@"C:\projects\my-app")]
+    [InlineData("")]
+    [InlineData("   ")]
+    [InlineData("user@host:22")]
+    [InlineData(@"\\unc\share\path")]
+    public void GetHexColor_ReturnsValidHexFormat(string key)
+    {
+        var hex = ColorService.GetHexColor(key);
+        Assert.NotNull(hex);
+        Assert.Equal(7, hex.Length);
+        Assert.StartsWith("#", hex);
+        Assert.Matches("^#[0-9A-Fa-f]{6}$", hex);
+    }
+
+    [Fact]
+    public void GetHexColor_ReturnedValue_IsAlwaysFromPalette()
+    {
+        var paletteSet = new HashSet<string>(ExpectedPalette, StringComparer.OrdinalIgnoreCase);
+        for (int i = 0; i < 200; i++)
+        {
+            var key = $"C:\\repo\\project-{i}";
+            var hex = ColorService.GetHexColor(key);
+            Assert.Contains(hex, paletteSet);
+        }
+    }
+
+    [Fact]
+    public void GetHexColor_DistributesAcrossAllPaletteColors_OverLargeSample()
+    {
+        // Over ~100 distinct keys, FNV-1a should hit every one of the 12 palette
+        // entries at least once. If this becomes flaky, widen the sample — don't
+        // weaken the assertion, since uneven distribution is a real regression signal.
+        var counts = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
+        foreach (var color in ExpectedPalette) counts[color] = 0;
+
+        for (int i = 0; i < 120; i++)
+        {
+            var key = $"C:\\repo\\project-{i}";
+            counts[ColorService.GetHexColor(key)]++;
+        }
+
+        Assert.All(ExpectedPalette, color =>
+            Assert.True(counts[color] > 0, $"Palette color {color} was never produced over 120 sample keys."));
+    }
+
+    [Fact]
+    public void GetHexColor_IsCaseInsensitive()
+    {
+        // Implementation lower-cases the input via ToLowerInvariant() before hashing,
+        // so paths that differ only by case must map to the same palette color.
+        var upper = ColorService.GetHexColor(@"C:\Foo\Bar");
+        var lower = ColorService.GetHexColor(@"c:\foo\bar");
+        Assert.Equal(upper, lower);
+    }
+
+    [Fact]
+    public void GetHexColor_TrimsTrailingSlashesAndBackslashes()
+    {
+        // Implementation calls TrimEnd('/', '\\') so all four variants must collapse
+        // to the same color.
+        var bare = ColorService.GetHexColor(@"C:\projects\app");
+        var trailingBackslash = ColorService.GetHexColor(@"C:\projects\app\");
+        var trailingForward = ColorService.GetHexColor(@"C:\projects\app/");
+        var trailingMixed = ColorService.GetHexColor(@"C:\projects\app/\");
+
+        Assert.Equal(bare, trailingBackslash);
+        Assert.Equal(bare, trailingForward);
+        Assert.Equal(bare, trailingMixed);
+    }
+
+    [Fact]
+    public void GetHexColor_DoesNotTrimInternalSlashes()
+    {
+        // Only trailing slashes are stripped. A path with internal separators must
+        // produce a different color than the same path with those separators removed.
+        var withSeparators = ColorService.GetHexColor(@"C:\projects\app");
+        var collapsed = ColorService.GetHexColor("Cprojectsapp");
+        Assert.NotEqual(withSeparators, collapsed);
+    }
+
+    [Fact]
+    public void GetHexColor_EmptyString_ReturnsDeterministicPaletteColor()
+    {
+        // Locks current behavior: empty string is a valid input — FNV-1a of "" is the
+        // initial offset basis, so this maps to a specific palette slot. Don't tolerate
+        // a silent change to this without a test failure.
+        var hex = ColorService.GetHexColor(string.Empty);
+        Assert.Contains(hex, ExpectedPalette);
+        // FNV-1a offset basis 2166136261 % 12 == 1 → Palette[1] == "#FF9E42"
+        Assert.Equal("#FF9E42", hex);
+    }
+
+    [Fact]
+    public void GetHexColor_WhitespaceString_ReturnsValidPaletteColor()
+    {
+        // TrimEnd only strips '/' and '\\', so whitespace is preserved and hashed.
+        // Document this rather than fix it — callers feed real folder paths.
+        var hex = ColorService.GetHexColor("   ");
+        Assert.Contains(hex, ExpectedPalette);
+    }
+
+    [Fact]
+    public void GetHexColor_Null_Throws()
+    {
+        // Implementation does folderPath.ToLowerInvariant() without a null check,
+        // which throws NullReferenceException. Lock that contract — callers should
+        // never pass null. If a guard is added later, update this test deliberately.
+        Assert.Throws<NullReferenceException>(() => ColorService.GetHexColor(null!));
+    }
+
+    [Fact]
+    public void GetColor_RoundTripsHexValue()
+    {
+        const string key = @"C:\projects\round-trip";
+        var hex = ColorService.GetHexColor(key);
+        var color = ColorService.GetColor(key);
+
+        var expected = (System.Windows.Media.Color)
+            System.Windows.Media.ColorConverter.ConvertFromString(hex)!;
+
+        Assert.Equal(expected, color);
+    }
+
+    [Fact]
+    public void GetBrush_ProducesBrushWithMatchingColor()
+    {
+        const string key = "user@example.com";
+        var brush = ColorService.GetBrush(key);
+        var color = ColorService.GetColor(key);
+
+        Assert.NotNull(brush);
+        Assert.Equal(color, brush.Color);
+    }
+}
diff --git a/tests/CodeShellManager.Tests/OutputIndexerTests.cs b/tests/CodeShellManager.Tests/OutputIndexerTests.cs
new file mode 100644
index 0000000..33dc7e4
--- /dev/null
+++ b/tests/CodeShellManager.Tests/OutputIndexerTests.cs
@@ -0,0 +1,168 @@
+using System.Reflection;
+using System.Text.RegularExpressions;
+using CodeShellManager.Terminal;
+using Xunit;
+
+namespace CodeShellManager.Tests;
+
+/// <summary>
+/// Tests for the ANSI-stripping regex used by <see cref="OutputIndexer"/> before
+/// feeding lines into the FTS5 index. The regex is a <c>private static partial</c>
+/// method generated by <c>[GeneratedRegex]</c>, so it's reached via reflection.
+///
+/// The pattern (as of writing) is:
+/// <code>
+/// \x1B\[[?0-9;]*[mGKHFJABCDsuhl]   // CSI: ESC[ ... final-byte
+/// | \x1B\].*?(?:\x07|\x1B\\)        // OSC: ESC] ... BEL or ESC\ (ST)
+/// | \x1B[=>]                        // DECKPAM / DECKPNM (ESC= / ESC>)
+/// | \r                              // carriage return
+/// </code>
+///
+/// Note: this regex deliberately handles only the subset of ANSI control sequences
+/// that ConPTY + xterm.js commonly emit. CSI sequences whose final byte is outside
+/// <c>[mGKHFJABCDsuhl]</c> (for example DEC private-mode <c>n</c>, <c>r</c>, <c>t</c>,
+/// or device-status reports) are intentionally left in the indexed text.
+///
+/// String-literal note: ESC and BEL are written as <c></c> / <c></c>
+/// (fixed 4-digit form). The variable-length <c>\x</c> escape would greedily eat
+/// any hex letter that follows (e.g. <c>"\x1Bb"</c> parses as the single
+/// character <c>U+01BB</c>, not ESC + 'b').
+/// </summary>
+public class OutputIndexerTests
+{
+    private const string ESC = "";
+    private const string BEL = "";
+
+    private static readonly Regex Ansi = InvokeAnsiPattern();
+
+    private static Regex InvokeAnsiPattern()
+    {
+        var mi = typeof(OutputIndexer).GetMethod(
+            "AnsiPattern",
+            BindingFlags.NonPublic | BindingFlags.Static);
+        Assert.NotNull(mi);
+        var rx = (Regex?)mi!.Invoke(null, null);
+        Assert.NotNull(rx);
+        return rx!;
+    }
+
+    private static string Strip(string input) => Ansi.Replace(input, "");
+
+    [Fact]
+    public void Strip_BasicCsiColor_RemovesEscapes()
+    {
+        Assert.Equal("red", Strip($"{ESC}[31mred{ESC}[0m"));
+    }
+
+    [Fact]
+    public void Strip_CsiWithMultipleParameters_RemovesEscapes()
+    {
+        Assert.Equal("bold green", Strip($"{ESC}[1;32mbold green{ESC}[0m"));
+    }
+
+    [Fact]
+    public void Strip_CsiCursorMotion_ClearScreenAndHome_AreRemoved()
+    {
+        // ESC[2J = clear screen, ESC[H = cursor home
+        Assert.Equal("", Strip($"{ESC}[2J{ESC}[H"));
+    }
+
+    [Fact]
+    public void Strip_CsiCursorMovementSequences_AreRemoved()
+    {
+        // A/B/C/D = cursor up/down/forward/back, G = horizontal absolute,
+        // K = erase in line, F = previous-line, s/u = save/restore cursor.
+        var input = $"x{ESC}[2Ay{ESC}[3Bz{ESC}[4Cw{ESC}[5Dv{ESC}[10Gu{ESC}[Kt{ESC}[Fs{ESC}[sr{ESC}[uq";
+        Assert.Equal("xyzwvutsrq", Strip(input));
+    }
+
+    [Fact]
+    public void Strip_CsiPrivateMode_AltScreenAndBracketedPaste_AreRemoved()
+    {
+        // ESC[?1049h = enable alt screen, ESC[?2004h = bracketed paste on,
+        // ESC[?2004l = bracketed paste off. The `?` is matched by [?0-9;]*.
+        Assert.Equal("body", Strip($"{ESC}[?1049h{ESC}[?2004hbody{ESC}[?2004l{ESC}[?1049l"));
+    }
+
+    [Fact]
+    public void Strip_OscWithBelTerminator_RemovesSequence()
+    {
+        // Set window title: ESC]0;title BEL
+        Assert.Equal("rest", Strip($"{ESC}]0;title{BEL}rest"));
+    }
+
+    [Fact]
+    public void Strip_OscWithStringTerminator_RemovesSequence()
+    {
+        // String Terminator (ST) = ESC \. The regex's OSC arm accepts both BEL
+        // and ESC\, so this should also be stripped.
+        Assert.Equal("rest", Strip($"{ESC}]0;title{ESC}\\rest"));
+    }
+
+    [Fact]
+    public void Strip_OscIsNonGreedy_DoesNotEatPastFirstTerminator()
+    {
+        // Two OSCs back-to-back: the non-greedy `.*?` should stop at the first BEL.
+        Assert.Equal("middleend", Strip($"{ESC}]0;a{BEL}middle{ESC}]0;b{BEL}end"));
+    }
+
+    [Fact]
+    public void Strip_CarriageReturn_IsRemoved()
+    {
+        Assert.Equal("ab", Strip("a\rb"));
+    }
+
+    [Fact]
+    public void Strip_CarriageReturnPreservesNewline()
+    {
+        // CRLF -> LF (CR removed, LF kept). Feed() relies on this so that the
+        // \n split produces clean lines without trailing \r.
+        Assert.Equal("line1\nline2", Strip("line1\r\nline2"));
+    }
+
+    [Fact]
+    public void Strip_KeypadModeEscapes_AreRemoved()
+    {
+        // ESC= (DECKPAM) and ESC> (DECKPNM) — two-byte escapes ConPTY uses.
+        Assert.Equal("hello", Strip($"{ESC}=hel{ESC}>lo"));
+    }
+
+    [Fact]
+    public void Strip_PlainText_IsUnchanged()
+    {
+        Assert.Equal("hello world", Strip("hello world"));
+    }
+
+    [Fact]
+    public void Strip_EmptyInput_ReturnsEmpty()
+    {
+        Assert.Equal("", Strip(""));
+    }
+
+    [Fact]
+    public void Strip_MixedAnsiAndPlain_RemovesOnlyEscapes()
+    {
+        var input = $"{ESC}[31mError:{ESC}[0m something {ESC}[1;33mwarning{ESC}[0m done";
+        Assert.Equal("Error: something warning done", Strip(input));
+    }
+
+    [Fact]
+    public void Strip_LeavesUnsupportedCsiFinalsIntact()
+    {
+        // Documenting current behavior: the regex's CSI arm only accepts finals
+        // in [mGKHFJABCDsuhl]. A device-status query like ESC[6n (final 'n') is
+        // NOT stripped. If the regex is later widened, update this test.
+        var input = $"before{ESC}[6nafter";
+        // The escape sequence remains intact because the CSI arm requires a
+        // matching final byte that we don't list.
+        Assert.Contains($"{ESC}[6n", Strip(input));
+    }
+
+    [Fact]
+    public void Strip_LoneEscapeWithoutSequence_IsLeftAlone()
+    {
+        // A bare ESC with no [, ], =, or > following it is not matched by any
+        // arm of the regex. Documenting that as intentional.
+        Assert.Equal($"a{ESC}b", Strip($"a{ESC}b"));
+    }
+}
diff --git a/tests/CodeShellManager.Tests/RecentlyClosedEntryTests.cs b/tests/CodeShellManager.Tests/RecentlyClosedEntryTests.cs
new file mode 100644
index 0000000..8a2cfda
--- /dev/null
+++ b/tests/CodeShellManager.Tests/RecentlyClosedEntryTests.cs
@@ -0,0 +1,132 @@
+using System.Linq;
+using CodeShellManager.Models;
+using Xunit;
+
+namespace CodeShellManager.Tests;
+
+public class RecentlyClosedEntryTests
+{
+    [Fact]
+    public void FromSession_CopiesScalarAndSshFields()
+    {
+        var s = new ShellSession
+        {
+            Name = "alpha",
+            WorkingFolder = @"C:\proj",
+            Command = "claude",
+            Args = "--resume foo",
+            GroupId = "g1",
+            ColorOverride = "#abcdef",
+            IsRemote = true,
+            SshUser = "alice",
+            SshHost = "dev.example.com",
+            SshPort = 2222,
+            SshRemoteFolder = "/srv",
+        };
+
+        var e = RecentlyClosedEntry.FromSession(s);
+
+        Assert.Equal("alpha", e.Name);
+        Assert.Equal(@"C:\proj", e.WorkingFolder);
+        Assert.Equal("claude", e.Command);
+        Assert.Equal("--resume foo", e.Args);
+        Assert.Equal("g1", e.GroupId);
+        Assert.Equal("#abcdef", e.ColorOverride);
+        Assert.True(e.IsRemote);
+        Assert.Equal("alice", e.SshUser);
+        Assert.Equal("dev.example.com", e.SshHost);
+        Assert.Equal(2222, e.SshPort);
+        Assert.Equal("/srv", e.SshRemoteFolder);
+    }
+
+    [Fact]
+    public void FromSession_CopiesProfileOverrides()
+    {
+        var s = new ShellSession
+        {
+            ProfileFontFamily = "Cascadia",
+            ProfileFontSize = 16,
+            ProfileFontWeight = "bold",
+            ProfileFontLigatures = true,
+            ProfileCursorShape = "underline",
+            ProfileCursorBlink = false,
+            ProfilePadding = "8 8 8 8",
+            ProfileBackgroundOpacity = 0.85,
+            ProfileRetroEffect = true,
+            ProfileColorSchemeJson = "{\"foreground\":\"#fff\"}",
+        };
+
+        var e = RecentlyClosedEntry.FromSession(s);
+
+        Assert.Equal("Cascadia", e.ProfileFontFamily);
+        Assert.Equal(16, e.ProfileFontSize);
+        Assert.Equal("bold", e.ProfileFontWeight);
+        Assert.True(e.ProfileFontLigatures);
+        Assert.Equal("underline", e.ProfileCursorShape);
+        Assert.False(e.ProfileCursorBlink);
+        Assert.Equal("8 8 8 8", e.ProfilePadding);
+        Assert.Equal(0.85, e.ProfileBackgroundOpacity);
+        Assert.True(e.ProfileRetroEffect);
+        Assert.Equal("{\"foreground\":\"#fff\"}", e.ProfileColorSchemeJson);
+    }
+
+    [Fact]
+    public void FromSession_DeepCopiesRunCommandsWithFreshIds()
+    {
+        var s = new ShellSession();
+        s.RunCommands.Add(new RunCommandItem
+        {
+            Id = "original-id",
+            Label = "Test",
+            CommandLine = "dotnet test",
+            IsDefault = true,
+            Mode = RunMode.PowerShell,
+            PostRunUrl = "http://localhost:5173",
+        });
+
+        var e = RecentlyClosedEntry.FromSession(s);
+
+        Assert.Single(e.RunCommands);
+        var copy = e.RunCommands[0];
+        Assert.NotEqual("original-id", copy.Id); // fresh Id
+        Assert.Equal("Test", copy.Label);
+        Assert.Equal("dotnet test", copy.CommandLine);
+        Assert.True(copy.IsDefault);
+        Assert.Equal(RunMode.PowerShell, copy.Mode);
+        Assert.Equal("http://localhost:5173", copy.PostRunUrl);
+        // Mutating the copy must NOT touch the source.
+        copy.Label = "MUTATED";
+        Assert.Equal("Test", s.RunCommands[0].Label);
+    }
+
+    [Fact]
+    public void Subtitle_RemoteSession_ReturnsUserAtHost()
+    {
+        var e = new RecentlyClosedEntry
+        {
+            IsRemote = true,
+            SshUser = "bob",
+            SshHost = "dev.local",
+            WorkingFolder = @"C:\should-be-ignored",
+        };
+        Assert.Equal("bob@dev.local", e.Subtitle);
+    }
+
+    [Fact]
+    public void Subtitle_RemoteSessionWithoutUser_ReturnsHostOnly()
+    {
+        var e = new RecentlyClosedEntry
+        {
+            IsRemote = true,
+            SshHost = "dev.local",
+        };
+        Assert.Equal("dev.local", e.Subtitle);
+    }
+
+    [Fact]
+    public void Subtitle_LocalSession_ReturnsWorkingFolder()
+    {
+        var e = new RecentlyClosedEntry { WorkingFolder = @"C:\proj" };
+        Assert.Equal(@"C:\proj", e.Subtitle);
+    }
+}
diff --git a/tests/CodeShellManager.Tests/RunCommandItemTests.cs b/tests/CodeShellManager.Tests/RunCommandItemTests.cs
index 20747bb..84a02ea 100644
--- a/tests/CodeShellManager.Tests/RunCommandItemTests.cs
+++ b/tests/CodeShellManager.Tests/RunCommandItemTests.cs
@@ -43,4 +43,14 @@ public void EnsureSingleDefault_EmptyList_NoOp()
         RunCommandItem.EnsureSingleDefault(list);
         Assert.Empty(list);
     }
+
+    [Fact]
+    public void Defaults_ModeIsProcess_PostRunUrlIsNull()
+    {
+        // Back-compat: legacy state.json files that lack Mode/PostRunUrl must round-trip
+        // to "Process" and null respectively so existing run commands keep working.
+        var item = new RunCommandItem();
+        Assert.Equal(RunMode.Process, item.Mode);
+        Assert.Null(item.PostRunUrl);
+    }
 }
diff --git a/tests/CodeShellManager.Tests/RunInstanceTests.cs b/tests/CodeShellManager.Tests/RunInstanceTests.cs
index 5e608ad..bd0f83a 100644
--- a/tests/CodeShellManager.Tests/RunInstanceTests.cs
+++ b/tests/CodeShellManager.Tests/RunInstanceTests.cs
@@ -64,4 +64,19 @@ public void BuildSshArgs_CommandLineWithApostrophe_IsEscaped()
         string args = RunInstance.BuildSshArgs(p, "echo it's me");
         Assert.Contains(@"bash -c 'echo it'\''s me'", args);
     }
+
+    [Fact]
+    public void BuildPwshArgs_RoundTripsCommandLineViaBase64()
+    {
+        // -EncodedCommand expects UTF-16 LE base64. Round-trip a known string with
+        // tricky chars ($env: would otherwise be eaten by cmd.exe parsing) to
+        // confirm the wrapping is preserved verbatim.
+        const string cmd = "Write-Host \"hi $env:USERNAME!\" | Out-Default";
+        string args = RunInstance.BuildPwshArgs(cmd);
+
+        Assert.StartsWith("-NonInteractive -NoLogo -ExecutionPolicy Bypass -EncodedCommand ", args);
+        string b64 = args.Substring(args.LastIndexOf(' ') + 1);
+        string decoded = System.Text.Encoding.Unicode.GetString(System.Convert.FromBase64String(b64));
+        Assert.Equal(cmd, decoded);
+    }
 }
diff --git a/tests/CodeShellManager.Tests/SearchServiceTests.cs b/tests/CodeShellManager.Tests/SearchServiceTests.cs
new file mode 100644
index 0000000..5a4867d
--- /dev/null
+++ b/tests/CodeShellManager.Tests/SearchServiceTests.cs
@@ -0,0 +1,431 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using CodeShellManager.Services;
+using Microsoft.Data.Sqlite;
+using Xunit;
+
+namespace CodeShellManager.Tests;
+
+/// <summary>
+/// Tests for <see cref="SearchService"/>. Each test gets its own temporary SQLite
+/// file (<see cref="SearchService"/> takes a <see cref="SqliteConnection"/> directly,
+/// so we open a fresh file-backed connection, run <see cref="SearchService.InitializeSchemaAsync"/>,
+/// seed rows via the same INSERT statement <c>OutputIndexer</c> uses, and delete the
+/// file on dispose). File-backed (not <c>:memory:</c>) so all `_db.CreateCommand()`
+/// calls inside the service see the same data — though SearchService holds one
+/// connection so :memory: would technically work too.
+/// </summary>
+public class SearchServiceTests : IDisposable
+{
+    private readonly string _dbPath;
+    private readonly SqliteConnection _db;
+    private readonly SearchService _svc;
+
+    public SearchServiceTests()
+    {
+        _dbPath = Path.Combine(Path.GetTempPath(), $"csm-search-{Guid.NewGuid():N}.db");
+        _db = new SqliteConnection($"Data Source={_dbPath}");
+        _db.Open();
+        SearchService.InitializeSchemaAsync(_db).GetAwaiter().GetResult();
+        _svc = new SearchService(_db);
+    }
+
+    public void Dispose()
+    {
+        try { _db.Close(); } catch { }
+        try { _db.Dispose(); } catch { }
+        // SQLite holds an exclusive lock on Windows until the connection is fully
+        // released and pooling is cleared.
+        try { SqliteConnection.ClearAllPools(); } catch { }
+        try
+        {
+            if (File.Exists(_dbPath)) File.Delete(_dbPath);
+        }
+        catch { /* best-effort cleanup */ }
+    }
+
+    // ── helpers ──────────────────────────────────────────────────────────────
+
+    private async Task SeedOutputAsync(string sessionId, string sessionName, string line, long? tsMs = null)
+    {
+        await using var cmd = _db.CreateCommand();
+        cmd.CommandText = """
+            INSERT INTO session_output (session_id, session_name, ts, line)
+            VALUES ($sid, $sname, $ts, $line)
+            """;
+        cmd.Parameters.AddWithValue("$sid", sessionId);
+        cmd.Parameters.AddWithValue("$sname", sessionName);
+        cmd.Parameters.AddWithValue("$ts", tsMs ?? DateTimeOffset.UtcNow.ToUnixTimeMilliseconds());
+        cmd.Parameters.AddWithValue("$line", line);
+        await cmd.ExecuteNonQueryAsync();
+    }
+
+    // ── SearchAsync — output (FTS5) ──────────────────────────────────────────
+
+    [Fact]
+    public async Task SearchAsync_EmptyDatabase_ReturnsNoResults()
+    {
+        var results = await _svc.SearchAsync("anything");
+        Assert.Empty(results);
+    }
+
+    [Fact]
+    public async Task SearchAsync_BlankQuery_ReturnsNoResults()
+    {
+        await SeedOutputAsync("s1", "Session 1", "hello world");
+        var results = await _svc.SearchAsync("   ");
+        Assert.Empty(results);
+    }
+
+    [Fact]
+    public async Task SearchAsync_UniqueToken_ReturnsOneResultWithSessionIdAndSnippet()
+    {
+        await SeedOutputAsync("sess-A", "Alpha", "the quick brown fox");
+        await SeedOutputAsync("sess-B", "Beta", "lazy dog jumps over");
+        await SeedOutputAsync("sess-C", "Gamma", "nothing relevant here");
+
+        var results = await _svc.SearchAsync("quick");
+
+        Assert.Single(results);
+        var hit = results[0];
+        Assert.Equal("sess-A", hit.SessionId);
+        Assert.Equal("Alpha", hit.SessionName);
+        Assert.False(string.IsNullOrEmpty(hit.Snippet));
+        Assert.Equal(SearchResultType.Output, hit.Type);
+        // snippet uses '[' / ']' markers around the matched token
+        Assert.Contains("[quick]", hit.Snippet, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public async Task SearchAsync_MultiWordQuery_AppliesImplicitAnd()
+    {
+        await SeedOutputAsync("s1", "S1", "foo bar baz");
+        await SeedOutputAsync("s2", "S2", "foo only");
+        await SeedOutputAsync("s3", "S3", "bar only");
+
+        var results = await _svc.SearchAsync("foo bar");
+
+        // FTS5 default is implicit AND — only s1 has both tokens
+        Assert.Single(results);
+        Assert.Equal("s1", results[0].SessionId);
+    }
+
+    [Fact]
+    public async Task SearchAsync_NoMatch_ReturnsEmpty()
+    {
+        await SeedOutputAsync("s1", "S1", "hello world");
+        var results = await _svc.SearchAsync("zzznotfoundzzz");
+        Assert.Empty(results);
+    }
+
+    [Fact]
+    public async Task SearchAsync_RespectsLimit()
+    {
+        for (int i = 0; i < 5; i++)
+            await SeedOutputAsync($"s{i}", $"S{i}", $"matchtoken row {i}");
+
+        var results = await _svc.SearchAsync("matchtoken", limit: 3);
+
+        Assert.True(results.Count <= 3, $"expected <= 3 results, got {results.Count}");
+        Assert.Equal(3, results.Count);
+    }
+
+    [Fact]
+    public async Task SearchAsync_SnippetContainsMatchedToken()
+    {
+        await SeedOutputAsync("s1", "S1", "before middle needle middle after");
+        var results = await _svc.SearchAsync("needle");
+        Assert.Single(results);
+        // snippet wraps the matched token in brackets
+        Assert.Contains("needle", results[0].Snippet);
+    }
+
+    [Fact]
+    public async Task SearchAsync_OrdersByTimestampDescending()
+    {
+        long t0 = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+        await SeedOutputAsync("old", "Old", "needle old", tsMs: t0 - 60_000);
+        await SeedOutputAsync("new", "New", "needle new", tsMs: t0);
+        await SeedOutputAsync("mid", "Mid", "needle mid", tsMs: t0 - 30_000);
+
+        var results = await _svc.SearchAsync("needle");
+
+        Assert.Equal(3, results.Count);
+        Assert.Equal("new", results[0].SessionId);
+        Assert.Equal("mid", results[1].SessionId);
+        Assert.Equal("old", results[2].SessionId);
+    }
+
+    [Fact]
+    public async Task SearchAsync_MalformedFtsQuery_DoesNotThrow()
+    {
+        await SeedOutputAsync("s1", "S1", "anything");
+        // unbalanced quote → FTS5 syntax error inside SearchAsync's try/catch
+        var results = await _svc.SearchAsync("\"unterminated");
+        Assert.NotNull(results);
+        // FTS error is swallowed → output search yields nothing; notes search runs too but finds nothing
+        Assert.Empty(results);
+    }
+
+    // ── SearchAsync — project notes ──────────────────────────────────────────
+
+    [Fact]
+    public async Task SearchAsync_MatchesProjectNotes()
+    {
+        await _svc.SaveNoteAsync(@"C:\repos\myproject", "remember to fix the unique-thing later");
+
+        var results = await _svc.SearchAsync("unique-thing");
+
+        var note = Assert.Single(results, r => r.Type == SearchResultType.Note);
+        Assert.Equal("myproject", note.SessionName);
+        Assert.Equal(@"C:\repos\myproject", note.FolderPath);
+        Assert.Contains("[unique-thing]", note.Snippet);
+        Assert.True(note.IsNote);
+        Assert.Equal("note", note.TypeLabel);
+    }
+
+    // ── Project notes ────────────────────────────────────────────────────────
+
+    [Fact]
+    public async Task GetNoteAsync_MissingFolder_ReturnsNull()
+    {
+        var note = await _svc.GetNoteAsync(@"C:\does\not\exist");
+        Assert.Null(note);
+    }
+
+    [Fact]
+    public async Task SaveNoteAsync_ThenGet_RoundTrips()
+    {
+        await _svc.SaveNoteAsync(@"C:\repos\foo", "hello note");
+        var note = await _svc.GetNoteAsync(@"C:\repos\foo");
+        Assert.Equal("hello note", note);
+    }
+
+    [Fact]
+    public async Task SaveNoteAsync_Upserts()
+    {
+        await _svc.SaveNoteAsync(@"C:\repos\foo", "first");
+        await _svc.SaveNoteAsync(@"C:\repos\foo", "second");
+        var note = await _svc.GetNoteAsync(@"C:\repos\foo");
+        Assert.Equal("second", note);
+    }
+
+    // ── Session history ─────────────────────────────────────────────────────
+
+    [Fact]
+    public async Task GetSessionHistoryAsync_MissingId_ReturnsNull()
+    {
+        var entry = await _svc.GetSessionHistoryAsync("nope");
+        Assert.Null(entry);
+    }
+
+    [Fact]
+    public async Task RecordSessionHistoryAsync_ThenGet_RoundTrips()
+    {
+        await _svc.RecordSessionHistoryAsync(
+            sessionId: "sid-1",
+            sessionName: "My Session",
+            workingFolder: @"C:\repos\proj",
+            command: "claude",
+            args: "--resume xyz",
+            groupId: "grp-1");
+
+        var entry = await _svc.GetSessionHistoryAsync("sid-1");
+
+        Assert.NotNull(entry);
+        Assert.Equal("sid-1", entry!.SessionId);
+        Assert.Equal("My Session", entry.SessionName);
+        Assert.Equal(@"C:\repos\proj", entry.WorkingFolder);
+        Assert.Equal("claude", entry.Command);
+        Assert.Equal("--resume xyz", entry.Args);
+        Assert.Equal("grp-1", entry.GroupId);
+    }
+
+    [Fact]
+    public async Task GetLatestSessionHistoryForFolderAsync_ReturnsMostRecent()
+    {
+        // Seed timestamps directly rather than relying on Task.Delay between RecordSessionHistoryAsync
+        // calls — Windows' default 15.6ms timer resolution can collide millisecond unix timestamps
+        // on slow CI workers, making "most recent" nondeterministic.
+        await SeedSessionHistoryAsync("sid-old", "Old", @"C:\proj", "claude", tsMs: 1000);
+        await SeedSessionHistoryAsync("sid-new", "New", @"C:\proj", "claude", tsMs: 2000);
+
+        var entry = await _svc.GetLatestSessionHistoryForFolderAsync(@"C:\proj");
+
+        Assert.NotNull(entry);
+        Assert.Equal("sid-new", entry!.SessionId);
+    }
+
+    private async Task SeedSessionHistoryAsync(string sessionId, string sessionName, string workingFolder, string command, long tsMs)
+    {
+        await using var cmd = _db.CreateCommand();
+        cmd.CommandText = """
+            INSERT INTO session_history
+                (session_id, session_name, working_folder, command, args, group_id, exited_at)
+            VALUES ($sid, $name, $folder, $cmd, '', '', $ts)
+            """;
+        cmd.Parameters.AddWithValue("$sid", sessionId);
+        cmd.Parameters.AddWithValue("$name", sessionName);
+        cmd.Parameters.AddWithValue("$folder", workingFolder);
+        cmd.Parameters.AddWithValue("$cmd", command);
+        cmd.Parameters.AddWithValue("$ts", tsMs);
+        await cmd.ExecuteNonQueryAsync();
+    }
+
+    [Fact]
+    public async Task GetLatestSessionHistoryForFolderAsync_NoMatch_ReturnsNull()
+    {
+        await _svc.RecordSessionHistoryAsync("sid", "S", @"C:\a", "claude", "", "");
+        var entry = await _svc.GetLatestSessionHistoryForFolderAsync(@"C:\different");
+        Assert.Null(entry);
+    }
+
+    // ── Storage management ──────────────────────────────────────────────────
+
+    [Fact]
+    public async Task DeleteSessionLogsAsync_RemovesOnlyMatchingSession()
+    {
+        await SeedOutputAsync("keep", "Keep", "alpha line");
+        await SeedOutputAsync("drop", "Drop", "alpha line");
+
+        await _svc.DeleteSessionLogsAsync("drop");
+        var results = await _svc.SearchAsync("alpha");
+
+        Assert.Single(results);
+        Assert.Equal("keep", results[0].SessionId);
+    }
+
+    [Fact]
+    public async Task PruneOldOutputAsync_NonPositiveRetention_NoOp()
+    {
+        await SeedOutputAsync("s1", "S1", "alpha");
+        Assert.Equal(0, await _svc.PruneOldOutputAsync(0));
+        Assert.Equal(0, await _svc.PruneOldOutputAsync(-5));
+        var results = await _svc.SearchAsync("alpha");
+        Assert.Single(results);
+    }
+
+    [Fact]
+    public async Task PruneOldOutputAsync_DeletesRowsOlderThanCutoff()
+    {
+        long now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+        long oldTs = now - TimeSpan.FromDays(30).Ticks / TimeSpan.TicksPerMillisecond;
+
+        await SeedOutputAsync("recent", "R", "alpha recent", tsMs: now);
+        await SeedOutputAsync("old", "O", "alpha old", tsMs: oldTs);
+
+        int deleted = await _svc.PruneOldOutputAsync(retentionDays: 7);
+
+        Assert.Equal(1, deleted);
+        var results = await _svc.SearchAsync("alpha");
+        Assert.Single(results);
+        Assert.Equal("recent", results[0].SessionId);
+    }
+
+    [Fact]
+    public async Task ClearAllOutputAsync_WipesEverything()
+    {
+        await SeedOutputAsync("s1", "S1", "alpha");
+        await SeedOutputAsync("s2", "S2", "beta");
+
+        await _svc.ClearAllOutputAsync();
+        var resultsA = await _svc.SearchAsync("alpha");
+        var resultsB = await _svc.SearchAsync("beta");
+
+        Assert.Empty(resultsA);
+        Assert.Empty(resultsB);
+    }
+
+    [Fact]
+    public async Task GetDatabaseSizeBytesAsync_ReturnsPositiveSize()
+    {
+        await SeedOutputAsync("s1", "S1", "some line");
+        long size = await _svc.GetDatabaseSizeBytesAsync();
+        Assert.True(size > 0, $"expected size > 0, got {size}");
+    }
+
+    // ── Usage stats ─────────────────────────────────────────────────────────
+
+    [Theory]
+    [InlineData("claude --continue", "claude")]
+    [InlineData("CLAUDE", "claude")]
+    [InlineData("pwsh", "pwsh")]
+    [InlineData("pwsh -NoLogo", "pwsh")]
+    [InlineData("", "(unknown)")]
+    [InlineData(null, "(unknown)")]
+    [InlineData("   ", "(unknown)")]
+    public void NormalizeCommandName_BehavesAsExpected(string? input, string expected)
+    {
+        Assert.Equal(expected, SearchService.NormalizeCommandName(input));
+    }
+
+    [Fact]
+    public async Task RecordSessionStartAsync_IncrementsSessionCount()
+    {
+        await _svc.RecordSessionStartAsync("claude");
+        await _svc.RecordSessionStartAsync("claude --resume abc");
+        await _svc.RecordSessionStartAsync("pwsh");
+
+        var stats = await _svc.GetUsageStatsAsync();
+
+        var claude = stats.Single(s => s.Command == "claude");
+        var pwsh = stats.Single(s => s.Command == "pwsh");
+        Assert.Equal(2, claude.Sessions);
+        Assert.Equal(1, pwsh.Sessions);
+    }
+
+    [Fact]
+    public async Task RecordSessionDurationAsync_AccumulatesSeconds()
+    {
+        await _svc.RecordSessionStartAsync("claude");
+        await _svc.RecordSessionDurationAsync("claude", 120);
+        await _svc.RecordSessionDurationAsync("claude --resume", 60);
+
+        var stats = await _svc.GetUsageStatsAsync();
+        var claude = stats.Single(s => s.Command == "claude");
+        Assert.Equal(180, claude.TotalSeconds);
+    }
+
+    [Fact]
+    public async Task RecordSessionDurationAsync_NonPositive_NoOp()
+    {
+        await _svc.RecordSessionStartAsync("claude");
+        await _svc.RecordSessionDurationAsync("claude", 0);
+        await _svc.RecordSessionDurationAsync("claude", -10);
+
+        var stats = await _svc.GetUsageStatsAsync();
+        var claude = stats.Single(s => s.Command == "claude");
+        Assert.Equal(0, claude.TotalSeconds);
+    }
+
+    [Fact]
+    public async Task GetUsageStatsAsync_EmptyDb_ReturnsEmptyList()
+    {
+        var stats = await _svc.GetUsageStatsAsync();
+        Assert.Empty(stats);
+    }
+
+    [Fact]
+    public async Task GetUsageStatsAsync_OrdersBySessionsDescending()
+    {
+        // claude: 3 starts; pwsh: 1 start; bash: 2 starts
+        await _svc.RecordSessionStartAsync("claude");
+        await _svc.RecordSessionStartAsync("claude");
+        await _svc.RecordSessionStartAsync("claude");
+        await _svc.RecordSessionStartAsync("pwsh");
+        await _svc.RecordSessionStartAsync("bash");
+        await _svc.RecordSessionStartAsync("bash");
+
+        var stats = await _svc.GetUsageStatsAsync();
+
+        Assert.Equal(3, stats.Count);
+        Assert.Equal("claude", stats[0].Command);
+        Assert.Equal(3, stats[0].Sessions);
+        Assert.Equal("bash", stats[1].Command);
+        Assert.Equal(2, stats[1].Sessions);
+        Assert.Equal("pwsh", stats[2].Command);
+        Assert.Equal(1, stats[2].Sessions);
+    }
+}
diff --git a/tests/CodeShellManager.Tests/SessionRunnerTests.cs b/tests/CodeShellManager.Tests/SessionRunnerTests.cs
new file mode 100644
index 0000000..87e07fc
--- /dev/null
+++ b/tests/CodeShellManager.Tests/SessionRunnerTests.cs
@@ -0,0 +1,323 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using CodeShellManager.Models;
+using CodeShellManager.Services;
+using CodeShellManager.Terminal;
+using Xunit;
+
+namespace CodeShellManager.Tests;
+
+/// <summary>
+/// Lifecycle tests for <see cref="SessionRunner"/> and <see cref="RunInstance"/> using a
+/// hand-rolled <see cref="FakePseudoTerminal"/>. The PTY interface seam lives at
+/// <see cref="IPseudoTerminal"/> — production code constructs a real ConPTY wrapper,
+/// tests inject a fake that lets us simulate output bytes and exit codes synchronously.
+/// </summary>
+public class SessionRunnerTests
+{
+    private sealed class FakePseudoTerminal : IPseudoTerminal
+    {
+        public bool StartCalled { get; private set; }
+        public bool DisposeCalled { get; private set; }
+        public string? StartCommand { get; private set; }
+        public string? StartArgs { get; private set; }
+        public string? StartWorkingDirectory { get; private set; }
+
+        public int? ExitCode { get; private set; }
+
+        public event Action<string>? DataReceived;
+        public event Action? Exited;
+
+        public void Start(string command, string args, string workingDirectory,
+            int cols = 220, int rows = 50, bool useJobObject = false)
+        {
+            StartCalled = true;
+            StartCommand = command;
+            StartArgs = args;
+            StartWorkingDirectory = workingDirectory;
+        }
+
+        public void EmitData(string text) => DataReceived?.Invoke(text);
+
+        public void EmitExit(int code)
+        {
+            ExitCode = code;
+            Exited?.Invoke();
+        }
+
+        public void Dispose() => DisposeCalled = true;
+    }
+
+    private static ShellSession LocalSession() => new()
+    {
+        WorkingFolder = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
+    };
+
+    private static RunCommandItem Item(string id = "item-1", string label = "Build", string cmd = "dotnet build")
+        => new() { Id = id, Label = label, CommandLine = cmd };
+
+    // ── SessionRunner lifecycle ──────────────────────────────────────────────
+
+    [Fact]
+    public void Run_CreatesInstanceAndFiresInstancesChanged()
+    {
+        var fake = new FakePseudoTerminal();
+        var runner = new SessionRunner(LocalSession(), () => fake);
+        int fired = 0;
+        runner.InstancesChanged += () => fired++;
+
+        var inst = runner.Run(Item());
+
+        Assert.NotNull(inst);
+        Assert.True(fake.StartCalled);
+        Assert.Single(runner.Instances);
+        Assert.Same(inst, runner.Instances["item-1"]);
+        Assert.True(fired >= 1, $"InstancesChanged should fire on Run; fired={fired}");
+    }
+
+    [Fact]
+    public void Run_TwiceOnSameItem_DisposesPriorAndReplaces()
+    {
+        var fakes = new Queue<FakePseudoTerminal>(new[] { new FakePseudoTerminal(), new FakePseudoTerminal() });
+        var runner = new SessionRunner(LocalSession(), () => fakes.Dequeue());
+
+        var first = runner.Run(Item());
+        var firstFake = (FakePseudoTerminal)GetPty(first)!;
+        Assert.False(firstFake.DisposeCalled);
+
+        var second = runner.Run(Item());
+        var secondFake = (FakePseudoTerminal)GetPty(second)!;
+
+        Assert.True(firstFake.DisposeCalled, "First instance's PTY should be disposed when re-Run replaces it.");
+        Assert.False(secondFake.DisposeCalled);
+        Assert.NotSame(first, second);
+        Assert.Single(runner.Instances);
+        Assert.Same(second, runner.Instances["item-1"]);
+    }
+
+    [Fact]
+    public void Stop_DisposesInstanceAndFiresInstancesChanged()
+    {
+        var fake = new FakePseudoTerminal();
+        var runner = new SessionRunner(LocalSession(), () => fake);
+        runner.Run(Item());
+
+        int firedAfterRun = 0;
+        runner.InstancesChanged += () => firedAfterRun++;
+
+        runner.Stop("item-1");
+
+        Assert.True(fake.DisposeCalled);
+        Assert.True(firedAfterRun >= 1, $"InstancesChanged should fire on Stop; fired={firedAfterRun}");
+        // Stop keeps the instance around so the chip can still show failure state.
+        Assert.Single(runner.Instances);
+    }
+
+    [Fact]
+    public void Stop_UnknownItem_IsNoOp()
+    {
+        var runner = new SessionRunner(LocalSession(), () => new FakePseudoTerminal());
+        int fired = 0;
+        runner.InstancesChanged += () => fired++;
+
+        runner.Stop("does-not-exist");
+
+        Assert.Equal(0, fired);
+        Assert.Empty(runner.Instances);
+    }
+
+    [Fact]
+    public void Dismiss_RemovesInstanceFromDictionary()
+    {
+        var fake = new FakePseudoTerminal();
+        var runner = new SessionRunner(LocalSession(), () => fake);
+        runner.Run(Item());
+        Assert.Single(runner.Instances);
+
+        int fired = 0;
+        runner.InstancesChanged += () => fired++;
+
+        runner.Dismiss("item-1");
+
+        Assert.Empty(runner.Instances);
+        Assert.True(fake.DisposeCalled);
+        Assert.True(fired >= 1, $"InstancesChanged should fire on Dismiss; fired={fired}");
+    }
+
+    [Fact]
+    public void Dispose_StopsEveryRunningInstance()
+    {
+        var fakes = new List<FakePseudoTerminal>();
+        var runner = new SessionRunner(LocalSession(), () =>
+        {
+            var f = new FakePseudoTerminal();
+            fakes.Add(f);
+            return f;
+        });
+
+        runner.Run(Item(id: "a", cmd: "echo a"));
+        runner.Run(Item(id: "b", cmd: "echo b"));
+        runner.Run(Item(id: "c", cmd: "echo c"));
+        Assert.Equal(3, fakes.Count);
+
+        runner.Dispose();
+
+        Assert.All(fakes, f => Assert.True(f.DisposeCalled));
+        Assert.Empty(runner.Instances);
+    }
+
+    [Fact]
+    public void StopAll_StopsEveryRunningInstance()
+    {
+        var fakes = new List<FakePseudoTerminal>();
+        var runner = new SessionRunner(LocalSession(), () =>
+        {
+            var f = new FakePseudoTerminal();
+            fakes.Add(f);
+            return f;
+        });
+        runner.Run(Item(id: "a"));
+        runner.Run(Item(id: "b"));
+
+        runner.StopAll();
+
+        Assert.All(fakes, f => Assert.True(f.DisposeCalled));
+        Assert.Empty(runner.Instances);
+    }
+
+    // ── RunInstance state transitions ───────────────────────────────────────
+
+    [Fact]
+    public void RunInstance_Start_TransitionsToRunning()
+    {
+        var fake = new FakePseudoTerminal();
+        var inst = new RunInstance(Item(), () => fake);
+
+        inst.Start(LocalSession());
+
+        Assert.Equal(RunState.Running, inst.State);
+        Assert.True(fake.StartCalled);
+        Assert.NotNull(inst.StartedAt);
+        Assert.Null(inst.EndedAt);
+    }
+
+    [Fact]
+    public void RunInstance_ExitZero_TransitionsToExitedOk()
+    {
+        var fake = new FakePseudoTerminal();
+        var inst = new RunInstance(Item(), () => fake);
+        inst.Start(LocalSession());
+
+        int stateChanges = 0;
+        inst.StateChanged += () => stateChanges++;
+
+        fake.EmitExit(0);
+
+        Assert.Equal(RunState.ExitedOk, inst.State);
+        Assert.Equal(0, inst.ExitCode);
+        Assert.NotNull(inst.EndedAt);
+        Assert.True(stateChanges >= 1);
+    }
+
+    [Fact]
+    public void RunInstance_ExitNonZero_TransitionsToExitedFailed()
+    {
+        var fake = new FakePseudoTerminal();
+        var inst = new RunInstance(Item(), () => fake);
+        inst.Start(LocalSession());
+
+        fake.EmitExit(1);
+
+        Assert.Equal(RunState.ExitedFailed, inst.State);
+        Assert.Equal(1, inst.ExitCode);
+        Assert.NotNull(inst.EndedAt);
+    }
+
+    [Fact]
+    public void RunInstance_ExitNegative_TransitionsToExitedFailed()
+    {
+        // Windows exit codes can be negative (e.g. STATUS_CONTROL_C_EXIT = unchecked((int)0xC000013A)).
+        var fake = new FakePseudoTerminal();
+        var inst = new RunInstance(Item(), () => fake);
+        inst.Start(LocalSession());
+
+        fake.EmitExit(unchecked((int)0xC000013A));
+
+        Assert.Equal(RunState.ExitedFailed, inst.State);
+    }
+
+    [Fact]
+    public void RunInstance_DisposeWhileRunning_ForcesExitedFailed()
+    {
+        var fake = new FakePseudoTerminal();
+        var inst = new RunInstance(Item(), () => fake);
+        inst.Start(LocalSession());
+        Assert.Equal(RunState.Running, inst.State);
+
+        inst.Dispose();
+
+        Assert.True(fake.DisposeCalled);
+        Assert.Equal(RunState.ExitedFailed, inst.State);
+        Assert.NotNull(inst.EndedAt);
+    }
+
+    // ── Output buffer ────────────────────────────────────────────────────────
+
+    [Fact]
+    public void RunInstance_OutputBufferAppendsOnPtyData()
+    {
+        var fake = new FakePseudoTerminal();
+        var inst = new RunInstance(Item(), () => fake);
+        inst.Start(LocalSession());
+
+        int outputEvents = 0;
+        inst.OutputChanged += () => outputEvents++;
+
+        fake.EmitData("hello ");
+        fake.EmitData("world\n");
+
+        Assert.Equal("hello world\n", inst.SnapshotOutput());
+        Assert.True(outputEvents >= 2);
+    }
+
+    [Fact]
+    public void RunInstance_OutputBufferStripsAnsiEscapeSequences()
+    {
+        var fake = new FakePseudoTerminal();
+        var inst = new RunInstance(Item(), () => fake);
+        inst.Start(LocalSession());
+
+        // ESC[31m red ESC[0m → "red "
+        fake.EmitData("\x1B[31mred\x1B[0m text");
+
+        Assert.Equal("red text", inst.SnapshotOutput());
+    }
+
+    [Fact]
+    public void RunInstance_OutputBufferCapsAtOneMegabyte()
+    {
+        var fake = new FakePseudoTerminal();
+        var inst = new RunInstance(Item(), () => fake);
+        inst.Start(LocalSession());
+
+        // Push 1.5MB of plain ASCII (no ANSI, no \r — both get stripped).
+        // The buffer is documented to cap at 1MB (1_000_000 chars) and drop from the head.
+        const int chunkSize = 100_000;
+        string chunk = new('x', chunkSize);
+        for (int i = 0; i < 15; i++) fake.EmitData(chunk);
+
+        string snap = inst.SnapshotOutput();
+        Assert.Equal(1_000_000, snap.Length);
+    }
+
+    // ── Internal accessor for the private _pty field via reflection ──────────
+
+    private static IPseudoTerminal? GetPty(RunInstance inst)
+    {
+        var field = typeof(RunInstance).GetField(
+            "_pty",
+            System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+        return (IPseudoTerminal?)field!.GetValue(inst);
+    }
+}